summaryrefslogtreecommitdiffstats
path: root/languages/ada
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit114a878c64ce6f8223cfd22d76a20eb16d177e5e (patch)
treeacaf47eb0fa12142d3896416a69e74cbf5a72242 /languages/ada
downloadtdevelop-114a878c64ce6f8223cfd22d76a20eb16d177e5e.tar.gz
tdevelop-114a878c64ce6f8223cfd22d76a20eb16d177e5e.zip
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
Diffstat (limited to 'languages/ada')
-rw-r--r--languages/ada/AdaAST.hpp77
-rw-r--r--languages/ada/AdaLexer.cpp1507
-rw-r--r--languages/ada/AdaLexer.hpp86
-rw-r--r--languages/ada/AdaParser.cpp12283
-rw-r--r--languages/ada/AdaParser.hpp389
-rw-r--r--languages/ada/AdaStoreWalker.cpp9439
-rw-r--r--languages/ada/AdaStoreWalker.hpp350
-rw-r--r--languages/ada/AdaStoreWalkerTokenTypes.hpp307
-rw-r--r--languages/ada/AdaStoreWalkerTokenTypes.txt289
-rw-r--r--languages/ada/AdaTokenTypes.hpp306
-rw-r--r--languages/ada/AdaTokenTypes.txt288
-rw-r--r--languages/ada/AdaTreeParserSuper.cpp9050
-rw-r--r--languages/ada/AdaTreeParserSuper.hpp241
-rw-r--r--languages/ada/AdaTreeParserSuperTokenTypes.hpp307
-rw-r--r--languages/ada/AdaTreeParserSuperTokenTypes.txt289
-rw-r--r--languages/ada/Makefile.am41
-rw-r--r--languages/ada/README1
-rw-r--r--languages/ada/README.dox31
-rw-r--r--languages/ada/ada.g1982
-rw-r--r--languages/ada/ada.store.g610
-rw-r--r--languages/ada/ada.tree.g964
-rw-r--r--languages/ada/ada_utils.cpp69
-rw-r--r--languages/ada/ada_utils.hpp15
-rw-r--r--languages/ada/adasupport.cpp168
-rw-r--r--languages/ada/adasupport.hpp13
-rw-r--r--languages/ada/adasupportpart.cpp376
-rw-r--r--languages/ada/adasupportpart.h50
-rw-r--r--languages/ada/addclass.cpp351
-rw-r--r--languages/ada/addclass.h55
-rw-r--r--languages/ada/addclassdlg.ui434
-rw-r--r--languages/ada/app_templates/Makefile.am5
-rw-r--r--languages/ada/app_templates/ada.appwizard2
-rw-r--r--languages/ada/app_templates/adahello/.kdev_ignore0
-rw-r--r--languages/ada/app_templates/adahello/Makefile.am16
-rw-r--r--languages/ada/app_templates/adahello/ada-Makefile2
-rw-r--r--languages/ada/app_templates/adahello/ada-Makefile.am5
-rw-r--r--languages/ada/app_templates/adahello/ada-Makefile.cvs8
-rw-r--r--languages/ada/app_templates/adahello/adahello10
-rw-r--r--languages/ada/app_templates/adahello/adahello.kdevtemplate132
-rw-r--r--languages/ada/app_templates/adahello/adahello.pngbin0 -> 10118 bytes
-rw-r--r--languages/ada/app_templates/adahello/app.kdevelop84
-rw-r--r--languages/ada/app_templates/adahello/app.kdevelop.filelist1
-rw-r--r--languages/ada/app_templates/adahello/configure.in10
-rw-r--r--languages/ada/app_templates/adahello/main.adb8
-rw-r--r--languages/ada/app_templates/adahello/src-Makefile.am8
-rw-r--r--languages/ada/backgroundparser.cpp77
-rw-r--r--languages/ada/backgroundparser.h37
-rw-r--r--languages/ada/configproblemreporter.ui89
-rw-r--r--languages/ada/configproblemreporter.ui.h39
-rw-r--r--languages/ada/configure.in.in4
-rw-r--r--languages/ada/doc/Makefile.am6
-rw-r--r--languages/ada/doc/ada.toc130
-rw-r--r--languages/ada/doc/ada_bugs_gcc.toc7
-rw-r--r--languages/ada/file_templates/Makefile.am3
-rw-r--r--languages/ada/file_templates/adb12
-rw-r--r--languages/ada/file_templates/ads12
-rw-r--r--languages/ada/kdevadasupport.desktop87
-rw-r--r--languages/ada/kdevadasupport.rc11
-rw-r--r--languages/ada/preambles.h89
-rw-r--r--languages/ada/problemreporter.cpp282
-rw-r--r--languages/ada/problemreporter.h79
61 files changed, 41623 insertions, 0 deletions
diff --git a/languages/ada/AdaAST.hpp b/languages/ada/AdaAST.hpp
new file mode 100644
index 00000000..1bb2bd07
--- /dev/null
+++ b/languages/ada/AdaAST.hpp
@@ -0,0 +1,77 @@
+#ifndef ADAAST_HPP
+#define ADAAST_HPP
+
+#include <antlr/CommonAST.hpp>
+
+class AdaAST;
+typedef antlr::ASTRefCount<AdaAST> RefAdaAST;
+
+class AdaAST : public antlr::CommonAST {
+public:
+ AdaAST() : m_line (0), m_column (0) {}
+
+ ~AdaAST() {}
+
+ 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 std::string& txt) {
+ setType (t);
+ setText (txt);
+ m_line = 0;
+ m_column = 0;
+ }
+
+ RefAdaAST duplicate (void) const {
+ AdaAST *ast = new AdaAST (*this);
+ return RefAdaAST (ast);
+ }
+
+ void set (int t, const std::string& txt) {
+ setType (t);
+ setText (txt);
+ }
+
+ void addChild (RefAdaAST c) {
+ antlr::RefAST n( c.get() );
+ antlr::BaseAST::addChild (n);
+ }
+
+ RefAdaAST down () const {
+ return RefAdaAST (antlr::BaseAST::getFirstChild ());
+ }
+
+ RefAdaAST right () const {
+ return RefAdaAST (antlr::BaseAST::getNextSibling ());
+ }
+
+ /* bool equals(RefAdaAST t) const {
+ return ((antlr::BaseAST*)this)->equals (t);
+ } */
+
+ static antlr::RefAST factory (void) {
+ RefAdaAST n( new AdaAST );
+ return n.get();
+ }
+
+ static const RefAdaAST nullAdaAST;
+
+private:
+ int m_line;
+ int m_column;
+};
+
+#define Set(n, t) (n)->set(t, #t)
+// for Java compatibility:
+#define boolean bool
+
+#endif
diff --git a/languages/ada/AdaLexer.cpp b/languages/ada/AdaLexer.cpp
new file mode 100644
index 00000000..2ac19416
--- /dev/null
+++ b/languages/ada/AdaLexer.cpp
@@ -0,0 +1,1507 @@
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaLexer.cpp"$ */
+#include "AdaLexer.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 1531 "ada.g"
+
+#include "preambles.h"
+
+#line 16 "AdaLexer.cpp"
+AdaLexer::AdaLexer(ANTLR_USE_NAMESPACE(std)istream& in)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false)
+{
+ initLiterals();
+}
+
+AdaLexer::AdaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false)
+{
+ initLiterals();
+}
+
+AdaLexer::AdaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false)
+{
+ initLiterals();
+}
+
+void AdaLexer::initLiterals()
+{
+ literals["until"] = 78;
+ literals["xor"] = 86;
+ literals["abstract"] = 40;
+ literals["reverse"] = 71;
+ literals["use"] = 13;
+ literals["requeue"] = 84;
+ literals["with"] = 11;
+ literals["task"] = 42;
+ literals["at"] = 49;
+ literals["for"] = 47;
+ literals["else"] = 68;
+ literals["is"] = 23;
+ literals["of"] = 55;
+ literals["range"] = 16;
+ literals["and"] = 85;
+ literals["begin"] = 62;
+ literals["procedure"] = 24;
+ literals["separate"] = 39;
+ literals["private"] = 20;
+ literals["pragma"] = 4;
+ literals["delay"] = 77;
+ literals["abort"] = 80;
+ literals["function"] = 25;
+ literals["digits"] = 17;
+ literals["declare"] = 72;
+ literals["raise"] = 83;
+ literals["not"] = 87;
+ literals["record"] = 38;
+ literals["all"] = 30;
+ literals["in"] = 32;
+ literals["generic"] = 61;
+ literals["terminate"] = 82;
+ literals["subtype"] = 51;
+ literals["delta"] = 18;
+ literals["when"] = 58;
+ literals["null"] = 37;
+ literals["entry"] = 46;
+ literals["elsif"] = 67;
+ literals["case"] = 57;
+ literals["others"] = 27;
+ literals["do"] = 76;
+ literals["abs"] = 100;
+ literals["constant"] = 53;
+ literals["renames"] = 34;
+ literals["then"] = 66;
+ literals["exception"] = 52;
+ literals["protected"] = 43;
+ literals["accept"] = 75;
+ literals["or"] = 81;
+ literals["if"] = 65;
+ literals["aliased"] = 56;
+ literals["loop"] = 69;
+ literals["return"] = 41;
+ literals["limited"] = 60;
+ literals["new"] = 26;
+ literals["array"] = 54;
+ literals["rem"] = 99;
+ literals["end"] = 48;
+ literals["body"] = 22;
+ literals["mod"] = 50;
+ literals["goto"] = 74;
+ literals["tagged"] = 59;
+ literals["select"] = 79;
+ literals["while"] = 70;
+ literals["package"] = 21;
+ literals["type"] = 14;
+ literals["access"] = 19;
+ literals["out"] = 33;
+ literals["exit"] = 73;
+}
+
+ANTLR_USE_NAMESPACE(antlr)RefToken AdaLexer::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 0x7c /* '|' */ :
+ {
+ mPIPE(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x26 /* '&' */ :
+ {
+ mCONCAT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x2b /* '+' */ :
+ {
+ mPLUS(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x28 /* '(' */ :
+ {
+ mLPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x29 /* ')' */ :
+ {
+ mRPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x2c /* ',' */ :
+ {
+ mCOMMA(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x3b /* ';' */ :
+ {
+ mSEMI(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' */ :
+ {
+ mIDENTIFIER(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x27 /* '\'' */ :
+ {
+ mTIC_OR_CHARACTER_LITERAL(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x22 /* '\"' */ :
+ {
+ mCHAR_STRING(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' */ :
+ {
+ mNUMERIC_LIT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x9 /* '\t' */ :
+ case 0xa /* '\n' */ :
+ case 0xc /* '\14' */ :
+ case 0xd /* '\r' */ :
+ case 0x20 /* ' ' */ :
+ {
+ mWS_(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ default:
+ if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x2d /* '-' */ ) && ((LA(3) >= 0x3 /* '\3' */ && LA(3) <= 0xff))) {
+ mCOMMENT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x2d /* '-' */ ) && (true)) {
+ mCOMMENT_INTRO(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2e /* '.' */ ) && (LA(2) == 0x2e /* '.' */ )) {
+ mDOT_DOT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3c /* '<' */ )) {
+ mLT_LT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) {
+ mOX(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ )) {
+ mGT_GT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3e /* '>' */ )) {
+ mRIGHT_SHAFT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mNE(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) == 0x2a /* '*' */ ) && (LA(2) == 0x2a /* '*' */ )) {
+ mEXPON(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2e /* '.' */ ) && (true)) {
+ mDOT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3d /* '=' */ ) && (true)) {
+ mEQ(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (true)) {
+ mLT_(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (true)) {
+ mGT(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)) {
+ mDIV(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3a /* ':' */ ) && (true)) {
+ mCOLON(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 AdaLexer::mCOMMENT_INTRO(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = COMMENT_INTRO;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("--");
+#line 1888 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 345 "AdaLexer.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 AdaLexer::mDOT_DOT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DOT_DOT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("..");
+#line 1889 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 362 "AdaLexer.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 AdaLexer::mLT_LT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LT_LT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("<<");
+#line 1890 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 379 "AdaLexer.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 AdaLexer::mOX(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = OX;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("<>");
+#line 1891 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 396 "AdaLexer.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 AdaLexer::mGT_GT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = GT_GT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">>");
+#line 1892 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 413 "AdaLexer.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 AdaLexer::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(":=");
+#line 1893 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 430 "AdaLexer.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 AdaLexer::mRIGHT_SHAFT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = RIGHT_SHAFT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("=>");
+#line 1894 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 447 "AdaLexer.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 AdaLexer::mNE(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = NE;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("/=");
+#line 1895 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 464 "AdaLexer.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 AdaLexer::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("<=");
+#line 1896 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 481 "AdaLexer.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 AdaLexer::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(">=");
+#line 1897 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 498 "AdaLexer.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 AdaLexer::mEXPON(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = EXPON;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("**");
+#line 1898 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 515 "AdaLexer.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 AdaLexer::mPIPE(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = PIPE;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('|' /* charlit */ );
+#line 1899 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 532 "AdaLexer.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 AdaLexer::mCONCAT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = CONCAT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('&' /* charlit */ );
+#line 1900 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 549 "AdaLexer.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 AdaLexer::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 */ );
+#line 1901 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 566 "AdaLexer.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 AdaLexer::mEQ(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = EQ;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('=' /* charlit */ );
+#line 1902 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 583 "AdaLexer.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 AdaLexer::mLT_(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LT_;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('<' /* charlit */ );
+#line 1903 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 600 "AdaLexer.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 AdaLexer::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 */ );
+#line 1904 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 617 "AdaLexer.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 AdaLexer::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 */ );
+#line 1905 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 634 "AdaLexer.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 AdaLexer::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 */ );
+#line 1906 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 651 "AdaLexer.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 AdaLexer::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 */ );
+#line 1907 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 668 "AdaLexer.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 AdaLexer::mDIV(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DIV;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('/' /* charlit */ );
+#line 1908 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 685 "AdaLexer.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 AdaLexer::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 */ );
+#line 1909 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 702 "AdaLexer.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 AdaLexer::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 */ );
+#line 1910 "ada.g"
+ lastTokenWasTicCompatible=true;
+#line 719 "AdaLexer.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 AdaLexer::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 */ );
+#line 1911 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 736 "AdaLexer.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 AdaLexer::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 */ );
+#line 1912 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 753 "AdaLexer.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 AdaLexer::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 */ );
+#line 1913 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 770 "AdaLexer.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 AdaLexer::mIDENTIFIER(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = IDENTIFIER;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ matchRange('a','z');
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((_tokenSet_0.member(LA(1)))) {
+ {
+ switch ( LA(1)) {
+ case 0x5f /* '_' */ :
+ {
+ 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' */ :
+ 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' */ :
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ 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;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ }
+ else {
+ goto _loop512;
+ }
+
+ }
+ _loop512:;
+ } // ( ... )*
+ _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 AdaLexer::mTIC_OR_CHARACTER_LITERAL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = TIC_OR_CHARACTER_LITERAL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ _saveIndex = text.length();
+ match("\'");
+ text.erase(_saveIndex);
+#line 1927 "ada.g"
+ _ttype = TIC;
+#line 921 "AdaLexer.cpp"
+ {
+ if ((((LA(1) >= 0x3 /* '\3' */ && LA(1) <= 0xff)))&&( ! lastTokenWasTicCompatible )) {
+ matchNot(EOF/*_CHAR*/);
+ _saveIndex = text.length();
+ match("\'");
+ text.erase(_saveIndex);
+#line 1929 "ada.g"
+ _ttype = CHARACTER_LITERAL;
+#line 930 "AdaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+#line 1931 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 938 "AdaLexer.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 AdaLexer::mCHAR_STRING(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = CHAR_STRING;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ _saveIndex = text.length();
+ match('\"' /* charlit */ );
+ text.erase(_saveIndex);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == 0x22 /* '\"' */ ) && (LA(2) == 0x22 /* '\"' */ )) {
+ match("\"\"");
+ }
+ else if ((_tokenSet_1.member(LA(1)))) {
+ {
+ match(_tokenSet_1);
+ }
+ }
+ else {
+ goto _loop518;
+ }
+
+ }
+ _loop518:;
+ } // ( ... )*
+ _saveIndex = text.length();
+ match('\"' /* charlit */ );
+ text.erase(_saveIndex);
+#line 1934 "ada.g"
+ lastTokenWasTicCompatible=true;
+#line 977 "AdaLexer.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 AdaLexer::mNUMERIC_LIT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = NUMERIC_LIT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ { // ( ... )+
+ int _cnt521=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ mDIGIT(false);
+ }
+ else {
+ if ( _cnt521>=1 ) { goto _loop521; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt521++;
+ }
+ _loop521:;
+ } // ( ... )+
+ {
+ switch ( LA(1)) {
+ case 0x23 /* '#' */ :
+ {
+ match('#' /* charlit */ );
+ mBASED_INTEGER(false);
+ {
+ switch ( LA(1)) {
+ case 0x2e /* '.' */ :
+ {
+ match('.' /* charlit */ );
+ mBASED_INTEGER(false);
+ break;
+ }
+ case 0x23 /* '#' */ :
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ match('#' /* charlit */ );
+ break;
+ }
+ case 0x5f /* '_' */ :
+ {
+ { // ( ... )+
+ int _cnt527=0;
+ for (;;) {
+ if ((LA(1) == 0x5f /* '_' */ )) {
+ match('_' /* charlit */ );
+ { // ( ... )+
+ int _cnt526=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ mDIGIT(false);
+ }
+ else {
+ if ( _cnt526>=1 ) { goto _loop526; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt526++;
+ }
+ _loop526:;
+ } // ( ... )+
+ }
+ else {
+ if ( _cnt527>=1 ) { goto _loop527; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt527++;
+ }
+ _loop527:;
+ } // ( ... )+
+ break;
+ }
+ default:
+ {
+ }
+ }
+ }
+ {
+ if (((LA(1) == 0x2e /* '.' */ || LA(1) == 0x65 /* 'e' */ ))&&( LA(2)!='.' )) {
+ {
+ switch ( LA(1)) {
+ case 0x2e /* '.' */ :
+ {
+ match('.' /* charlit */ );
+ { // ( ... )+
+ int _cnt531=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ mDIGIT(false);
+ }
+ else {
+ if ( _cnt531>=1 ) { goto _loop531; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt531++;
+ }
+ _loop531:;
+ } // ( ... )+
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == 0x5f /* '_' */ )) {
+ match('_' /* charlit */ );
+ { // ( ... )+
+ int _cnt534=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ mDIGIT(false);
+ }
+ else {
+ if ( _cnt534>=1 ) { goto _loop534; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt534++;
+ }
+ _loop534:;
+ } // ( ... )+
+ }
+ else {
+ goto _loop535;
+ }
+
+ }
+ _loop535:;
+ } // ( ... )*
+ {
+ if ((LA(1) == 0x65 /* 'e' */ )) {
+ mEXPONENT(false);
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 0x65 /* 'e' */ :
+ {
+ mEXPONENT(false);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ }
+ else {
+ }
+
+ }
+#line 1945 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 1144 "AdaLexer.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 AdaLexer::mDIGIT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DIGIT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ matchRange('0','9');
+ }
+#line 1950 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 1163 "AdaLexer.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 AdaLexer::mBASED_INTEGER(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BASED_INTEGER;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ mEXTENDED_DIGIT(false);
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((_tokenSet_2.member(LA(1)))) {
+ {
+ switch ( LA(1)) {
+ case 0x5f /* '_' */ :
+ {
+ 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' */ :
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ mEXTENDED_DIGIT(false);
+ }
+ else {
+ goto _loop550;
+ }
+
+ }
+ _loop550:;
+ } // ( ... )*
+#line 1959 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 1226 "AdaLexer.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 AdaLexer::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 _cnt543=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ mDIGIT(false);
+ }
+ else {
+ if ( _cnt543>=1 ) { goto _loop543; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt543++;
+ }
+ _loop543:;
+ } // ( ... )+
+#line 1953 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 1290 "AdaLexer.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 AdaLexer::mEXTENDED_DIGIT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = EXTENDED_DIGIT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ 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' */ :
+ {
+ mDIGIT(false);
+ break;
+ }
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ {
+ matchRange('a','f');
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1956 "ada.g"
+ lastTokenWasTicCompatible=false;
+#line 1338 "AdaLexer.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 AdaLexer::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 1971 "ada.g"
+ newline();
+#line 1389 "AdaLexer.cpp"
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1973 "ada.g"
+ _ttype = antlr::Token::SKIP;
+#line 1400 "AdaLexer.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 AdaLexer::mCOMMENT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = COMMENT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ mCOMMENT_INTRO(false);
+ { // ( ... )*
+ for (;;) {
+ if ((_tokenSet_3.member(LA(1)))) {
+ {
+ match(_tokenSet_3);
+ }
+ }
+ else {
+ goto _loop557;
+ }
+
+ }
+ _loop557:;
+ } // ( ... )*
+ {
+ switch ( LA(1)) {
+ case 0xa /* '\n' */ :
+ {
+ match('\n' /* charlit */ );
+ break;
+ }
+ case 0xd /* '\r' */ :
+ {
+ match('\r' /* charlit */ );
+ {
+ if ((LA(1) == 0xa /* '\n' */ )) {
+ match('\n' /* charlit */ );
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1978 "ada.g"
+ _ttype = antlr::Token::SKIP;
+ newline();
+ lastTokenWasTicCompatible=false;
+#line 1459 "AdaLexer.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;
+}
+
+
+const unsigned long AdaLexer::_tokenSet_0_data_[] = { 0UL, 67043328UL, 2147483648UL, 134217726UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 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
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_0(_tokenSet_0_data_,10);
+const unsigned long AdaLexer::_tokenSet_1_data_[] = { 4294967288UL, 4294967291UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 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 0xbe 0xbf 0xc0 0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 0xc9
+// 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7
+// 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 0xe2 0xe3 0xe4 0xe5
+// 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef 0xf0 0xf1 0xf2 0xf3
+// 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_1(_tokenSet_1_data_,16);
+const unsigned long AdaLexer::_tokenSet_2_data_[] = { 0UL, 67043328UL, 2147483648UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0 1 2 3 4 5 6 7 8 9 _ a b c d e f
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_2(_tokenSet_2_data_,10);
+const unsigned long AdaLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 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 0xbe 0xbf 0xc0 0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 0xc9
+// 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7
+// 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 0xe2 0xe3 0xe4 0xe5
+// 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef 0xf0 0xf1 0xf2 0xf3
+// 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_3(_tokenSet_3_data_,16);
+
diff --git a/languages/ada/AdaLexer.hpp b/languages/ada/AdaLexer.hpp
new file mode 100644
index 00000000..795c7bba
--- /dev/null
+++ b/languages/ada/AdaLexer.hpp
@@ -0,0 +1,86 @@
+#ifndef INC_AdaLexer_hpp_
+#define INC_AdaLexer_hpp_
+
+#line 29 "ada.g"
+
+#include <antlr/SemanticException.hpp> // antlr wants this
+#include "AdaAST.hpp"
+#include "preambles.h"
+
+#line 11 "AdaLexer.hpp"
+#include <antlr/config.hpp>
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaLexer.hpp"$ */
+#include <antlr/CommonToken.hpp>
+#include <antlr/InputBuffer.hpp>
+#include <antlr/BitSet.hpp>
+#include "AdaTokenTypes.hpp"
+#include <antlr/CharScanner.hpp>
+class CUSTOM_API AdaLexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public AdaTokenTypes
+{
+#line 1879 "ada.g"
+
+ ANTLR_LEXER_PREAMBLE
+ private:
+ bool lastTokenWasTicCompatible;
+#line 22 "AdaLexer.hpp"
+private:
+ void initLiterals();
+public:
+ bool getCaseSensitiveLiterals() const
+ {
+ return false;
+ }
+public:
+ AdaLexer(ANTLR_USE_NAMESPACE(std)istream& in);
+ AdaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib);
+ AdaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state);
+ ANTLR_USE_NAMESPACE(antlr)RefToken nextToken();
+ public: void mCOMMENT_INTRO(bool _createToken);
+ public: void mDOT_DOT(bool _createToken);
+ public: void mLT_LT(bool _createToken);
+ public: void mOX(bool _createToken);
+ public: void mGT_GT(bool _createToken);
+ public: void mASSIGN(bool _createToken);
+ public: void mRIGHT_SHAFT(bool _createToken);
+ public: void mNE(bool _createToken);
+ public: void mLE(bool _createToken);
+ public: void mGE(bool _createToken);
+ public: void mEXPON(bool _createToken);
+ public: void mPIPE(bool _createToken);
+ public: void mCONCAT(bool _createToken);
+ public: void mDOT(bool _createToken);
+ public: void mEQ(bool _createToken);
+ public: void mLT_(bool _createToken);
+ public: void mGT(bool _createToken);
+ public: void mPLUS(bool _createToken);
+ public: void mMINUS(bool _createToken);
+ public: void mSTAR(bool _createToken);
+ public: void mDIV(bool _createToken);
+ public: void mLPAREN(bool _createToken);
+ public: void mRPAREN(bool _createToken);
+ public: void mCOLON(bool _createToken);
+ public: void mCOMMA(bool _createToken);
+ public: void mSEMI(bool _createToken);
+ public: void mIDENTIFIER(bool _createToken);
+ public: void mTIC_OR_CHARACTER_LITERAL(bool _createToken);
+ public: void mCHAR_STRING(bool _createToken);
+ public: void mNUMERIC_LIT(bool _createToken);
+ protected: void mDIGIT(bool _createToken);
+ protected: void mBASED_INTEGER(bool _createToken);
+ protected: void mEXPONENT(bool _createToken);
+ protected: void mEXTENDED_DIGIT(bool _createToken);
+ public: void mWS_(bool _createToken);
+ public: void mCOMMENT(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_AdaLexer_hpp_*/
diff --git a/languages/ada/AdaParser.cpp b/languages/ada/AdaParser.cpp
new file mode 100644
index 00000000..e783595e
--- /dev/null
+++ b/languages/ada/AdaParser.cpp
@@ -0,0 +1,12283 @@
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaParser.cpp"$ */
+#include "AdaParser.hpp"
+#include <antlr/NoViableAltException.hpp>
+#include <antlr/SemanticException.hpp>
+#include <antlr/ASTFactory.hpp>
+#line 1 "ada.g"
+#line 8 "AdaParser.cpp"
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
+{
+}
+
+AdaParser::AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
+{
+}
+
+void AdaParser::compilation_unit() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST compilation_unit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ context_items_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case GENERIC:
+ {
+ library_item();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEPARATE:
+ {
+ subunit();
+ 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) == PRAGMA)) {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop4;
+ }
+
+ }
+ _loop4:;
+ } // ( ... )*
+ compilation_unit_AST = RefAdaAST(currentAST.root);
+ returnAST = compilation_unit_AST;
+}
+
+void AdaParser::context_items_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST context_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case WITH:
+ {
+ with_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case USE:
+ {
+ use_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop14;
+ }
+ }
+ }
+ _loop14:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ context_items_opt_AST = RefAdaAST(currentAST.root);
+#line 86 "ada.g"
+ context_items_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CONTEXT_CLAUSE,"CONTEXT_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(context_items_opt_AST))));
+#line 135 "AdaParser.cpp"
+ currentAST.root = context_items_opt_AST;
+ if ( context_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ context_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = context_items_opt_AST->getFirstChild();
+ else
+ currentAST.child = context_items_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ context_items_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = context_items_opt_AST;
+}
+
+void AdaParser::library_item() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST library_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ private_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case PACKAGE:
+ {
+ lib_pkg_spec_or_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ subprog_decl_or_rename_or_inst_or_body(true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case GENERIC:
+ {
+ generic_decl(true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ library_item_AST = RefAdaAST(currentAST.root);
+#line 133 "ada.g"
+ library_item_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LIBRARY_ITEM,"LIBRARY_ITEM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(library_item_AST))));
+#line 194 "AdaParser.cpp"
+ currentAST.root = library_item_AST;
+ if ( library_item_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ library_item_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = library_item_AST->getFirstChild();
+ else
+ currentAST.child = library_item_AST;
+ currentAST.advanceChildToEnd();
+ }
+ library_item_AST = RefAdaAST(currentAST.root);
+ returnAST = library_item_AST;
+}
+
+void AdaParser::subunit() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subunit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken sep = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST sep_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ sep = LT(1);
+ if ( inputState->guessing == 0 ) {
+ sep_AST = astFactory->create(sep);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sep_AST));
+ }
+ match(SEPARATE);
+ match(LPAREN);
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 1497 "ada.g"
+ Set(sep_AST, SUBUNIT);
+#line 229 "AdaParser.cpp"
+ }
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ subprogram_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PACKAGE:
+ {
+ package_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case TASK:
+ {
+ task_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROTECTED:
+ {
+ protected_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subunit_AST = RefAdaAST(currentAST.root);
+ returnAST = subunit_AST;
+}
+
+void AdaParser::pragma() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST pragma_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp3_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp3_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST));
+ }
+ match(PRAGMA);
+ RefAdaAST tmp4_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp4_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST));
+ }
+ match(IDENTIFIER);
+ pragma_args_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ pragma_AST = RefAdaAST(currentAST.root);
+ returnAST = pragma_AST;
+}
+
+void AdaParser::pragma_args_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST pragma_args_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ pragma_arg();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ pragma_arg();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop9;
+ }
+
+ }
+ _loop9:;
+ } // ( ... )*
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ pragma_args_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = pragma_args_opt_AST;
+}
+
+void AdaParser::pragma_arg() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST pragma_arg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) {
+ RefAdaAST tmp9_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp9_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST));
+ }
+ match(IDENTIFIER);
+ RefAdaAST tmp10_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp10_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST));
+ }
+ match(RIGHT_SHAFT);
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ pragma_arg_AST = RefAdaAST(currentAST.root);
+ returnAST = pragma_arg_AST;
+}
+
+void AdaParser::expression() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken o = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST o_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ relation();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case AND:
+ {
+ a = LT(1);
+ if ( inputState->guessing == 0 ) {
+ a_AST = astFactory->create(a);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+ }
+ match(AND);
+ {
+ switch ( LA(1)) {
+ case THEN:
+ {
+ match(THEN);
+ if ( inputState->guessing==0 ) {
+#line 1417 "ada.g"
+ Set (a_AST, AND_THEN);
+#line 416 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relation();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case OR:
+ {
+ o = LT(1);
+ if ( inputState->guessing == 0 ) {
+ o_AST = astFactory->create(o);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST));
+ }
+ match(OR);
+ {
+ switch ( LA(1)) {
+ case ELSE:
+ {
+ match(ELSE);
+ if ( inputState->guessing==0 ) {
+#line 1418 "ada.g"
+ Set (o_AST, OR_ELSE);
+#line 462 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relation();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case XOR:
+ {
+ RefAdaAST tmp13_AST = RefAdaAST(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(XOR);
+ relation();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop450;
+ }
+ }
+ }
+ _loop450:;
+ } // ( ... )*
+ expression_AST = RefAdaAST(currentAST.root);
+ returnAST = expression_AST;
+}
+
+void AdaParser::with_clause() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST with_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ w = LT(1);
+ if ( inputState->guessing == 0 ) {
+ w_AST = astFactory->create(w);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+ }
+ match(WITH);
+ c_name_list();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 94 "ada.g"
+ Set(w_AST, WITH_CLAUSE);
+#line 539 "AdaParser.cpp"
+ }
+ with_clause_AST = RefAdaAST(currentAST.root);
+ returnAST = with_clause_AST;
+}
+
+void AdaParser::use_clause() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST use_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken u = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST u_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ u = LT(1);
+ if ( inputState->guessing == 0 ) {
+ u_AST = astFactory->create(u);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(u_AST));
+ }
+ match(USE);
+ {
+ switch ( LA(1)) {
+ case TYPE:
+ {
+ match(TYPE);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop25;
+ }
+
+ }
+ _loop25:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+#line 108 "ada.g"
+ Set(u_AST, USE_TYPE_CLAUSE);
+#line 586 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ c_name_list();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 109 "ada.g"
+ Set(u_AST, USE_CLAUSE);
+#line 599 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ use_clause_AST = RefAdaAST(currentAST.root);
+ returnAST = use_clause_AST;
+}
+
+void AdaParser::c_name_list() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST c_name_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop18;
+ }
+
+ }
+ _loop18:;
+ } // ( ... )*
+ c_name_list_AST = RefAdaAST(currentAST.root);
+ returnAST = c_name_list_AST;
+}
+
+void AdaParser::compound_name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST compound_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp19_AST = RefAdaAST(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(IDENTIFIER);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == DOT)) {
+ RefAdaAST tmp20_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp20_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST));
+ }
+ match(DOT);
+ RefAdaAST tmp21_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp21_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST));
+ }
+ match(IDENTIFIER);
+ }
+ else {
+ goto _loop21;
+ }
+
+ }
+ _loop21:;
+ } // ( ... )*
+ compound_name_AST = RefAdaAST(currentAST.root);
+ returnAST = compound_name_AST;
+}
+
+void AdaParser::subtype_mark() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subtype_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case TIC:
+ {
+ RefAdaAST tmp22_AST = RefAdaAST(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(TIC);
+ attribute_id();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case LPAREN:
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case USE:
+ case RANGE:
+ case DIGITS:
+ case DELTA:
+ case IS:
+ case PIPE:
+ case DOT_DOT:
+ case RENAMES:
+ case ASSIGN:
+ case AT:
+ case THEN:
+ case LOOP:
+ case OR:
+ case AND:
+ case XOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subtype_mark_AST = RefAdaAST(currentAST.root);
+ returnAST = subtype_mark_AST;
+}
+
+void AdaParser::attribute_id() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST attribute_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case RANGE:
+ {
+ RefAdaAST tmp23_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp23_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST));
+ }
+ match(RANGE);
+ attribute_id_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case DIGITS:
+ {
+ RefAdaAST tmp24_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp24_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
+ }
+ match(DIGITS);
+ attribute_id_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case DELTA:
+ {
+ RefAdaAST tmp25_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp25_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST));
+ }
+ match(DELTA);
+ attribute_id_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case ACCESS:
+ {
+ RefAdaAST tmp26_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp26_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST));
+ }
+ match(ACCESS);
+ attribute_id_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp27_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp27_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST));
+ }
+ match(IDENTIFIER);
+ attribute_id_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = attribute_id_AST;
+}
+
+void AdaParser::private_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ RefAdaAST tmp28_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp28_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST));
+ }
+ match(PRIVATE);
+ break;
+ }
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case GENERIC:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ private_opt_AST = RefAdaAST(currentAST.root);
+#line 137 "ada.g"
+ private_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_opt_AST))));
+#line 843 "AdaParser.cpp"
+ currentAST.root = private_opt_AST;
+ if ( private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = private_opt_AST->getFirstChild();
+ else
+ currentAST.child = private_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ private_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = private_opt_AST;
+}
+
+void AdaParser::lib_pkg_spec_or_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST lib_pkg_spec_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ pkg = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pkg_AST = astFactory->create(pkg);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+ }
+ match(PACKAGE);
+ {
+ switch ( LA(1)) {
+ case BODY:
+ {
+ match(BODY);
+ def_id(true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ pkg_body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 143 "ada.g"
+ Set(pkg_AST, PACKAGE_BODY);
+#line 887 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ def_id(true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ spec_decl_part(pkg_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ lib_pkg_spec_or_body_AST = RefAdaAST(currentAST.root);
+ returnAST = lib_pkg_spec_or_body_AST;
+}
+
+void AdaParser::subprog_decl_or_rename_or_inst_or_body(
+ boolean lib_level
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 944 "ada.g"
+ RefAdaAST t;
+#line 925 "AdaParser.cpp"
+
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROCEDURE);
+ def_id(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ if ((LA(1) == IS) && (LA(2) == NEW)) {
+ generic_subp_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 948 "ada.g"
+ Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
+#line 949 "AdaParser.cpp"
+ }
+ }
+ else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 950 "ada.g"
+ Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
+#line 968 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IS:
+ {
+ match(IS);
+ {
+ switch ( LA(1)) {
+ case SEPARATE:
+ case ABSTRACT:
+ {
+ separate_or_abstract(p_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ case BEGIN:
+ {
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 952 "ada.g"
+ Set(p_AST, PROCEDURE_BODY);
+#line 1007 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 954 "ada.g"
+ pop_def_id();
+ Set(p_AST, PROCEDURE_DECLARATION);
+#line 1025 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ f = LT(1);
+ if ( inputState->guessing == 0 ) {
+ f_AST = astFactory->create(f);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+ }
+ match(FUNCTION);
+ def_designator(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ generic_subp_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 961 "ada.g"
+ Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
+#line 1068 "AdaParser.cpp"
+ }
+ break;
+ }
+ case LPAREN:
+ case RETURN:
+ {
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 963 "ada.g"
+ Set(f_AST, FUNCTION_RENAMING_DECLARATION);
+#line 1090 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IS:
+ {
+ match(IS);
+ {
+ switch ( LA(1)) {
+ case SEPARATE:
+ case ABSTRACT:
+ {
+ separate_or_abstract(f_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ case BEGIN:
+ {
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 965 "ada.g"
+ Set(f_AST, FUNCTION_BODY);
+#line 1129 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 967 "ada.g"
+ pop_def_id();
+ Set(f_AST, FUNCTION_DECLARATION);
+#line 1147 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = subprog_decl_or_rename_or_inst_or_body_AST;
+}
+
+void AdaParser::generic_decl(
+ boolean lib_level
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST generic_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken g = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST g_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ g = LT(1);
+ if ( inputState->guessing == 0 ) {
+ g_AST = astFactory->create(g);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(g_AST));
+ }
+ match(GENERIC);
+ generic_formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case PACKAGE:
+ {
+ match(PACKAGE);
+ def_id(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 865 "ada.g"
+ Set(g_AST, GENERIC_PACKAGE_RENAMING);
+#line 1216 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IS:
+ {
+ match(IS);
+ pkg_spec_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 866 "ada.g"
+ Set(g_AST, GENERIC_PACKAGE_DECLARATION);
+#line 1230 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case PROCEDURE:
+ {
+ match(PROCEDURE);
+ def_id(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 869 "ada.g"
+ Set(g_AST, GENERIC_PROCEDURE_RENAMING);
+#line 1264 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 872 "ada.g"
+ Set(g_AST, GENERIC_PROCEDURE_DECLARATION); pop_def_id();
+#line 1273 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case FUNCTION:
+ {
+ match(FUNCTION);
+ def_designator(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 875 "ada.g"
+ Set(g_AST, GENERIC_FUNCTION_RENAMING);
+#line 1307 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 878 "ada.g"
+ Set(g_AST, GENERIC_FUNCTION_DECLARATION); pop_def_id();
+#line 1316 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ generic_decl_AST = RefAdaAST(currentAST.root);
+ returnAST = generic_decl_AST;
+}
+
+void AdaParser::def_id(
+ boolean lib_level
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST def_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST cn_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if (((LA(1) == IDENTIFIER) && (_tokenSet_4.member(LA(2))))&&( lib_level )) {
+ compound_name();
+ if (inputState->guessing==0) {
+ cn_AST = returnAST;
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 171 "ada.g"
+ push_def_id(cn_AST);
+#line 1358 "AdaParser.cpp"
+ }
+ def_id_AST = RefAdaAST(currentAST.root);
+ }
+ else if (((LA(1) == IDENTIFIER) && (_tokenSet_5.member(LA(2))))&&( !lib_level )) {
+ n = LT(1);
+ if ( inputState->guessing == 0 ) {
+ n_AST = astFactory->create(n);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+ }
+ match(IDENTIFIER);
+ if ( inputState->guessing==0 ) {
+#line 172 "ada.g"
+ push_def_id(n_AST);
+#line 1372 "AdaParser.cpp"
+ }
+ def_id_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = def_id_AST;
+}
+
+void AdaParser::pkg_body_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST pkg_body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ declarative_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ block_body_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ pkg_body_part_AST = RefAdaAST(currentAST.root);
+ returnAST = pkg_body_part_AST;
+}
+
+void AdaParser::spec_decl_part(
+ RefAdaAST pkg
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST spec_decl_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ {
+ switch ( LA(1)) {
+ case NEW:
+ {
+ generic_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 364 "ada.g"
+ Set(pkg, GENERIC_PACKAGE_INSTANTIATION);
+#line 1427 "AdaParser.cpp"
+ }
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PRIVATE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case END:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ pkg_spec_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 365 "ada.g"
+ Set(pkg, PACKAGE_SPECIFICATION);
+#line 1453 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 367 "ada.g"
+ Set(pkg, PACKAGE_RENAMING_DECLARATION);
+#line 1474 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ spec_decl_part_AST = RefAdaAST(currentAST.root);
+ returnAST = spec_decl_part_AST;
+}
+
+void AdaParser::subprog_decl(
+ boolean lib_level
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subprog_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 148 "ada.g"
+ RefAdaAST t;
+#line 1501 "AdaParser.cpp"
+
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROCEDURE);
+ def_id(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ if ((LA(1) == IS) && (LA(2) == NEW)) {
+ generic_subp_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 152 "ada.g"
+ Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
+#line 1525 "AdaParser.cpp"
+ }
+ }
+ else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 154 "ada.g"
+ Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
+#line 1544 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ case IS:
+ {
+ is_separate_or_abstract_or_decl(p_AST);
+ 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);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ subprog_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ f = LT(1);
+ if ( inputState->guessing == 0 ) {
+ f_AST = astFactory->create(f);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+ }
+ match(FUNCTION);
+ def_designator(lib_level);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ generic_subp_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 161 "ada.g"
+ Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
+#line 1596 "AdaParser.cpp"
+ }
+ break;
+ }
+ case LPAREN:
+ case RETURN:
+ {
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RENAMES:
+ {
+ renames();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 163 "ada.g"
+ Set(f_AST, FUNCTION_RENAMING_DECLARATION);
+#line 1618 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ case IS:
+ {
+ is_separate_or_abstract_or_decl(f_AST);
+ 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);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subprog_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = subprog_decl_AST;
+}
+
+void AdaParser::generic_subp_inst() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST generic_subp_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(IS);
+ generic_inst();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ generic_subp_inst_AST = RefAdaAST(currentAST.root);
+ returnAST = generic_subp_inst_AST;
+}
+
+void AdaParser::formal_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ parameter_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ parameter_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop70;
+ }
+
+ }
+ _loop70:;
+ } // ( ... )*
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ case IS:
+ case RENAMES:
+ case WHEN:
+ case DO:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 235 "ada.g"
+ formal_part_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(formal_part_opt_AST))));
+#line 1723 "AdaParser.cpp"
+ currentAST.root = formal_part_opt_AST;
+ if ( formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = formal_part_opt_AST->getFirstChild();
+ else
+ currentAST.child = formal_part_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ formal_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = formal_part_opt_AST;
+}
+
+void AdaParser::renames() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST renames_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 258 "ada.g"
+ RefAdaAST dummy;
+#line 1742 "AdaParser.cpp"
+
+ match(RENAMES);
+ {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CHAR_STRING:
+ {
+ dummy=definable_operator_symbol();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 262 "ada.g"
+ pop_def_id();
+#line 1772 "AdaParser.cpp"
+ }
+ renames_AST = RefAdaAST(currentAST.root);
+ returnAST = renames_AST;
+}
+
+void AdaParser::is_separate_or_abstract_or_decl(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST is_separate_or_abstract_or_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ separate_or_abstract(t);
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 305 "ada.g"
+ pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, PROCEDURE_DECLARATION);
+ else
+ Set(t, FUNCTION_DECLARATION);
+
+#line 1802 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = is_separate_or_abstract_or_decl_AST;
+}
+
+void AdaParser::def_designator(
+ boolean lib_level
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST def_designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 330 "ada.g"
+ RefAdaAST d;
+#line 1823 "AdaParser.cpp"
+
+ if (((LA(1) == IDENTIFIER) && (_tokenSet_7.member(LA(2))))&&( lib_level )) {
+ compound_name();
+ if (inputState->guessing==0) {
+ n_AST = returnAST;
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 332 "ada.g"
+ push_def_id(n_AST);
+#line 1834 "AdaParser.cpp"
+ }
+ def_designator_AST = RefAdaAST(currentAST.root);
+ }
+ else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) {
+ d=designator();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 333 "ada.g"
+ push_def_id(d);
+#line 1846 "AdaParser.cpp"
+ }
+ def_designator_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = def_designator_AST;
+}
+
+void AdaParser::function_tail() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST function_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ func_formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RETURN);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail_AST = RefAdaAST(currentAST.root);
+ returnAST = function_tail_AST;
+}
+
+void AdaParser::generic_inst() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST generic_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(NEW);
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ value_s();
+ 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());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 179 "ada.g"
+ pop_def_id();
+#line 1910 "AdaParser.cpp"
+ }
+ generic_inst_AST = RefAdaAST(currentAST.root);
+ returnAST = generic_inst_AST;
+}
+
+void AdaParser::value_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST value_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ value();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ value();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop445;
+ }
+
+ }
+ _loop445:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ value_s_AST = RefAdaAST(currentAST.root);
+#line 1405 "ada.g"
+ value_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VALUES,"VALUES")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(value_s_AST))));
+#line 1945 "AdaParser.cpp"
+ currentAST.root = value_s_AST;
+ if ( value_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ value_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = value_s_AST->getFirstChild();
+ else
+ currentAST.child = value_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ value_s_AST = RefAdaAST(currentAST.root);
+ returnAST = value_s_AST;
+}
+
+void AdaParser::parenth_values() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST parenth_values_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(LPAREN);
+ value();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ value();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop46;
+ }
+
+ }
+ _loop46:;
+ } // ( ... )*
+ match(RPAREN);
+ parenth_values_AST = RefAdaAST(currentAST.root);
+ returnAST = parenth_values_AST;
+}
+
+void AdaParser::value() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST value_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case OTHERS:
+ {
+ RefAdaAST tmp60_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp60_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp60_AST));
+ }
+ match(OTHERS);
+ match(RIGHT_SHAFT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ ranged_expr_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RIGHT_SHAFT:
+ {
+ RefAdaAST tmp62_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp62_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp62_AST));
+ }
+ match(RIGHT_SHAFT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case COMMA:
+ case RPAREN:
+ case WITH:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ value_AST = RefAdaAST(currentAST.root);
+ returnAST = value_AST;
+}
+
+void AdaParser::ranged_expr_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST ranged_expr_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ ranged_expr();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PIPE)) {
+ RefAdaAST tmp63_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp63_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp63_AST));
+ }
+ match(PIPE);
+ ranged_expr();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop52;
+ }
+
+ }
+ _loop52:;
+ } // ( ... )*
+ ranged_expr_s_AST = RefAdaAST(currentAST.root);
+ returnAST = ranged_expr_s_AST;
+}
+
+void AdaParser::ranged_expr() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST ranged_expr_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case DOT_DOT:
+ {
+ RefAdaAST tmp64_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp64_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp64_AST));
+ }
+ match(DOT_DOT);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RANGE:
+ {
+ RefAdaAST tmp65_AST = RefAdaAST(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(RANGE);
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case PIPE:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ ranged_expr_AST = RefAdaAST(currentAST.root);
+ returnAST = ranged_expr_AST;
+}
+
+void AdaParser::simple_expression() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST simple_expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ signed_term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ RefAdaAST tmp66_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp66_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp66_AST));
+ }
+ match(PLUS);
+ signed_term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case MINUS:
+ {
+ RefAdaAST tmp67_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp67_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST));
+ }
+ match(MINUS);
+ signed_term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CONCAT:
+ {
+ RefAdaAST tmp68_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp68_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp68_AST));
+ }
+ match(CONCAT);
+ signed_term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop458;
+ }
+ }
+ }
+ _loop458:;
+ } // ( ... )*
+ simple_expression_AST = RefAdaAST(currentAST.root);
+ returnAST = simple_expression_AST;
+}
+
+void AdaParser::range() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched59 = false;
+ if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+ int _m59 = mark();
+ synPredMatched59 = true;
+ inputState->guessing++;
+ try {
+ {
+ range_dots();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched59 = false;
+ }
+ rewind(_m59);
+ inputState->guessing--;
+ }
+ if ( synPredMatched59 ) {
+ range_dots();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) {
+ range_attrib_ref();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ range_AST = RefAdaAST(currentAST.root);
+ returnAST = range_AST;
+}
+
+void AdaParser::range_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(RANGE);
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 203 "ada.g"
+ Set(r_AST, RANGE_CONSTRAINT);
+#line 2287 "AdaParser.cpp"
+ }
+ range_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = range_constraint_AST;
+}
+
+void AdaParser::range_dots() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_dots_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ RefAdaAST tmp69_AST = RefAdaAST(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(DOT_DOT);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_dots_AST = RefAdaAST(currentAST.root);
+ returnAST = range_dots_AST;
+}
+
+void AdaParser::range_attrib_ref() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_attrib_ref_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ prefix();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(TIC);
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(RANGE);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case RANGE:
+ case DIGITS:
+ case IS:
+ case PIPE:
+ case DOT_DOT:
+ case ASSIGN:
+ case THEN:
+ case LOOP:
+ case OR:
+ case AND:
+ case XOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 219 "ada.g"
+ Set(r_AST, RANGE_ATTRIBUTE_REFERENCE);
+#line 2374 "AdaParser.cpp"
+ }
+ range_attrib_ref_AST = RefAdaAST(currentAST.root);
+ returnAST = range_attrib_ref_AST;
+}
+
+void AdaParser::prefix() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prefix_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp73_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp73_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST));
+ }
+ match(IDENTIFIER);
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ RefAdaAST tmp74_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp74_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp74_AST));
+ }
+ match(DOT);
+ {
+ switch ( LA(1)) {
+ case ALL:
+ {
+ RefAdaAST tmp75_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp75_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp75_AST));
+ }
+ match(ALL);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp76_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp76_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp76_AST));
+ }
+ match(IDENTIFIER);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case LPAREN:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(LPAREN);
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 228 "ada.g"
+ Set(p_AST, INDEXED_COMPONENT);
+#line 2450 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop66;
+ }
+ }
+ }
+ _loop66:;
+ } // ( ... )*
+ prefix_AST = RefAdaAST(currentAST.root);
+ returnAST = prefix_AST;
+}
+
+void AdaParser::parameter_specification() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST parameter_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ def_ids_colon();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ mode_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ parameter_specification_AST = RefAdaAST(currentAST.root);
+#line 240 "ada.g"
+ parameter_specification_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(parameter_specification_AST))));
+#line 2492 "AdaParser.cpp"
+ currentAST.root = parameter_specification_AST;
+ if ( parameter_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ parameter_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = parameter_specification_AST->getFirstChild();
+ else
+ currentAST.child = parameter_specification_AST;
+ currentAST.advanceChildToEnd();
+ }
+ parameter_specification_AST = RefAdaAST(currentAST.root);
+ returnAST = parameter_specification_AST;
+}
+
+void AdaParser::def_ids_colon() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST def_ids_colon_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ defining_identifier_list();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ def_ids_colon_AST = RefAdaAST(currentAST.root);
+ returnAST = def_ids_colon_AST;
+}
+
+void AdaParser::mode_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST mode_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case IN:
+ {
+ RefAdaAST tmp79_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp79_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp79_AST));
+ }
+ match(IN);
+ {
+ switch ( LA(1)) {
+ case OUT:
+ {
+ RefAdaAST tmp80_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp80_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST));
+ }
+ match(OUT);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case OUT:
+ {
+ RefAdaAST tmp81_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp81_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp81_AST));
+ }
+ match(OUT);
+ break;
+ }
+ case ACCESS:
+ {
+ RefAdaAST tmp82_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp82_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp82_AST));
+ }
+ match(ACCESS);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ mode_opt_AST = RefAdaAST(currentAST.root);
+#line 255 "ada.g"
+ mode_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mode_opt_AST))));
+#line 2592 "AdaParser.cpp"
+ currentAST.root = mode_opt_AST;
+ if ( mode_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ mode_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = mode_opt_AST->getFirstChild();
+ else
+ currentAST.child = mode_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ mode_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = mode_opt_AST;
+}
+
+void AdaParser::init_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST init_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ match(ASSIGN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ init_opt_AST = RefAdaAST(currentAST.root);
+#line 468 "ada.g"
+ init_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INIT_OPT,"INIT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(init_opt_AST))));
+#line 2636 "AdaParser.cpp"
+ currentAST.root = init_opt_AST;
+ if ( init_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ init_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = init_opt_AST->getFirstChild();
+ else
+ currentAST.child = init_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ init_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = init_opt_AST;
+}
+
+void AdaParser::defining_identifier_list() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST defining_identifier_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp84_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp84_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp84_AST));
+ }
+ match(IDENTIFIER);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ RefAdaAST tmp86_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp86_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp86_AST));
+ }
+ match(IDENTIFIER);
+ }
+ else {
+ goto _loop75;
+ }
+
+ }
+ _loop75:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ defining_identifier_list_AST = RefAdaAST(currentAST.root);
+#line 249 "ada.g"
+ defining_identifier_list_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFINING_IDENTIFIER_LIST,"DEFINING_IDENTIFIER_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(defining_identifier_list_AST))));
+#line 2683 "AdaParser.cpp"
+ currentAST.root = defining_identifier_list_AST;
+ if ( defining_identifier_list_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ defining_identifier_list_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = defining_identifier_list_AST->getFirstChild();
+ else
+ currentAST.child = defining_identifier_list_AST;
+ currentAST.advanceChildToEnd();
+ }
+ defining_identifier_list_AST = RefAdaAST(currentAST.root);
+ returnAST = defining_identifier_list_AST;
+}
+
+void AdaParser::name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 265 "ada.g"
+ RefAdaAST dummy;
+#line 2704 "AdaParser.cpp"
+
+ RefAdaAST tmp87_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp87_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp87_AST));
+ }
+ match(IDENTIFIER);
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ RefAdaAST tmp88_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp88_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp88_AST));
+ }
+ match(DOT);
+ {
+ switch ( LA(1)) {
+ case ALL:
+ {
+ RefAdaAST tmp89_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp89_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp89_AST));
+ }
+ match(ALL);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp90_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp90_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp90_AST));
+ }
+ match(IDENTIFIER);
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp91_AST = RefAdaAST(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(CHARACTER_LITERAL);
+ break;
+ }
+ case CHAR_STRING:
+ {
+ dummy=is_operator();
+ 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 LPAREN:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(LPAREN);
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 273 "ada.g"
+ Set(p_AST, INDEXED_COMPONENT);
+#line 2787 "AdaParser.cpp"
+ }
+ break;
+ }
+ case TIC:
+ {
+ RefAdaAST tmp93_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp93_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp93_AST));
+ }
+ match(TIC);
+ attribute_id();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop84;
+ }
+ }
+ }
+ _loop84:;
+ } // ( ... )*
+ name_AST = RefAdaAST(currentAST.root);
+ returnAST = name_AST;
+}
+
+RefAdaAST AdaParser::definable_operator_symbol() {
+#line 285 "ada.g"
+ RefAdaAST d;
+#line 2820 "AdaParser.cpp"
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST definable_operator_symbol_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if (!( definable_operator(LT(1)->getText().c_str()) ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" definable_operator(LT(1)->getText().c_str()) ");
+ op = LT(1);
+ if ( inputState->guessing == 0 ) {
+ op_AST = astFactory->create(op);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST));
+ }
+ match(CHAR_STRING);
+ if ( inputState->guessing==0 ) {
+#line 287 "ada.g"
+ op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
+#line 2838 "AdaParser.cpp"
+ }
+ definable_operator_symbol_AST = RefAdaAST(currentAST.root);
+ returnAST = definable_operator_symbol_AST;
+ return d;
+}
+
+RefAdaAST AdaParser::is_operator() {
+#line 280 "ada.g"
+ RefAdaAST d;
+#line 2848 "AdaParser.cpp"
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST is_operator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if (!( is_operator_symbol(LT(1)->getText().c_str()) ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(LT(1)->getText().c_str()) ");
+ op = LT(1);
+ if ( inputState->guessing == 0 ) {
+ op_AST = astFactory->create(op);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST));
+ }
+ match(CHAR_STRING);
+ if ( inputState->guessing==0 ) {
+#line 282 "ada.g"
+ op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
+#line 2866 "AdaParser.cpp"
+ }
+ is_operator_AST = RefAdaAST(currentAST.root);
+ returnAST = is_operator_AST;
+ return d;
+}
+
+void AdaParser::parenthesized_primary() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST parenthesized_primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pp = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pp_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ pp = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pp_AST = astFactory->create(pp);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pp_AST));
+ }
+ match(LPAREN);
+ {
+ if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
+ RefAdaAST tmp94_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp94_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp94_AST));
+ }
+ match(NuLL);
+ match(RECORD);
+ }
+ else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ extension_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 295 "ada.g"
+ Set(pp_AST, PARENTHESIZED_PRIMARY);
+#line 2915 "AdaParser.cpp"
+ }
+ parenthesized_primary_AST = RefAdaAST(currentAST.root);
+ returnAST = parenthesized_primary_AST;
+}
+
+void AdaParser::extension_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST extension_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case WITH:
+ {
+ match(WITH);
+ {
+ if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
+ RefAdaAST tmp98_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp98_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp98_AST));
+ }
+ match(NuLL);
+ match(RECORD);
+ }
+ else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ break;
+ }
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ extension_opt_AST = RefAdaAST(currentAST.root);
+#line 299 "ada.g"
+ extension_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTENSION_OPT,"EXTENSION_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(extension_opt_AST))));
+#line 2969 "AdaParser.cpp"
+ currentAST.root = extension_opt_AST;
+ if ( extension_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ extension_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = extension_opt_AST->getFirstChild();
+ else
+ currentAST.child = extension_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ extension_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = extension_opt_AST;
+}
+
+void AdaParser::separate_or_abstract(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST separate_or_abstract_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case SEPARATE:
+ {
+ match(SEPARATE);
+ if ( inputState->guessing==0 ) {
+#line 315 "ada.g"
+ pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, PROCEDURE_BODY_STUB);
+ else
+ Set(t, FUNCTION_BODY_STUB);
+
+#line 3001 "AdaParser.cpp"
+ }
+ break;
+ }
+ case ABSTRACT:
+ {
+ match(ABSTRACT);
+ if ( inputState->guessing==0 ) {
+#line 322 "ada.g"
+ pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, ABSTRACT_PROCEDURE_DECLARATION);
+ else
+ Set(t, ABSTRACT_FUNCTION_DECLARATION);
+
+#line 3016 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = separate_or_abstract_AST;
+}
+
+RefAdaAST AdaParser::designator() {
+#line 336 "ada.g"
+ RefAdaAST d;
+#line 3031 "AdaParser.cpp"
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 336 "ada.g"
+ RefAdaAST op;
+#line 3039 "AdaParser.cpp"
+
+ switch ( LA(1)) {
+ case CHAR_STRING:
+ {
+ op=definable_operator_symbol();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 338 "ada.g"
+ d = op;
+#line 3051 "AdaParser.cpp"
+ }
+ designator_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ n = LT(1);
+ if ( inputState->guessing == 0 ) {
+ n_AST = astFactory->create(n);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+ }
+ match(IDENTIFIER);
+ if ( inputState->guessing==0 ) {
+#line 339 "ada.g"
+ d = n_AST;
+#line 3067 "AdaParser.cpp"
+ }
+ designator_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = designator_AST;
+ return d;
+}
+
+void AdaParser::func_formal_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST func_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ func_param();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ func_param();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop100;
+ }
+
+ }
+ _loop100:;
+ } // ( ... )*
+ match(RPAREN);
+ break;
+ }
+ case RETURN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ func_formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 348 "ada.g"
+ func_formal_part_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_formal_part_opt_AST))));
+#line 3129 "AdaParser.cpp"
+ currentAST.root = func_formal_part_opt_AST;
+ if ( func_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ func_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = func_formal_part_opt_AST->getFirstChild();
+ else
+ currentAST.child = func_formal_part_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ func_formal_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = func_formal_part_opt_AST;
+}
+
+void AdaParser::func_param() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST func_param_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ def_ids_colon();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ in_access_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ func_param_AST = RefAdaAST(currentAST.root);
+#line 354 "ada.g"
+ func_param_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_param_AST))));
+#line 3168 "AdaParser.cpp"
+ currentAST.root = func_param_AST;
+ if ( func_param_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ func_param_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = func_param_AST->getFirstChild();
+ else
+ currentAST.child = func_param_AST;
+ currentAST.advanceChildToEnd();
+ }
+ func_param_AST = RefAdaAST(currentAST.root);
+ returnAST = func_param_AST;
+}
+
+void AdaParser::in_access_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST in_access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case IN:
+ {
+ RefAdaAST tmp105_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp105_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp105_AST));
+ }
+ match(IN);
+ break;
+ }
+ case ACCESS:
+ {
+ RefAdaAST tmp106_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp106_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp106_AST));
+ }
+ match(ACCESS);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ in_access_opt_AST = RefAdaAST(currentAST.root);
+#line 360 "ada.g"
+ in_access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(in_access_opt_AST))));
+#line 3222 "AdaParser.cpp"
+ currentAST.root = in_access_opt_AST;
+ if ( in_access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ in_access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = in_access_opt_AST->getFirstChild();
+ else
+ currentAST.child = in_access_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ in_access_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = in_access_opt_AST;
+}
+
+void AdaParser::pkg_spec_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST pkg_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ basic_declarative_items_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ private_declarative_items_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ pkg_spec_part_AST = RefAdaAST(currentAST.root);
+ returnAST = pkg_spec_part_AST;
+}
+
+void AdaParser::basic_declarative_items_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST basic_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ basic_decl_item();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop114;
+ }
+ }
+ }
+ _loop114:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ basic_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+#line 385 "ada.g"
+ basic_declarative_items_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_opt_AST))));
+#line 3303 "AdaParser.cpp"
+ currentAST.root = basic_declarative_items_opt_AST;
+ if ( basic_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ basic_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = basic_declarative_items_opt_AST->getFirstChild();
+ else
+ currentAST.child = basic_declarative_items_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ basic_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = basic_declarative_items_opt_AST;
+}
+
+void AdaParser::private_declarative_items_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST private_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ basic_decl_item();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop111;
+ }
+ }
+ }
+ _loop111:;
+ } // ( ... )*
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ private_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+#line 378 "ada.g"
+ private_declarative_items_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_DECLARATIVE_ITEMS_OPT,"PRIVATE_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_declarative_items_opt_AST))));
+#line 3380 "AdaParser.cpp"
+ currentAST.root = private_declarative_items_opt_AST;
+ if ( private_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ private_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = private_declarative_items_opt_AST->getFirstChild();
+ else
+ currentAST.child = private_declarative_items_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ private_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = private_declarative_items_opt_AST;
+}
+
+void AdaParser::end_id_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST end_id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ e = LT(1);
+ if ( inputState->guessing == 0 ) {
+ e_AST = astFactory->create(e);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+ }
+ match(END);
+ id_opt_aux();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1176 "ada.g"
+ Set(e_AST, END_ID_OPT);
+#line 3413 "AdaParser.cpp"
+ }
+ end_id_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = end_id_opt_AST;
+}
+
+void AdaParser::basic_decl_item() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST basic_decl_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case PACKAGE:
+ {
+ pkg = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pkg_AST = astFactory->create(pkg);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+ }
+ match(PACKAGE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ spec_decl_part(pkg_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ basic_decl_item_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case TASK:
+ {
+ tsk = LT(1);
+ if ( inputState->guessing == 0 ) {
+ tsk_AST = astFactory->create(tsk);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST));
+ }
+ match(TASK);
+ task_type_or_single_decl(tsk_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ basic_decl_item_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PROTECTED:
+ {
+ pro = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pro_AST = astFactory->create(pro);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST));
+ }
+ match(PROTECTED);
+ prot_type_or_single_decl(pro_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ basic_decl_item_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ subprog_decl(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ basic_decl_item_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ decl_common();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ basic_decl_item_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = basic_decl_item_AST;
+}
+
+void AdaParser::basic_declarative_items() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST basic_declarative_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )+
+ int _cnt117=0;
+ for (;;) {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ basic_decl_item();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ if ( _cnt117>=1 ) { goto _loop117; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+ }
+ _cnt117++;
+ }
+ _loop117:;
+ } // ( ... )+
+ if ( inputState->guessing==0 ) {
+ basic_declarative_items_AST = RefAdaAST(currentAST.root);
+#line 392 "ada.g"
+ basic_declarative_items_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_AST))));
+#line 3562 "AdaParser.cpp"
+ currentAST.root = basic_declarative_items_AST;
+ if ( basic_declarative_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ basic_declarative_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = basic_declarative_items_AST->getFirstChild();
+ else
+ currentAST.child = basic_declarative_items_AST;
+ currentAST.advanceChildToEnd();
+ }
+ basic_declarative_items_AST = RefAdaAST(currentAST.root);
+ returnAST = basic_declarative_items_AST;
+}
+
+void AdaParser::task_type_or_single_decl(
+ RefAdaAST tsk
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST task_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case TYPE:
+ {
+ match(TYPE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrim_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ task_definition_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 408 "ada.g"
+ Set(tsk, TASK_TYPE_DECLARATION);
+#line 3601 "AdaParser.cpp"
+ }
+ task_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ task_definition_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 410 "ada.g"
+ Set(tsk, SINGLE_TASK_DECLARATION);
+#line 3619 "AdaParser.cpp"
+ }
+ task_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = task_type_or_single_decl_AST;
+}
+
+void AdaParser::prot_type_or_single_decl(
+ RefAdaAST pro
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case TYPE:
+ {
+ match(TYPE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrim_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ protected_definition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 539 "ada.g"
+ Set(pro, PROTECTED_TYPE_DECLARATION);
+#line 3658 "AdaParser.cpp"
+ }
+ prot_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ protected_definition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 541 "ada.g"
+ Set(pro, SINGLE_PROTECTED_DECLARATION);
+#line 3676 "AdaParser.cpp"
+ }
+ prot_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = prot_type_or_single_decl_AST;
+}
+
+void AdaParser::decl_common() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST decl_common_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken erd = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST erd_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken ord = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST ord_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken od = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST od_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case TYPE:
+ {
+ t = LT(1);
+ if ( inputState->guessing == 0 ) {
+ t_AST = astFactory->create(t);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+ }
+ match(TYPE);
+ RefAdaAST tmp111_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp111_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST));
+ }
+ match(IDENTIFIER);
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ type_def(t_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case LPAREN:
+ {
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ discrim_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ derived_or_private_or_record(t_AST, true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 587 "ada.g"
+ Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
+#line 3759 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case SEMI:
+ {
+ empty_discrim_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 590 "ada.g"
+ Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
+#line 3780 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ decl_common_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case SUBTYPE:
+ {
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(SUBTYPE);
+ RefAdaAST tmp115_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp115_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST));
+ }
+ match(IDENTIFIER);
+ match(IS);
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 604 "ada.g"
+ Set(s_AST, SUBTYPE_DECLARATION);
+#line 3825 "AdaParser.cpp"
+ }
+ decl_common_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case GENERIC:
+ {
+ generic_decl(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ decl_common_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case USE:
+ {
+ use_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ decl_common_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FOR:
+ {
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(FOR);
+ {
+ bool synPredMatched184 = false;
+ if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) {
+ int _m184 = mark();
+ synPredMatched184 = true;
+ inputState->guessing++;
+ try {
+ {
+ local_enum_name();
+ match(USE);
+ match(LPAREN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched184 = false;
+ }
+ rewind(_m184);
+ inputState->guessing--;
+ }
+ if ( synPredMatched184 ) {
+ local_enum_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(USE);
+ enumeration_aggregate();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 609 "ada.g"
+ Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE);
+#line 3888 "AdaParser.cpp"
+ }
+ }
+ else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) {
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(USE);
+ rep_spec_part(r_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ match(SEMI);
+ decl_common_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ bool synPredMatched186 = false;
+ if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
+ int _m186 = mark();
+ synPredMatched186 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(IDENTIFIER);
+ match(COLON);
+ match(EXCEPTION);
+ match(RENAMES);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched186 = false;
+ }
+ rewind(_m186);
+ inputState->guessing--;
+ }
+ if ( synPredMatched186 ) {
+ RefAdaAST tmp121_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp121_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp121_AST));
+ }
+ match(IDENTIFIER);
+ erd = LT(1);
+ if ( inputState->guessing == 0 ) {
+ erd_AST = astFactory->create(erd);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(erd_AST));
+ }
+ match(COLON);
+ match(EXCEPTION);
+ match(RENAMES);
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 615 "ada.g"
+ Set(erd_AST, EXCEPTION_RENAMING_DECLARATION);
+#line 3954 "AdaParser.cpp"
+ }
+ decl_common_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched188 = false;
+ if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
+ int _m188 = mark();
+ synPredMatched188 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(IDENTIFIER);
+ match(COLON);
+ subtype_mark();
+ match(RENAMES);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched188 = false;
+ }
+ rewind(_m188);
+ inputState->guessing--;
+ }
+ if ( synPredMatched188 ) {
+ RefAdaAST tmp125_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp125_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST));
+ }
+ match(IDENTIFIER);
+ ord = LT(1);
+ if ( inputState->guessing == 0 ) {
+ ord_AST = astFactory->create(ord);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ord_AST));
+ }
+ match(COLON);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RENAMES);
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 618 "ada.g"
+ Set(ord_AST, OBJECT_RENAMING_DECLARATION);
+#line 4004 "AdaParser.cpp"
+ }
+ decl_common_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) {
+ defining_identifier_list();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ od = LT(1);
+ if ( inputState->guessing == 0 ) {
+ od_AST = astFactory->create(od);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(od_AST));
+ }
+ match(COLON);
+ {
+ if ((LA(1) == EXCEPTION)) {
+ match(EXCEPTION);
+ if ( inputState->guessing==0 ) {
+#line 621 "ada.g"
+ Set(od_AST, EXCEPTION_DECLARATION);
+#line 4025 "AdaParser.cpp"
+ }
+ }
+ else {
+ bool synPredMatched191 = false;
+ if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) {
+ int _m191 = mark();
+ synPredMatched191 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(CONSTANT);
+ match(ASSIGN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched191 = false;
+ }
+ rewind(_m191);
+ inputState->guessing--;
+ }
+ if ( synPredMatched191 ) {
+ match(CONSTANT);
+ match(ASSIGN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 623 "ada.g"
+ Set(od_AST, NUMBER_DECLARATION);
+#line 4056 "AdaParser.cpp"
+ }
+ }
+ else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
+ aliased_constant_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case ARRAY:
+ {
+ array_type_definition(od_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 626 "ada.g"
+ Set(od_AST, ARRAY_OBJECT_DECLARATION);
+#line 4079 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 630 "ada.g"
+ Set(od_AST, OBJECT_DECLARATION);
+#line 4096 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ decl_common_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }}
+ returnAST = decl_common_AST;
+}
+
+void AdaParser::discrim_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrim_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ discrim_part_text();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case IS:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ discrim_part_opt_AST = RefAdaAST(currentAST.root);
+#line 420 "ada.g"
+ discrim_part_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_opt_AST))));
+#line 4153 "AdaParser.cpp"
+ currentAST.root = discrim_part_opt_AST;
+ if ( discrim_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discrim_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discrim_part_opt_AST->getFirstChild();
+ else
+ currentAST.child = discrim_part_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discrim_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = discrim_part_opt_AST;
+}
+
+void AdaParser::task_definition_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST task_definition_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ task_items_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ private_task_items_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ task_definition_opt_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case SEMI:
+ {
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 415 "ada.g"
+ pop_def_id();
+#line 4197 "AdaParser.cpp"
+ }
+ task_definition_opt_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = task_definition_opt_AST;
+}
+
+void AdaParser::task_items_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PRAGMA)) {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop138;
+ }
+
+ }
+ _loop138:;
+ } // ( ... )*
+ entrydecls_repspecs_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ task_items_opt_AST = RefAdaAST(currentAST.root);
+#line 473 "ada.g"
+ task_items_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TASK_ITEMS_OPT,"TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(task_items_opt_AST))));
+#line 4239 "AdaParser.cpp"
+ currentAST.root = task_items_opt_AST;
+ if ( task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = task_items_opt_AST->getFirstChild();
+ else
+ currentAST.child = task_items_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ task_items_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = task_items_opt_AST;
+}
+
+void AdaParser::private_task_items_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST private_task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PRAGMA)) {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop163;
+ }
+
+ }
+ _loop163:;
+ } // ( ... )*
+ entrydecls_repspecs_opt();
+ 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());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ private_task_items_opt_AST = RefAdaAST(currentAST.root);
+#line 530 "ada.g"
+ private_task_items_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_TASK_ITEMS_OPT,"PRIVATE_TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_task_items_opt_AST))));
+#line 4298 "AdaParser.cpp"
+ currentAST.root = private_task_items_opt_AST;
+ if ( private_task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ private_task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = private_task_items_opt_AST->getFirstChild();
+ else
+ currentAST.child = private_task_items_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ private_task_items_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = private_task_items_opt_AST;
+}
+
+void AdaParser::discrim_part_text() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrim_part_text_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(LPAREN);
+ {
+ switch ( LA(1)) {
+ case BOX:
+ {
+ RefAdaAST tmp137_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp137_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST));
+ }
+ match(BOX);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ discriminant_specifications();
+ 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(RPAREN);
+ discrim_part_text_AST = RefAdaAST(currentAST.root);
+ returnAST = discrim_part_text_AST;
+}
+
+void AdaParser::discriminant_specifications() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminant_specifications_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ discriminant_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ discriminant_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop130;
+ }
+
+ }
+ _loop130:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ discriminant_specifications_AST = RefAdaAST(currentAST.root);
+#line 450 "ada.g"
+ discriminant_specifications_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATIONS,"DISCRIMINANT_SPECIFICATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specifications_AST))));
+#line 4378 "AdaParser.cpp"
+ currentAST.root = discriminant_specifications_AST;
+ if ( discriminant_specifications_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discriminant_specifications_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discriminant_specifications_AST->getFirstChild();
+ else
+ currentAST.child = discriminant_specifications_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discriminant_specifications_AST = RefAdaAST(currentAST.root);
+ returnAST = discriminant_specifications_AST;
+}
+
+void AdaParser::known_discrim_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST known_discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(LPAREN);
+ discriminant_specifications();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+ known_discrim_part_AST = RefAdaAST(currentAST.root);
+#line 430 "ada.g"
+ known_discrim_part_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(known_discrim_part_AST))));
+#line 4407 "AdaParser.cpp"
+ currentAST.root = known_discrim_part_AST;
+ if ( known_discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ known_discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = known_discrim_part_AST->getFirstChild();
+ else
+ currentAST.child = known_discrim_part_AST;
+ currentAST.advanceChildToEnd();
+ }
+ known_discrim_part_AST = RefAdaAST(currentAST.root);
+ returnAST = known_discrim_part_AST;
+}
+
+void AdaParser::empty_discrim_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST empty_discrim_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if ( inputState->guessing==0 ) {
+ empty_discrim_opt_AST = RefAdaAST(currentAST.root);
+#line 436 "ada.g"
+ empty_discrim_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_discrim_opt_AST))));
+#line 4430 "AdaParser.cpp"
+ currentAST.root = empty_discrim_opt_AST;
+ if ( empty_discrim_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ empty_discrim_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = empty_discrim_opt_AST->getFirstChild();
+ else
+ currentAST.child = empty_discrim_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ empty_discrim_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = empty_discrim_opt_AST;
+}
+
+void AdaParser::discrim_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ discrim_part_text();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ discrim_part_AST = RefAdaAST(currentAST.root);
+#line 443 "ada.g"
+ discrim_part_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_AST))));
+#line 4457 "AdaParser.cpp"
+ currentAST.root = discrim_part_AST;
+ if ( discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discrim_part_AST->getFirstChild();
+ else
+ currentAST.child = discrim_part_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discrim_part_AST = RefAdaAST(currentAST.root);
+ returnAST = discrim_part_AST;
+}
+
+void AdaParser::discriminant_specification() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminant_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ def_ids_colon();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ access_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ discriminant_specification_AST = RefAdaAST(currentAST.root);
+#line 457 "ada.g"
+ discriminant_specification_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATION,"DISCRIMINANT_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specification_AST))));
+#line 4496 "AdaParser.cpp"
+ currentAST.root = discriminant_specification_AST;
+ if ( discriminant_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discriminant_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discriminant_specification_AST->getFirstChild();
+ else
+ currentAST.child = discriminant_specification_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discriminant_specification_AST = RefAdaAST(currentAST.root);
+ returnAST = discriminant_specification_AST;
+}
+
+void AdaParser::access_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ACCESS:
+ {
+ RefAdaAST tmp142_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp142_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp142_AST));
+ }
+ match(ACCESS);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ access_opt_AST = RefAdaAST(currentAST.root);
+#line 464 "ada.g"
+ access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(access_opt_AST))));
+#line 4540 "AdaParser.cpp"
+ currentAST.root = access_opt_AST;
+ if ( access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = access_opt_AST->getFirstChild();
+ else
+ currentAST.child = access_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ access_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = access_opt_AST;
+}
+
+void AdaParser::entrydecls_repspecs_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entrydecls_repspecs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == ENTRY)) {
+ entry_declaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case FOR:
+ {
+ rep_spec();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop142;
+ }
+ }
+ }
+ _loop142:;
+ } // ( ... )*
+ }
+ else {
+ goto _loop143;
+ }
+
+ }
+ _loop143:;
+ } // ( ... )*
+ entrydecls_repspecs_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = entrydecls_repspecs_opt_AST;
+}
+
+void AdaParser::entry_declaration() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_declaration_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ e = LT(1);
+ if ( inputState->guessing == 0 ) {
+ e_AST = astFactory->create(e);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+ }
+ match(ENTRY);
+ RefAdaAST tmp143_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp143_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp143_AST));
+ }
+ match(IDENTIFIER);
+ discrete_subtype_def_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 482 "ada.g"
+ Set (e_AST, ENTRY_DECLARATION);
+#line 4635 "AdaParser.cpp"
+ }
+ entry_declaration_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_declaration_AST;
+}
+
+void AdaParser::rep_spec() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST rep_spec_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(FOR);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(USE);
+ rep_spec_part(r_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ rep_spec_AST = RefAdaAST(currentAST.root);
+ returnAST = rep_spec_AST;
+}
+
+void AdaParser::discrete_subtype_def_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrete_subtype_def_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched148 = false;
+ if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+ int _m148 = mark();
+ synPredMatched148 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(LPAREN);
+ discrete_subtype_definition();
+ match(RPAREN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched148 = false;
+ }
+ rewind(_m148);
+ inputState->guessing--;
+ }
+ if ( synPredMatched148 ) {
+ match(LPAREN);
+ discrete_subtype_definition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ }
+ else if ((LA(1) == SEMI || LA(1) == LPAREN) && (_tokenSet_14.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState->guessing==0 ) {
+ discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root);
+#line 489 "ada.g"
+ discrete_subtype_def_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,"DISCRETE_SUBTYPE_DEF_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrete_subtype_def_opt_AST))));
+#line 4712 "AdaParser.cpp"
+ currentAST.root = discrete_subtype_def_opt_AST;
+ if ( discrete_subtype_def_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discrete_subtype_def_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discrete_subtype_def_opt_AST->getFirstChild();
+ else
+ currentAST.child = discrete_subtype_def_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = discrete_subtype_def_opt_AST;
+}
+
+void AdaParser::discrete_subtype_definition() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrete_subtype_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched152 = false;
+ if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+ int _m152 = mark();
+ synPredMatched152 = true;
+ inputState->guessing++;
+ try {
+ {
+ range();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched152 = false;
+ }
+ rewind(_m152);
+ inputState->guessing--;
+ }
+ if ( synPredMatched152 ) {
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENTIFIER) && (_tokenSet_15.member(LA(2)))) {
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ discrete_subtype_definition_AST = RefAdaAST(currentAST.root);
+ returnAST = discrete_subtype_definition_AST;
+}
+
+void AdaParser::subtype_ind() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subtype_ind_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constraint_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ subtype_ind_AST = RefAdaAST(currentAST.root);
+#line 693 "ada.g"
+ subtype_ind_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SUBTYPE_INDICATION,"SUBTYPE_INDICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(subtype_ind_AST))));
+#line 4785 "AdaParser.cpp"
+ currentAST.root = subtype_ind_AST;
+ if ( subtype_ind_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ subtype_ind_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = subtype_ind_AST->getFirstChild();
+ else
+ currentAST.child = subtype_ind_AST;
+ currentAST.advanceChildToEnd();
+ }
+ subtype_ind_AST = RefAdaAST(currentAST.root);
+ returnAST = subtype_ind_AST;
+}
+
+void AdaParser::rep_spec_part(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST rep_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case RECORD:
+ {
+ match(RECORD);
+ align_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ comp_loc_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(RECORD);
+ if ( inputState->guessing==0 ) {
+#line 512 "ada.g"
+ Set(t, RECORD_REPRESENTATION_CLAUSE);
+#line 4822 "AdaParser.cpp"
+ }
+ rep_spec_part_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case AT:
+ {
+ match(AT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 514 "ada.g"
+ Set(t, AT_CLAUSE);
+#line 4837 "AdaParser.cpp"
+ }
+ rep_spec_part_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 517 "ada.g"
+ Set(t, ATTRIBUTE_DEFINITION_CLAUSE);
+#line 4861 "AdaParser.cpp"
+ }
+ rep_spec_part_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = rep_spec_part_AST;
+}
+
+void AdaParser::align_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST align_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case AT:
+ {
+ match(AT);
+ match(MOD);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ align_opt_AST = RefAdaAST(currentAST.root);
+#line 521 "ada.g"
+ align_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MOD_CLAUSE_OPT,"MOD_CLAUSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(align_opt_AST))));
+#line 4908 "AdaParser.cpp"
+ currentAST.root = align_opt_AST;
+ if ( align_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ align_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = align_opt_AST->getFirstChild();
+ else
+ currentAST.child = align_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ align_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = align_opt_AST;
+}
+
+void AdaParser::comp_loc_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST comp_loc_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(AT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RANGE);
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ default:
+ {
+ goto _loop159;
+ }
+ }
+ }
+ _loop159:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ comp_loc_s_AST = RefAdaAST(currentAST.root);
+#line 525 "ada.g"
+ comp_loc_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_CLAUSES_OPT,"COMPONENT_CLAUSES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_loc_s_AST))));
+#line 4968 "AdaParser.cpp"
+ currentAST.root = comp_loc_s_AST;
+ if ( comp_loc_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ comp_loc_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = comp_loc_s_AST->getFirstChild();
+ else
+ currentAST.child = comp_loc_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ comp_loc_s_AST = RefAdaAST(currentAST.root);
+ returnAST = comp_loc_s_AST;
+}
+
+void AdaParser::protected_definition() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST protected_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(IS);
+ prot_op_decl_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ prot_private_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ protected_definition_AST = RefAdaAST(currentAST.root);
+ returnAST = protected_definition_AST;
+}
+
+void AdaParser::prot_private_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ case PROCEDURE:
+ case FUNCTION:
+ case ENTRY:
+ case FOR:
+ {
+ prot_op_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ comp_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop168;
+ }
+ }
+ }
+ _loop168:;
+ } // ( ... )*
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ prot_private_opt_AST = RefAdaAST(currentAST.root);
+#line 545 "ada.g"
+ prot_private_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_PRIVATE_OPT,"PROT_PRIVATE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_private_opt_AST))));
+#line 5061 "AdaParser.cpp"
+ currentAST.root = prot_private_opt_AST;
+ if ( prot_private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ prot_private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = prot_private_opt_AST->getFirstChild();
+ else
+ currentAST.child = prot_private_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ prot_private_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = prot_private_opt_AST;
+}
+
+void AdaParser::prot_op_decl() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_op_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case ENTRY:
+ {
+ entry_declaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ prot_op_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PROCEDURE:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROCEDURE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 561 "ada.g"
+ pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
+#line 5113 "AdaParser.cpp"
+ }
+ prot_op_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ f = LT(1);
+ if ( inputState->guessing == 0 ) {
+ f_AST = astFactory->create(f);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+ }
+ match(FUNCTION);
+ def_designator(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 563 "ada.g"
+ pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
+#line 5138 "AdaParser.cpp"
+ }
+ prot_op_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FOR:
+ {
+ rep_spec();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ prot_op_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ prot_op_decl_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = prot_op_decl_AST;
+}
+
+void AdaParser::comp_decl() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST comp_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ def_ids_colon();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ component_subtype_def();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ init_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+ comp_decl_AST = RefAdaAST(currentAST.root);
+#line 575 "ada.g"
+ comp_decl_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_DECLARATION,"COMPONENT_DECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_decl_AST))));
+#line 5192 "AdaParser.cpp"
+ currentAST.root = comp_decl_AST;
+ if ( comp_decl_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ comp_decl_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = comp_decl_AST->getFirstChild();
+ else
+ currentAST.child = comp_decl_AST;
+ currentAST.advanceChildToEnd();
+ }
+ comp_decl_AST = RefAdaAST(currentAST.root);
+ returnAST = comp_decl_AST;
+}
+
+void AdaParser::prot_op_decl_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_op_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ if ((_tokenSet_16.member(LA(1)))) {
+ prot_op_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop172;
+ }
+
+ }
+ _loop172:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ prot_op_decl_s_AST = RefAdaAST(currentAST.root);
+#line 555 "ada.g"
+ prot_op_decl_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_DECLARATIONS,"PROT_OP_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_decl_s_AST))));
+#line 5229 "AdaParser.cpp"
+ currentAST.root = prot_op_decl_s_AST;
+ if ( prot_op_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ prot_op_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = prot_op_decl_s_AST->getFirstChild();
+ else
+ currentAST.child = prot_op_decl_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ prot_op_decl_s_AST = RefAdaAST(currentAST.root);
+ returnAST = prot_op_decl_s_AST;
+}
+
+void AdaParser::prot_member_decl_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_member_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ case PROCEDURE:
+ case FUNCTION:
+ case ENTRY:
+ case FOR:
+ {
+ prot_op_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ comp_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop176;
+ }
+ }
+ }
+ _loop176:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ prot_member_decl_s_AST = RefAdaAST(currentAST.root);
+#line 569 "ada.g"
+ prot_member_decl_s_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_MEMBER_DECLARATIONS,"PROT_MEMBER_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_member_decl_s_AST))));
+#line 5283 "AdaParser.cpp"
+ currentAST.root = prot_member_decl_s_AST;
+ if ( prot_member_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ prot_member_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = prot_member_decl_s_AST->getFirstChild();
+ else
+ currentAST.child = prot_member_decl_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ prot_member_decl_s_AST = RefAdaAST(currentAST.root);
+ returnAST = prot_member_decl_s_AST;
+}
+
+void AdaParser::component_subtype_def() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST component_subtype_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ aliased_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ component_subtype_def_AST = RefAdaAST(currentAST.root);
+ returnAST = component_subtype_def_AST;
+}
+
+void AdaParser::type_def(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST type_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ enum_id_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 638 "ada.g"
+ Set(t, ENUMERATION_TYPE_DECLARATION);
+#line 5332 "AdaParser.cpp"
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case RANGE:
+ {
+ match(RANGE);
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 640 "ada.g"
+ Set(t, SIGNED_INTEGER_TYPE_DECLARATION);
+#line 5347 "AdaParser.cpp"
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case MOD:
+ {
+ match(MOD);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 642 "ada.g"
+ Set(t, MODULAR_TYPE_DECLARATION);
+#line 5362 "AdaParser.cpp"
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case DIGITS:
+ {
+ match(DIGITS);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_constraint_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 644 "ada.g"
+ Set(t, FLOATING_POINT_DECLARATION);
+#line 5381 "AdaParser.cpp"
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case DELTA:
+ {
+ match(DELTA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case RANGE:
+ {
+ match(RANGE);
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 647 "ada.g"
+ Set(t, ORDINARY_FIXED_POINT_DECLARATION);
+#line 5405 "AdaParser.cpp"
+ }
+ break;
+ }
+ case DIGITS:
+ {
+ match(DIGITS);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_constraint_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 649 "ada.g"
+ Set(t, DECIMAL_FIXED_POINT_DECLARATION);
+#line 5423 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case ARRAY:
+ {
+ array_type_definition(t);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case ACCESS:
+ {
+ access_type_definition(t);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PRIVATE:
+ case NEW:
+ case NuLL:
+ case RECORD:
+ case ABSTRACT:
+ case TAGGED:
+ case LIMITED:
+ {
+ empty_discrim_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ derived_or_private_or_record(t, false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_def_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = type_def_AST;
+}
+
+void AdaParser::derived_or_private_or_record(
+ RefAdaAST t, boolean has_discrim
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST derived_or_private_or_record_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ bool synPredMatched246 = false;
+ if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
+ int _m246 = mark();
+ synPredMatched246 = true;
+ inputState->guessing++;
+ try {
+ {
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ match(ABSTRACT);
+ break;
+ }
+ case NEW:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(NEW);
+ subtype_ind();
+ match(WITH);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched246 = false;
+ }
+ rewind(_m246);
+ inputState->guessing--;
+ }
+ if ( synPredMatched246 ) {
+ abstract_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(NEW);
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(WITH);
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ if ( inputState->guessing==0 ) {
+#line 772 "ada.g"
+ Set(t, PRIVATE_EXTENSION_DECLARATION);
+#line 5542 "AdaParser.cpp"
+ }
+ break;
+ }
+ case NuLL:
+ case RECORD:
+ {
+ record_definition(has_discrim);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 774 "ada.g"
+ Set(t, DERIVED_RECORD_EXTENSION);
+#line 5556 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
+ match(NEW);
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 776 "ada.g"
+ Set(t, ORDINARY_DERIVED_TYPE_DECLARATION);
+#line 5577 "AdaParser.cpp"
+ }
+ derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
+ abstract_tagged_limited_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ if ( inputState->guessing==0 ) {
+#line 778 "ada.g"
+ Set(t, PRIVATE_TYPE_DECLARATION);
+#line 5594 "AdaParser.cpp"
+ }
+ break;
+ }
+ case NuLL:
+ case RECORD:
+ {
+ record_definition(has_discrim);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 780 "ada.g"
+ Set(t, RECORD_TYPE_DECLARATION);
+#line 5608 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = derived_or_private_or_record_AST;
+}
+
+void AdaParser::local_enum_name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST local_enum_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp177_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp177_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp177_AST));
+ }
+ match(IDENTIFIER);
+ local_enum_name_AST = RefAdaAST(currentAST.root);
+ returnAST = local_enum_name_AST;
+}
+
+void AdaParser::enumeration_aggregate() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST enumeration_aggregate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ parenth_values();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ enumeration_aggregate_AST = RefAdaAST(currentAST.root);
+ returnAST = enumeration_aggregate_AST;
+}
+
+void AdaParser::aliased_constant_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST aliased_constant_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ALIASED:
+ {
+ RefAdaAST tmp178_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp178_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp178_AST));
+ }
+ match(ALIASED);
+ break;
+ }
+ case IDENTIFIER:
+ case CONSTANT:
+ case ARRAY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case CONSTANT:
+ {
+ RefAdaAST tmp179_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp179_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp179_AST));
+ }
+ match(CONSTANT);
+ break;
+ }
+ case IDENTIFIER:
+ case ARRAY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ aliased_constant_opt_AST = RefAdaAST(currentAST.root);
+#line 858 "ada.g"
+ aliased_constant_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_constant_opt_AST))));
+#line 5712 "AdaParser.cpp"
+ currentAST.root = aliased_constant_opt_AST;
+ if ( aliased_constant_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ aliased_constant_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = aliased_constant_opt_AST->getFirstChild();
+ else
+ currentAST.child = aliased_constant_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ aliased_constant_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = aliased_constant_opt_AST;
+}
+
+void AdaParser::array_type_definition(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST array_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(ARRAY);
+ match(LPAREN);
+ index_or_discrete_range_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ match(OF);
+ component_subtype_def();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 669 "ada.g"
+ Set(t, ARRAY_TYPE_DECLARATION);
+#line 5747 "AdaParser.cpp"
+ }
+ array_type_definition_AST = RefAdaAST(currentAST.root);
+ returnAST = array_type_definition_AST;
+}
+
+void AdaParser::enum_id_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST enum_id_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ enumeration_literal_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ enumeration_literal_specification();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop197;
+ }
+
+ }
+ _loop197:;
+ } // ( ... )*
+ enum_id_s_AST = RefAdaAST(currentAST.root);
+ returnAST = enum_id_s_AST;
+}
+
+void AdaParser::range_constraint_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case RANGE:
+ {
+ range_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case WITH:
+ case ASSIGN:
+ case LOOP:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ range_constraint_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = range_constraint_opt_AST;
+}
+
+void AdaParser::access_type_definition(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST access_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(ACCESS);
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ case PROTECTED:
+ {
+ protected_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ match(PROCEDURE);
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 751 "ada.g"
+ Set(t, ACCESS_TO_PROCEDURE_DECLARATION);
+#line 5846 "AdaParser.cpp"
+ }
+ break;
+ }
+ case FUNCTION:
+ {
+ match(FUNCTION);
+ func_formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RETURN);
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 753 "ada.g"
+ Set(t, ACCESS_TO_FUNCTION_DECLARATION);
+#line 5865 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case ALL:
+ case CONSTANT:
+ {
+ constant_all_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 756 "ada.g"
+ Set(t, ACCESS_TO_OBJECT_DECLARATION);
+#line 5892 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ access_type_definition_AST = RefAdaAST(currentAST.root);
+ returnAST = access_type_definition_AST;
+}
+
+void AdaParser::enumeration_literal_specification() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST enumeration_literal_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp189_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp189_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp189_AST));
+ }
+ match(IDENTIFIER);
+ enumeration_literal_specification_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp190_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp190_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp190_AST));
+ }
+ match(CHARACTER_LITERAL);
+ enumeration_literal_specification_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = enumeration_literal_specification_AST;
+}
+
+void AdaParser::index_or_discrete_range_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST index_or_discrete_range_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ index_or_discrete_range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ RefAdaAST tmp191_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp191_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp191_AST));
+ }
+ match(COMMA);
+ index_or_discrete_range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop204;
+ }
+
+ }
+ _loop204:;
+ } // ( ... )*
+ index_or_discrete_range_s_AST = RefAdaAST(currentAST.root);
+ returnAST = index_or_discrete_range_s_AST;
+}
+
+void AdaParser::index_or_discrete_range() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST index_or_discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case DOT_DOT:
+ {
+ RefAdaAST tmp192_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp192_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp192_AST));
+ }
+ match(DOT_DOT);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RANGE:
+ {
+ RefAdaAST tmp193_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp193_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp193_AST));
+ }
+ match(RANGE);
+ {
+ switch ( LA(1)) {
+ case BOX:
+ {
+ RefAdaAST tmp194_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp194_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp194_AST));
+ }
+ match(BOX);
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ range();
+ 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 COMMA:
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ index_or_discrete_range_AST = RefAdaAST(currentAST.root);
+ returnAST = index_or_discrete_range_AST;
+}
+
+void AdaParser::aliased_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST aliased_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ALIASED:
+ {
+ RefAdaAST tmp195_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp195_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp195_AST));
+ }
+ match(ALIASED);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ aliased_opt_AST = RefAdaAST(currentAST.root);
+#line 689 "ada.g"
+ aliased_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_opt_AST))));
+#line 6093 "AdaParser.cpp"
+ currentAST.root = aliased_opt_AST;
+ if ( aliased_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ aliased_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = aliased_opt_AST->getFirstChild();
+ else
+ currentAST.child = aliased_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ aliased_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = aliased_opt_AST;
+}
+
+void AdaParser::constraint_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case RANGE:
+ {
+ range_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DIGITS:
+ {
+ digits_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DELTA:
+ {
+ delta_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case WITH:
+ case ASSIGN:
+ case LOOP:
+ {
+ break;
+ }
+ default:
+ bool synPredMatched215 = false;
+ if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+ int _m215 = mark();
+ synPredMatched215 = true;
+ inputState->guessing++;
+ try {
+ {
+ index_constraint();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched215 = false;
+ }
+ rewind(_m215);
+ inputState->guessing--;
+ }
+ if ( synPredMatched215 ) {
+ index_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2)))) {
+ discriminant_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ constraint_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = constraint_opt_AST;
+}
+
+void AdaParser::digits_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST digits_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ d = LT(1);
+ if ( inputState->guessing == 0 ) {
+ d_AST = astFactory->create(d);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+ }
+ match(DIGITS);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_constraint_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 706 "ada.g"
+ Set(d_AST, DIGITS_CONSTRAINT);
+#line 6208 "AdaParser.cpp"
+ }
+ digits_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = digits_constraint_AST;
+}
+
+void AdaParser::delta_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST delta_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ d = LT(1);
+ if ( inputState->guessing == 0 ) {
+ d_AST = astFactory->create(d);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+ }
+ match(DELTA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_constraint_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 710 "ada.g"
+ Set(d_AST, DELTA_CONSTRAINT);
+#line 6238 "AdaParser.cpp"
+ }
+ delta_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = delta_constraint_AST;
+}
+
+void AdaParser::index_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST index_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(LPAREN);
+ discrete_range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ discrete_range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop220;
+ }
+
+ }
+ _loop220:;
+ } // ( ... )*
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 714 "ada.g"
+ Set(p_AST, INDEX_CONSTRAINT);
+#line 6281 "AdaParser.cpp"
+ }
+ index_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = index_constraint_AST;
+}
+
+void AdaParser::discriminant_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminant_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(LPAREN);
+ discriminant_association();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ discriminant_association();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop226;
+ }
+
+ }
+ _loop226:;
+ } // ( ... )*
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 724 "ada.g"
+ Set(p_AST, DISCRIMINANT_CONSTRAINT);
+#line 6324 "AdaParser.cpp"
+ }
+ discriminant_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = discriminant_constraint_AST;
+}
+
+void AdaParser::discrete_range() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ bool synPredMatched223 = false;
+ if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+ int _m223 = mark();
+ synPredMatched223 = true;
+ inputState->guessing++;
+ try {
+ {
+ range();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched223 = false;
+ }
+ rewind(_m223);
+ inputState->guessing--;
+ }
+ if ( synPredMatched223 ) {
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrete_range_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENTIFIER) && (_tokenSet_19.member(LA(2)))) {
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrete_range_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = discrete_range_AST;
+}
+
+void AdaParser::discriminant_association() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminant_association_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ selector_names_opt();
+ 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));
+ }
+ if ( inputState->guessing==0 ) {
+ discriminant_association_AST = RefAdaAST(currentAST.root);
+#line 728 "ada.g"
+ discriminant_association_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_ASSOCIATION,"DISCRIMINANT_ASSOCIATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_association_AST))));
+#line 6390 "AdaParser.cpp"
+ currentAST.root = discriminant_association_AST;
+ if ( discriminant_association_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ discriminant_association_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = discriminant_association_AST->getFirstChild();
+ else
+ currentAST.child = discriminant_association_AST;
+ currentAST.advanceChildToEnd();
+ }
+ discriminant_association_AST = RefAdaAST(currentAST.root);
+ returnAST = discriminant_association_AST;
+}
+
+void AdaParser::selector_names_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST selector_names_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched231 = false;
+ if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) {
+ int _m231 = mark();
+ synPredMatched231 = true;
+ inputState->guessing++;
+ try {
+ {
+ association_head();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched231 = false;
+ }
+ rewind(_m231);
+ inputState->guessing--;
+ }
+ if ( synPredMatched231 ) {
+ association_head();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState->guessing==0 ) {
+ selector_names_opt_AST = RefAdaAST(currentAST.root);
+#line 736 "ada.g"
+ selector_names_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SELECTOR_NAMES_OPT,"SELECTOR_NAMES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(selector_names_opt_AST))));
+#line 6443 "AdaParser.cpp"
+ currentAST.root = selector_names_opt_AST;
+ if ( selector_names_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ selector_names_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = selector_names_opt_AST->getFirstChild();
+ else
+ currentAST.child = selector_names_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ selector_names_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = selector_names_opt_AST;
+}
+
+void AdaParser::association_head() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST association_head_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ selector_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PIPE)) {
+ match(PIPE);
+ selector_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop234;
+ }
+
+ }
+ _loop234:;
+ } // ( ... )*
+ match(RIGHT_SHAFT);
+ association_head_AST = RefAdaAST(currentAST.root);
+ returnAST = association_head_AST;
+}
+
+void AdaParser::selector_name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST selector_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp202_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp202_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp202_AST));
+ }
+ match(IDENTIFIER);
+ selector_name_AST = RefAdaAST(currentAST.root);
+ returnAST = selector_name_AST;
+}
+
+void AdaParser::protected_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST protected_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PROTECTED:
+ {
+ RefAdaAST tmp203_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp203_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp203_AST));
+ }
+ match(PROTECTED);
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ protected_opt_AST = RefAdaAST(currentAST.root);
+#line 761 "ada.g"
+ protected_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(protected_opt_AST))));
+#line 6533 "AdaParser.cpp"
+ currentAST.root = protected_opt_AST;
+ if ( protected_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ protected_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = protected_opt_AST->getFirstChild();
+ else
+ currentAST.child = protected_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ protected_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = protected_opt_AST;
+}
+
+void AdaParser::constant_all_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST constant_all_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case CONSTANT:
+ {
+ RefAdaAST tmp204_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp204_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp204_AST));
+ }
+ match(CONSTANT);
+ break;
+ }
+ case ALL:
+ {
+ RefAdaAST tmp205_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp205_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp205_AST));
+ }
+ match(ALL);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ constant_all_opt_AST = RefAdaAST(currentAST.root);
+#line 765 "ada.g"
+ constant_all_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(constant_all_opt_AST))));
+#line 6588 "AdaParser.cpp"
+ currentAST.root = constant_all_opt_AST;
+ if ( constant_all_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ constant_all_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = constant_all_opt_AST->getFirstChild();
+ else
+ currentAST.child = constant_all_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ constant_all_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = constant_all_opt_AST;
+}
+
+void AdaParser::abstract_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST abstract_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ RefAdaAST tmp206_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp206_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp206_AST));
+ }
+ match(ABSTRACT);
+ break;
+ }
+ case NEW:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ abstract_opt_AST = RefAdaAST(currentAST.root);
+#line 785 "ada.g"
+ abstract_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_opt_AST))));
+#line 6632 "AdaParser.cpp"
+ currentAST.root = abstract_opt_AST;
+ if ( abstract_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ abstract_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = abstract_opt_AST->getFirstChild();
+ else
+ currentAST.child = abstract_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ abstract_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = abstract_opt_AST;
+}
+
+void AdaParser::record_definition(
+ boolean has_discrim
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST record_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case RECORD:
+ {
+ match(RECORD);
+ component_list(has_discrim);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(RECORD);
+ record_definition_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case NuLL:
+ {
+ match(NuLL);
+ match(RECORD);
+ record_definition_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = record_definition_AST;
+}
+
+void AdaParser::abstract_tagged_limited_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST abstract_tagged_limited_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ RefAdaAST tmp212_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp212_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp212_AST));
+ }
+ match(ABSTRACT);
+ match(TAGGED);
+ break;
+ }
+ case TAGGED:
+ {
+ RefAdaAST tmp214_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp214_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp214_AST));
+ }
+ match(TAGGED);
+ break;
+ }
+ case PRIVATE:
+ case NuLL:
+ case RECORD:
+ case LIMITED:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case LIMITED:
+ {
+ RefAdaAST tmp215_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp215_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp215_AST));
+ }
+ match(LIMITED);
+ break;
+ }
+ case PRIVATE:
+ case NuLL:
+ case RECORD:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root);
+#line 847 "ada.g"
+ abstract_tagged_limited_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_tagged_limited_opt_AST))));
+#line 6750 "AdaParser.cpp"
+ currentAST.root = abstract_tagged_limited_opt_AST;
+ if ( abstract_tagged_limited_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ abstract_tagged_limited_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = abstract_tagged_limited_opt_AST->getFirstChild();
+ else
+ currentAST.child = abstract_tagged_limited_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = abstract_tagged_limited_opt_AST;
+}
+
+void AdaParser::component_list(
+ boolean has_discrim
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST component_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case NuLL:
+ {
+ match(NuLL);
+ match(SEMI);
+ component_list_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ {
+ component_items();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case CASE:
+ {
+ variant_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if (!( has_discrim ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
+ break;
+ }
+ case END:
+ case WHEN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ component_list_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case CASE:
+ {
+ empty_component_items();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ variant_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if (!( has_discrim ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
+ component_list_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = component_list_AST;
+}
+
+void AdaParser::component_items() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )+
+ int _cnt256=0;
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ comp_decl();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ if ( _cnt256>=1 ) { goto _loop256; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+ }
+ _cnt256++;
+ }
+ _loop256:;
+ } // ( ... )+
+ if ( inputState->guessing==0 ) {
+ component_items_AST = RefAdaAST(currentAST.root);
+#line 800 "ada.g"
+ component_items_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(component_items_AST))));
+#line 6873 "AdaParser.cpp"
+ currentAST.root = component_items_AST;
+ if ( component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = component_items_AST->getFirstChild();
+ else
+ currentAST.child = component_items_AST;
+ currentAST.advanceChildToEnd();
+ }
+ component_items_AST = RefAdaAST(currentAST.root);
+ returnAST = component_items_AST;
+}
+
+void AdaParser::variant_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST variant_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ c = LT(1);
+ if ( inputState->guessing == 0 ) {
+ c_AST = astFactory->create(c);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST));
+ }
+ match(CASE);
+ discriminant_direct_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ variant_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(CASE);
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 812 "ada.g"
+ Set (c_AST, VARIANT_PART);
+#line 6914 "AdaParser.cpp"
+ }
+ variant_part_AST = RefAdaAST(currentAST.root);
+ returnAST = variant_part_AST;
+}
+
+void AdaParser::empty_component_items() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST empty_component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if ( inputState->guessing==0 ) {
+ empty_component_items_AST = RefAdaAST(currentAST.root);
+#line 806 "ada.g"
+ empty_component_items_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_component_items_AST))));
+#line 6930 "AdaParser.cpp"
+ currentAST.root = empty_component_items_AST;
+ if ( empty_component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ empty_component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = empty_component_items_AST->getFirstChild();
+ else
+ currentAST.child = empty_component_items_AST;
+ currentAST.advanceChildToEnd();
+ }
+ empty_component_items_AST = RefAdaAST(currentAST.root);
+ returnAST = empty_component_items_AST;
+}
+
+void AdaParser::discriminant_direct_name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminant_direct_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp222_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp222_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp222_AST));
+ }
+ match(IDENTIFIER);
+ discriminant_direct_name_AST = RefAdaAST(currentAST.root);
+ returnAST = discriminant_direct_name_AST;
+}
+
+void AdaParser::variant_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST variant_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )+
+ int _cnt262=0;
+ for (;;) {
+ if ((LA(1) == WHEN)) {
+ variant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt262>=1 ) { goto _loop262; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt262++;
+ }
+ _loop262:;
+ } // ( ... )+
+ if ( inputState->guessing==0 ) {
+ variant_s_AST = RefAdaAST(currentAST.root);
+#line 819 "ada.g"
+ variant_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VARIANTS,"VARIANTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(variant_s_AST))));
+#line 6984 "AdaParser.cpp"
+ currentAST.root = variant_s_AST;
+ if ( variant_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ variant_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = variant_s_AST->getFirstChild();
+ else
+ currentAST.child = variant_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ variant_s_AST = RefAdaAST(currentAST.root);
+ returnAST = variant_s_AST;
+}
+
+void AdaParser::variant() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST variant_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ w = LT(1);
+ if ( inputState->guessing == 0 ) {
+ w_AST = astFactory->create(w);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+ }
+ match(WHEN);
+ choice_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RIGHT_SHAFT);
+ component_list(true);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 823 "ada.g"
+ Set (w_AST, VARIANT);
+#line 7022 "AdaParser.cpp"
+ }
+ variant_AST = RefAdaAST(currentAST.root);
+ returnAST = variant_AST;
+}
+
+void AdaParser::choice_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ choice();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PIPE)) {
+ RefAdaAST tmp224_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp224_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp224_AST));
+ }
+ match(PIPE);
+ choice();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop266;
+ }
+
+ }
+ _loop266:;
+ } // ( ... )*
+ choice_s_AST = RefAdaAST(currentAST.root);
+ returnAST = choice_s_AST;
+}
+
+void AdaParser::choice() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ if ((LA(1) == OTHERS)) {
+ RefAdaAST tmp225_AST = RefAdaAST(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(OTHERS);
+ choice_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched269 = false;
+ if (((_tokenSet_0.member(LA(1))) && (_tokenSet_20.member(LA(2))))) {
+ int _m269 = mark();
+ synPredMatched269 = true;
+ inputState->guessing++;
+ try {
+ {
+ discrete_with_range();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched269 = false;
+ }
+ rewind(_m269);
+ inputState->guessing--;
+ }
+ if ( synPredMatched269 ) {
+ discrete_with_range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ choice_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ choice_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = choice_AST;
+}
+
+void AdaParser::discrete_with_range() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discrete_with_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ bool synPredMatched272 = false;
+ if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) {
+ int _m272 = mark();
+ synPredMatched272 = true;
+ inputState->guessing++;
+ try {
+ {
+ mark_with_constraint();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched272 = false;
+ }
+ rewind(_m272);
+ inputState->guessing--;
+ }
+ if ( synPredMatched272 ) {
+ mark_with_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrete_with_range_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2)))) {
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrete_with_range_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = discrete_with_range_AST;
+}
+
+void AdaParser::mark_with_constraint() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST mark_with_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_constraint();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ mark_with_constraint_AST = RefAdaAST(currentAST.root);
+#line 839 "ada.g"
+ mark_with_constraint_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MARK_WITH_CONSTRAINT,"MARK_WITH_CONSTRAINT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mark_with_constraint_AST))));
+#line 7174 "AdaParser.cpp"
+ currentAST.root = mark_with_constraint_AST;
+ if ( mark_with_constraint_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ mark_with_constraint_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = mark_with_constraint_AST->getFirstChild();
+ else
+ currentAST.child = mark_with_constraint_AST;
+ currentAST.advanceChildToEnd();
+ }
+ mark_with_constraint_AST = RefAdaAST(currentAST.root);
+ returnAST = mark_with_constraint_AST;
+}
+
+void AdaParser::generic_formal_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST generic_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case USE:
+ {
+ use_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case WITH:
+ case TYPE:
+ {
+ generic_formal_parameter();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop289;
+ }
+ }
+ }
+ _loop289:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ generic_formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 885 "ada.g"
+ generic_formal_part_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(GENERIC_FORMAL_PART,"GENERIC_FORMAL_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(generic_formal_part_opt_AST))));
+#line 7234 "AdaParser.cpp"
+ currentAST.root = generic_formal_part_opt_AST;
+ if ( generic_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ generic_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = generic_formal_part_opt_AST->getFirstChild();
+ else
+ currentAST.child = generic_formal_part_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ generic_formal_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = generic_formal_part_opt_AST;
+}
+
+void AdaParser::generic_formal_parameter() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST generic_formal_parameter_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case TYPE:
+ {
+ t = LT(1);
+ if ( inputState->guessing == 0 ) {
+ t_AST = astFactory->create(t);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+ }
+ match(TYPE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ match(BOX);
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 895 "ada.g"
+ Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION);
+#line 7285 "AdaParser.cpp"
+ }
+ break;
+ }
+ case RANGE:
+ {
+ match(RANGE);
+ match(BOX);
+ if ( inputState->guessing==0 ) {
+#line 897 "ada.g"
+ Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
+#line 7296 "AdaParser.cpp"
+ }
+ break;
+ }
+ case MOD:
+ {
+ match(MOD);
+ match(BOX);
+ if ( inputState->guessing==0 ) {
+#line 899 "ada.g"
+ Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION);
+#line 7307 "AdaParser.cpp"
+ }
+ break;
+ }
+ case DELTA:
+ {
+ match(DELTA);
+ match(BOX);
+ {
+ switch ( LA(1)) {
+ case DIGITS:
+ {
+ match(DIGITS);
+ match(BOX);
+ if ( inputState->guessing==0 ) {
+#line 902 "ada.g"
+ Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
+#line 7324 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 903 "ada.g"
+ Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
+#line 7333 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case DIGITS:
+ {
+ match(DIGITS);
+ match(BOX);
+ if ( inputState->guessing==0 ) {
+#line 906 "ada.g"
+ Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION);
+#line 7352 "AdaParser.cpp"
+ }
+ break;
+ }
+ case ARRAY:
+ {
+ array_type_definition(t_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case ACCESS:
+ {
+ access_type_definition(t_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRIVATE:
+ case NEW:
+ case ABSTRACT:
+ case TAGGED:
+ case LIMITED:
+ {
+ empty_discrim_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discriminable_type_definition(t_AST);
+ 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 LPAREN:
+ {
+ discrim_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ discriminable_type_definition(t_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 913 "ada.g"
+ pop_def_id();
+#line 7418 "AdaParser.cpp"
+ }
+ break;
+ }
+ case WITH:
+ {
+ w = LT(1);
+ if ( inputState->guessing == 0 ) {
+ w_AST = astFactory->create(w);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+ }
+ match(WITH);
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ match(PROCEDURE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subprogram_default_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 915 "ada.g"
+ Set(w_AST, FORMAL_PROCEDURE_DECLARATION);
+#line 7450 "AdaParser.cpp"
+ }
+ break;
+ }
+ case FUNCTION:
+ {
+ match(FUNCTION);
+ def_designator(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subprogram_default_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 917 "ada.g"
+ Set(w_AST, FORMAL_FUNCTION_DECLARATION);
+#line 7472 "AdaParser.cpp"
+ }
+ break;
+ }
+ case PACKAGE:
+ {
+ match(PACKAGE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ match(NEW);
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_package_actual_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 919 "ada.g"
+ Set(w_AST, FORMAL_PACKAGE_DECLARATION);
+#line 7496 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 921 "ada.g"
+ pop_def_id();
+#line 7509 "AdaParser.cpp"
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ parameter_specification();
+ 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);
+ generic_formal_parameter_AST = RefAdaAST(currentAST.root);
+ returnAST = generic_formal_parameter_AST;
+}
+
+void AdaParser::discriminable_type_definition(
+ RefAdaAST t
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST discriminable_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ bool synPredMatched299 = false;
+ if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
+ int _m299 = mark();
+ synPredMatched299 = true;
+ inputState->guessing++;
+ try {
+ {
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ match(ABSTRACT);
+ break;
+ }
+ case NEW:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(NEW);
+ subtype_ind();
+ match(WITH);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched299 = false;
+ }
+ rewind(_m299);
+ inputState->guessing--;
+ }
+ if ( synPredMatched299 ) {
+ abstract_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(NEW);
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(WITH);
+ match(PRIVATE);
+ if ( inputState->guessing==0 ) {
+#line 930 "ada.g"
+ Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION);
+#line 7589 "AdaParser.cpp"
+ }
+ discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
+ match(NEW);
+ subtype_ind();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 932 "ada.g"
+ Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
+#line 7602 "AdaParser.cpp"
+ }
+ discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2)))) {
+ abstract_tagged_limited_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(PRIVATE);
+ if ( inputState->guessing==0 ) {
+#line 934 "ada.g"
+ Set (t, FORMAL_PRIVATE_TYPE_DECLARATION);
+#line 7615 "AdaParser.cpp"
+ }
+ discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = discriminable_type_definition_AST;
+}
+
+void AdaParser::subprogram_default_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subprogram_default_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ {
+ switch ( LA(1)) {
+ case BOX:
+ {
+ RefAdaAST tmp253_AST = RefAdaAST(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(BOX);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ name();
+ 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 SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subprogram_default_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = subprogram_default_opt_AST;
+}
+
+void AdaParser::formal_package_actual_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST formal_package_actual_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ {
+ switch ( LA(1)) {
+ case BOX:
+ {
+ RefAdaAST tmp255_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp255_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp255_AST));
+ }
+ match(BOX);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ defining_identifier_list();
+ 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(RPAREN);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ formal_package_actual_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = formal_package_actual_part_opt_AST;
+}
+
+void AdaParser::body_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ declarative_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ block_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ body_part_AST = RefAdaAST(currentAST.root);
+ returnAST = body_part_AST;
+}
+
+void AdaParser::declarative_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST declarative_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ declarative_item();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop316;
+ }
+ }
+ }
+ _loop316:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ declarative_part_AST = RefAdaAST(currentAST.root);
+#line 978 "ada.g"
+ declarative_part_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARATIVE_PART,"DECLARATIVE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declarative_part_AST))));
+#line 7799 "AdaParser.cpp"
+ currentAST.root = declarative_part_AST;
+ if ( declarative_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ declarative_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = declarative_part_AST->getFirstChild();
+ else
+ currentAST.child = declarative_part_AST;
+ currentAST.advanceChildToEnd();
+ }
+ declarative_part_AST = RefAdaAST(currentAST.root);
+ returnAST = declarative_part_AST;
+}
+
+void AdaParser::block_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST block_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken b = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST b_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ b = LT(1);
+ if ( inputState->guessing == 0 ) {
+ b_AST = astFactory->create(b);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(b_AST));
+ }
+ match(BEGIN);
+ handled_stmt_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1058 "ada.g"
+ Set(b_AST, BLOCK_BODY);
+#line 7832 "AdaParser.cpp"
+ }
+ block_body_AST = RefAdaAST(currentAST.root);
+ returnAST = block_body_AST;
+}
+
+void AdaParser::declarative_item() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST declarative_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PACKAGE:
+ {
+ pkg = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pkg_AST = astFactory->create(pkg);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+ }
+ match(PACKAGE);
+ {
+ switch ( LA(1)) {
+ case BODY:
+ {
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case SEPARATE:
+ {
+ separate();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 986 "ada.g"
+ Set(pkg_AST, PACKAGE_BODY_STUB);
+#line 7878 "AdaParser.cpp"
+ }
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case END:
+ case SUBTYPE:
+ case GENERIC:
+ case BEGIN:
+ {
+ pkg_body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 988 "ada.g"
+ Set(pkg_AST, PACKAGE_BODY);
+#line 7904 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ spec_decl_part(pkg_AST);
+ 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 TASK:
+ {
+ tsk = LT(1);
+ if ( inputState->guessing == 0 ) {
+ tsk_AST = astFactory->create(tsk);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST));
+ }
+ match(TASK);
+ {
+ switch ( LA(1)) {
+ case BODY:
+ {
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case SEPARATE:
+ {
+ separate();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 994 "ada.g"
+ Set(tsk_AST, TASK_BODY_STUB);
+#line 7964 "AdaParser.cpp"
+ }
+ break;
+ }
+ case PRAGMA:
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case PACKAGE:
+ case PROCEDURE:
+ case FUNCTION:
+ case TASK:
+ case PROTECTED:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ case BEGIN:
+ {
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 995 "ada.g"
+ Set(tsk_AST, TASK_BODY);
+#line 7989 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ break;
+ }
+ case IDENTIFIER:
+ case TYPE:
+ {
+ task_type_or_single_decl(tsk_AST);
+ 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 PROTECTED:
+ {
+ pro = LT(1);
+ if ( inputState->guessing == 0 ) {
+ pro_AST = astFactory->create(pro);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST));
+ }
+ match(PROTECTED);
+ {
+ switch ( LA(1)) {
+ case BODY:
+ {
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case SEPARATE:
+ {
+ separate();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1002 "ada.g"
+ Set(pro_AST, PROTECTED_BODY_STUB);
+#line 8046 "AdaParser.cpp"
+ }
+ break;
+ }
+ case PRAGMA:
+ case PROCEDURE:
+ case FUNCTION:
+ case ENTRY:
+ case END:
+ {
+ prot_op_bodies_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1004 "ada.g"
+ Set(pro_AST, PROTECTED_BODY);
+#line 8067 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case TYPE:
+ {
+ prot_type_or_single_decl(pro_AST);
+ 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);
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ subprog_decl_or_rename_or_inst_or_body(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case USE:
+ case TYPE:
+ case FOR:
+ case SUBTYPE:
+ case GENERIC:
+ {
+ decl_common();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ declarative_item_AST = RefAdaAST(currentAST.root);
+ returnAST = declarative_item_AST;
+}
+
+void AdaParser::body_is() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST body_is_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(BODY);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ body_is_AST = RefAdaAST(currentAST.root);
+ returnAST = body_is_AST;
+}
+
+void AdaParser::separate() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST separate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(SEPARATE);
+ if ( inputState->guessing==0 ) {
+#line 1023 "ada.g"
+ pop_def_id();
+#line 8153 "AdaParser.cpp"
+ }
+ separate_AST = RefAdaAST(currentAST.root);
+ returnAST = separate_AST;
+}
+
+void AdaParser::prot_op_bodies_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST prot_op_bodies_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case ENTRY:
+ {
+ entry_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ subprog_decl_or_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop332;
+ }
+ }
+ }
+ _loop332:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ prot_op_bodies_opt_AST = RefAdaAST(currentAST.root);
+#line 1039 "ada.g"
+ prot_op_bodies_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_BODIES_OPT,"PROT_OP_BODIES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_bodies_opt_AST))));
+#line 8205 "AdaParser.cpp"
+ currentAST.root = prot_op_bodies_opt_AST;
+ if ( prot_op_bodies_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ prot_op_bodies_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = prot_op_bodies_opt_AST->getFirstChild();
+ else
+ currentAST.child = prot_op_bodies_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ prot_op_bodies_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = prot_op_bodies_opt_AST;
+}
+
+void AdaParser::block_body_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST block_body_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ {
+ match(BEGIN);
+ handled_stmt_s();
+ 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());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ block_body_opt_AST = RefAdaAST(currentAST.root);
+#line 1030 "ada.g"
+ block_body_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_BODY_OPT,"BLOCK_BODY_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_body_opt_AST))));
+#line 8249 "AdaParser.cpp"
+ currentAST.root = block_body_opt_AST;
+ if ( block_body_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ block_body_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = block_body_opt_AST->getFirstChild();
+ else
+ currentAST.child = block_body_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ block_body_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = block_body_opt_AST;
+}
+
+void AdaParser::handled_stmt_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST handled_stmt_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ except_handler_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ handled_stmt_s_AST = RefAdaAST(currentAST.root);
+#line 1062 "ada.g"
+ handled_stmt_s_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,"HANDLED_SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmt_s_AST))));
+#line 8280 "AdaParser.cpp"
+ currentAST.root = handled_stmt_s_AST;
+ if ( handled_stmt_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ handled_stmt_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = handled_stmt_s_AST->getFirstChild();
+ else
+ currentAST.child = handled_stmt_s_AST;
+ currentAST.advanceChildToEnd();
+ }
+ handled_stmt_s_AST = RefAdaAST(currentAST.root);
+ returnAST = handled_stmt_s_AST;
+}
+
+void AdaParser::entry_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ e = LT(1);
+ if ( inputState->guessing == 0 ) {
+ e_AST = astFactory->create(e);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+ }
+ match(ENTRY);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ entry_body_formal_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ entry_barrier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1236 "ada.g"
+ Set (e_AST, ENTRY_BODY);
+#line 8327 "AdaParser.cpp"
+ }
+ entry_body_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_body_AST;
+}
+
+void AdaParser::subprog_decl_or_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subprog_decl_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROCEDURE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1046 "ada.g"
+ Set(p_AST, PROCEDURE_BODY);
+#line 8371 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 1047 "ada.g"
+ pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
+#line 8380 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ subprog_decl_or_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ f = LT(1);
+ if ( inputState->guessing == 0 ) {
+ f_AST = astFactory->create(f);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+ }
+ match(FUNCTION);
+ def_designator(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IS:
+ {
+ match(IS);
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1051 "ada.g"
+ Set(f_AST, FUNCTION_BODY);
+#line 8422 "AdaParser.cpp"
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 1052 "ada.g"
+ pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
+#line 8431 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ subprog_decl_or_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = subprog_decl_or_body_AST;
+}
+
+void AdaParser::statements() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST statements_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )+
+ int _cnt342=0;
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case NuLL:
+ case RETURN:
+ case FOR:
+ case CASE:
+ case BEGIN:
+ case LT_LT:
+ case IF:
+ case LOOP:
+ case WHILE:
+ case DECLARE:
+ case EXIT:
+ case GOTO:
+ case ACCEPT:
+ case DELAY:
+ case SELECT:
+ case ABORT:
+ case RAISE:
+ case REQUEUE:
+ {
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ if ( _cnt342>=1 ) { goto _loop342; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+ }
+ _cnt342++;
+ }
+ _loop342:;
+ } // ( ... )+
+ if ( inputState->guessing==0 ) {
+ statements_AST = RefAdaAST(currentAST.root);
+#line 1074 "ada.g"
+ statements_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SEQUENCE_OF_STATEMENTS,"SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statements_AST))));
+#line 8509 "AdaParser.cpp"
+ currentAST.root = statements_AST;
+ if ( statements_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ statements_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = statements_AST->getFirstChild();
+ else
+ currentAST.child = statements_AST;
+ currentAST.advanceChildToEnd();
+ }
+ statements_AST = RefAdaAST(currentAST.root);
+ returnAST = statements_AST;
+}
+
+void AdaParser::except_handler_part_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST except_handler_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case EXCEPTION:
+ {
+ match(EXCEPTION);
+ { // ( ... )+
+ int _cnt429=0;
+ for (;;) {
+ if ((LA(1) == WHEN)) {
+ exception_handler();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt429>=1 ) { goto _loop429; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt429++;
+ }
+ _loop429:;
+ } // ( ... )+
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ except_handler_part_opt_AST = RefAdaAST(currentAST.root);
+#line 1365 "ada.g"
+ except_handler_part_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXCEPT_HANDLER_PART_OPT,"EXCEPT_HANDLER_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(except_handler_part_opt_AST))));
+#line 8566 "AdaParser.cpp"
+ currentAST.root = except_handler_part_opt_AST;
+ if ( except_handler_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ except_handler_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = except_handler_part_opt_AST->getFirstChild();
+ else
+ currentAST.child = except_handler_part_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ except_handler_part_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = except_handler_part_opt_AST;
+}
+
+void AdaParser::handled_stmts_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST handled_stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case PRAGMA:
+ case IDENTIFIER:
+ case NuLL:
+ case RETURN:
+ case FOR:
+ case CASE:
+ case BEGIN:
+ case LT_LT:
+ case IF:
+ case LOOP:
+ case WHILE:
+ case DECLARE:
+ case EXIT:
+ case GOTO:
+ case ACCEPT:
+ case DELAY:
+ case SELECT:
+ case ABORT:
+ case RAISE:
+ case REQUEUE:
+ {
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ except_handler_part_opt();
+ 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());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ handled_stmts_opt_AST = RefAdaAST(currentAST.root);
+#line 1068 "ada.g"
+ handled_stmts_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_STMTS_OPT,"HANDLED_STMTS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmts_opt_AST))));
+#line 8632 "AdaParser.cpp"
+ currentAST.root = handled_stmts_opt_AST;
+ if ( handled_stmts_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ handled_stmts_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = handled_stmts_opt_AST->getFirstChild();
+ else
+ currentAST.child = handled_stmts_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ handled_stmts_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = handled_stmts_opt_AST;
+}
+
+void AdaParser::statement() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST statement_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ def_label_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case NuLL:
+ {
+ null_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case EXIT:
+ {
+ exit_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RETURN:
+ {
+ return_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case GOTO:
+ {
+ goto_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DELAY:
+ {
+ delay_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case ABORT:
+ {
+ abort_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RAISE:
+ {
+ raise_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case REQUEUE:
+ {
+ requeue_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case ACCEPT:
+ {
+ accept_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SELECT:
+ {
+ select_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IF:
+ {
+ if_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CASE:
+ {
+ case_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case FOR:
+ case LOOP:
+ case WHILE:
+ {
+ loop_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case BEGIN:
+ case DECLARE:
+ {
+ block();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(SEMI);
+ break;
+ }
+ default:
+ if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
+ statement_identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case FOR:
+ case LOOP:
+ case WHILE:
+ {
+ loop_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case BEGIN:
+ case DECLARE:
+ {
+ block();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else if ((LA(1) == IDENTIFIER) && (_tokenSet_24.member(LA(2)))) {
+ call_or_assignment();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ statement_AST = RefAdaAST(currentAST.root);
+#line 1100 "ada.g"
+ statement_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STATEMENT,"STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statement_AST))));
+#line 8833 "AdaParser.cpp"
+ currentAST.root = statement_AST;
+ if ( statement_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ statement_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = statement_AST->getFirstChild();
+ else
+ currentAST.child = statement_AST;
+ currentAST.advanceChildToEnd();
+ }
+ statement_AST = RefAdaAST(currentAST.root);
+ returnAST = statement_AST;
+}
+
+void AdaParser::def_label_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST def_label_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case LT_LT:
+ {
+ match(LT_LT);
+ RefAdaAST tmp277_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp277_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp277_AST));
+ }
+ match(IDENTIFIER);
+ match(GT_GT);
+ break;
+ }
+ case IDENTIFIER:
+ case NuLL:
+ case RETURN:
+ case FOR:
+ case CASE:
+ case BEGIN:
+ case IF:
+ case LOOP:
+ case WHILE:
+ case DECLARE:
+ case EXIT:
+ case GOTO:
+ case ACCEPT:
+ case DELAY:
+ case SELECT:
+ case ABORT:
+ case RAISE:
+ case REQUEUE:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ def_label_opt_AST = RefAdaAST(currentAST.root);
+#line 1104 "ada.g"
+ def_label_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LABEL_OPT,"LABEL_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(def_label_opt_AST))));
+#line 8896 "AdaParser.cpp"
+ currentAST.root = def_label_opt_AST;
+ if ( def_label_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ def_label_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = def_label_opt_AST->getFirstChild();
+ else
+ currentAST.child = def_label_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ def_label_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = def_label_opt_AST;
+}
+
+void AdaParser::null_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST null_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(NuLL);
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1108 "ada.g"
+ Set(s_AST, NULL_STATEMENT);
+#line 8926 "AdaParser.cpp"
+ }
+ null_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = null_stmt_AST;
+}
+
+void AdaParser::exit_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST exit_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(EXIT);
+ {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ label_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case WHEN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case WHEN:
+ {
+ RefAdaAST tmp280_AST = RefAdaAST(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(WHEN);
+ condition();
+ 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);
+ if ( inputState->guessing==0 ) {
+#line 1206 "ada.g"
+ Set(s_AST, EXIT_STATEMENT);
+#line 8996 "AdaParser.cpp"
+ }
+ exit_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = exit_stmt_AST;
+}
+
+void AdaParser::return_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST return_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(RETURN);
+ {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ expression();
+ 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);
+ if ( inputState->guessing==0 ) {
+#line 1213 "ada.g"
+ Set(s_AST, RETURN_STATEMENT);
+#line 9049 "AdaParser.cpp"
+ }
+ return_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = return_stmt_AST;
+}
+
+void AdaParser::goto_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST goto_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(GOTO);
+ label_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1217 "ada.g"
+ Set(s_AST, GOTO_STATEMENT);
+#line 9076 "AdaParser.cpp"
+ }
+ goto_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = goto_stmt_AST;
+}
+
+void AdaParser::delay_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST delay_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ d = LT(1);
+ if ( inputState->guessing == 0 ) {
+ d_AST = astFactory->create(d);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+ }
+ match(DELAY);
+ until_opt();
+ 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));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1282 "ada.g"
+ Set (d_AST, DELAY_STATEMENT);
+#line 9107 "AdaParser.cpp"
+ }
+ delay_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = delay_stmt_AST;
+}
+
+void AdaParser::abort_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST abort_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ a = LT(1);
+ if ( inputState->guessing == 0 ) {
+ a_AST = astFactory->create(a);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+ }
+ match(ABORT);
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop425;
+ }
+
+ }
+ _loop425:;
+ } // ( ... )*
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1361 "ada.g"
+ Set (a_AST, ABORT_STATEMENT);
+#line 9150 "AdaParser.cpp"
+ }
+ abort_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = abort_stmt_AST;
+}
+
+void AdaParser::raise_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST raise_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(RAISE);
+ {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ compound_name();
+ 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);
+ if ( inputState->guessing==0 ) {
+#line 1389 "ada.g"
+ Set (r_AST, RAISE_STATEMENT);
+#line 9193 "AdaParser.cpp"
+ }
+ raise_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = raise_stmt_AST;
+}
+
+void AdaParser::requeue_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST requeue_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ r = LT(1);
+ if ( inputState->guessing == 0 ) {
+ r_AST = astFactory->create(r);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+ }
+ match(REQUEUE);
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case WITH:
+ {
+ match(WITH);
+ RefAdaAST tmp289_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp289_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp289_AST));
+ }
+ match(ABORT);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1393 "ada.g"
+ Set (r_AST, REQUEUE_STATEMENT);
+#line 9243 "AdaParser.cpp"
+ }
+ requeue_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = requeue_stmt_AST;
+}
+
+void AdaParser::accept_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST accept_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ a = LT(1);
+ if ( inputState->guessing == 0 ) {
+ a_AST = astFactory->create(a);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+ }
+ match(ACCEPT);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ entry_index_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case DO:
+ {
+ match(DO);
+ handled_stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case SEMI:
+ {
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1264 "ada.g"
+ pop_def_id();
+#line 9296 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 1266 "ada.g"
+ Set (a_AST, ACCEPT_STATEMENT);
+#line 9309 "AdaParser.cpp"
+ }
+ accept_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = accept_stmt_AST;
+}
+
+void AdaParser::select_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST select_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(SELECT);
+ {
+ bool synPredMatched403 = false;
+ if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (_tokenSet_25.member(LA(2))))) {
+ int _m403 = mark();
+ synPredMatched403 = true;
+ inputState->guessing++;
+ try {
+ {
+ triggering_alternative();
+ match(THEN);
+ match(ABORT);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched403 = false;
+ }
+ rewind(_m403);
+ inputState->guessing--;
+ }
+ if ( synPredMatched403 ) {
+ triggering_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(THEN);
+ match(ABORT);
+ abortable_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1297 "ada.g"
+ Set (s_AST, ASYNCHRONOUS_SELECT);
+#line 9361 "AdaParser.cpp"
+ }
+ }
+ else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) {
+ selective_accept();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1299 "ada.g"
+ Set (s_AST, SELECTIVE_ACCEPT);
+#line 9372 "AdaParser.cpp"
+ }
+ }
+ else if ((LA(1) == IDENTIFIER) && (_tokenSet_28.member(LA(2)))) {
+ entry_call_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case OR:
+ {
+ match(OR);
+ delay_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1301 "ada.g"
+ Set (s_AST, TIMED_ENTRY_CALL);
+#line 9392 "AdaParser.cpp"
+ }
+ break;
+ }
+ case ELSE:
+ {
+ match(ELSE);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1302 "ada.g"
+ Set (s_AST, CONDITIONAL_ENTRY_CALL);
+#line 9406 "AdaParser.cpp"
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ match(END);
+ match(SELECT);
+ match(SEMI);
+ select_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = select_stmt_AST;
+}
+
+void AdaParser::if_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST if_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(IF);
+ cond_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ elsifs_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ else_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(IF);
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1114 "ada.g"
+ Set(s_AST, IF_STATEMENT);
+#line 9460 "AdaParser.cpp"
+ }
+ if_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = if_stmt_AST;
+}
+
+void AdaParser::case_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST case_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(CASE);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ alternative_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(CASE);
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1134 "ada.g"
+ Set(s_AST, CASE_STATEMENT);
+#line 9494 "AdaParser.cpp"
+ }
+ case_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = case_stmt_AST;
+}
+
+void AdaParser::loop_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST loop_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken l = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST l_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ iteration_scheme_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ l = LT(1);
+ if ( inputState->guessing == 0 ) {
+ l_AST = astFactory->create(l);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(l_AST));
+ }
+ match(LOOP);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(LOOP);
+ if ( inputState->guessing==0 ) {
+#line 1146 "ada.g"
+ Set(l_AST, LOOP_STATEMENT);
+#line 9526 "AdaParser.cpp"
+ }
+ loop_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = loop_stmt_AST;
+}
+
+void AdaParser::block() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST block_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ declare_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ block_body();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ block_AST = RefAdaAST(currentAST.root);
+#line 1198 "ada.g"
+ block_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_STATEMENT,"BLOCK_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_AST))));
+#line 9549 "AdaParser.cpp"
+ currentAST.root = block_AST;
+ if ( block_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ block_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = block_AST->getFirstChild();
+ else
+ currentAST.child = block_AST;
+ currentAST.advanceChildToEnd();
+ }
+ block_AST = RefAdaAST(currentAST.root);
+ returnAST = block_AST;
+}
+
+void AdaParser::statement_identifier() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST statement_identifier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ n = LT(1);
+ if ( inputState->guessing == 0 ) {
+ n_AST = astFactory->create(n);
+ }
+ match(IDENTIFIER);
+ match(COLON);
+ if ( inputState->guessing==0 ) {
+#line 1186 "ada.g"
+ push_def_id(n_AST);
+#line 9578 "AdaParser.cpp"
+ }
+ returnAST = statement_identifier_AST;
+}
+
+void AdaParser::id_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ id_opt_aux();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ id_opt_AST = RefAdaAST(currentAST.root);
+#line 1172 "ada.g"
+ id_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ID_OPT,"ID_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_opt_AST))));
+#line 9596 "AdaParser.cpp"
+ currentAST.root = id_opt_AST;
+ if ( id_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ id_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = id_opt_AST->getFirstChild();
+ else
+ currentAST.child = id_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ id_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = id_opt_AST;
+}
+
+void AdaParser::call_or_assignment() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST call_or_assignment_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ match(ASSIGN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ call_or_assignment_AST = RefAdaAST(currentAST.root);
+#line 1222 "ada.g"
+ call_or_assignment_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ASSIGNMENT_STATEMENT,"ASSIGNMENT_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST))));
+#line 9632 "AdaParser.cpp"
+ currentAST.root = call_or_assignment_AST;
+ if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = call_or_assignment_AST->getFirstChild();
+ else
+ currentAST.child = call_or_assignment_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+ call_or_assignment_AST = RefAdaAST(currentAST.root);
+#line 1225 "ada.g"
+ call_or_assignment_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CALL_STATEMENT,"CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST))));
+#line 9650 "AdaParser.cpp"
+ currentAST.root = call_or_assignment_AST;
+ if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = call_or_assignment_AST->getFirstChild();
+ else
+ currentAST.child = call_or_assignment_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ call_or_assignment_AST = RefAdaAST(currentAST.root);
+ returnAST = call_or_assignment_AST;
+}
+
+void AdaParser::cond_clause() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST cond_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ condition();
+ 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(THEN);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1118 "ada.g"
+ Set(c_AST, COND_CLAUSE);
+#line 9696 "AdaParser.cpp"
+ }
+ cond_clause_AST = RefAdaAST(currentAST.root);
+ returnAST = cond_clause_AST;
+}
+
+void AdaParser::elsifs_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST elsifs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == ELSIF)) {
+ match(ELSIF);
+ cond_clause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop354;
+ }
+
+ }
+ _loop354:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ elsifs_opt_AST = RefAdaAST(currentAST.root);
+#line 1126 "ada.g"
+ elsifs_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSIFS_OPT,"ELSIFS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(elsifs_opt_AST))));
+#line 9727 "AdaParser.cpp"
+ currentAST.root = elsifs_opt_AST;
+ if ( elsifs_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ elsifs_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = elsifs_opt_AST->getFirstChild();
+ else
+ currentAST.child = elsifs_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ elsifs_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = elsifs_opt_AST;
+}
+
+void AdaParser::else_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST else_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ 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());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ else_opt_AST = RefAdaAST(currentAST.root);
+#line 1130 "ada.g"
+ else_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSE_OPT,"ELSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(else_opt_AST))));
+#line 9770 "AdaParser.cpp"
+ currentAST.root = else_opt_AST;
+ if ( else_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ else_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = else_opt_AST->getFirstChild();
+ else
+ currentAST.child = else_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ else_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = else_opt_AST;
+}
+
+void AdaParser::condition() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST condition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ condition_AST = RefAdaAST(currentAST.root);
+ returnAST = condition_AST;
+}
+
+void AdaParser::alternative_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST alternative_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )+
+ int _cnt360=0;
+ for (;;) {
+ if ((LA(1) == WHEN)) {
+ case_statement_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt360>=1 ) { goto _loop360; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt360++;
+ }
+ _loop360:;
+ } // ( ... )+
+ alternative_s_AST = RefAdaAST(currentAST.root);
+ returnAST = alternative_s_AST;
+}
+
+void AdaParser::case_statement_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST case_statement_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ s = LT(1);
+ if ( inputState->guessing == 0 ) {
+ s_AST = astFactory->create(s);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+ }
+ match(WHEN);
+ choice_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RIGHT_SHAFT);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1141 "ada.g"
+ Set(s_AST, CASE_STATEMENT_ALTERNATIVE);
+#line 9847 "AdaParser.cpp"
+ }
+ case_statement_alternative_AST = RefAdaAST(currentAST.root);
+ returnAST = case_statement_alternative_AST;
+}
+
+void AdaParser::iteration_scheme_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST iteration_scheme_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case WHILE:
+ {
+ RefAdaAST tmp316_AST = RefAdaAST(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(WHILE);
+ condition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case FOR:
+ {
+ RefAdaAST tmp317_AST = RefAdaAST(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(FOR);
+ RefAdaAST tmp318_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp318_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp318_AST));
+ }
+ match(IDENTIFIER);
+ match(IN);
+ reverse_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ discrete_subtype_definition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LOOP:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ iteration_scheme_opt_AST = RefAdaAST(currentAST.root);
+#line 1152 "ada.g"
+ iteration_scheme_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ITERATION_SCHEME_OPT,"ITERATION_SCHEME_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(iteration_scheme_opt_AST))));
+#line 9914 "AdaParser.cpp"
+ currentAST.root = iteration_scheme_opt_AST;
+ if ( iteration_scheme_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ iteration_scheme_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = iteration_scheme_opt_AST->getFirstChild();
+ else
+ currentAST.child = iteration_scheme_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ iteration_scheme_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = iteration_scheme_opt_AST;
+}
+
+void AdaParser::reverse_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST reverse_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case REVERSE:
+ {
+ RefAdaAST tmp320_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp320_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp320_AST));
+ }
+ match(REVERSE);
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ reverse_opt_AST = RefAdaAST(currentAST.root);
+#line 1158 "ada.g"
+ reverse_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(reverse_opt_AST))));
+#line 9968 "AdaParser.cpp"
+ currentAST.root = reverse_opt_AST;
+ if ( reverse_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ reverse_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = reverse_opt_AST->getFirstChild();
+ else
+ currentAST.child = reverse_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ reverse_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = reverse_opt_AST;
+}
+
+void AdaParser::id_opt_aux() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST id_opt_aux_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 1161 "ada.g"
+ RefAdaAST endid;
+#line 9988 "AdaParser.cpp"
+
+ switch ( LA(1)) {
+ case CHAR_STRING:
+ {
+ endid=definable_operator_symbol();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if (!( end_id_matches_def_id (endid) ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (endid) ");
+ id_opt_aux_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ compound_name();
+ if (inputState->guessing==0) {
+ n_AST = returnAST;
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if (!( end_id_matches_def_id (n_AST) ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (n_AST) ");
+ id_opt_aux_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case SEMI:
+ {
+ if ( inputState->guessing==0 ) {
+#line 1168 "ada.g"
+ pop_def_id();
+#line 10019 "AdaParser.cpp"
+ }
+ id_opt_aux_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = id_opt_aux_AST;
+}
+
+void AdaParser::declare_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST declare_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case DECLARE:
+ {
+ match(DECLARE);
+ declarative_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case BEGIN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ declare_opt_AST = RefAdaAST(currentAST.root);
+#line 1202 "ada.g"
+ declare_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARE_OPT,"DECLARE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declare_opt_AST))));
+#line 10062 "AdaParser.cpp"
+ currentAST.root = declare_opt_AST;
+ if ( declare_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ declare_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = declare_opt_AST->getFirstChild();
+ else
+ currentAST.child = declare_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ declare_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = declare_opt_AST;
+}
+
+void AdaParser::label_name() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST label_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ RefAdaAST tmp322_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp322_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp322_AST));
+ }
+ match(IDENTIFIER);
+ label_name_AST = RefAdaAST(currentAST.root);
+ returnAST = label_name_AST;
+}
+
+void AdaParser::entry_body_formal_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_body_formal_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ entry_index_spec_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ entry_body_formal_part_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_body_formal_part_AST;
+}
+
+void AdaParser::entry_barrier() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_barrier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(WHEN);
+ condition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ entry_barrier_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_barrier_AST;
+}
+
+void AdaParser::entry_index_spec_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_index_spec_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched388 = false;
+ if (((LA(1) == LPAREN) && (LA(2) == FOR))) {
+ int _m388 = mark();
+ synPredMatched388 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(LPAREN);
+ match(FOR);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched388 = false;
+ }
+ rewind(_m388);
+ inputState->guessing--;
+ }
+ if ( synPredMatched388 ) {
+ match(LPAREN);
+ match(FOR);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IN);
+ discrete_subtype_definition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ }
+ else if ((LA(1) == LPAREN || LA(1) == WHEN) && (_tokenSet_0.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState->guessing==0 ) {
+ entry_index_spec_opt_AST = RefAdaAST(currentAST.root);
+#line 1247 "ada.g"
+ entry_index_spec_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_SPECIFICATION,"ENTRY_INDEX_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_spec_opt_AST))));
+#line 10170 "AdaParser.cpp"
+ currentAST.root = entry_index_spec_opt_AST;
+ if ( entry_index_spec_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ entry_index_spec_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = entry_index_spec_opt_AST->getFirstChild();
+ else
+ currentAST.child = entry_index_spec_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ entry_index_spec_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_index_spec_opt_AST;
+}
+
+void AdaParser::entry_call_stmt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_call_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+ entry_call_stmt_AST = RefAdaAST(currentAST.root);
+#line 1257 "ada.g"
+ entry_call_stmt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_STATEMENT,"ENTRY_CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_stmt_AST))));
+#line 10198 "AdaParser.cpp"
+ currentAST.root = entry_call_stmt_AST;
+ if ( entry_call_stmt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ entry_call_stmt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = entry_call_stmt_AST->getFirstChild();
+ else
+ currentAST.child = entry_call_stmt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ entry_call_stmt_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_call_stmt_AST;
+}
+
+void AdaParser::entry_index_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_index_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ bool synPredMatched396 = false;
+ if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+ int _m396 = mark();
+ synPredMatched396 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(LPAREN);
+ expression();
+ match(RPAREN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched396 = false;
+ }
+ rewind(_m396);
+ inputState->guessing--;
+ }
+ if ( synPredMatched396 ) {
+ match(LPAREN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ }
+ else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (_tokenSet_29.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState->guessing==0 ) {
+ entry_index_opt_AST = RefAdaAST(currentAST.root);
+#line 1276 "ada.g"
+ entry_index_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_OPT,"ENTRY_INDEX_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_opt_AST))));
+#line 10255 "AdaParser.cpp"
+ currentAST.root = entry_index_opt_AST;
+ if ( entry_index_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ entry_index_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = entry_index_opt_AST->getFirstChild();
+ else
+ currentAST.child = entry_index_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ entry_index_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_index_opt_AST;
+}
+
+void AdaParser::until_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST until_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case UNTIL:
+ {
+ RefAdaAST tmp331_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp331_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp331_AST));
+ }
+ match(UNTIL);
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+ until_opt_AST = RefAdaAST(currentAST.root);
+#line 1286 "ada.g"
+ until_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(until_opt_AST))));
+#line 10309 "AdaParser.cpp"
+ currentAST.root = until_opt_AST;
+ if ( until_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ until_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = until_opt_AST->getFirstChild();
+ else
+ currentAST.child = until_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ until_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = until_opt_AST;
+}
+
+void AdaParser::triggering_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST triggering_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case DELAY:
+ {
+ delay_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ {
+ entry_call_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ triggering_alternative_AST = RefAdaAST(currentAST.root);
+#line 1310 "ada.g"
+ triggering_alternative_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TRIGGERING_ALTERNATIVE,"TRIGGERING_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(triggering_alternative_AST))));
+#line 10360 "AdaParser.cpp"
+ currentAST.root = triggering_alternative_AST;
+ if ( triggering_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ triggering_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = triggering_alternative_AST->getFirstChild();
+ else
+ currentAST.child = triggering_alternative_AST;
+ currentAST.advanceChildToEnd();
+ }
+ triggering_alternative_AST = RefAdaAST(currentAST.root);
+ returnAST = triggering_alternative_AST;
+}
+
+void AdaParser::abortable_part() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST abortable_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ abortable_part_AST = RefAdaAST(currentAST.root);
+#line 1316 "ada.g"
+ abortable_part_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ABORTABLE_PART,"ABORTABLE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abortable_part_AST))));
+#line 10387 "AdaParser.cpp"
+ currentAST.root = abortable_part_AST;
+ if ( abortable_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ abortable_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = abortable_part_AST->getFirstChild();
+ else
+ currentAST.child = abortable_part_AST;
+ currentAST.advanceChildToEnd();
+ }
+ abortable_part_AST = RefAdaAST(currentAST.root);
+ returnAST = abortable_part_AST;
+}
+
+void AdaParser::selective_accept() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST selective_accept_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ guard_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ select_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ or_select_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ else_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ selective_accept_AST = RefAdaAST(currentAST.root);
+ returnAST = selective_accept_AST;
+}
+
+void AdaParser::entry_call_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST entry_call_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ entry_call_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ entry_call_alternative_AST = RefAdaAST(currentAST.root);
+#line 1322 "ada.g"
+ entry_call_alternative_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_ALTERNATIVE,"ENTRY_CALL_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_alternative_AST))));
+#line 10443 "AdaParser.cpp"
+ currentAST.root = entry_call_alternative_AST;
+ if ( entry_call_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ entry_call_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = entry_call_alternative_AST->getFirstChild();
+ else
+ currentAST.child = entry_call_alternative_AST;
+ currentAST.advanceChildToEnd();
+ }
+ entry_call_alternative_AST = RefAdaAST(currentAST.root);
+ returnAST = entry_call_alternative_AST;
+}
+
+void AdaParser::delay_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST delay_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ delay_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ delay_alternative_AST = RefAdaAST(currentAST.root);
+#line 1347 "ada.g"
+ delay_alternative_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DELAY_ALTERNATIVE,"DELAY_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(delay_alternative_AST))));
+#line 10474 "AdaParser.cpp"
+ currentAST.root = delay_alternative_AST;
+ if ( delay_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ delay_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = delay_alternative_AST->getFirstChild();
+ else
+ currentAST.child = delay_alternative_AST;
+ currentAST.advanceChildToEnd();
+ }
+ delay_alternative_AST = RefAdaAST(currentAST.root);
+ returnAST = delay_alternative_AST;
+}
+
+void AdaParser::stmts_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case PRAGMA:
+ {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case NuLL:
+ case RETURN:
+ case FOR:
+ case CASE:
+ case BEGIN:
+ case LT_LT:
+ case IF:
+ case LOOP:
+ case WHILE:
+ case DECLARE:
+ case EXIT:
+ case GOTO:
+ case ACCEPT:
+ case DELAY:
+ case SELECT:
+ case ABORT:
+ case RAISE:
+ case REQUEUE:
+ {
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop419;
+ }
+ }
+ }
+ _loop419:;
+ } // ( ... )*
+ stmts_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = stmts_opt_AST;
+}
+
+void AdaParser::guard_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST guard_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case WHEN:
+ {
+ w = LT(1);
+ if ( inputState->guessing == 0 ) {
+ w_AST = astFactory->create(w);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+ }
+ match(WHEN);
+ condition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RIGHT_SHAFT);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PRAGMA)) {
+ pragma();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop413;
+ }
+
+ }
+ _loop413:;
+ } // ( ... )*
+ break;
+ }
+ case ACCEPT:
+ case DELAY:
+ case TERMINATE:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState->guessing==0 ) {
+#line 1331 "ada.g"
+ Set(w_AST, GUARD_OPT);
+#line 10595 "AdaParser.cpp"
+ }
+ guard_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = guard_opt_AST;
+}
+
+void AdaParser::select_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST select_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case ACCEPT:
+ {
+ accept_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ select_alternative_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case DELAY:
+ {
+ delay_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ select_alternative_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case TERMINATE:
+ {
+ t = LT(1);
+ if ( inputState->guessing == 0 ) {
+ t_AST = astFactory->create(t);
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+ }
+ match(TERMINATE);
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1337 "ada.g"
+ Set(t_AST, TERMINATE_ALTERNATIVE);
+#line 10639 "AdaParser.cpp"
+ }
+ select_alternative_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = select_alternative_AST;
+}
+
+void AdaParser::or_select_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST or_select_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == OR)) {
+ match(OR);
+ guard_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ select_alternative();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop422;
+ }
+
+ }
+ _loop422:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ or_select_opt_AST = RefAdaAST(currentAST.root);
+#line 1356 "ada.g"
+ or_select_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(OR_SELECT_OPT,"OR_SELECT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(or_select_opt_AST))));
+#line 10682 "AdaParser.cpp"
+ currentAST.root = or_select_opt_AST;
+ if ( or_select_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ or_select_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = or_select_opt_AST->getFirstChild();
+ else
+ currentAST.child = or_select_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ or_select_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = or_select_opt_AST;
+}
+
+void AdaParser::accept_alternative() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST accept_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ accept_stmt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stmts_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+ accept_alternative_AST = RefAdaAST(currentAST.root);
+#line 1341 "ada.g"
+ accept_alternative_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ACCEPT_ALTERNATIVE,"ACCEPT_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(accept_alternative_AST))));
+#line 10713 "AdaParser.cpp"
+ currentAST.root = accept_alternative_AST;
+ if ( accept_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ accept_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = accept_alternative_AST->getFirstChild();
+ else
+ currentAST.child = accept_alternative_AST;
+ currentAST.advanceChildToEnd();
+ }
+ accept_alternative_AST = RefAdaAST(currentAST.root);
+ returnAST = accept_alternative_AST;
+}
+
+void AdaParser::exception_handler() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST exception_handler_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ w = LT(1);
+ if ( inputState->guessing == 0 ) {
+ w_AST = astFactory->create(w);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+ }
+ match(WHEN);
+ identifier_colon_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ except_choice_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RIGHT_SHAFT);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1372 "ada.g"
+ Set (w_AST, EXCEPTION_HANDLER);
+#line 10755 "AdaParser.cpp"
+ }
+ exception_handler_AST = RefAdaAST(currentAST.root);
+ returnAST = exception_handler_AST;
+}
+
+void AdaParser::identifier_colon_opt() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST identifier_colon_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
+ RefAdaAST tmp336_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp336_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp336_AST));
+ }
+ match(IDENTIFIER);
+ match(COLON);
+ }
+ else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState->guessing==0 ) {
+ identifier_colon_opt_AST = RefAdaAST(currentAST.root);
+#line 1376 "ada.g"
+ identifier_colon_opt_AST =
+ RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IDENTIFIER_COLON_OPT,"IDENTIFIER_COLON_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(identifier_colon_opt_AST))));
+#line 10788 "AdaParser.cpp"
+ currentAST.root = identifier_colon_opt_AST;
+ if ( identifier_colon_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ identifier_colon_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = identifier_colon_opt_AST->getFirstChild();
+ else
+ currentAST.child = identifier_colon_opt_AST;
+ currentAST.advanceChildToEnd();
+ }
+ identifier_colon_opt_AST = RefAdaAST(currentAST.root);
+ returnAST = identifier_colon_opt_AST;
+}
+
+void AdaParser::except_choice_s() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST except_choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ exception_choice();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == PIPE)) {
+ RefAdaAST tmp338_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp338_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp338_AST));
+ }
+ match(PIPE);
+ exception_choice();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop435;
+ }
+
+ }
+ _loop435:;
+ } // ( ... )*
+ except_choice_s_AST = RefAdaAST(currentAST.root);
+ returnAST = except_choice_s_AST;
+}
+
+void AdaParser::exception_choice() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST exception_choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ compound_name();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exception_choice_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case OTHERS:
+ {
+ RefAdaAST tmp339_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp339_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp339_AST));
+ }
+ match(OTHERS);
+ exception_choice_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = exception_choice_AST;
+}
+
+void AdaParser::operator_call() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST operator_call_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ cs = LT(1);
+ if ( inputState->guessing == 0 ) {
+ cs_AST = astFactory->create(cs);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST));
+ }
+ match(CHAR_STRING);
+ operator_call_tail(cs_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ operator_call_AST = RefAdaAST(currentAST.root);
+ returnAST = operator_call_AST;
+}
+
+void AdaParser::operator_call_tail(
+ RefAdaAST opstr
+) {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST operator_call_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ match(LPAREN);
+ if (!( is_operator_symbol(opstr->getText().c_str()) ))
+ throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(opstr->getText().c_str()) ");
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 1401 "ada.g"
+ opstr->setType(OPERATOR_SYMBOL);
+#line 10908 "AdaParser.cpp"
+ }
+ operator_call_tail_AST = RefAdaAST(currentAST.root);
+ returnAST = operator_call_tail_AST;
+}
+
+void AdaParser::relation() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST relation_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case IN:
+ {
+ RefAdaAST tmp342_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp342_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp342_AST));
+ }
+ match(IN);
+ range_or_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case NOT:
+ {
+ n = LT(1);
+ if ( inputState->guessing == 0 ) {
+ n_AST = astFactory->create(n);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+ }
+ match(NOT);
+ match(IN);
+ range_or_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1425 "ada.g"
+ Set (n_AST, NOT_IN);
+#line 10957 "AdaParser.cpp"
+ }
+ break;
+ }
+ case EQ:
+ {
+ RefAdaAST tmp344_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp344_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp344_AST));
+ }
+ match(EQ);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case NE:
+ {
+ RefAdaAST tmp345_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp345_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp345_AST));
+ }
+ match(NE);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LT_:
+ {
+ RefAdaAST tmp346_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp346_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp346_AST));
+ }
+ match(LT_);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LE:
+ {
+ RefAdaAST tmp347_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp347_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp347_AST));
+ }
+ match(LE);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case GT:
+ {
+ RefAdaAST tmp348_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp348_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp348_AST));
+ }
+ match(GT);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case GE:
+ {
+ RefAdaAST tmp349_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp349_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp349_AST));
+ }
+ match(GE);
+ simple_expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case RANGE:
+ case DIGITS:
+ case IS:
+ case PIPE:
+ case DOT_DOT:
+ case ASSIGN:
+ case THEN:
+ case LOOP:
+ case OR:
+ case AND:
+ case XOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relation_AST = RefAdaAST(currentAST.root);
+ returnAST = relation_AST;
+}
+
+void AdaParser::range_or_mark() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST range_or_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ bool synPredMatched455 = false;
+ if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+ int _m455 = mark();
+ synPredMatched455 = true;
+ inputState->guessing++;
+ try {
+ {
+ range();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched455 = false;
+ }
+ rewind(_m455);
+ inputState->guessing--;
+ }
+ if ( synPredMatched455 ) {
+ range();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_or_mark_AST = RefAdaAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENTIFIER) && (_tokenSet_30.member(LA(2)))) {
+ subtype_mark();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ range_or_mark_AST = RefAdaAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = range_or_mark_AST;
+}
+
+void AdaParser::signed_term() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST signed_term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST m_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PLUS);
+ term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1447 "ada.g"
+ Set(p_AST, UNARY_PLUS);
+#line 11141 "AdaParser.cpp"
+ }
+ signed_term_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case MINUS:
+ {
+ m = LT(1);
+ if ( inputState->guessing == 0 ) {
+ m_AST = astFactory->create(m);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(m_AST));
+ }
+ match(MINUS);
+ term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1448 "ada.g"
+ Set(m_AST, UNARY_MINUS);
+#line 11161 "AdaParser.cpp"
+ }
+ signed_term_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case ABS:
+ case NUMERIC_LIT:
+ {
+ term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ signed_term_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = signed_term_AST;
+}
+
+void AdaParser::term() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ RefAdaAST tmp350_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp350_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp350_AST));
+ }
+ match(STAR);
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DIV:
+ {
+ RefAdaAST tmp351_AST = RefAdaAST(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(DIV);
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case MOD:
+ {
+ RefAdaAST tmp352_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp352_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp352_AST));
+ }
+ match(MOD);
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case REM:
+ {
+ RefAdaAST tmp353_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp353_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp353_AST));
+ }
+ match(REM);
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop462;
+ }
+ }
+ }
+ _loop462:;
+ } // ( ... )*
+ term_AST = RefAdaAST(currentAST.root);
+ returnAST = term_AST;
+}
+
+void AdaParser::factor() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST factor_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case NOT:
+ {
+ RefAdaAST tmp354_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp354_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp354_AST));
+ }
+ match(NOT);
+ primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case ABS:
+ {
+ RefAdaAST tmp355_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp355_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp355_AST));
+ }
+ match(ABS);
+ primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case LPAREN:
+ case NEW:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NUMERIC_LIT:
+ {
+ primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case EXPON:
+ {
+ RefAdaAST tmp356_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp356_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp356_AST));
+ }
+ match(EXPON);
+ primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case RANGE:
+ case DIGITS:
+ case IS:
+ case PIPE:
+ case DOT_DOT:
+ case IN:
+ case ASSIGN:
+ case MOD:
+ case THEN:
+ case LOOP:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ factor_AST = RefAdaAST(currentAST.root);
+ returnAST = factor_AST;
+}
+
+void AdaParser::primary() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ {
+ switch ( LA(1)) {
+ case IDENTIFIER:
+ {
+ name_or_qualified();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LPAREN:
+ {
+ parenthesized_primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case NEW:
+ {
+ allocator();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case NuLL:
+ {
+ RefAdaAST tmp357_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp357_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp357_AST));
+ }
+ match(NuLL);
+ break;
+ }
+ case NUMERIC_LIT:
+ {
+ RefAdaAST tmp358_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp358_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp358_AST));
+ }
+ match(NUMERIC_LIT);
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp359_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp359_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp359_AST));
+ }
+ match(CHARACTER_LITERAL);
+ break;
+ }
+ case CHAR_STRING:
+ {
+ cs = LT(1);
+ if ( inputState->guessing == 0 ) {
+ cs_AST = astFactory->create(cs);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST));
+ }
+ match(CHAR_STRING);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ operator_call_tail(cs_AST);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ case RPAREN:
+ case RIGHT_SHAFT:
+ case WITH:
+ case RANGE:
+ case DIGITS:
+ case IS:
+ case PIPE:
+ case DOT_DOT:
+ case IN:
+ case ASSIGN:
+ case MOD:
+ case THEN:
+ case LOOP:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case EXPON:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ primary_AST = RefAdaAST(currentAST.root);
+ returnAST = primary_AST;
+}
+
+void AdaParser::name_or_qualified() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST name_or_qualified_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 1479 "ada.g"
+ RefAdaAST dummy;
+#line 11528 "AdaParser.cpp"
+
+ RefAdaAST tmp360_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp360_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp360_AST));
+ }
+ match(IDENTIFIER);
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ RefAdaAST tmp361_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp361_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp361_AST));
+ }
+ match(DOT);
+ {
+ switch ( LA(1)) {
+ case ALL:
+ {
+ RefAdaAST tmp362_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp362_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp362_AST));
+ }
+ match(ALL);
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp363_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp363_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp363_AST));
+ }
+ match(IDENTIFIER);
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp364_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp364_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp364_AST));
+ }
+ match(CHARACTER_LITERAL);
+ break;
+ }
+ case CHAR_STRING:
+ {
+ dummy=is_operator();
+ 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 LPAREN:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(LPAREN);
+ value_s();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ if ( inputState->guessing==0 ) {
+#line 1487 "ada.g"
+ Set(p_AST, INDEXED_COMPONENT);
+#line 11611 "AdaParser.cpp"
+ }
+ break;
+ }
+ case TIC:
+ {
+ RefAdaAST tmp366_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp366_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp366_AST));
+ }
+ match(TIC);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ parenthesized_primary();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENTIFIER:
+ case RANGE:
+ case DIGITS:
+ case DELTA:
+ case ACCESS:
+ {
+ attribute_id();
+ 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;
+ }
+ default:
+ {
+ goto _loop473;
+ }
+ }
+ }
+ _loop473:;
+ } // ( ... )*
+ name_or_qualified_AST = RefAdaAST(currentAST.root);
+ returnAST = name_or_qualified_AST;
+}
+
+void AdaParser::allocator() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST allocator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ n = LT(1);
+ if ( inputState->guessing == 0 ) {
+ n_AST = astFactory->create(n);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+ }
+ match(NEW);
+ name_or_qualified();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ if ( inputState->guessing==0 ) {
+#line 1493 "ada.g"
+ Set(n_AST, ALLOCATOR);
+#line 11685 "AdaParser.cpp"
+ }
+ allocator_AST = RefAdaAST(currentAST.root);
+ returnAST = allocator_AST;
+}
+
+void AdaParser::subprogram_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST subprogram_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROCEDURE);
+ def_id(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formal_part_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1507 "ada.g"
+ pop_def_id(); Set(p_AST, PROCEDURE_BODY);
+#line 11726 "AdaParser.cpp"
+ }
+ subprogram_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ f = LT(1);
+ if ( inputState->guessing == 0 ) {
+ f_AST = astFactory->create(f);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+ }
+ match(FUNCTION);
+ def_designator(false);
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ function_tail();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(IS);
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1509 "ada.g"
+ pop_def_id(); Set(f_AST, FUNCTION_BODY);
+#line 11756 "AdaParser.cpp"
+ }
+ subprogram_body_AST = RefAdaAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = subprogram_body_AST;
+}
+
+void AdaParser::package_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST package_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PACKAGE);
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ pkg_body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1513 "ada.g"
+ Set(p_AST, PACKAGE_BODY);
+#line 11794 "AdaParser.cpp"
+ }
+ package_body_AST = RefAdaAST(currentAST.root);
+ returnAST = package_body_AST;
+}
+
+void AdaParser::task_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST task_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ t = LT(1);
+ if ( inputState->guessing == 0 ) {
+ t_AST = astFactory->create(t);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+ }
+ match(TASK);
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ body_part();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1517 "ada.g"
+ Set(t_AST, TASK_BODY);
+#line 11825 "AdaParser.cpp"
+ }
+ task_body_AST = RefAdaAST(currentAST.root);
+ returnAST = task_body_AST;
+}
+
+void AdaParser::protected_body() {
+ returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefAdaAST protected_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ p = LT(1);
+ if ( inputState->guessing == 0 ) {
+ p_AST = astFactory->create(p);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+ }
+ match(PROTECTED);
+ body_is();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ prot_op_bodies_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ end_id_opt();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ if ( inputState->guessing==0 ) {
+#line 1521 "ada.g"
+ Set(p_AST, PROTECTED_BODY);
+#line 11860 "AdaParser.cpp"
+ }
+ protected_body_AST = RefAdaAST(currentAST.root);
+ returnAST = protected_body_AST;
+}
+
+void AdaParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
+{
+ factory.setMaxNodeType(289);
+}
+const char* AdaParser::tokenNames[] = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "\"pragma\"",
+ "IDENTIFIER",
+ "SEMI",
+ "LPAREN",
+ "COMMA",
+ "RPAREN",
+ "RIGHT_SHAFT",
+ "\"with\"",
+ "DOT",
+ "\"use\"",
+ "\"type\"",
+ "TIC",
+ "\"range\"",
+ "\"digits\"",
+ "\"delta\"",
+ "\"access\"",
+ "\"private\"",
+ "\"package\"",
+ "\"body\"",
+ "\"is\"",
+ "\"procedure\"",
+ "\"function\"",
+ "\"new\"",
+ "\"others\"",
+ "PIPE",
+ "DOT_DOT",
+ "\"all\"",
+ "COLON",
+ "\"in\"",
+ "\"out\"",
+ "\"renames\"",
+ "CHARACTER_LITERAL",
+ "CHAR_STRING",
+ "\"null\"",
+ "\"record\"",
+ "\"separate\"",
+ "\"abstract\"",
+ "\"return\"",
+ "\"task\"",
+ "\"protected\"",
+ "BOX",
+ "ASSIGN",
+ "\"entry\"",
+ "\"for\"",
+ "\"end\"",
+ "\"at\"",
+ "\"mod\"",
+ "\"subtype\"",
+ "\"exception\"",
+ "\"constant\"",
+ "\"array\"",
+ "\"of\"",
+ "\"aliased\"",
+ "\"case\"",
+ "\"when\"",
+ "\"tagged\"",
+ "\"limited\"",
+ "\"generic\"",
+ "\"begin\"",
+ "LT_LT",
+ "GT_GT",
+ "\"if\"",
+ "\"then\"",
+ "\"elsif\"",
+ "\"else\"",
+ "\"loop\"",
+ "\"while\"",
+ "\"reverse\"",
+ "\"declare\"",
+ "\"exit\"",
+ "\"goto\"",
+ "\"accept\"",
+ "\"do\"",
+ "\"delay\"",
+ "\"until\"",
+ "\"select\"",
+ "\"abort\"",
+ "\"or\"",
+ "\"terminate\"",
+ "\"raise\"",
+ "\"requeue\"",
+ "\"and\"",
+ "\"xor\"",
+ "\"not\"",
+ "EQ",
+ "NE",
+ "LT_",
+ "LE",
+ "GT",
+ "GE",
+ "PLUS",
+ "MINUS",
+ "CONCAT",
+ "STAR",
+ "DIV",
+ "\"rem\"",
+ "\"abs\"",
+ "EXPON",
+ "NUMERIC_LIT",
+ "ABORTABLE_PART",
+ "ABORT_STATEMENT",
+ "ACCEPT_ALTERNATIVE",
+ "ACCEPT_STATEMENT",
+ "ALLOCATOR",
+ "ASSIGNMENT_STATEMENT",
+ "ASYNCHRONOUS_SELECT",
+ "ATTRIBUTE_DEFINITION_CLAUSE",
+ "AT_CLAUSE",
+ "BLOCK_STATEMENT",
+ "CASE_STATEMENT",
+ "CASE_STATEMENT_ALTERNATIVE",
+ "CODE_STATEMENT",
+ "COMPONENT_DECLARATION",
+ "CONDITIONAL_ENTRY_CALL",
+ "CONTEXT_CLAUSE",
+ "DECLARATIVE_PART",
+ "DEFINING_IDENTIFIER_LIST",
+ "DELAY_ALTERNATIVE",
+ "DELAY_STATEMENT",
+ "DELTA_CONSTRAINT",
+ "DIGITS_CONSTRAINT",
+ "DISCRIMINANT_ASSOCIATION",
+ "DISCRIMINANT_CONSTRAINT",
+ "DISCRIMINANT_SPECIFICATION",
+ "ENTRY_BODY",
+ "ENTRY_CALL_ALTERNATIVE",
+ "ENTRY_CALL_STATEMENT",
+ "ENTRY_DECLARATION",
+ "ENTRY_INDEX_SPECIFICATION",
+ "ENUMERATION_REPESENTATION_CLAUSE",
+ "EXCEPTION_DECLARATION",
+ "EXCEPTION_HANDLER",
+ "EXCEPTION_RENAMING_DECLARATION",
+ "EXIT_STATEMENT",
+ "FORMAL_PACKAGE_DECLARATION",
+ "GENERIC_FORMAL_PART",
+ "GENERIC_PACKAGE_DECLARATION",
+ "GOTO_STATEMENT",
+ "HANDLED_SEQUENCE_OF_STATEMENTS",
+ "HANDLED_STMTS_OPT",
+ "IF_STATEMENT",
+ "INCOMPLETE_TYPE_DECLARATION",
+ "INDEXED_COMPONENT",
+ "INDEX_CONSTRAINT",
+ "LIBRARY_ITEM",
+ "LOOP_STATEMENT",
+ "NAME",
+ "NULL_STATEMENT",
+ "NUMBER_DECLARATION",
+ "OBJECT_DECLARATION",
+ "OBJECT_RENAMING_DECLARATION",
+ "OPERATOR_SYMBOL",
+ "PACKAGE_BODY",
+ "PACKAGE_BODY_STUB",
+ "PACKAGE_RENAMING_DECLARATION",
+ "PACKAGE_SPECIFICATION",
+ "PARAMETER_SPECIFICATION",
+ "PRIVATE_EXTENSION_DECLARATION",
+ "PRIVATE_TYPE_DECLARATION",
+ "PROTECTED_BODY",
+ "PROTECTED_BODY_STUB",
+ "PROTECTED_TYPE_DECLARATION",
+ "RAISE_STATEMENT",
+ "RANGE_ATTRIBUTE_REFERENCE",
+ "RECORD_REPRESENTATION_CLAUSE",
+ "REQUEUE_STATEMENT",
+ "RETURN_STATEMENT",
+ "SELECTIVE_ACCEPT",
+ "SEQUENCE_OF_STATEMENTS",
+ "SINGLE_PROTECTED_DECLARATION",
+ "SINGLE_TASK_DECLARATION",
+ "STATEMENT",
+ "SUBTYPE_DECLARATION",
+ "SUBTYPE_INDICATION",
+ "SUBTYPE_MARK",
+ "SUBUNIT",
+ "TASK_BODY",
+ "TASK_BODY_STUB",
+ "TASK_TYPE_DECLARATION",
+ "TERMINATE_ALTERNATIVE",
+ "TIMED_ENTRY_CALL",
+ "TRIGGERING_ALTERNATIVE",
+ "USE_CLAUSE",
+ "USE_TYPE_CLAUSE",
+ "VARIANT",
+ "VARIANT_PART",
+ "WITH_CLAUSE",
+ "ABSTRACT_FUNCTION_DECLARATION",
+ "ABSTRACT_PROCEDURE_DECLARATION",
+ "ACCESS_TO_FUNCTION_DECLARATION",
+ "ACCESS_TO_OBJECT_DECLARATION",
+ "ACCESS_TO_PROCEDURE_DECLARATION",
+ "ARRAY_OBJECT_DECLARATION",
+ "ARRAY_TYPE_DECLARATION",
+ "AND_THEN",
+ "BASIC_DECLARATIVE_ITEMS_OPT",
+ "BLOCK_BODY",
+ "BLOCK_BODY_OPT",
+ "CALL_STATEMENT",
+ "COMPONENT_CLAUSES_OPT",
+ "COMPONENT_ITEMS",
+ "COND_CLAUSE",
+ "DECIMAL_FIXED_POINT_DECLARATION",
+ "DECLARE_OPT",
+ "DERIVED_RECORD_EXTENSION",
+ "DISCRETE_SUBTYPE_DEF_OPT",
+ "DISCRIMINANT_SPECIFICATIONS",
+ "DISCRIM_PART_OPT",
+ "ELSE_OPT",
+ "ELSIFS_OPT",
+ "END_ID_OPT",
+ "ENTRY_INDEX_OPT",
+ "ENUMERATION_TYPE_DECLARATION",
+ "EXCEPT_HANDLER_PART_OPT",
+ "EXTENSION_OPT",
+ "FLOATING_POINT_DECLARATION",
+ "FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
+ "FORMAL_DISCRETE_TYPE_DECLARATION",
+ "FORMAL_FLOATING_POINT_DECLARATION",
+ "FORMAL_FUNCTION_DECLARATION",
+ "FORMAL_MODULAR_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
+ "FORMAL_PART_OPT",
+ "FORMAL_PRIVATE_EXTENSION_DECLARATION",
+ "FORMAL_PRIVATE_TYPE_DECLARATION",
+ "FORMAL_PROCEDURE_DECLARATION",
+ "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
+ "FUNCTION_BODY",
+ "FUNCTION_BODY_STUB",
+ "FUNCTION_DECLARATION",
+ "FUNCTION_RENAMING_DECLARATION",
+ "GENERIC_FUNCTION_DECLARATION",
+ "GENERIC_FUNCTION_INSTANTIATION",
+ "GENERIC_FUNCTION_RENAMING",
+ "GENERIC_PACKAGE_INSTANTIATION",
+ "GENERIC_PACKAGE_RENAMING",
+ "GENERIC_PROCEDURE_DECLARATION",
+ "GENERIC_PROCEDURE_INSTANTIATION",
+ "GENERIC_PROCEDURE_RENAMING",
+ "GUARD_OPT",
+ "IDENTIFIER_COLON_OPT",
+ "ID_OPT",
+ "INIT_OPT",
+ "ITERATION_SCHEME_OPT",
+ "LABEL_OPT",
+ "MARK_WITH_CONSTRAINT",
+ "MODIFIERS",
+ "MODULAR_TYPE_DECLARATION",
+ "MOD_CLAUSE_OPT",
+ "NOT_IN",
+ "ORDINARY_DERIVED_TYPE_DECLARATION",
+ "ORDINARY_FIXED_POINT_DECLARATION",
+ "OR_ELSE",
+ "OR_SELECT_OPT",
+ "PARENTHESIZED_PRIMARY",
+ "PRIVATE_DECLARATIVE_ITEMS_OPT",
+ "PRIVATE_TASK_ITEMS_OPT",
+ "PROCEDURE_BODY",
+ "PROCEDURE_BODY_STUB",
+ "PROCEDURE_DECLARATION",
+ "PROCEDURE_RENAMING_DECLARATION",
+ "PROT_MEMBER_DECLARATIONS",
+ "PROT_OP_BODIES_OPT",
+ "PROT_OP_DECLARATIONS",
+ "PROT_PRIVATE_OPT",
+ "RANGED_EXPRS",
+ "RANGE_CONSTRAINT",
+ "RECORD_TYPE_DECLARATION",
+ "SELECTOR_NAMES_OPT",
+ "SIGNED_INTEGER_TYPE_DECLARATION",
+ "TASK_ITEMS_OPT",
+ "UNARY_MINUS",
+ "UNARY_PLUS",
+ "VALUE",
+ "VALUES",
+ "VARIANTS",
+ "COMMENT_INTRO",
+ "OX",
+ "TIC_OR_CHARACTER_LITERAL",
+ "DIGIT",
+ "EXPONENT",
+ "EXTENDED_DIGIT",
+ "BASED_INTEGER",
+ "WS_",
+ "COMMENT",
+ 0
+};
+
+const unsigned long AdaParser::_tokenSet_0_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "not" PLUS
+// MINUS "abs" NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10);
+const unsigned long AdaParser::_tokenSet_1_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN DOT TIC "new" "others" "in" CHARACTER_LITERAL
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10);
+const unsigned long AdaParser::_tokenSet_2_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN "is" "renames"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10);
+const unsigned long AdaParser::_tokenSet_3_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function"
+// CHAR_STRING "separate" "abstract" "task" "protected" "for" "end" "subtype"
+// "generic" "begin"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10);
+const unsigned long AdaParser::_tokenSet_4_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT "is" "in" "renames" "when" "do"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10);
+const unsigned long AdaParser::_tokenSet_5_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN "is" "in" "renames" "when" "do"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10);
+const unsigned long AdaParser::_tokenSet_6_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure"
+// "function" CHAR_STRING "separate" "abstract" "task" "protected" "for"
+// "end" "subtype" "generic"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10);
+const unsigned long AdaParser::_tokenSet_7_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN DOT "is" "return"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10);
+const unsigned long AdaParser::_tokenSet_8_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN DOT TIC "new" "others" DOT_DOT CHARACTER_LITERAL CHAR_STRING
+// "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10);
+const unsigned long AdaParser::_tokenSet_9_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN "new" "others" CHARACTER_LITERAL CHAR_STRING "null"
+// "not" PLUS MINUS "abs" NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10);
+const unsigned long AdaParser::_tokenSet_10_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "new"
+// "others" PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod"
+// "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV
+// "rem" "abs" EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10);
+const unsigned long AdaParser::_tokenSet_11_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT DOT TIC "range" "new" "others"
+// PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" "or" "and"
+// "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" "abs"
+// EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10);
+const unsigned long AdaParser::_tokenSet_12_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER "constant" "array" "aliased"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10);
+const unsigned long AdaParser::_tokenSet_13_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN DOT TIC "range" "digits" "delta" ASSIGN "constant"
+// "array"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10);
+const unsigned long AdaParser::_tokenSet_14_data_[] = { 51380274UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "private" "procedure" "function" "entry" "for"
+// "end"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10);
+const unsigned long AdaParser::_tokenSet_15_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN RPAREN DOT TIC "range" "digits" "delta" "loop"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10);
+const unsigned long AdaParser::_tokenSet_16_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" "procedure" "function" "entry" "for"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10);
+const unsigned long AdaParser::_tokenSet_17_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "private" "null" "record" "abstract" "tagged" "limited"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10);
+const unsigned long AdaParser::_tokenSet_18_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" IDENTIFIER SEMI "private" "null" "record" "case" "tagged" "limited"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10);
+const unsigned long AdaParser::_tokenSet_19_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN COMMA RPAREN DOT TIC "range" "digits" "delta"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10);
+const unsigned long AdaParser::_tokenSet_20_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN DOT TIC "range" "new" "others" DOT_DOT CHARACTER_LITERAL
+// CHAR_STRING "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs"
+// EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10);
+const unsigned long AdaParser::_tokenSet_21_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN RIGHT_SHAFT DOT TIC "new" "others" PIPE "in" CHARACTER_LITERAL
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10);
+const unsigned long AdaParser::_tokenSet_22_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "private" "abstract" "tagged" "limited"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10);
+const unsigned long AdaParser::_tokenSet_23_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "private" "tagged" "limited"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10);
+const unsigned long AdaParser::_tokenSet_24_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT TIC ASSIGN
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10);
+const unsigned long AdaParser::_tokenSet_25_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN DOT TIC "new" CHARACTER_LITERAL CHAR_STRING "null"
+// "until" "not" PLUS MINUS "abs" NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10);
+const unsigned long AdaParser::_tokenSet_26_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "when" "accept" "delay" "terminate"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10);
+const unsigned long AdaParser::_tokenSet_27_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "until"
+// "not" PLUS MINUS "abs" NUMERIC_LIT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10);
+const unsigned long AdaParser::_tokenSet_28_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT TIC
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10);
+const unsigned long AdaParser::_tokenSet_29_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" IDENTIFIER "null" "return" "for" "end" "exception" "case" "when"
+// "begin" LT_LT "if" "then" "elsif" "else" "loop" "while" "declare" "exit"
+// "goto" "accept" "delay" "select" "abort" "or" "raise" "requeue"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10);
+const unsigned long AdaParser::_tokenSet_30_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" "is" PIPE
+// DOT_DOT ASSIGN "then" "loop" "or" "and" "xor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10);
+
+
diff --git a/languages/ada/AdaParser.hpp b/languages/ada/AdaParser.hpp
new file mode 100644
index 00000000..0074c820
--- /dev/null
+++ b/languages/ada/AdaParser.hpp
@@ -0,0 +1,389 @@
+#ifndef INC_AdaParser_hpp_
+#define INC_AdaParser_hpp_
+
+#line 29 "ada.g"
+
+#include <antlr/SemanticException.hpp> // antlr wants this
+#include "AdaAST.hpp"
+#include "preambles.h"
+
+#line 11 "AdaParser.hpp"
+#include <antlr/config.hpp>
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaParser.hpp"$ */
+#include <antlr/TokenStream.hpp>
+#include <antlr/TokenBuffer.hpp>
+#include "AdaTokenTypes.hpp"
+#include <antlr/LLkParser.hpp>
+
+class CUSTOM_API AdaParser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public AdaTokenTypes
+{
+#line 53 "ada.g"
+
+ ANTLR_PARSER_PREAMBLE
+
+public:
+ // Ada support stuff
+ void push_def_id (const RefAdaAST& defid);
+ const RefAdaAST& pop_def_id ();
+ bool end_id_matches_def_id (const RefAdaAST& endid);
+ bool definable_operator (const char *string); // operator_symbol sans "/="
+ bool is_operator_symbol (const char *string);
+#line 22 "AdaParser.hpp"
+public:
+ void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
+protected:
+ AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k);
+public:
+ AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf);
+protected:
+ AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k);
+public:
+ AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer);
+ AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state);
+ int getNumTokens() const
+ {
+ return AdaParser::NUM_TOKENS;
+ }
+ const char* getTokenName( int type ) const
+ {
+ if( type > getNumTokens() ) return 0;
+ return AdaParser::tokenNames[type];
+ }
+ const char* const* getTokenNames() const
+ {
+ return AdaParser::tokenNames;
+ }
+ public: void compilation_unit();
+ public: void context_items_opt();
+ public: void library_item();
+ public: void subunit();
+ public: void pragma();
+ public: void pragma_args_opt();
+ public: void pragma_arg();
+ public: void expression();
+ public: void with_clause();
+ public: void use_clause();
+ public: void c_name_list();
+ public: void compound_name();
+ public: void subtype_mark();
+ public: void attribute_id();
+ public: void private_opt();
+ public: void lib_pkg_spec_or_body();
+ public: void subprog_decl_or_rename_or_inst_or_body(
+ boolean lib_level
+ );
+ public: void generic_decl(
+ boolean lib_level
+ );
+ public: void def_id(
+ boolean lib_level
+ );
+ public: void pkg_body_part();
+ public: void spec_decl_part(
+ RefAdaAST pkg
+ );
+ public: void subprog_decl(
+ boolean lib_level
+ );
+ public: void generic_subp_inst();
+ public: void formal_part_opt();
+ public: void renames();
+ public: void is_separate_or_abstract_or_decl(
+ RefAdaAST t
+ );
+ public: void def_designator(
+ boolean lib_level
+ );
+ public: void function_tail();
+ public: void generic_inst();
+ public: void value_s();
+ public: void parenth_values();
+ public: void value();
+ public: void ranged_expr_s();
+ public: void ranged_expr();
+ public: void simple_expression();
+ public: void range();
+ public: void range_constraint();
+ public: void range_dots();
+ public: void range_attrib_ref();
+ public: void prefix();
+ public: void parameter_specification();
+ public: void def_ids_colon();
+ public: void mode_opt();
+ public: void init_opt();
+ public: void defining_identifier_list();
+ public: void name();
+ public: RefAdaAST definable_operator_symbol();
+ public: RefAdaAST is_operator();
+ public: void parenthesized_primary();
+ public: void extension_opt();
+ public: void separate_or_abstract(
+ RefAdaAST t
+ );
+ public: RefAdaAST designator();
+ public: void func_formal_part_opt();
+ public: void func_param();
+ public: void in_access_opt();
+ public: void pkg_spec_part();
+ public: void basic_declarative_items_opt();
+ public: void private_declarative_items_opt();
+ public: void end_id_opt();
+ public: void basic_decl_item();
+ public: void basic_declarative_items();
+ public: void task_type_or_single_decl(
+ RefAdaAST tsk
+ );
+ public: void prot_type_or_single_decl(
+ RefAdaAST pro
+ );
+ public: void decl_common();
+ public: void discrim_part_opt();
+ public: void task_definition_opt();
+ public: void task_items_opt();
+ public: void private_task_items_opt();
+ public: void discrim_part_text();
+ public: void discriminant_specifications();
+ public: void known_discrim_part();
+ public: void empty_discrim_opt();
+ public: void discrim_part();
+ public: void discriminant_specification();
+ public: void access_opt();
+ public: void entrydecls_repspecs_opt();
+ public: void entry_declaration();
+ public: void rep_spec();
+ public: void discrete_subtype_def_opt();
+ public: void discrete_subtype_definition();
+ public: void subtype_ind();
+ public: void rep_spec_part(
+ RefAdaAST t
+ );
+ public: void align_opt();
+ public: void comp_loc_s();
+ public: void protected_definition();
+ public: void prot_private_opt();
+ public: void prot_op_decl();
+ public: void comp_decl();
+ public: void prot_op_decl_s();
+ public: void prot_member_decl_s();
+ public: void component_subtype_def();
+ public: void type_def(
+ RefAdaAST t
+ );
+ public: void derived_or_private_or_record(
+ RefAdaAST t, boolean has_discrim
+ );
+ public: void local_enum_name();
+ public: void enumeration_aggregate();
+ public: void aliased_constant_opt();
+ public: void array_type_definition(
+ RefAdaAST t
+ );
+ public: void enum_id_s();
+ public: void range_constraint_opt();
+ public: void access_type_definition(
+ RefAdaAST t
+ );
+ public: void enumeration_literal_specification();
+ public: void index_or_discrete_range_s();
+ public: void index_or_discrete_range();
+ public: void aliased_opt();
+ public: void constraint_opt();
+ public: void digits_constraint();
+ public: void delta_constraint();
+ public: void index_constraint();
+ public: void discriminant_constraint();
+ public: void discrete_range();
+ public: void discriminant_association();
+ public: void selector_names_opt();
+ public: void association_head();
+ public: void selector_name();
+ public: void protected_opt();
+ public: void constant_all_opt();
+ public: void abstract_opt();
+ public: void record_definition(
+ boolean has_discrim
+ );
+ public: void abstract_tagged_limited_opt();
+ public: void component_list(
+ boolean has_discrim
+ );
+ public: void component_items();
+ public: void variant_part();
+ public: void empty_component_items();
+ public: void discriminant_direct_name();
+ public: void variant_s();
+ public: void variant();
+ public: void choice_s();
+ public: void choice();
+ public: void discrete_with_range();
+ public: void mark_with_constraint();
+ public: void generic_formal_part_opt();
+ public: void generic_formal_parameter();
+ public: void discriminable_type_definition(
+ RefAdaAST t
+ );
+ public: void subprogram_default_opt();
+ public: void formal_package_actual_part_opt();
+ public: void body_part();
+ public: void declarative_part();
+ public: void block_body();
+ public: void declarative_item();
+ public: void body_is();
+ public: void separate();
+ public: void prot_op_bodies_opt();
+ public: void block_body_opt();
+ public: void handled_stmt_s();
+ public: void entry_body();
+ public: void subprog_decl_or_body();
+ public: void statements();
+ public: void except_handler_part_opt();
+ public: void handled_stmts_opt();
+ public: void statement();
+ public: void def_label_opt();
+ public: void null_stmt();
+ public: void exit_stmt();
+ public: void return_stmt();
+ public: void goto_stmt();
+ public: void delay_stmt();
+ public: void abort_stmt();
+ public: void raise_stmt();
+ public: void requeue_stmt();
+ public: void accept_stmt();
+ public: void select_stmt();
+ public: void if_stmt();
+ public: void case_stmt();
+ public: void loop_stmt();
+ public: void block();
+ public: void statement_identifier();
+ public: void id_opt();
+ public: void call_or_assignment();
+ public: void cond_clause();
+ public: void elsifs_opt();
+ public: void else_opt();
+ public: void condition();
+ public: void alternative_s();
+ public: void case_statement_alternative();
+ public: void iteration_scheme_opt();
+ public: void reverse_opt();
+ public: void id_opt_aux();
+ public: void declare_opt();
+ public: void label_name();
+ public: void entry_body_formal_part();
+ public: void entry_barrier();
+ public: void entry_index_spec_opt();
+ public: void entry_call_stmt();
+ public: void entry_index_opt();
+ public: void until_opt();
+ public: void triggering_alternative();
+ public: void abortable_part();
+ public: void selective_accept();
+ public: void entry_call_alternative();
+ public: void delay_alternative();
+ public: void stmts_opt();
+ public: void guard_opt();
+ public: void select_alternative();
+ public: void or_select_opt();
+ public: void accept_alternative();
+ public: void exception_handler();
+ public: void identifier_colon_opt();
+ public: void except_choice_s();
+ public: void exception_choice();
+ public: void operator_call();
+ public: void operator_call_tail(
+ RefAdaAST opstr
+ );
+ public: void relation();
+ public: void range_or_mark();
+ public: void signed_term();
+ public: void term();
+ public: void factor();
+ public: void primary();
+ public: void name_or_qualified();
+ public: void allocator();
+ public: void subprogram_body();
+ public: void package_body();
+ public: void task_body();
+ public: void protected_body();
+public:
+ ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
+ {
+ return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST);
+ }
+
+protected:
+ RefAdaAST returnAST;
+private:
+ static const char* tokenNames[];
+#ifndef NO_STATIC_CONSTS
+ static const int NUM_TOKENS = 290;
+#else
+ enum {
+ NUM_TOKENS = 290
+ };
+#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;
+};
+
+#endif /*INC_AdaParser_hpp_*/
diff --git a/languages/ada/AdaStoreWalker.cpp b/languages/ada/AdaStoreWalker.cpp
new file mode 100644
index 00000000..167d671c
--- /dev/null
+++ b/languages/ada/AdaStoreWalker.cpp
@@ -0,0 +1,9439 @@
+/* $ANTLR 2.7.7 (20070609): "expandedada.store.g" -> "AdaStoreWalker.cpp"$ */
+#include "AdaStoreWalker.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 "expandedada.store.g"
+#line 11 "AdaStoreWalker.cpp"
+AdaStoreWalker::AdaStoreWalker()
+ : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
+}
+
+void AdaStoreWalker::compilation_unit(RefAdaAST _t) {
+ RefAdaAST compilation_unit_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+#line 116 "expandedada.store.g"
+ init();
+#line 22 "AdaStoreWalker.cpp"
+ context_items_opt(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case LIBRARY_ITEM:
+ {
+ library_item(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBUNIT:
+ {
+ subunit(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == PRAGMA)) {
+ pragma(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop4;
+ }
+
+ }
+ _loop4:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::context_items_opt(RefAdaAST _t) {
+ RefAdaAST context_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t70 = _t;
+ RefAdaAST tmp1_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONTEXT_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case WITH_CLAUSE:
+ {
+ with_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop72;
+ }
+ }
+ }
+ _loop72:;
+ } // ( ... )*
+ _t = __t70;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::library_item(RefAdaAST _t) {
+ RefAdaAST library_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST pb = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST gpi = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST ps = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefAdaAST prd = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefAdaAST __t17 = _t;
+ RefAdaAST tmp2_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LIBRARY_ITEM);
+ _t = _t->getFirstChild();
+ RefAdaAST __t18 = _t;
+ RefAdaAST tmp3_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODIFIERS);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRIVATE:
+ {
+ RefAdaAST tmp4_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE);
+ _t = _t->getNextSibling();
+#line 132 "expandedada.store.g"
+ m_currentAccess = CodeModelItem::Protected;
+#line 149 "AdaStoreWalker.cpp"
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t18;
+ _t = _t->getNextSibling();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ lib_subprog_decl_or_rename_or_inst_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ RefAdaAST __t21 = _t;
+ RefAdaAST tmp5_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ pb = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t21;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ RefAdaAST __t22 = _t;
+ RefAdaAST tmp6_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ gpi = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+#line 136 "expandedada.store.g"
+
+ defineScope( gpi );
+
+#line 213 "AdaStoreWalker.cpp"
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t22;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_SPECIFICATION:
+ {
+ RefAdaAST __t23 = _t;
+ RefAdaAST tmp7_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_SPECIFICATION);
+ _t = _t->getFirstChild();
+ ps = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+#line 142 "expandedada.store.g"
+
+ NamespaceDom psc = defineScope( ps );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+
+#line 236 "AdaStoreWalker.cpp"
+ pkg_spec_part(_t);
+ _t = _retTree;
+#line 149 "expandedada.store.g"
+
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0) {
+ kdDebug() << "adastore: m_scopeStack is empty!" << endl;
+ m_scopeStack.append( m_model->globalNamespace() );
+ }
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setEndPosition (endLine, 0);
+ m_addToStore = false;
+
+#line 250 "AdaStoreWalker.cpp"
+ _t = __t23;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t24 = _t;
+ RefAdaAST tmp8_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ prd = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+#line 161 "expandedada.store.g"
+
+ defineScope( prd );
+
+#line 268 "AdaStoreWalker.cpp"
+ renames(_t);
+ _t = _retTree;
+ _t = __t24;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ generic_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t17;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subunit(RefAdaAST _t) {
+ RefAdaAST subunit_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t521 = _t;
+ RefAdaAST tmp9_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBUNIT);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case FUNCTION_BODY:
+ case PROCEDURE_BODY:
+ {
+ subprogram_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ package_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case TASK_BODY:
+ {
+ task_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_BODY:
+ {
+ protected_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t521;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::pragma(RefAdaAST _t) {
+ RefAdaAST pragma_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t64 = _t;
+ RefAdaAST tmp10_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRAGMA);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp11_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_0.member(_t->getType()))) {
+ pragma_arg(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop66;
+ }
+
+ }
+ _loop66:;
+ } // ( ... )*
+ _t = __t64;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::with_clause(RefAdaAST _t) {
+ RefAdaAST with_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t6 = _t;
+ RefAdaAST tmp12_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WITH_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt8=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
+ compound_name(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt8>=1 ) { goto _loop8; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt8++;
+ }
+ _loop8:;
+ } // ( ... )+
+ _t = __t6;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::compound_name(RefAdaAST _t) {
+ RefAdaAST compound_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp13_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ RefAdaAST __t74 = _t;
+ RefAdaAST tmp14_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ RefAdaAST tmp15_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::use_clause(RefAdaAST _t) {
+ RefAdaAST use_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST c = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case USE_TYPE_CLAUSE:
+ {
+ RefAdaAST __t10 = _t;
+ RefAdaAST tmp16_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),USE_TYPE_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt12=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT || _t->getType() == TIC)) {
+ subtype_mark(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt12>=1 ) { goto _loop12; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt12++;
+ }
+ _loop12:;
+ } // ( ... )+
+ _t = __t10;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case USE_CLAUSE:
+ {
+ RefAdaAST __t13 = _t;
+ RefAdaAST tmp17_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),USE_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt15=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
+ c = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ compound_name(_t);
+ _t = _retTree;
+#line 127 "expandedada.store.g"
+ m_imports.back ().push_back (qtext (c));
+#line 527 "AdaStoreWalker.cpp"
+ }
+ else {
+ if ( _cnt15>=1 ) { goto _loop15; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt15++;
+ }
+ _loop15:;
+ } // ( ... )+
+ _t = __t13;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subtype_mark(RefAdaAST _t) {
+ RefAdaAST subtype_mark_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case TIC:
+ {
+ RefAdaAST __t76 = _t;
+ RefAdaAST tmp18_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ attribute_id(_t);
+ _t = _retTree;
+ _t = __t76;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::lib_subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t) {
+ RefAdaAST lib_subprog_decl_or_rename_or_inst_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+#line 310 "expandedada.store.g"
+ m_addToStore = true;
+#line 603 "AdaStoreWalker.cpp"
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+#line 315 "expandedada.store.g"
+ m_addToStore = false;
+#line 643 "AdaStoreWalker.cpp"
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::def_id(RefAdaAST _t) {
+ RefAdaAST def_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST cn = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ cn = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ compound_name(_t);
+ _t = _retTree;
+#line 189 "expandedada.store.g"
+
+ // kdDebug() << "cn:compound_name started " << endl;
+ if (m_addToStore) {
+ // kdDebug() << "cn:compound_name m_addToStore " << endl;
+ if (m_isSubprogram) {
+ // kdDebug() << "cn:compound_name m_isSubprogram " << endl;
+ FunctionDom method = m_model->create<FunctionModel>();
+ method->setName (qtext (cn));
+ method->setFileName(m_fileName);
+ // kdDebug() << "cn:compound_name method->setStartPosition(" << endl;
+ method->setStartPosition(cn->getLine(), cn->getColumn());
+
+ if (m_currentContainer == m_model->globalNamespace())
+ m_file->addFunction(method);
+ else
+ m_currentContainer->addFunction(method);
+ //FIXME: adymo: is this valid for CodeModel
+ /* ParsedMethod *old = m_currentContainer->getMethod (method);
+ if (old) {
+ delete (method);
+ method = old;
+ } else {
+ m_currentContainer->addMethod (method);
+ }*/
+ } else {
+ // TBC: what about other declarations?
+ }
+ }
+
+#line 691 "AdaStoreWalker.cpp"
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::pkg_body_part(RefAdaAST _t) {
+ RefAdaAST pkg_body_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ declarative_part(_t);
+ _t = _retTree;
+ block_body_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::generic_inst(RefAdaAST _t) {
+ RefAdaAST generic_inst_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ compound_name(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::pkg_spec_part(RefAdaAST _t) {
+ RefAdaAST pkg_spec_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ basic_declarative_items_opt(_t);
+ _t = _retTree;
+ private_declarative_items_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::renames(RefAdaAST _t) {
+ RefAdaAST renames_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case CHARACTER_STRING:
+ {
+ RefAdaAST tmp19_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_STRING);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ RefAdaAST tmp20_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::generic_decl(RefAdaAST _t) {
+ RefAdaAST generic_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST gpd = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PACKAGE_RENAMING:
+ {
+ RefAdaAST __t49 = _t;
+ RefAdaAST tmp21_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t49;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ {
+ RefAdaAST __t50 = _t;
+ RefAdaAST tmp22_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ gpd = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+#line 284 "expandedada.store.g"
+
+ NamespaceDom psc = defineScope( gpd );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+
+#line 860 "AdaStoreWalker.cpp"
+ pkg_spec_part(_t);
+ _t = _retTree;
+#line 291 "expandedada.store.g"
+
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0)
+ m_scopeStack.append( m_model->globalNamespace() );
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setDeclarationEndsOnLine (endLine);
+ m_addToStore = false;
+
+#line 872 "AdaStoreWalker.cpp"
+ _t = __t50;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ RefAdaAST __t51 = _t;
+ RefAdaAST tmp23_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t51;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t52 = _t;
+ RefAdaAST tmp24_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t52;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_RENAMING:
+ {
+ RefAdaAST __t53 = _t;
+ RefAdaAST tmp25_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t53;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t54 = _t;
+ RefAdaAST tmp26_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ subprog_def_id(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t54;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprog_def_id(RefAdaAST _t) {
+ RefAdaAST subprog_def_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+#line 171 "expandedada.store.g"
+ m_isSubprogram = true;
+#line 965 "AdaStoreWalker.cpp"
+ def_id(_t);
+ _t = _retTree;
+#line 173 "expandedada.store.g"
+ m_isSubprogram = false;
+#line 970 "AdaStoreWalker.cpp"
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprog_decl(RefAdaAST _t) {
+ RefAdaAST subprog_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ {
+ RefAdaAST __t27 = _t;
+ RefAdaAST tmp27_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t27;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t28 = _t;
+ RefAdaAST tmp28_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t28;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t29 = _t;
+ RefAdaAST tmp29_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t29;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_BODY_STUB:
+ {
+ RefAdaAST __t30 = _t;
+ RefAdaAST tmp30_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_BODY_STUB);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t30;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t31 = _t;
+ RefAdaAST tmp31_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t31;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_INSTANTIATION:
+ {
+ RefAdaAST __t32 = _t;
+ RefAdaAST tmp32_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t32;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t33 = _t;
+ RefAdaAST tmp33_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t33;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t34 = _t;
+ RefAdaAST tmp34_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t34;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_BODY_STUB:
+ {
+ RefAdaAST __t35 = _t;
+ RefAdaAST tmp35_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t35;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t36 = _t;
+ RefAdaAST tmp36_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t36;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::formal_part_opt(RefAdaAST _t) {
+ RefAdaAST formal_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t112 = _t;
+ RefAdaAST tmp37_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PART_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == PARAMETER_SPECIFICATION)) {
+ parameter_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop114;
+ }
+
+ }
+ _loop114:;
+ } // ( ... )*
+ _t = __t112;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::def_designator(RefAdaAST _t) {
+ RefAdaAST def_designator_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST cn = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ cn = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ compound_name(_t);
+ _t = _retTree;
+#line 221 "expandedada.store.g"
+
+ // kdDebug() << "def_designator cn:compound_name started" << endl;
+ if (m_addToStore) {
+ // kdDebug() << "def_designator cn:compound_name m_addToStore" << endl;
+ FunctionDom method = m_model->create<FunctionModel>();
+ method->setName (qtext (cn));
+ method->setFileName(m_fileName);
+ // kdDebug() << "def_designator cn:compound_name method->setStartPosition(" << endl;
+ method->setStartPosition(cn->getLine(), cn->getColumn());
+
+ if (m_currentContainer == m_model->globalNamespace())
+ m_file->addFunction(method);
+ else
+ m_currentContainer->addFunction(method);
+ //FIXME: adymo: is this valid for CodeModel
+ /* ParsedMethod *old = m_currentContainer->getMethod (method);
+ if (old) {
+ delete method;
+ method = old;
+ } else {
+ m_currentContainer->addMethod (method);
+ }*/
+ }
+
+#line 1218 "AdaStoreWalker.cpp"
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ definable_operator_symbol(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::function_tail(RefAdaAST _t) {
+ RefAdaAST function_tail_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ formal_part_opt(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::definable_operator_symbol(RefAdaAST _t) {
+ RefAdaAST definable_operator_symbol_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp38_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::spec_decl_part(RefAdaAST _t) {
+ RefAdaAST spec_decl_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST ps = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ RefAdaAST __t40 = _t;
+ RefAdaAST tmp39_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t40;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_SPECIFICATION:
+ {
+ RefAdaAST __t41 = _t;
+ RefAdaAST tmp40_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_SPECIFICATION);
+ _t = _t->getFirstChild();
+ ps = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+#line 250 "expandedada.store.g"
+
+ NamespaceDom psc = defineScope( ps );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+
+#line 1312 "AdaStoreWalker.cpp"
+ pkg_spec_part(_t);
+ _t = _retTree;
+#line 257 "expandedada.store.g"
+
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0) {
+ kdDebug() << "adastore: m_scopeStack is empty!" << endl;
+ m_scopeStack.append( m_model->globalNamespace() );
+ }
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setDeclarationEndsOnLine (endLine);
+ m_addToStore = false;
+
+#line 1326 "AdaStoreWalker.cpp"
+ _t = __t41;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t42 = _t;
+ RefAdaAST tmp41_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t42;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::basic_declarative_items_opt(RefAdaAST _t) {
+ RefAdaAST basic_declarative_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t136 = _t;
+ RefAdaAST tmp42_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BASIC_DECLARATIVE_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_1.member(_t->getType()))) {
+ basic_decl_item(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop138;
+ }
+
+ }
+ _loop138:;
+ } // ( ... )*
+ _t = __t136;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::private_declarative_items_opt(RefAdaAST _t) {
+ RefAdaAST private_declarative_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case PROTECTED_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SINGLE_PROTECTED_DECLARATION:
+ case SINGLE_TASK_DECLARATION:
+ case SUBTYPE_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+#line 276 "expandedada.store.g"
+ m_currentAccess = CodeModelItem::Protected;
+#line 1457 "AdaStoreWalker.cpp"
+ { // ( ... )+
+ int _cnt47=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case PROTECTED_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SINGLE_PROTECTED_DECLARATION:
+ case SINGLE_TASK_DECLARATION:
+ case SUBTYPE_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ basic_decl_item(_t);
+ _t = _retTree;
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ if ( _cnt47>=1 ) { goto _loop47; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+ }
+ _cnt47++;
+ }
+ _loop47:;
+ } // ( ... )+
+#line 278 "expandedada.store.g"
+ m_currentAccess = CodeModelItem::Public;
+#line 1538 "AdaStoreWalker.cpp"
+ break;
+ }
+ case END:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::end_id_opt(RefAdaAST _t) {
+ RefAdaAST end_id_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t86 = _t;
+ RefAdaAST tmp43_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),END);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case OPERATOR_SYMBOL:
+ {
+ def_designator(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t86;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::basic_decl_item(RefAdaAST _t) {
+ RefAdaAST basic_decl_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ spec_decl_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ {
+ task_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_TYPE_DECLARATION:
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ prot_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SUBTYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ decl_common(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::generic_formal_part_opt(RefAdaAST _t) {
+ RefAdaAST generic_formal_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t295 = _t;
+ RefAdaAST tmp44_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FORMAL_PART);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case FORMAL_PACKAGE_DECLARATION:
+ case PARAMETER_SPECIFICATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
+ case FORMAL_DISCRETE_TYPE_DECLARATION:
+ case FORMAL_FLOATING_POINT_DECLARATION:
+ case FORMAL_FUNCTION_DECLARATION:
+ case FORMAL_MODULAR_TYPE_DECLARATION:
+ case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
+ case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
+ case FORMAL_PRIVATE_EXTENSION_DECLARATION:
+ case FORMAL_PRIVATE_TYPE_DECLARATION:
+ case FORMAL_PROCEDURE_DECLARATION:
+ case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ generic_formal_parameter(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop297;
+ }
+ }
+ }
+ _loop297:;
+ } // ( ... )*
+ _t = __t295;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::procedure_body(RefAdaAST _t) {
+ RefAdaAST procedure_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t319 = _t;
+ RefAdaAST tmp45_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t319;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::function_body(RefAdaAST _t) {
+ RefAdaAST function_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t321 = _t;
+ RefAdaAST tmp46_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_BODY);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t321;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t) {
+ RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprog_decl_or_body(RefAdaAST _t) {
+ RefAdaAST subprog_decl_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t59 = _t;
+ RefAdaAST tmp47_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ subprog_def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t59;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t60 = _t;
+ RefAdaAST tmp48_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t60;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::package_body(RefAdaAST _t) {
+ RefAdaAST package_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ RefAdaAST id = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefAdaAST __t62 = _t;
+ RefAdaAST tmp49_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ id = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t62;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::pragma_arg(RefAdaAST _t) {
+ RefAdaAST pragma_arg_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RIGHT_SHAFT:
+ {
+ RefAdaAST __t68 = _t;
+ RefAdaAST tmp50_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RIGHT_SHAFT);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp51_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ _t = __t68;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::expression(RefAdaAST _t) {
+ RefAdaAST expression_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case AND:
+ {
+ RefAdaAST __t479 = _t;
+ RefAdaAST tmp52_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t479;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case AND_THEN:
+ {
+ RefAdaAST __t480 = _t;
+ RefAdaAST tmp53_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND_THEN);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t480;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OR:
+ {
+ RefAdaAST __t481 = _t;
+ RefAdaAST tmp54_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t481;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OR_ELSE:
+ {
+ RefAdaAST __t482 = _t;
+ RefAdaAST tmp55_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR_ELSE);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t482;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case XOR:
+ {
+ RefAdaAST __t483 = _t;
+ RefAdaAST tmp56_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),XOR);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t483;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case NOT_IN:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ relation(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::attribute_id(RefAdaAST _t) {
+ RefAdaAST attribute_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE:
+ {
+ RefAdaAST tmp57_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DIGITS:
+ {
+ RefAdaAST tmp58_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIGITS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DELTA:
+ {
+ RefAdaAST tmp59_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELTA);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS:
+ {
+ RefAdaAST tmp60_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp61_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::modifiers(RefAdaAST _t) {
+ RefAdaAST modifiers_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t79 = _t;
+ RefAdaAST tmp62_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODIFIERS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT:
+ {
+ RefAdaAST tmp63_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS:
+ {
+ RefAdaAST tmp64_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ALIASED:
+ {
+ RefAdaAST tmp65_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALIASED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ALL:
+ {
+ RefAdaAST tmp66_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONSTANT:
+ {
+ RefAdaAST tmp67_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONSTANT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IN:
+ {
+ RefAdaAST tmp68_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LIMITED:
+ {
+ RefAdaAST tmp69_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LIMITED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OUT:
+ {
+ RefAdaAST tmp70_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE:
+ {
+ RefAdaAST tmp71_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED:
+ {
+ RefAdaAST tmp72_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case REVERSE:
+ {
+ RefAdaAST tmp73_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REVERSE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TAGGED:
+ {
+ RefAdaAST tmp74_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TAGGED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ goto _loop81;
+ }
+ }
+ }
+ _loop81:;
+ } // ( ... )*
+ _t = __t79;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::id_opt(RefAdaAST _t) {
+ RefAdaAST id_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t83 = _t;
+ RefAdaAST tmp75_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ID_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case OPERATOR_SYMBOL:
+ {
+ def_designator(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t83;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::value_s(RefAdaAST _t) {
+ RefAdaAST value_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t475 = _t;
+ RefAdaAST tmp76_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VALUES);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt477=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_2.member(_t->getType()))) {
+ value(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt477>=1 ) { goto _loop477; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt477++;
+ }
+ _loop477:;
+ } // ( ... )+
+ _t = __t475;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::value(RefAdaAST _t) {
+ RefAdaAST value_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case OTHERS:
+ {
+ RefAdaAST __t91 = _t;
+ RefAdaAST tmp77_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ _t = __t91;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RIGHT_SHAFT:
+ {
+ RefAdaAST __t92 = _t;
+ RefAdaAST tmp78_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RIGHT_SHAFT);
+ _t = _t->getFirstChild();
+ ranged_expr_s(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t92;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case PIPE:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ ranged_expr_s(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::ranged_expr_s(RefAdaAST _t) {
+ RefAdaAST ranged_expr_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ RefAdaAST __t94 = _t;
+ RefAdaAST tmp79_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE);
+ _t = _t->getFirstChild();
+ ranged_expr_s(_t);
+ _t = _retTree;
+ ranged_expr(_t);
+ _t = _retTree;
+ _t = __t94;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ ranged_expr(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::ranged_expr(RefAdaAST _t) {
+ RefAdaAST ranged_expr_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ RefAdaAST __t96 = _t;
+ RefAdaAST tmp80_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t96;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RANGE:
+ {
+ RefAdaAST __t97 = _t;
+ RefAdaAST tmp81_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ _t = __t97;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::simple_expression(RefAdaAST _t) {
+ RefAdaAST simple_expression_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PLUS:
+ {
+ RefAdaAST __t495 = _t;
+ RefAdaAST tmp82_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t495;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MINUS:
+ {
+ RefAdaAST __t496 = _t;
+ RefAdaAST tmp83_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t496;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONCAT:
+ {
+ RefAdaAST __t497 = _t;
+ RefAdaAST tmp84_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONCAT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t497;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ signed_term(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range(RefAdaAST _t) {
+ RefAdaAST range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ range_dots(_t);
+ _t = _retTree;
+ break;
+ }
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range_attrib_ref(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range_constraint(RefAdaAST _t) {
+ RefAdaAST range_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t99 = _t;
+ RefAdaAST tmp85_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE_CONSTRAINT);
+ _t = _t->getFirstChild();
+ range(_t);
+ _t = _retTree;
+ _t = __t99;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range_dots(RefAdaAST _t) {
+ RefAdaAST range_dots_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t103 = _t;
+ RefAdaAST tmp86_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t103;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range_attrib_ref(RefAdaAST _t) {
+ RefAdaAST range_attrib_ref_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t105 = _t;
+ RefAdaAST tmp87_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE_ATTRIBUTE_REFERENCE);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t105;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prefix(RefAdaAST _t) {
+ RefAdaAST prefix_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp88_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ RefAdaAST __t108 = _t;
+ RefAdaAST tmp89_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ RefAdaAST tmp90_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp91_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t108;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ RefAdaAST __t110 = _t;
+ RefAdaAST tmp92_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t110;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::parameter_specification(RefAdaAST _t) {
+ RefAdaAST parameter_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t116 = _t;
+ RefAdaAST tmp93_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARAMETER_SPECIFICATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t116;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::defining_identifier_list(RefAdaAST _t) {
+ RefAdaAST defining_identifier_list_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t118 = _t;
+ RefAdaAST tmp94_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DEFINING_IDENTIFIER_LIST);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt120=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER)) {
+ RefAdaAST tmp95_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ else {
+ if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt120++;
+ }
+ _loop120:;
+ } // ( ... )+
+ _t = __t118;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::init_opt(RefAdaAST _t) {
+ RefAdaAST init_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t154 = _t;
+ RefAdaAST tmp96_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INIT_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t154;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::name(RefAdaAST _t) {
+ RefAdaAST name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp97_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ RefAdaAST __t123 = _t;
+ RefAdaAST tmp98_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ RefAdaAST tmp99_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp100_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp101_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ RefAdaAST tmp102_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t123;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ RefAdaAST __t125 = _t;
+ RefAdaAST tmp103_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t125;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIC:
+ {
+ RefAdaAST __t126 = _t;
+ RefAdaAST tmp104_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ attribute_id(_t);
+ _t = _retTree;
+ _t = __t126;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::parenthesized_primary(RefAdaAST _t) {
+ RefAdaAST parenthesized_primary_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t129 = _t;
+ RefAdaAST tmp105_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARENTHESIZED_PRIMARY);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NuLL:
+ {
+ RefAdaAST tmp106_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ extension_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t129;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::extension_opt(RefAdaAST _t) {
+ RefAdaAST extension_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t132 = _t;
+ RefAdaAST tmp107_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTENSION_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NuLL:
+ {
+ RefAdaAST tmp108_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t132;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::task_type_or_single_decl(RefAdaAST _t) {
+ RefAdaAST task_type_or_single_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case TASK_TYPE_DECLARATION:
+ {
+ RefAdaAST __t141 = _t;
+ RefAdaAST tmp109_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ task_definition_opt(_t);
+ _t = _retTree;
+ _t = __t141;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ {
+ RefAdaAST __t142 = _t;
+ RefAdaAST tmp110_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SINGLE_TASK_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ task_definition_opt(_t);
+ _t = _retTree;
+ _t = __t142;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_type_or_single_decl(RefAdaAST _t) {
+ RefAdaAST prot_type_or_single_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROTECTED_TYPE_DECLARATION:
+ {
+ RefAdaAST __t182 = _t;
+ RefAdaAST tmp111_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ protected_definition(_t);
+ _t = _retTree;
+ _t = __t182;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ RefAdaAST __t183 = _t;
+ RefAdaAST tmp112_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SINGLE_PROTECTED_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ protected_definition(_t);
+ _t = _retTree;
+ _t = __t183;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::decl_common(RefAdaAST _t) {
+ RefAdaAST decl_common_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENUMERATION_TYPE_DECLARATION:
+ {
+ RefAdaAST __t202 = _t;
+ RefAdaAST tmp113_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp114_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ enum_id_s(_t);
+ _t = _retTree;
+ _t = __t202;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ RefAdaAST __t203 = _t;
+ RefAdaAST tmp115_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SIGNED_INTEGER_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp116_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ range(_t);
+ _t = _retTree;
+ _t = __t203;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MODULAR_TYPE_DECLARATION:
+ {
+ RefAdaAST __t204 = _t;
+ RefAdaAST tmp117_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODULAR_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp118_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ _t = __t204;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FLOATING_POINT_DECLARATION:
+ {
+ RefAdaAST __t205 = _t;
+ RefAdaAST tmp119_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FLOATING_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp120_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t205;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ {
+ RefAdaAST __t206 = _t;
+ RefAdaAST tmp121_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ORDINARY_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp122_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ _t = __t206;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ {
+ RefAdaAST __t207 = _t;
+ RefAdaAST tmp123_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECIMAL_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp124_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t207;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_TYPE_DECLARATION:
+ {
+ array_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ access_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case INCOMPLETE_TYPE_DECLARATION:
+ {
+ RefAdaAST __t208 = _t;
+ RefAdaAST tmp125_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INCOMPLETE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp126_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrim_part_opt(_t);
+ _t = _retTree;
+ _t = __t208;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE_EXTENSION_DECLARATION:
+ {
+ RefAdaAST __t209 = _t;
+ RefAdaAST tmp127_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_EXTENSION_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t209;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DERIVED_RECORD_EXTENSION:
+ {
+ RefAdaAST __t210 = _t;
+ RefAdaAST tmp128_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DERIVED_RECORD_EXTENSION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ record_definition(_t);
+ _t = _retTree;
+ _t = __t210;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ {
+ RefAdaAST __t211 = _t;
+ RefAdaAST tmp129_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ORDINARY_DERIVED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t211;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE_TYPE_DECLARATION:
+ {
+ RefAdaAST __t212 = _t;
+ RefAdaAST tmp130_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ _t = __t212;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RECORD_TYPE_DECLARATION:
+ {
+ RefAdaAST __t213 = _t;
+ RefAdaAST tmp131_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ record_definition(_t);
+ _t = _retTree;
+ _t = __t213;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SUBTYPE_DECLARATION:
+ {
+ RefAdaAST __t214 = _t;
+ RefAdaAST tmp132_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBTYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp133_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t214;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ generic_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ case EXCEPTION_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t215 = _t;
+ RefAdaAST tmp134_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ compound_name(_t);
+ _t = _retTree;
+ _t = __t215;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OBJECT_RENAMING_DECLARATION:
+ {
+ RefAdaAST __t216 = _t;
+ RefAdaAST tmp135_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OBJECT_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ name(_t);
+ _t = _retTree;
+ _t = __t216;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EXCEPTION_DECLARATION:
+ {
+ RefAdaAST __t217 = _t;
+ RefAdaAST tmp136_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ _t = __t217;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NUMBER_DECLARATION:
+ {
+ RefAdaAST __t218 = _t;
+ RefAdaAST tmp137_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUMBER_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t218;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_OBJECT_DECLARATION:
+ {
+ RefAdaAST __t219 = _t;
+ RefAdaAST tmp138_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARRAY_OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ array_type_definition(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t219;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OBJECT_DECLARATION:
+ {
+ RefAdaAST __t220 = _t;
+ RefAdaAST tmp139_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t220;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discrim_part_opt(RefAdaAST _t) {
+ RefAdaAST discrim_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t145 = _t;
+ RefAdaAST tmp140_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIM_PART_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ RefAdaAST tmp141_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DISCRIMINANT_SPECIFICATIONS:
+ {
+ discriminant_specifications(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t145;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::task_definition_opt(RefAdaAST _t) {
+ RefAdaAST task_definition_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ task_items_opt(_t);
+ _t = _retTree;
+ private_task_items_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::task_items_opt(RefAdaAST _t) {
+ RefAdaAST task_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t157 = _t;
+ RefAdaAST tmp142_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ entrydecls_repspecs_opt(_t);
+ _t = _retTree;
+ _t = __t157;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::private_task_items_opt(RefAdaAST _t) {
+ RefAdaAST private_task_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t180 = _t;
+ RefAdaAST tmp143_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_TASK_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ entrydecls_repspecs_opt(_t);
+ _t = _retTree;
+ _t = __t180;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discriminant_specifications(RefAdaAST _t) {
+ RefAdaAST discriminant_specifications_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t148 = _t;
+ RefAdaAST tmp144_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_SPECIFICATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == DISCRIMINANT_SPECIFICATION)) {
+ discriminant_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop150;
+ }
+
+ }
+ _loop150:;
+ } // ( ... )*
+ _t = __t148;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discriminant_specification(RefAdaAST _t) {
+ RefAdaAST discriminant_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t152 = _t;
+ RefAdaAST tmp145_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_SPECIFICATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t152;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entrydecls_repspecs_opt(RefAdaAST _t) {
+ RefAdaAST entrydecls_repspecs_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENTRY_DECLARATION:
+ {
+ entry_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop160;
+ }
+ }
+ }
+ _loop160:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_declaration(RefAdaAST _t) {
+ RefAdaAST entry_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t162 = _t;
+ RefAdaAST tmp146_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp147_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrete_subtype_def_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t162;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::rep_spec(RefAdaAST _t) {
+ RefAdaAST rep_spec_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ RefAdaAST __t168 = _t;
+ RefAdaAST tmp148_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD_REPRESENTATION_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ align_opt(_t);
+ _t = _retTree;
+ comp_loc_s(_t);
+ _t = _retTree;
+ _t = __t168;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case AT_CLAUSE:
+ {
+ RefAdaAST __t169 = _t;
+ RefAdaAST tmp149_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AT_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t169;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ {
+ RefAdaAST __t170 = _t;
+ RefAdaAST tmp150_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ATTRIBUTE_DEFINITION_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t170;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ {
+ RefAdaAST __t171 = _t;
+ RefAdaAST tmp151_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_REPESENTATION_CLAUSE);
+ _t = _t->getFirstChild();
+ local_enum_name(_t);
+ _t = _retTree;
+ enumeration_aggregate(_t);
+ _t = _retTree;
+ _t = __t171;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discrete_subtype_def_opt(RefAdaAST _t) {
+ RefAdaAST discrete_subtype_def_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t164 = _t;
+ RefAdaAST tmp152_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRETE_SUBTYPE_DEF_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case SUBTYPE_INDICATION:
+ {
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t164;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discrete_subtype_definition(RefAdaAST _t) {
+ RefAdaAST discrete_subtype_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBTYPE_INDICATION:
+ {
+ subtype_ind(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subtype_ind(RefAdaAST _t) {
+ RefAdaAST subtype_ind_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t239 = _t;
+ RefAdaAST tmp153_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBTYPE_INDICATION);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ constraint_opt(_t);
+ _t = _retTree;
+ _t = __t239;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::align_opt(RefAdaAST _t) {
+ RefAdaAST align_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t173 = _t;
+ RefAdaAST tmp154_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MOD_CLAUSE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t173;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::comp_loc_s(RefAdaAST _t) {
+ RefAdaAST comp_loc_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t176 = _t;
+ RefAdaAST tmp155_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_CLAUSES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ {
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop178;
+ }
+ }
+ }
+ _loop178:;
+ } // ( ... )*
+ _t = __t176;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::local_enum_name(RefAdaAST _t) {
+ RefAdaAST local_enum_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp156_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::enumeration_aggregate(RefAdaAST _t) {
+ RefAdaAST enumeration_aggregate_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_2.member(_t->getType()))) {
+ value(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop293;
+ }
+
+ }
+ _loop293:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::protected_definition(RefAdaAST _t) {
+ RefAdaAST protected_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ prot_op_decl_s(_t);
+ _t = _retTree;
+ prot_private_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_private_opt(RefAdaAST _t) {
+ RefAdaAST prot_private_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t185 = _t;
+ RefAdaAST tmp157_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_PRIVATE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROT_MEMBER_DECLARATIONS:
+ {
+ prot_member_decl_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t185;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_member_decl_s(RefAdaAST _t) {
+ RefAdaAST prot_member_decl_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t196 = _t;
+ RefAdaAST tmp158_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_MEMBER_DECLARATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENTRY_DECLARATION:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case FUNCTION_DECLARATION:
+ case PROCEDURE_DECLARATION:
+ {
+ prot_op_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMPONENT_DECLARATION:
+ {
+ comp_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop198;
+ }
+ }
+ }
+ _loop198:;
+ } // ( ... )*
+ _t = __t196;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_op_decl_s(RefAdaAST _t) {
+ RefAdaAST prot_op_decl_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t189 = _t;
+ RefAdaAST tmp159_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_OP_DECLARATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_3.member(_t->getType()))) {
+ prot_op_decl(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop191;
+ }
+
+ }
+ _loop191:;
+ } // ( ... )*
+ _t = __t189;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_op_decl(RefAdaAST _t) {
+ RefAdaAST prot_op_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENTRY_DECLARATION:
+ {
+ entry_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t193 = _t;
+ RefAdaAST tmp160_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t193;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t194 = _t;
+ RefAdaAST tmp161_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t194;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::comp_decl(RefAdaAST _t) {
+ RefAdaAST comp_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t200 = _t;
+ RefAdaAST tmp162_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ component_subtype_def(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t200;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::component_subtype_def(RefAdaAST _t) {
+ RefAdaAST component_subtype_def_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::enum_id_s(RefAdaAST _t) {
+ RefAdaAST enum_id_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ { // ( ... )+
+ int _cnt224=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == CHARACTER_LITERAL)) {
+ enumeration_literal_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt224>=1 ) { goto _loop224; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt224++;
+ }
+ _loop224:;
+ } // ( ... )+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range_constraint_opt(RefAdaAST _t) {
+ RefAdaAST range_constraint_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE_CONSTRAINT:
+ {
+ range_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::array_type_declaration(RefAdaAST _t) {
+ RefAdaAST array_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t230 = _t;
+ RefAdaAST tmp163_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARRAY_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp164_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ array_type_definition(_t);
+ _t = _retTree;
+ _t = __t230;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::access_type_declaration(RefAdaAST _t) {
+ RefAdaAST access_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t263 = _t;
+ RefAdaAST tmp165_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp166_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t263;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t264 = _t;
+ RefAdaAST tmp167_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp168_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t264;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS_TO_OBJECT_DECLARATION:
+ {
+ RefAdaAST __t265 = _t;
+ RefAdaAST tmp169_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp170_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t265;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::id_and_discrim(RefAdaAST _t) {
+ RefAdaAST id_and_discrim_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp171_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrim_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::record_definition(RefAdaAST _t) {
+ RefAdaAST record_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case COMPONENT_ITEMS:
+ {
+ component_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::array_type_definition(RefAdaAST _t) {
+ RefAdaAST array_type_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ index_or_discrete_range_s(_t);
+ _t = _retTree;
+ component_subtype_def(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::enumeration_literal_specification(RefAdaAST _t) {
+ RefAdaAST enumeration_literal_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp172_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp173_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL);
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::index_or_discrete_range_s(RefAdaAST _t) {
+ RefAdaAST index_or_discrete_range_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case DOT_DOT:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ index_or_discrete_range(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMMA:
+ {
+ RefAdaAST __t232 = _t;
+ RefAdaAST tmp174_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMMA);
+ _t = _t->getFirstChild();
+ index_or_discrete_range_s(_t);
+ _t = _retTree;
+ index_or_discrete_range(_t);
+ _t = _retTree;
+ _t = __t232;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::index_or_discrete_range(RefAdaAST _t) {
+ RefAdaAST index_or_discrete_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ RefAdaAST __t234 = _t;
+ RefAdaAST tmp175_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t234;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RANGE:
+ {
+ RefAdaAST __t235 = _t;
+ RefAdaAST tmp176_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ RefAdaAST tmp177_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t235;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ simple_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::constraint_opt(RefAdaAST _t) {
+ RefAdaAST constraint_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE_CONSTRAINT:
+ {
+ range_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DIGITS_CONSTRAINT:
+ {
+ digits_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELTA_CONSTRAINT:
+ {
+ delta_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case INDEX_CONSTRAINT:
+ {
+ index_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DISCRIMINANT_CONSTRAINT:
+ {
+ discriminant_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::digits_constraint(RefAdaAST _t) {
+ RefAdaAST digits_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t243 = _t;
+ RefAdaAST tmp178_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIGITS_CONSTRAINT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t243;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::delta_constraint(RefAdaAST _t) {
+ RefAdaAST delta_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t245 = _t;
+ RefAdaAST tmp179_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELTA_CONSTRAINT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t245;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::index_constraint(RefAdaAST _t) {
+ RefAdaAST index_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t247 = _t;
+ RefAdaAST tmp180_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEX_CONSTRAINT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt249=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == DOT_DOT || _t->getType() == RANGE_ATTRIBUTE_REFERENCE || _t->getType() == SUBTYPE_INDICATION)) {
+ discrete_range(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt249>=1 ) { goto _loop249; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt249++;
+ }
+ _loop249:;
+ } // ( ... )+
+ _t = __t247;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discriminant_constraint(RefAdaAST _t) {
+ RefAdaAST discriminant_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t252 = _t;
+ RefAdaAST tmp181_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_CONSTRAINT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt254=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == DISCRIMINANT_ASSOCIATION)) {
+ discriminant_association(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt254>=1 ) { goto _loop254; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt254++;
+ }
+ _loop254:;
+ } // ( ... )+
+ _t = __t252;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discrete_range(RefAdaAST _t) {
+ RefAdaAST discrete_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBTYPE_INDICATION:
+ {
+ subtype_ind(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discriminant_association(RefAdaAST _t) {
+ RefAdaAST discriminant_association_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t256 = _t;
+ RefAdaAST tmp182_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_ASSOCIATION);
+ _t = _t->getFirstChild();
+ selector_names_opt(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t256;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::selector_names_opt(RefAdaAST _t) {
+ RefAdaAST selector_names_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t258 = _t;
+ RefAdaAST tmp183_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SELECTOR_NAMES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER)) {
+ selector_name(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop260;
+ }
+
+ }
+ _loop260:;
+ } // ( ... )*
+ _t = __t258;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::selector_name(RefAdaAST _t) {
+ RefAdaAST selector_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp184_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::component_list(RefAdaAST _t) {
+ RefAdaAST component_list_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ component_items(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case VARIANT_PART:
+ {
+ variant_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::component_items(RefAdaAST _t) {
+ RefAdaAST component_items_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t271 = _t;
+ RefAdaAST tmp185_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_ITEMS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMPONENT_DECLARATION:
+ {
+ comp_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop273;
+ }
+ }
+ }
+ _loop273:;
+ } // ( ... )*
+ _t = __t271;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::variant_part(RefAdaAST _t) {
+ RefAdaAST variant_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t275 = _t;
+ RefAdaAST tmp186_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT_PART);
+ _t = _t->getFirstChild();
+ discriminant_direct_name(_t);
+ _t = _retTree;
+ variant_s(_t);
+ _t = _retTree;
+ _t = __t275;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discriminant_direct_name(RefAdaAST _t) {
+ RefAdaAST discriminant_direct_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp187_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::variant_s(RefAdaAST _t) {
+ RefAdaAST variant_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t278 = _t;
+ RefAdaAST tmp188_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANTS);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt280=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == VARIANT)) {
+ variant(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt280>=1 ) { goto _loop280; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt280++;
+ }
+ _loop280:;
+ } // ( ... )+
+ _t = __t278;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::variant(RefAdaAST _t) {
+ RefAdaAST variant_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t282 = _t;
+ RefAdaAST tmp189_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case COMPONENT_ITEMS:
+ {
+ component_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t282;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::choice_s(RefAdaAST _t) {
+ RefAdaAST choice_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ RefAdaAST __t285 = _t;
+ RefAdaAST tmp190_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ choice(_t);
+ _t = _retTree;
+ _t = __t285;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case OTHERS:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case AND_THEN:
+ case MARK_WITH_CONSTRAINT:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ choice(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::choice(RefAdaAST _t) {
+ RefAdaAST choice_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case OTHERS:
+ {
+ RefAdaAST tmp191_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case MARK_WITH_CONSTRAINT:
+ {
+ discrete_with_range(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::discrete_with_range(RefAdaAST _t) {
+ RefAdaAST discrete_with_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case MARK_WITH_CONSTRAINT:
+ {
+ mark_with_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::mark_with_constraint(RefAdaAST _t) {
+ RefAdaAST mark_with_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t289 = _t;
+ RefAdaAST tmp192_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MARK_WITH_CONSTRAINT);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ range_constraint(_t);
+ _t = _retTree;
+ _t = __t289;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::generic_formal_parameter(RefAdaAST _t) {
+ RefAdaAST generic_formal_parameter_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case FORMAL_DISCRETE_TYPE_DECLARATION:
+ {
+ RefAdaAST __t299 = _t;
+ RefAdaAST tmp193_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_DISCRETE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t299;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ RefAdaAST __t300 = _t;
+ RefAdaAST tmp194_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t300;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_MODULAR_TYPE_DECLARATION:
+ {
+ RefAdaAST __t301 = _t;
+ RefAdaAST tmp195_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_MODULAR_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t301;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
+ {
+ RefAdaAST __t302 = _t;
+ RefAdaAST tmp196_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t302;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
+ {
+ RefAdaAST __t303 = _t;
+ RefAdaAST tmp197_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t303;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_FLOATING_POINT_DECLARATION:
+ {
+ RefAdaAST __t304 = _t;
+ RefAdaAST tmp198_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_FLOATING_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t304;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_TYPE_DECLARATION:
+ {
+ formal_array_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ formal_access_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case FORMAL_PRIVATE_TYPE_DECLARATION:
+ {
+ RefAdaAST __t305 = _t;
+ RefAdaAST tmp199_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PRIVATE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ _t = __t305;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
+ {
+ RefAdaAST __t306 = _t;
+ RefAdaAST tmp200_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t306;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PRIVATE_EXTENSION_DECLARATION:
+ {
+ RefAdaAST __t307 = _t;
+ RefAdaAST tmp201_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PRIVATE_EXTENSION_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t307;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PROCEDURE_DECLARATION:
+ {
+ RefAdaAST __t308 = _t;
+ RefAdaAST tmp202_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ subprogram_default_opt(_t);
+ _t = _retTree;
+ _t = __t308;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_FUNCTION_DECLARATION:
+ {
+ RefAdaAST __t309 = _t;
+ RefAdaAST tmp203_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ subprogram_default_opt(_t);
+ _t = _retTree;
+ _t = __t309;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PACKAGE_DECLARATION:
+ {
+ RefAdaAST __t310 = _t;
+ RefAdaAST tmp204_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PACKAGE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ compound_name(_t);
+ _t = _retTree;
+ formal_package_actual_part_opt(_t);
+ _t = _retTree;
+ _t = __t310;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PARAMETER_SPECIFICATION:
+ {
+ parameter_specification(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::formal_array_type_declaration(RefAdaAST _t) {
+ RefAdaAST formal_array_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ array_type_declaration(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::formal_access_type_declaration(RefAdaAST _t) {
+ RefAdaAST formal_access_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ access_type_declaration(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::id_part(RefAdaAST _t) {
+ RefAdaAST id_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprogram_default_opt(RefAdaAST _t) {
+ RefAdaAST subprogram_default_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ RefAdaAST tmp205_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::formal_package_actual_part_opt(RefAdaAST _t) {
+ RefAdaAST formal_package_actual_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ RefAdaAST tmp206_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DEFINING_IDENTIFIER_LIST:
+ {
+ defining_identifier_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ 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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::body_part(RefAdaAST _t) {
+ RefAdaAST body_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ declarative_part(_t);
+ _t = _retTree;
+ block_body(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::declarative_part(RefAdaAST _t) {
+ RefAdaAST declarative_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t324 = _t;
+ RefAdaAST tmp207_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARATIVE_PART);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PACKAGE_BODY:
+ case PACKAGE_BODY_STUB:
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case PROTECTED_BODY:
+ case PROTECTED_BODY_STUB:
+ case PROTECTED_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SINGLE_PROTECTED_DECLARATION:
+ case SINGLE_TASK_DECLARATION:
+ case SUBTYPE_DECLARATION:
+ case TASK_BODY:
+ case TASK_BODY_STUB:
+ case TASK_TYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ declarative_item(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop326;
+ }
+ }
+ }
+ _loop326:;
+ } // ( ... )*
+ _t = __t324;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::block_body(RefAdaAST _t) {
+ RefAdaAST block_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t343 = _t;
+ RefAdaAST tmp208_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_BODY);
+ _t = _t->getFirstChild();
+ handled_stmt_s(_t);
+ _t = _retTree;
+ _t = __t343;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::declarative_item(RefAdaAST _t) {
+ RefAdaAST declarative_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PACKAGE_BODY_STUB:
+ {
+ RefAdaAST __t328 = _t;
+ RefAdaAST tmp209_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t328;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ RefAdaAST __t329 = _t;
+ RefAdaAST tmp210_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t329;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ spec_decl_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case TASK_BODY_STUB:
+ {
+ RefAdaAST __t330 = _t;
+ RefAdaAST tmp211_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t330;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TASK_BODY:
+ {
+ RefAdaAST __t331 = _t;
+ RefAdaAST tmp212_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t331;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ {
+ task_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_BODY_STUB:
+ {
+ RefAdaAST __t332 = _t;
+ RefAdaAST tmp213_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t332;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED_BODY:
+ {
+ RefAdaAST __t333 = _t;
+ RefAdaAST tmp214_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ prot_op_bodies_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t333;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED_TYPE_DECLARATION:
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ prot_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl_or_rename_or_inst_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SUBTYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ decl_common(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::prot_op_bodies_opt(RefAdaAST _t) {
+ RefAdaAST prot_op_bodies_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t339 = _t;
+ RefAdaAST tmp215_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_OP_BODIES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ENTRY_BODY:
+ {
+ entry_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ case FUNCTION_DECLARATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_DECLARATION:
+ {
+ subprog_decl_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop341;
+ }
+ }
+ }
+ _loop341:;
+ } // ( ... )*
+ _t = __t339;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::block_body_opt(RefAdaAST _t) {
+ RefAdaAST block_body_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t336 = _t;
+ RefAdaAST tmp216_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_BODY_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case HANDLED_SEQUENCE_OF_STATEMENTS:
+ {
+ handled_stmt_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t336;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::handled_stmt_s(RefAdaAST _t) {
+ RefAdaAST handled_stmt_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t345 = _t;
+ RefAdaAST tmp217_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),HANDLED_SEQUENCE_OF_STATEMENTS);
+ _t = _t->getFirstChild();
+ statements(_t);
+ _t = _retTree;
+ except_handler_part_opt(_t);
+ _t = _retTree;
+ _t = __t345;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_body(RefAdaAST _t) {
+ RefAdaAST entry_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t405 = _t;
+ RefAdaAST tmp218_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ entry_body_formal_part(_t);
+ _t = _retTree;
+ entry_barrier(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t405;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::statements(RefAdaAST _t) {
+ RefAdaAST statements_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t350 = _t;
+ RefAdaAST tmp219_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SEQUENCE_OF_STATEMENTS);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt352=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case STATEMENT:
+ {
+ statement(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ if ( _cnt352>=1 ) { goto _loop352; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+ }
+ _cnt352++;
+ }
+ _loop352:;
+ } // ( ... )+
+ _t = __t350;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::except_handler_part_opt(RefAdaAST _t) {
+ RefAdaAST except_handler_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t455 = _t;
+ RefAdaAST tmp220_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPT_HANDLER_PART_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == EXCEPTION_HANDLER)) {
+ exception_handler(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop457;
+ }
+
+ }
+ _loop457:;
+ } // ( ... )*
+ _t = __t455;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::handled_stmts_opt(RefAdaAST _t) {
+ RefAdaAST handled_stmts_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t347 = _t;
+ RefAdaAST tmp221_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),HANDLED_STMTS_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case SEQUENCE_OF_STATEMENTS:
+ {
+ statements(_t);
+ _t = _retTree;
+ except_handler_part_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t347;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::statement(RefAdaAST _t) {
+ RefAdaAST statement_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t354 = _t;
+ RefAdaAST tmp222_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STATEMENT);
+ _t = _t->getFirstChild();
+ def_label_opt(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NULL_STATEMENT:
+ {
+ null_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case EXIT_STATEMENT:
+ {
+ exit_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case RETURN_STATEMENT:
+ {
+ return_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case GOTO_STATEMENT:
+ {
+ goto_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELAY_STATEMENT:
+ {
+ delay_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABORT_STATEMENT:
+ {
+ abort_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case RAISE_STATEMENT:
+ {
+ raise_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case REQUEUE_STATEMENT:
+ {
+ requeue_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCEPT_STATEMENT:
+ {
+ accept_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ASYNCHRONOUS_SELECT:
+ case CONDITIONAL_ENTRY_CALL:
+ case SELECTIVE_ACCEPT:
+ case TIMED_ENTRY_CALL:
+ {
+ select_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case IF_STATEMENT:
+ {
+ if_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case CASE_STATEMENT:
+ {
+ case_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case LOOP_STATEMENT:
+ {
+ loop_stmt(_t);
+ _t = _retTree;
+ id_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case BLOCK_STATEMENT:
+ {
+ block(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ASSIGNMENT_STATEMENT:
+ case CALL_STATEMENT:
+ {
+ call_or_assignment(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t354;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::def_label_opt(RefAdaAST _t) {
+ RefAdaAST def_label_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t357 = _t;
+ RefAdaAST tmp223_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LABEL_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp224_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t357;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::null_stmt(RefAdaAST _t) {
+ RefAdaAST null_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp225_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NULL_STATEMENT);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::exit_stmt(RefAdaAST _t) {
+ RefAdaAST exit_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t392 = _t;
+ RefAdaAST tmp226_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXIT_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ label_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ case WHEN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case WHEN:
+ {
+ RefAdaAST tmp227_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN);
+ _t = _t->getNextSibling();
+ condition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t392;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::return_stmt(RefAdaAST _t) {
+ RefAdaAST return_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t397 = _t;
+ RefAdaAST tmp228_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RETURN_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t397;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::goto_stmt(RefAdaAST _t) {
+ RefAdaAST goto_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t400 = _t;
+ RefAdaAST tmp229_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GOTO_STATEMENT);
+ _t = _t->getFirstChild();
+ label_name(_t);
+ _t = _retTree;
+ _t = __t400;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::delay_stmt(RefAdaAST _t) {
+ RefAdaAST delay_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t419 = _t;
+ RefAdaAST tmp230_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELAY_STATEMENT);
+ _t = _t->getFirstChild();
+ modifiers(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t419;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::abort_stmt(RefAdaAST _t) {
+ RefAdaAST abort_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t451 = _t;
+ RefAdaAST tmp231_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORT_STATEMENT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt453=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_tokenSet_4.member(_t->getType()))) {
+ name(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt453>=1 ) { goto _loop453; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt453++;
+ }
+ _loop453:;
+ } // ( ... )+
+ _t = __t451;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::raise_stmt(RefAdaAST _t) {
+ RefAdaAST raise_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t467 = _t;
+ RefAdaAST tmp232_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RAISE_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t467;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::requeue_stmt(RefAdaAST _t) {
+ RefAdaAST requeue_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t470 = _t;
+ RefAdaAST tmp233_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REQUEUE_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABORT:
+ {
+ RefAdaAST tmp234_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t470;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::accept_stmt(RefAdaAST _t) {
+ RefAdaAST accept_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t414 = _t;
+ RefAdaAST tmp235_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCEPT_STATEMENT);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ entry_index_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ handled_stmts_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t414;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::select_stmt(RefAdaAST _t) {
+ RefAdaAST select_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ASYNCHRONOUS_SELECT:
+ {
+ RefAdaAST __t421 = _t;
+ RefAdaAST tmp236_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASYNCHRONOUS_SELECT);
+ _t = _t->getFirstChild();
+ triggering_alternative(_t);
+ _t = _retTree;
+ abortable_part(_t);
+ _t = _retTree;
+ _t = __t421;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SELECTIVE_ACCEPT:
+ {
+ RefAdaAST __t422 = _t;
+ RefAdaAST tmp237_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SELECTIVE_ACCEPT);
+ _t = _t->getFirstChild();
+ selective_accept(_t);
+ _t = _retTree;
+ _t = __t422;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIMED_ENTRY_CALL:
+ {
+ RefAdaAST __t423 = _t;
+ RefAdaAST tmp238_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIMED_ENTRY_CALL);
+ _t = _t->getFirstChild();
+ entry_call_alternative(_t);
+ _t = _retTree;
+ delay_alternative(_t);
+ _t = _retTree;
+ _t = __t423;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONDITIONAL_ENTRY_CALL:
+ {
+ RefAdaAST __t424 = _t;
+ RefAdaAST tmp239_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONDITIONAL_ENTRY_CALL);
+ _t = _t->getFirstChild();
+ entry_call_alternative(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t424;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::if_stmt(RefAdaAST _t) {
+ RefAdaAST if_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t361 = _t;
+ RefAdaAST tmp240_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF_STATEMENT);
+ _t = _t->getFirstChild();
+ cond_clause(_t);
+ _t = _retTree;
+ elsifs_opt(_t);
+ _t = _retTree;
+ else_opt(_t);
+ _t = _retTree;
+ _t = __t361;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::case_stmt(RefAdaAST _t) {
+ RefAdaAST case_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t373 = _t;
+ RefAdaAST tmp241_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE_STATEMENT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ alternative_s(_t);
+ _t = _retTree;
+ _t = __t373;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::loop_stmt(RefAdaAST _t) {
+ RefAdaAST loop_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t380 = _t;
+ RefAdaAST tmp242_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LOOP_STATEMENT);
+ _t = _t->getFirstChild();
+ iteration_scheme_opt(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t380;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::block(RefAdaAST _t) {
+ RefAdaAST block_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t387 = _t;
+ RefAdaAST tmp243_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_STATEMENT);
+ _t = _t->getFirstChild();
+ declare_opt(_t);
+ _t = _retTree;
+ block_body(_t);
+ _t = _retTree;
+ _t = __t387;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::call_or_assignment(RefAdaAST _t) {
+ RefAdaAST call_or_assignment_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ASSIGNMENT_STATEMENT:
+ {
+ RefAdaAST __t402 = _t;
+ RefAdaAST tmp244_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGNMENT_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t402;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CALL_STATEMENT:
+ {
+ RefAdaAST __t403 = _t;
+ RefAdaAST tmp245_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CALL_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ _t = __t403;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::cond_clause(RefAdaAST _t) {
+ RefAdaAST cond_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t363 = _t;
+ RefAdaAST tmp246_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COND_CLAUSE);
+ _t = _t->getFirstChild();
+ condition(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t363;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::elsifs_opt(RefAdaAST _t) {
+ RefAdaAST elsifs_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t366 = _t;
+ RefAdaAST tmp247_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSIFS_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == COND_CLAUSE)) {
+ cond_clause(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop368;
+ }
+
+ }
+ _loop368:;
+ } // ( ... )*
+ _t = __t366;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::else_opt(RefAdaAST _t) {
+ RefAdaAST else_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t370 = _t;
+ RefAdaAST tmp248_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case SEQUENCE_OF_STATEMENTS:
+ {
+ statements(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t370;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::condition(RefAdaAST _t) {
+ RefAdaAST condition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::alternative_s(RefAdaAST _t) {
+ RefAdaAST alternative_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ { // ( ... )+
+ int _cnt376=0;
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == CASE_STATEMENT_ALTERNATIVE)) {
+ case_statement_alternative(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt376>=1 ) { goto _loop376; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+ }
+
+ _cnt376++;
+ }
+ _loop376:;
+ } // ( ... )+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::case_statement_alternative(RefAdaAST _t) {
+ RefAdaAST case_statement_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t378 = _t;
+ RefAdaAST tmp249_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE_STATEMENT_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t378;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::iteration_scheme_opt(RefAdaAST _t) {
+ RefAdaAST iteration_scheme_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t382 = _t;
+ RefAdaAST tmp250_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ITERATION_SCHEME_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case WHILE:
+ {
+ RefAdaAST __t384 = _t;
+ RefAdaAST tmp251_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHILE);
+ _t = _t->getFirstChild();
+ condition(_t);
+ _t = _retTree;
+ _t = __t384;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FOR:
+ {
+ RefAdaAST __t385 = _t;
+ RefAdaAST tmp252_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR);
+ _t = _t->getFirstChild();
+ RefAdaAST tmp253_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ _t = __t385;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t382;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::declare_opt(RefAdaAST _t) {
+ RefAdaAST declare_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t389 = _t;
+ RefAdaAST tmp254_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DECLARATIVE_PART:
+ {
+ declarative_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t389;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::label_name(RefAdaAST _t) {
+ RefAdaAST label_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST tmp255_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_body_formal_part(RefAdaAST _t) {
+ RefAdaAST entry_body_formal_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ entry_index_spec_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_barrier(RefAdaAST _t) {
+ RefAdaAST entry_barrier_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ condition(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_index_spec_opt(RefAdaAST _t) {
+ RefAdaAST entry_index_spec_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t408 = _t;
+ RefAdaAST tmp256_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_INDEX_SPECIFICATION);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ def_id(_t);
+ _t = _retTree;
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t408;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_call_stmt(RefAdaAST _t) {
+ RefAdaAST entry_call_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t412 = _t;
+ RefAdaAST tmp257_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_CALL_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ _t = __t412;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_index_opt(RefAdaAST _t) {
+ RefAdaAST entry_index_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t416 = _t;
+ RefAdaAST tmp258_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_INDEX_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t416;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::triggering_alternative(RefAdaAST _t) {
+ RefAdaAST triggering_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t426 = _t;
+ RefAdaAST tmp259_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TRIGGERING_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DELAY_STATEMENT:
+ {
+ delay_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ENTRY_CALL_STATEMENT:
+ {
+ entry_call_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t426;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::abortable_part(RefAdaAST _t) {
+ RefAdaAST abortable_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t429 = _t;
+ RefAdaAST tmp260_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORTABLE_PART);
+ _t = _t->getFirstChild();
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t429;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::selective_accept(RefAdaAST _t) {
+ RefAdaAST selective_accept_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ guard_opt(_t);
+ _t = _retTree;
+ select_alternative(_t);
+ _t = _retTree;
+ or_select_opt(_t);
+ _t = _retTree;
+ else_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::entry_call_alternative(RefAdaAST _t) {
+ RefAdaAST entry_call_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t431 = _t;
+ RefAdaAST tmp261_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_CALL_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ entry_call_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t431;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::delay_alternative(RefAdaAST _t) {
+ RefAdaAST delay_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t442 = _t;
+ RefAdaAST tmp262_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELAY_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ delay_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t442;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::stmts_opt(RefAdaAST _t) {
+ RefAdaAST stmts_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case STATEMENT:
+ {
+ statement(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop445;
+ }
+ }
+ }
+ _loop445:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::guard_opt(RefAdaAST _t) {
+ RefAdaAST guard_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t434 = _t;
+ RefAdaAST tmp263_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GUARD_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ condition(_t);
+ _t = _retTree;
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == PRAGMA)) {
+ pragma(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop437;
+ }
+
+ }
+ _loop437:;
+ } // ( ... )*
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t434;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::select_alternative(RefAdaAST _t) {
+ RefAdaAST select_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ACCEPT_ALTERNATIVE:
+ {
+ accept_alternative(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELAY_ALTERNATIVE:
+ {
+ delay_alternative(_t);
+ _t = _retTree;
+ break;
+ }
+ case TERMINATE_ALTERNATIVE:
+ {
+ RefAdaAST tmp264_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TERMINATE_ALTERNATIVE);
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::or_select_opt(RefAdaAST _t) {
+ RefAdaAST or_select_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t447 = _t;
+ RefAdaAST tmp265_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR_SELECT_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ if ((_t->getType() == GUARD_OPT)) {
+ guard_opt(_t);
+ _t = _retTree;
+ select_alternative(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop449;
+ }
+
+ }
+ _loop449:;
+ } // ( ... )*
+ _t = __t447;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::accept_alternative(RefAdaAST _t) {
+ RefAdaAST accept_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t440 = _t;
+ RefAdaAST tmp266_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCEPT_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ accept_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t440;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::exception_handler(RefAdaAST _t) {
+ RefAdaAST exception_handler_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t459 = _t;
+ RefAdaAST tmp267_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_HANDLER);
+ _t = _t->getFirstChild();
+ identifier_colon_opt(_t);
+ _t = _retTree;
+ except_choice_s(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t459;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::identifier_colon_opt(RefAdaAST _t) {
+ RefAdaAST identifier_colon_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t461 = _t;
+ RefAdaAST tmp268_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER_COLON_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp269_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t461;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::except_choice_s(RefAdaAST _t) {
+ RefAdaAST except_choice_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ RefAdaAST __t464 = _t;
+ RefAdaAST tmp270_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE);
+ _t = _t->getFirstChild();
+ except_choice_s(_t);
+ _t = _retTree;
+ exception_choice(_t);
+ _t = _retTree;
+ _t = __t464;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case OTHERS:
+ {
+ exception_choice(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::exception_choice(RefAdaAST _t) {
+ RefAdaAST exception_choice_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case OTHERS:
+ {
+ RefAdaAST tmp271_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS);
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::operator_call(RefAdaAST _t) {
+ RefAdaAST operator_call_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t473 = _t;
+ RefAdaAST tmp272_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL);
+ _t = _t->getFirstChild();
+ value_s(_t);
+ _t = _retTree;
+ _t = __t473;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::relation(RefAdaAST _t) {
+ RefAdaAST relation_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IN:
+ {
+ RefAdaAST __t485 = _t;
+ RefAdaAST tmp273_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ range_or_mark(_t);
+ _t = _retTree;
+ _t = __t485;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NOT_IN:
+ {
+ RefAdaAST __t486 = _t;
+ RefAdaAST tmp274_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT_IN);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ range_or_mark(_t);
+ _t = _retTree;
+ _t = __t486;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EQ:
+ {
+ RefAdaAST __t487 = _t;
+ RefAdaAST tmp275_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQ);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t487;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NE:
+ {
+ RefAdaAST __t488 = _t;
+ RefAdaAST tmp276_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t488;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LT_:
+ {
+ RefAdaAST __t489 = _t;
+ RefAdaAST tmp277_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LT_);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t489;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LE:
+ {
+ RefAdaAST __t490 = _t;
+ RefAdaAST tmp278_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t490;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GT:
+ {
+ RefAdaAST __t491 = _t;
+ RefAdaAST tmp279_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t491;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GE:
+ {
+ RefAdaAST __t492 = _t;
+ RefAdaAST tmp280_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t492;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ simple_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::range_or_mark(RefAdaAST _t) {
+ RefAdaAST range_or_mark_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ {
+ subtype_mark(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::signed_term(RefAdaAST _t) {
+ RefAdaAST signed_term_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case UNARY_PLUS:
+ {
+ RefAdaAST __t499 = _t;
+ RefAdaAST tmp281_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_PLUS);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ _t = __t499;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case UNARY_MINUS:
+ {
+ RefAdaAST __t500 = _t;
+ RefAdaAST tmp282_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_MINUS);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ _t = __t500;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ term(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::term(RefAdaAST _t) {
+ RefAdaAST term_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case STAR:
+ {
+ RefAdaAST __t502 = _t;
+ RefAdaAST tmp283_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STAR);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t502;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DIV:
+ {
+ RefAdaAST __t503 = _t;
+ RefAdaAST tmp284_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIV);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t503;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MOD:
+ {
+ RefAdaAST __t504 = _t;
+ RefAdaAST tmp285_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MOD);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t504;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case REM:
+ {
+ RefAdaAST __t505 = _t;
+ RefAdaAST tmp286_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REM);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t505;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ factor(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::factor(RefAdaAST _t) {
+ RefAdaAST factor_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NOT:
+ {
+ RefAdaAST __t507 = _t;
+ RefAdaAST tmp287_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ _t = __t507;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABS:
+ {
+ RefAdaAST __t508 = _t;
+ RefAdaAST tmp288_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABS);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ _t = __t508;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EXPON:
+ {
+ RefAdaAST __t509 = _t;
+ RefAdaAST tmp289_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPON);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ primary(_t);
+ _t = _retTree;
+ _t = __t509;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ primary(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::primary(RefAdaAST _t) {
+ RefAdaAST primary_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name_or_qualified(_t);
+ _t = _retTree;
+ break;
+ }
+ case PARENTHESIZED_PRIMARY:
+ {
+ parenthesized_primary(_t);
+ _t = _retTree;
+ break;
+ }
+ case ALLOCATOR:
+ {
+ allocator(_t);
+ _t = _retTree;
+ break;
+ }
+ case NuLL:
+ {
+ RefAdaAST tmp290_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NUMERIC_LIT:
+ {
+ RefAdaAST tmp291_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUMERIC_LIT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp292_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHAR_STRING:
+ {
+ RefAdaAST tmp293_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHAR_STRING);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ operator_call(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::name_or_qualified(RefAdaAST _t) {
+ RefAdaAST name_or_qualified_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp294_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ RefAdaAST __t513 = _t;
+ RefAdaAST tmp295_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ RefAdaAST tmp296_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ RefAdaAST tmp297_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ RefAdaAST tmp298_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ RefAdaAST tmp299_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t513;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ RefAdaAST __t515 = _t;
+ RefAdaAST tmp300_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t515;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIC:
+ {
+ RefAdaAST __t516 = _t;
+ RefAdaAST tmp301_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ {
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PARENTHESIZED_PRIMARY:
+ {
+ parenthesized_primary(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case RANGE:
+ case DIGITS:
+ case DELTA:
+ case ACCESS:
+ {
+ attribute_id(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+ }
+ }
+ }
+ _t = __t516;
+ _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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::allocator(RefAdaAST _t) {
+ RefAdaAST allocator_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t519 = _t;
+ RefAdaAST tmp302_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALLOCATOR);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ _t = __t519;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::subprogram_body(RefAdaAST _t) {
+ RefAdaAST subprogram_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_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 != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::task_body(RefAdaAST _t) {
+ RefAdaAST task_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t525 = _t;
+ RefAdaAST tmp303_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t525;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::protected_body(RefAdaAST _t) {
+ RefAdaAST protected_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+
+ try { // for error handling
+ RefAdaAST __t527 = _t;
+ RefAdaAST tmp304_AST_in = _t;
+ match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ prot_op_bodies_opt(_t);
+ _t = _retTree;
+ _t = __t527;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaStoreWalker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
+{
+}
+const char* AdaStoreWalker::tokenNames[] = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "\"pragma\"",
+ "IDENTIFIER",
+ "SEMI",
+ "LPAREN",
+ "COMMA",
+ "RPAREN",
+ "RIGHT_SHAFT",
+ "\"with\"",
+ "DOT",
+ "\"use\"",
+ "\"type\"",
+ "TIC",
+ "\"range\"",
+ "\"digits\"",
+ "\"delta\"",
+ "\"access\"",
+ "\"private\"",
+ "\"package\"",
+ "\"body\"",
+ "\"is\"",
+ "\"procedure\"",
+ "\"function\"",
+ "\"new\"",
+ "\"others\"",
+ "PIPE",
+ "DOT_DOT",
+ "\"all\"",
+ "COLON",
+ "\"in\"",
+ "\"out\"",
+ "\"renames\"",
+ "CHARACTER_LITERAL",
+ "CHAR_STRING",
+ "\"null\"",
+ "\"record\"",
+ "\"separate\"",
+ "\"abstract\"",
+ "\"return\"",
+ "\"task\"",
+ "\"protected\"",
+ "BOX",
+ "ASSIGN",
+ "\"entry\"",
+ "\"for\"",
+ "\"end\"",
+ "\"at\"",
+ "\"mod\"",
+ "\"subtype\"",
+ "\"exception\"",
+ "\"constant\"",
+ "\"array\"",
+ "\"of\"",
+ "\"aliased\"",
+ "\"case\"",
+ "\"when\"",
+ "\"tagged\"",
+ "\"limited\"",
+ "\"generic\"",
+ "\"begin\"",
+ "LT_LT",
+ "GT_GT",
+ "\"if\"",
+ "\"then\"",
+ "\"elsif\"",
+ "\"else\"",
+ "\"loop\"",
+ "\"while\"",
+ "\"reverse\"",
+ "\"declare\"",
+ "\"exit\"",
+ "\"goto\"",
+ "\"accept\"",
+ "\"do\"",
+ "\"delay\"",
+ "\"until\"",
+ "\"select\"",
+ "\"abort\"",
+ "\"or\"",
+ "\"terminate\"",
+ "\"raise\"",
+ "\"requeue\"",
+ "\"and\"",
+ "\"xor\"",
+ "\"not\"",
+ "EQ",
+ "NE",
+ "LT_",
+ "LE",
+ "GT",
+ "GE",
+ "PLUS",
+ "MINUS",
+ "CONCAT",
+ "STAR",
+ "DIV",
+ "\"rem\"",
+ "\"abs\"",
+ "EXPON",
+ "NUMERIC_LIT",
+ "ABORTABLE_PART",
+ "ABORT_STATEMENT",
+ "ACCEPT_ALTERNATIVE",
+ "ACCEPT_STATEMENT",
+ "ALLOCATOR",
+ "ASSIGNMENT_STATEMENT",
+ "ASYNCHRONOUS_SELECT",
+ "ATTRIBUTE_DEFINITION_CLAUSE",
+ "AT_CLAUSE",
+ "BLOCK_STATEMENT",
+ "CASE_STATEMENT",
+ "CASE_STATEMENT_ALTERNATIVE",
+ "CODE_STATEMENT",
+ "COMPONENT_DECLARATION",
+ "CONDITIONAL_ENTRY_CALL",
+ "CONTEXT_CLAUSE",
+ "DECLARATIVE_PART",
+ "DEFINING_IDENTIFIER_LIST",
+ "DELAY_ALTERNATIVE",
+ "DELAY_STATEMENT",
+ "DELTA_CONSTRAINT",
+ "DIGITS_CONSTRAINT",
+ "DISCRIMINANT_ASSOCIATION",
+ "DISCRIMINANT_CONSTRAINT",
+ "DISCRIMINANT_SPECIFICATION",
+ "ENTRY_BODY",
+ "ENTRY_CALL_ALTERNATIVE",
+ "ENTRY_CALL_STATEMENT",
+ "ENTRY_DECLARATION",
+ "ENTRY_INDEX_SPECIFICATION",
+ "ENUMERATION_REPESENTATION_CLAUSE",
+ "EXCEPTION_DECLARATION",
+ "EXCEPTION_HANDLER",
+ "EXCEPTION_RENAMING_DECLARATION",
+ "EXIT_STATEMENT",
+ "FORMAL_PACKAGE_DECLARATION",
+ "GENERIC_FORMAL_PART",
+ "GENERIC_PACKAGE_DECLARATION",
+ "GOTO_STATEMENT",
+ "HANDLED_SEQUENCE_OF_STATEMENTS",
+ "HANDLED_STMTS_OPT",
+ "IF_STATEMENT",
+ "INCOMPLETE_TYPE_DECLARATION",
+ "INDEXED_COMPONENT",
+ "INDEX_CONSTRAINT",
+ "LIBRARY_ITEM",
+ "LOOP_STATEMENT",
+ "NAME",
+ "NULL_STATEMENT",
+ "NUMBER_DECLARATION",
+ "OBJECT_DECLARATION",
+ "OBJECT_RENAMING_DECLARATION",
+ "OPERATOR_SYMBOL",
+ "PACKAGE_BODY",
+ "PACKAGE_BODY_STUB",
+ "PACKAGE_RENAMING_DECLARATION",
+ "PACKAGE_SPECIFICATION",
+ "PARAMETER_SPECIFICATION",
+ "PRIVATE_EXTENSION_DECLARATION",
+ "PRIVATE_TYPE_DECLARATION",
+ "PROTECTED_BODY",
+ "PROTECTED_BODY_STUB",
+ "PROTECTED_TYPE_DECLARATION",
+ "RAISE_STATEMENT",
+ "RANGE_ATTRIBUTE_REFERENCE",
+ "RECORD_REPRESENTATION_CLAUSE",
+ "REQUEUE_STATEMENT",
+ "RETURN_STATEMENT",
+ "SELECTIVE_ACCEPT",
+ "SEQUENCE_OF_STATEMENTS",
+ "SINGLE_PROTECTED_DECLARATION",
+ "SINGLE_TASK_DECLARATION",
+ "STATEMENT",
+ "SUBTYPE_DECLARATION",
+ "SUBTYPE_INDICATION",
+ "SUBTYPE_MARK",
+ "SUBUNIT",
+ "TASK_BODY",
+ "TASK_BODY_STUB",
+ "TASK_TYPE_DECLARATION",
+ "TERMINATE_ALTERNATIVE",
+ "TIMED_ENTRY_CALL",
+ "TRIGGERING_ALTERNATIVE",
+ "USE_CLAUSE",
+ "USE_TYPE_CLAUSE",
+ "VARIANT",
+ "VARIANT_PART",
+ "WITH_CLAUSE",
+ "ABSTRACT_FUNCTION_DECLARATION",
+ "ABSTRACT_PROCEDURE_DECLARATION",
+ "ACCESS_TO_FUNCTION_DECLARATION",
+ "ACCESS_TO_OBJECT_DECLARATION",
+ "ACCESS_TO_PROCEDURE_DECLARATION",
+ "ARRAY_OBJECT_DECLARATION",
+ "ARRAY_TYPE_DECLARATION",
+ "AND_THEN",
+ "BASIC_DECLARATIVE_ITEMS_OPT",
+ "BLOCK_BODY",
+ "BLOCK_BODY_OPT",
+ "CALL_STATEMENT",
+ "COMPONENT_CLAUSES_OPT",
+ "COMPONENT_ITEMS",
+ "COND_CLAUSE",
+ "DECIMAL_FIXED_POINT_DECLARATION",
+ "DECLARE_OPT",
+ "DERIVED_RECORD_EXTENSION",
+ "DISCRETE_SUBTYPE_DEF_OPT",
+ "DISCRIMINANT_SPECIFICATIONS",
+ "DISCRIM_PART_OPT",
+ "ELSE_OPT",
+ "ELSIFS_OPT",
+ "END_ID_OPT",
+ "ENTRY_INDEX_OPT",
+ "ENUMERATION_TYPE_DECLARATION",
+ "EXCEPT_HANDLER_PART_OPT",
+ "EXTENSION_OPT",
+ "FLOATING_POINT_DECLARATION",
+ "FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
+ "FORMAL_DISCRETE_TYPE_DECLARATION",
+ "FORMAL_FLOATING_POINT_DECLARATION",
+ "FORMAL_FUNCTION_DECLARATION",
+ "FORMAL_MODULAR_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
+ "FORMAL_PART_OPT",
+ "FORMAL_PRIVATE_EXTENSION_DECLARATION",
+ "FORMAL_PRIVATE_TYPE_DECLARATION",
+ "FORMAL_PROCEDURE_DECLARATION",
+ "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
+ "FUNCTION_BODY",
+ "FUNCTION_BODY_STUB",
+ "FUNCTION_DECLARATION",
+ "FUNCTION_RENAMING_DECLARATION",
+ "GENERIC_FUNCTION_DECLARATION",
+ "GENERIC_FUNCTION_INSTANTIATION",
+ "GENERIC_FUNCTION_RENAMING",
+ "GENERIC_PACKAGE_INSTANTIATION",
+ "GENERIC_PACKAGE_RENAMING",
+ "GENERIC_PROCEDURE_DECLARATION",
+ "GENERIC_PROCEDURE_INSTANTIATION",
+ "GENERIC_PROCEDURE_RENAMING",
+ "GUARD_OPT",
+ "IDENTIFIER_COLON_OPT",
+ "ID_OPT",
+ "INIT_OPT",
+ "ITERATION_SCHEME_OPT",
+ "LABEL_OPT",
+ "MARK_WITH_CONSTRAINT",
+ "MODIFIERS",
+ "MODULAR_TYPE_DECLARATION",
+ "MOD_CLAUSE_OPT",
+ "NOT_IN",
+ "ORDINARY_DERIVED_TYPE_DECLARATION",
+ "ORDINARY_FIXED_POINT_DECLARATION",
+ "OR_ELSE",
+ "OR_SELECT_OPT",
+ "PARENTHESIZED_PRIMARY",
+ "PRIVATE_DECLARATIVE_ITEMS_OPT",
+ "PRIVATE_TASK_ITEMS_OPT",
+ "PROCEDURE_BODY",
+ "PROCEDURE_BODY_STUB",
+ "PROCEDURE_DECLARATION",
+ "PROCEDURE_RENAMING_DECLARATION",
+ "PROT_MEMBER_DECLARATIONS",
+ "PROT_OP_BODIES_OPT",
+ "PROT_OP_DECLARATIONS",
+ "PROT_PRIVATE_OPT",
+ "RANGED_EXPRS",
+ "RANGE_CONSTRAINT",
+ "RECORD_TYPE_DECLARATION",
+ "SELECTOR_NAMES_OPT",
+ "SIGNED_INTEGER_TYPE_DECLARATION",
+ "TASK_ITEMS_OPT",
+ "UNARY_MINUS",
+ "UNARY_PLUS",
+ "VALUE",
+ "VALUES",
+ "VARIANTS",
+ "COMMENT_INTRO",
+ "OX",
+ "TIC_OR_CHARACTER_LITERAL",
+ "DIGIT",
+ "EXPONENT",
+ "EXTENDED_DIGIT",
+ "BASED_INTEGER",
+ "WS_",
+ "COMMENT",
+ "CHARACTER_STRING",
+ 0
+};
+
+const unsigned long AdaStoreWalker::_tokenSet_0_data_[] = { 37920UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER RIGHT_SHAFT DOT TIC "in" CHARACTER_LITERAL CHAR_STRING "null"
+// "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR
+// DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT OPERATOR_SYMBOL
+// AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS UNARY_PLUS
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_0(_tokenSet_0_data_,20);
+const unsigned long AdaStoreWalker::_tokenSet_1_data_[] = { 0UL, 0UL, 0UL, 49152UL, 3338801504UL, 2353094950UL, 151076927UL, 2416967168UL, 328577UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENUMERATION_REPESENTATION_CLAUSE
+// EXCEPTION_DECLARATION EXCEPTION_RENAMING_DECLARATION GENERIC_PACKAGE_DECLARATION
+// INCOMPLETE_TYPE_DECLARATION NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION
+// PACKAGE_RENAMING_DECLARATION PACKAGE_SPECIFICATION PRIVATE_EXTENSION_DECLARATION
+// PRIVATE_TYPE_DECLARATION PROTECTED_TYPE_DECLARATION RECORD_REPRESENTATION_CLAUSE
+// SINGLE_PROTECTED_DECLARATION SINGLE_TASK_DECLARATION SUBTYPE_DECLARATION
+// TASK_TYPE_DECLARATION USE_CLAUSE USE_TYPE_CLAUSE ABSTRACT_FUNCTION_DECLARATION
+// ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION
+// ACCESS_TO_PROCEDURE_DECLARATION ARRAY_OBJECT_DECLARATION ARRAY_TYPE_DECLARATION
+// DECIMAL_FIXED_POINT_DECLARATION DERIVED_RECORD_EXTENSION ENUMERATION_TYPE_DECLARATION
+// FLOATING_POINT_DECLARATION FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION
+// GENERIC_FUNCTION_DECLARATION GENERIC_FUNCTION_INSTANTIATION GENERIC_FUNCTION_RENAMING
+// GENERIC_PACKAGE_INSTANTIATION GENERIC_PACKAGE_RENAMING GENERIC_PROCEDURE_DECLARATION
+// GENERIC_PROCEDURE_INSTANTIATION GENERIC_PROCEDURE_RENAMING MODULAR_TYPE_DECLARATION
+// ORDINARY_DERIVED_TYPE_DECLARATION ORDINARY_FIXED_POINT_DECLARATION PROCEDURE_BODY_STUB
+// PROCEDURE_DECLARATION PROCEDURE_RENAMING_DECLARATION RECORD_TYPE_DECLARATION
+// SIGNED_INTEGER_TYPE_DECLARATION
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_1(_tokenSet_1_data_,20);
+const unsigned long AdaStoreWalker::_tokenSet_2_data_[] = { 939627552UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER RIGHT_SHAFT DOT TIC "range" "others" PIPE DOT_DOT "in" CHARACTER_LITERAL
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT
+// OPERATOR_SYMBOL AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS
+// UNARY_PLUS
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_2(_tokenSet_2_data_,20);
+const unsigned long AdaStoreWalker::_tokenSet_3_data_[] = { 16UL, 0UL, 0UL, 49152UL, 40UL, 256UL, 0UL, 1024UL, 256UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENTRY_DECLARATION ENUMERATION_REPESENTATION_CLAUSE
+// RECORD_REPRESENTATION_CLAUSE FUNCTION_DECLARATION PROCEDURE_DECLARATION
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_3(_tokenSet_3_data_,20);
+const unsigned long AdaStoreWalker::_tokenSet_4_data_[] = { 36896UL, 0UL, 0UL, 0UL, 262144UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER DOT TIC INDEXED_COMPONENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_4(_tokenSet_4_data_,12);
+
+
diff --git a/languages/ada/AdaStoreWalker.hpp b/languages/ada/AdaStoreWalker.hpp
new file mode 100644
index 00000000..6f108ff6
--- /dev/null
+++ b/languages/ada/AdaStoreWalker.hpp
@@ -0,0 +1,350 @@
+#ifndef INC_AdaStoreWalker_hpp_
+#define INC_AdaStoreWalker_hpp_
+
+#line 1 "expandedada.store.g"
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qfileinfo.h>
+
+#include <codemodel.h>
+#include "AdaAST.hpp"
+#include "ada_utils.hpp"
+
+#line 15 "AdaStoreWalker.hpp"
+#include <antlr/config.hpp>
+#include "AdaStoreWalkerTokenTypes.hpp"
+/* $ANTLR 2.7.7 (20070609): "expandedada.store.g" -> "AdaStoreWalker.hpp"$ */
+#include <antlr/TreeParser.hpp>
+
+#line 10 "expandedada.store.g"
+
+#include <codemodel.h>
+#include <kdebug.h>
+
+#line 26 "AdaStoreWalker.hpp"
+class CUSTOM_API AdaStoreWalker : public ANTLR_USE_NAMESPACE(antlr)TreeParser, public AdaStoreWalkerTokenTypes
+{
+#line 25 "expandedada.store.g"
+
+private:
+ QString m_fileName;
+ QValueList<NamespaceDom> m_scopeStack;
+ CodeModel* m_model;
+ QValueList<QStringList> m_imports;
+ NamespaceDom m_currentContainer;
+ int m_currentAccess;
+ bool m_addToStore; /* auxiliary variable: for the moment, this is `true'
+ only when we are in specs, not bodies. */
+ bool m_isSubprogram; // auxiliary to def_id()
+ FileDom m_file;
+
+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_scopeStack.clear ();
+ m_imports.clear ();
+ m_currentContainer = m_model->globalNamespace ();
+ m_scopeStack.append (m_currentContainer);
+ m_currentAccess = CodeModelItem::Public;
+ m_addToStore = false;
+ m_isSubprogram = false;
+ if (m_model->hasFile(m_fileName))
+ m_model->removeFile (m_model->fileByName(m_fileName));
+ m_file = m_model->create<FileModel>();
+ m_file->setName(m_fileName);
+ m_model->addFile(m_file);
+ }
+
+ void wipeout () { m_model->wipeout (); }
+// void out () { m_store->out (); }
+ void removeWithReferences (const QString& fileName) {
+ m_model->removeFile (m_model->fileByName(fileName));
+ }
+ NamespaceDom insertScopeContainer
+ (NamespaceDom scope, const QStringList & scopes ) {
+ QStringList::ConstIterator it = scopes.begin();
+ QString prefix( *it );
+ NamespaceDom ns = scope->namespaceByName( prefix );
+// kdDebug() << "insertScopeContainer begin with prefix " << prefix << endl;
+ if (!ns.data()) {
+// kdDebug() << "insertScopeContainer: ns is empty" << endl;
+ ns = m_model->create<NamespaceModel>();
+// kdDebug() << "insertScopeContainer: ns created" << endl;
+ ns->setName( prefix );
+// kdDebug() << "insertScopeContainer: ns name set" << endl;
+ scope->addNamespace( ns );
+// kdDebug() << "insertScopeContainer: ns added to a scope" << endl;
+
+ if (scope == m_model->globalNamespace())
+ m_file->addNamespace( ns );
+ }
+// kdDebug() << "insertScopeContainer: while" << endl;
+ while ( ++it != scopes.end() ) {
+ QString nameSegment( *it );
+ prefix += "." + nameSegment;
+// kdDebug() << "insertScopeContainer: while prefix = " << prefix << endl;
+ NamespaceDom inner = scope->namespaceByName( prefix );
+ if (!inner.data() ) {
+// kdDebug() << "insertScopeContainer: inner is empty " << endl;
+ inner = m_model->create<NamespaceModel>();
+// kdDebug() << "insertScopeContainer: inner created " << endl;
+ inner->setName( nameSegment );
+ ns->addNamespace( inner );
+// kdDebug() << "insertScopeContainer: inner added " << endl;
+ }
+ ns = inner;
+ }
+ return ns;
+ }
+ NamespaceDom defineScope( RefAdaAST namenode ) {
+ QStringList scopes( qnamelist( namenode ) );
+// kdDebug() << "defineScope: " << scopes.join(" ") << endl;
+ NamespaceDom psc = insertScopeContainer( m_currentContainer, scopes );
+// kdDebug() << "defineScope psc created" << endl;
+ psc->setStartPosition(namenode->getLine(), namenode->getColumn());
+// kdDebug() << "defineScope start position set" << endl;
+ psc->setFileName(m_fileName);
+// kdDebug() << "defineScope file name set" << endl;
+ // psc->setEndPosition (endLine, 0);
+// kdDebug() << "defineScope return" << endl;
+ return psc;
+ }
+#line 30 "AdaStoreWalker.hpp"
+public:
+ AdaStoreWalker();
+ static void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
+ int getNumTokens() const
+ {
+ return AdaStoreWalker::NUM_TOKENS;
+ }
+ const char* getTokenName( int type ) const
+ {
+ if( type > getNumTokens() ) return 0;
+ return AdaStoreWalker::tokenNames[type];
+ }
+ const char* const* getTokenNames() const
+ {
+ return AdaStoreWalker::tokenNames;
+ }
+ public: void compilation_unit(RefAdaAST _t);
+ public: void context_items_opt(RefAdaAST _t);
+ public: void library_item(RefAdaAST _t);
+ public: void subunit(RefAdaAST _t);
+ public: void pragma(RefAdaAST _t);
+ public: void with_clause(RefAdaAST _t);
+ public: void compound_name(RefAdaAST _t);
+ public: void use_clause(RefAdaAST _t);
+ public: void subtype_mark(RefAdaAST _t);
+ public: void lib_subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t);
+ public: void def_id(RefAdaAST _t);
+ public: void pkg_body_part(RefAdaAST _t);
+ public: void generic_inst(RefAdaAST _t);
+ public: void pkg_spec_part(RefAdaAST _t);
+ public: void renames(RefAdaAST _t);
+ public: void generic_decl(RefAdaAST _t);
+ public: void subprog_def_id(RefAdaAST _t);
+ public: void subprog_decl(RefAdaAST _t);
+ public: void formal_part_opt(RefAdaAST _t);
+ public: void def_designator(RefAdaAST _t);
+ public: void function_tail(RefAdaAST _t);
+ public: void definable_operator_symbol(RefAdaAST _t);
+ public: void spec_decl_part(RefAdaAST _t);
+ public: void basic_declarative_items_opt(RefAdaAST _t);
+ public: void private_declarative_items_opt(RefAdaAST _t);
+ public: void end_id_opt(RefAdaAST _t);
+ public: void basic_decl_item(RefAdaAST _t);
+ public: void generic_formal_part_opt(RefAdaAST _t);
+ public: void procedure_body(RefAdaAST _t);
+ public: void function_body(RefAdaAST _t);
+ public: void subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t);
+ public: void subprog_decl_or_body(RefAdaAST _t);
+ public: void package_body(RefAdaAST _t);
+ public: void pragma_arg(RefAdaAST _t);
+ public: void expression(RefAdaAST _t);
+ public: void attribute_id(RefAdaAST _t);
+ public: void modifiers(RefAdaAST _t);
+ public: void id_opt(RefAdaAST _t);
+ public: void value_s(RefAdaAST _t);
+ public: void value(RefAdaAST _t);
+ public: void ranged_expr_s(RefAdaAST _t);
+ public: void ranged_expr(RefAdaAST _t);
+ public: void simple_expression(RefAdaAST _t);
+ public: void range(RefAdaAST _t);
+ public: void range_constraint(RefAdaAST _t);
+ public: void range_dots(RefAdaAST _t);
+ public: void range_attrib_ref(RefAdaAST _t);
+ public: void prefix(RefAdaAST _t);
+ public: void parameter_specification(RefAdaAST _t);
+ public: void defining_identifier_list(RefAdaAST _t);
+ public: void init_opt(RefAdaAST _t);
+ public: void name(RefAdaAST _t);
+ public: void parenthesized_primary(RefAdaAST _t);
+ public: void extension_opt(RefAdaAST _t);
+ public: void task_type_or_single_decl(RefAdaAST _t);
+ public: void prot_type_or_single_decl(RefAdaAST _t);
+ public: void decl_common(RefAdaAST _t);
+ public: void discrim_part_opt(RefAdaAST _t);
+ public: void task_definition_opt(RefAdaAST _t);
+ public: void task_items_opt(RefAdaAST _t);
+ public: void private_task_items_opt(RefAdaAST _t);
+ public: void discriminant_specifications(RefAdaAST _t);
+ public: void discriminant_specification(RefAdaAST _t);
+ public: void entrydecls_repspecs_opt(RefAdaAST _t);
+ public: void entry_declaration(RefAdaAST _t);
+ public: void rep_spec(RefAdaAST _t);
+ public: void discrete_subtype_def_opt(RefAdaAST _t);
+ public: void discrete_subtype_definition(RefAdaAST _t);
+ public: void subtype_ind(RefAdaAST _t);
+ public: void align_opt(RefAdaAST _t);
+ public: void comp_loc_s(RefAdaAST _t);
+ public: void local_enum_name(RefAdaAST _t);
+ public: void enumeration_aggregate(RefAdaAST _t);
+ public: void protected_definition(RefAdaAST _t);
+ public: void prot_private_opt(RefAdaAST _t);
+ public: void prot_member_decl_s(RefAdaAST _t);
+ public: void prot_op_decl_s(RefAdaAST _t);
+ public: void prot_op_decl(RefAdaAST _t);
+ public: void comp_decl(RefAdaAST _t);
+ public: void component_subtype_def(RefAdaAST _t);
+ public: void enum_id_s(RefAdaAST _t);
+ public: void range_constraint_opt(RefAdaAST _t);
+ public: void array_type_declaration(RefAdaAST _t);
+ public: void access_type_declaration(RefAdaAST _t);
+ public: void id_and_discrim(RefAdaAST _t);
+ public: void record_definition(RefAdaAST _t);
+ public: void array_type_definition(RefAdaAST _t);
+ public: void enumeration_literal_specification(RefAdaAST _t);
+ public: void index_or_discrete_range_s(RefAdaAST _t);
+ public: void index_or_discrete_range(RefAdaAST _t);
+ public: void constraint_opt(RefAdaAST _t);
+ public: void digits_constraint(RefAdaAST _t);
+ public: void delta_constraint(RefAdaAST _t);
+ public: void index_constraint(RefAdaAST _t);
+ public: void discriminant_constraint(RefAdaAST _t);
+ public: void discrete_range(RefAdaAST _t);
+ public: void discriminant_association(RefAdaAST _t);
+ public: void selector_names_opt(RefAdaAST _t);
+ public: void selector_name(RefAdaAST _t);
+ public: void component_list(RefAdaAST _t);
+ public: void component_items(RefAdaAST _t);
+ public: void variant_part(RefAdaAST _t);
+ public: void discriminant_direct_name(RefAdaAST _t);
+ public: void variant_s(RefAdaAST _t);
+ public: void variant(RefAdaAST _t);
+ public: void choice_s(RefAdaAST _t);
+ public: void choice(RefAdaAST _t);
+ public: void discrete_with_range(RefAdaAST _t);
+ public: void mark_with_constraint(RefAdaAST _t);
+ public: void generic_formal_parameter(RefAdaAST _t);
+ public: void formal_array_type_declaration(RefAdaAST _t);
+ public: void formal_access_type_declaration(RefAdaAST _t);
+ public: void id_part(RefAdaAST _t);
+ public: void subprogram_default_opt(RefAdaAST _t);
+ public: void formal_package_actual_part_opt(RefAdaAST _t);
+ public: void body_part(RefAdaAST _t);
+ public: void declarative_part(RefAdaAST _t);
+ public: void block_body(RefAdaAST _t);
+ public: void declarative_item(RefAdaAST _t);
+ public: void prot_op_bodies_opt(RefAdaAST _t);
+ public: void block_body_opt(RefAdaAST _t);
+ public: void handled_stmt_s(RefAdaAST _t);
+ public: void entry_body(RefAdaAST _t);
+ public: void statements(RefAdaAST _t);
+ public: void except_handler_part_opt(RefAdaAST _t);
+ public: void handled_stmts_opt(RefAdaAST _t);
+ public: void statement(RefAdaAST _t);
+ public: void def_label_opt(RefAdaAST _t);
+ public: void null_stmt(RefAdaAST _t);
+ public: void exit_stmt(RefAdaAST _t);
+ public: void return_stmt(RefAdaAST _t);
+ public: void goto_stmt(RefAdaAST _t);
+ public: void delay_stmt(RefAdaAST _t);
+ public: void abort_stmt(RefAdaAST _t);
+ public: void raise_stmt(RefAdaAST _t);
+ public: void requeue_stmt(RefAdaAST _t);
+ public: void accept_stmt(RefAdaAST _t);
+ public: void select_stmt(RefAdaAST _t);
+ public: void if_stmt(RefAdaAST _t);
+ public: void case_stmt(RefAdaAST _t);
+ public: void loop_stmt(RefAdaAST _t);
+ public: void block(RefAdaAST _t);
+ public: void call_or_assignment(RefAdaAST _t);
+ public: void cond_clause(RefAdaAST _t);
+ public: void elsifs_opt(RefAdaAST _t);
+ public: void else_opt(RefAdaAST _t);
+ public: void condition(RefAdaAST _t);
+ public: void alternative_s(RefAdaAST _t);
+ public: void case_statement_alternative(RefAdaAST _t);
+ public: void iteration_scheme_opt(RefAdaAST _t);
+ public: void declare_opt(RefAdaAST _t);
+ public: void label_name(RefAdaAST _t);
+ public: void entry_body_formal_part(RefAdaAST _t);
+ public: void entry_barrier(RefAdaAST _t);
+ public: void entry_index_spec_opt(RefAdaAST _t);
+ public: void entry_call_stmt(RefAdaAST _t);
+ public: void entry_index_opt(RefAdaAST _t);
+ public: void triggering_alternative(RefAdaAST _t);
+ public: void abortable_part(RefAdaAST _t);
+ public: void selective_accept(RefAdaAST _t);
+ public: void entry_call_alternative(RefAdaAST _t);
+ public: void delay_alternative(RefAdaAST _t);
+ public: void stmts_opt(RefAdaAST _t);
+ public: void guard_opt(RefAdaAST _t);
+ public: void select_alternative(RefAdaAST _t);
+ public: void or_select_opt(RefAdaAST _t);
+ public: void accept_alternative(RefAdaAST _t);
+ public: void exception_handler(RefAdaAST _t);
+ public: void identifier_colon_opt(RefAdaAST _t);
+ public: void except_choice_s(RefAdaAST _t);
+ public: void exception_choice(RefAdaAST _t);
+ public: void operator_call(RefAdaAST _t);
+ public: void relation(RefAdaAST _t);
+ public: void range_or_mark(RefAdaAST _t);
+ public: void signed_term(RefAdaAST _t);
+ public: void term(RefAdaAST _t);
+ public: void factor(RefAdaAST _t);
+ public: void primary(RefAdaAST _t);
+ public: void name_or_qualified(RefAdaAST _t);
+ public: void allocator(RefAdaAST _t);
+ public: void subprogram_body(RefAdaAST _t);
+ public: void task_body(RefAdaAST _t);
+ public: void protected_body(RefAdaAST _t);
+public:
+ ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
+ {
+ return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST);
+ }
+
+protected:
+ RefAdaAST returnAST;
+ RefAdaAST _retTree;
+private:
+ static const char* tokenNames[];
+#ifndef NO_STATIC_CONSTS
+ static const int NUM_TOKENS = 291;
+#else
+ enum {
+ NUM_TOKENS = 291
+ };
+#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;
+};
+
+#endif /*INC_AdaStoreWalker_hpp_*/
diff --git a/languages/ada/AdaStoreWalkerTokenTypes.hpp b/languages/ada/AdaStoreWalkerTokenTypes.hpp
new file mode 100644
index 00000000..daaa4b21
--- /dev/null
+++ b/languages/ada/AdaStoreWalkerTokenTypes.hpp
@@ -0,0 +1,307 @@
+#ifndef INC_AdaStoreWalkerTokenTypes_hpp_
+#define INC_AdaStoreWalkerTokenTypes_hpp_
+
+/* $ANTLR 2.7.7 (20070609): "expandedada.store.g" -> "AdaStoreWalkerTokenTypes.hpp"$ */
+
+#ifndef CUSTOM_API
+# define CUSTOM_API
+#endif
+
+#ifdef __cplusplus
+struct CUSTOM_API AdaStoreWalkerTokenTypes {
+#endif
+ enum {
+ EOF_ = 1,
+ PRAGMA = 4,
+ IDENTIFIER = 5,
+ SEMI = 6,
+ LPAREN = 7,
+ COMMA = 8,
+ RPAREN = 9,
+ RIGHT_SHAFT = 10,
+ WITH = 11,
+ DOT = 12,
+ USE = 13,
+ TYPE = 14,
+ TIC = 15,
+ RANGE = 16,
+ DIGITS = 17,
+ DELTA = 18,
+ ACCESS = 19,
+ PRIVATE = 20,
+ PACKAGE = 21,
+ BODY = 22,
+ IS = 23,
+ PROCEDURE = 24,
+ FUNCTION = 25,
+ NEW = 26,
+ OTHERS = 27,
+ PIPE = 28,
+ DOT_DOT = 29,
+ ALL = 30,
+ COLON = 31,
+ IN = 32,
+ OUT = 33,
+ RENAMES = 34,
+ CHARACTER_LITERAL = 35,
+ CHAR_STRING = 36,
+ NuLL = 37,
+ RECORD = 38,
+ SEPARATE = 39,
+ ABSTRACT = 40,
+ RETURN = 41,
+ TASK = 42,
+ PROTECTED = 43,
+ BOX = 44,
+ ASSIGN = 45,
+ ENTRY = 46,
+ FOR = 47,
+ END = 48,
+ AT = 49,
+ MOD = 50,
+ SUBTYPE = 51,
+ EXCEPTION = 52,
+ CONSTANT = 53,
+ ARRAY = 54,
+ OF = 55,
+ ALIASED = 56,
+ CASE = 57,
+ WHEN = 58,
+ TAGGED = 59,
+ LIMITED = 60,
+ GENERIC = 61,
+ BEGIN = 62,
+ LT_LT = 63,
+ GT_GT = 64,
+ IF = 65,
+ THEN = 66,
+ ELSIF = 67,
+ ELSE = 68,
+ LOOP = 69,
+ WHILE = 70,
+ REVERSE = 71,
+ DECLARE = 72,
+ EXIT = 73,
+ GOTO = 74,
+ ACCEPT = 75,
+ DO = 76,
+ DELAY = 77,
+ UNTIL = 78,
+ SELECT = 79,
+ ABORT = 80,
+ OR = 81,
+ TERMINATE = 82,
+ RAISE = 83,
+ REQUEUE = 84,
+ AND = 85,
+ XOR = 86,
+ NOT = 87,
+ EQ = 88,
+ NE = 89,
+ LT_ = 90,
+ LE = 91,
+ GT = 92,
+ GE = 93,
+ PLUS = 94,
+ MINUS = 95,
+ CONCAT = 96,
+ STAR = 97,
+ DIV = 98,
+ REM = 99,
+ ABS = 100,
+ EXPON = 101,
+ NUMERIC_LIT = 102,
+ ABORTABLE_PART = 103,
+ ABORT_STATEMENT = 104,
+ ACCEPT_ALTERNATIVE = 105,
+ ACCEPT_STATEMENT = 106,
+ ALLOCATOR = 107,
+ ASSIGNMENT_STATEMENT = 108,
+ ASYNCHRONOUS_SELECT = 109,
+ ATTRIBUTE_DEFINITION_CLAUSE = 110,
+ AT_CLAUSE = 111,
+ BLOCK_STATEMENT = 112,
+ CASE_STATEMENT = 113,
+ CASE_STATEMENT_ALTERNATIVE = 114,
+ CODE_STATEMENT = 115,
+ COMPONENT_DECLARATION = 116,
+ CONDITIONAL_ENTRY_CALL = 117,
+ CONTEXT_CLAUSE = 118,
+ DECLARATIVE_PART = 119,
+ DEFINING_IDENTIFIER_LIST = 120,
+ DELAY_ALTERNATIVE = 121,
+ DELAY_STATEMENT = 122,
+ DELTA_CONSTRAINT = 123,
+ DIGITS_CONSTRAINT = 124,
+ DISCRIMINANT_ASSOCIATION = 125,
+ DISCRIMINANT_CONSTRAINT = 126,
+ DISCRIMINANT_SPECIFICATION = 127,
+ ENTRY_BODY = 128,
+ ENTRY_CALL_ALTERNATIVE = 129,
+ ENTRY_CALL_STATEMENT = 130,
+ ENTRY_DECLARATION = 131,
+ ENTRY_INDEX_SPECIFICATION = 132,
+ ENUMERATION_REPESENTATION_CLAUSE = 133,
+ EXCEPTION_DECLARATION = 134,
+ EXCEPTION_HANDLER = 135,
+ EXCEPTION_RENAMING_DECLARATION = 136,
+ EXIT_STATEMENT = 137,
+ FORMAL_PACKAGE_DECLARATION = 138,
+ GENERIC_FORMAL_PART = 139,
+ GENERIC_PACKAGE_DECLARATION = 140,
+ GOTO_STATEMENT = 141,
+ HANDLED_SEQUENCE_OF_STATEMENTS = 142,
+ HANDLED_STMTS_OPT = 143,
+ IF_STATEMENT = 144,
+ INCOMPLETE_TYPE_DECLARATION = 145,
+ INDEXED_COMPONENT = 146,
+ INDEX_CONSTRAINT = 147,
+ LIBRARY_ITEM = 148,
+ LOOP_STATEMENT = 149,
+ NAME = 150,
+ NULL_STATEMENT = 151,
+ NUMBER_DECLARATION = 152,
+ OBJECT_DECLARATION = 153,
+ OBJECT_RENAMING_DECLARATION = 154,
+ OPERATOR_SYMBOL = 155,
+ PACKAGE_BODY = 156,
+ PACKAGE_BODY_STUB = 157,
+ PACKAGE_RENAMING_DECLARATION = 158,
+ PACKAGE_SPECIFICATION = 159,
+ PARAMETER_SPECIFICATION = 160,
+ PRIVATE_EXTENSION_DECLARATION = 161,
+ PRIVATE_TYPE_DECLARATION = 162,
+ PROTECTED_BODY = 163,
+ PROTECTED_BODY_STUB = 164,
+ PROTECTED_TYPE_DECLARATION = 165,
+ RAISE_STATEMENT = 166,
+ RANGE_ATTRIBUTE_REFERENCE = 167,
+ RECORD_REPRESENTATION_CLAUSE = 168,
+ REQUEUE_STATEMENT = 169,
+ RETURN_STATEMENT = 170,
+ SELECTIVE_ACCEPT = 171,
+ SEQUENCE_OF_STATEMENTS = 172,
+ SINGLE_PROTECTED_DECLARATION = 173,
+ SINGLE_TASK_DECLARATION = 174,
+ STATEMENT = 175,
+ SUBTYPE_DECLARATION = 176,
+ SUBTYPE_INDICATION = 177,
+ SUBTYPE_MARK = 178,
+ SUBUNIT = 179,
+ TASK_BODY = 180,
+ TASK_BODY_STUB = 181,
+ TASK_TYPE_DECLARATION = 182,
+ TERMINATE_ALTERNATIVE = 183,
+ TIMED_ENTRY_CALL = 184,
+ TRIGGERING_ALTERNATIVE = 185,
+ USE_CLAUSE = 186,
+ USE_TYPE_CLAUSE = 187,
+ VARIANT = 188,
+ VARIANT_PART = 189,
+ WITH_CLAUSE = 190,
+ ABSTRACT_FUNCTION_DECLARATION = 191,
+ ABSTRACT_PROCEDURE_DECLARATION = 192,
+ ACCESS_TO_FUNCTION_DECLARATION = 193,
+ ACCESS_TO_OBJECT_DECLARATION = 194,
+ ACCESS_TO_PROCEDURE_DECLARATION = 195,
+ ARRAY_OBJECT_DECLARATION = 196,
+ ARRAY_TYPE_DECLARATION = 197,
+ AND_THEN = 198,
+ BASIC_DECLARATIVE_ITEMS_OPT = 199,
+ BLOCK_BODY = 200,
+ BLOCK_BODY_OPT = 201,
+ CALL_STATEMENT = 202,
+ COMPONENT_CLAUSES_OPT = 203,
+ COMPONENT_ITEMS = 204,
+ COND_CLAUSE = 205,
+ DECIMAL_FIXED_POINT_DECLARATION = 206,
+ DECLARE_OPT = 207,
+ DERIVED_RECORD_EXTENSION = 208,
+ DISCRETE_SUBTYPE_DEF_OPT = 209,
+ DISCRIMINANT_SPECIFICATIONS = 210,
+ DISCRIM_PART_OPT = 211,
+ ELSE_OPT = 212,
+ ELSIFS_OPT = 213,
+ END_ID_OPT = 214,
+ ENTRY_INDEX_OPT = 215,
+ ENUMERATION_TYPE_DECLARATION = 216,
+ EXCEPT_HANDLER_PART_OPT = 217,
+ EXTENSION_OPT = 218,
+ FLOATING_POINT_DECLARATION = 219,
+ FORMAL_DECIMAL_FIXED_POINT_DECLARATION = 220,
+ FORMAL_DISCRETE_TYPE_DECLARATION = 221,
+ FORMAL_FLOATING_POINT_DECLARATION = 222,
+ FORMAL_FUNCTION_DECLARATION = 223,
+ FORMAL_MODULAR_TYPE_DECLARATION = 224,
+ FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION = 225,
+ FORMAL_ORDINARY_FIXED_POINT_DECLARATION = 226,
+ FORMAL_PART_OPT = 227,
+ FORMAL_PRIVATE_EXTENSION_DECLARATION = 228,
+ FORMAL_PRIVATE_TYPE_DECLARATION = 229,
+ FORMAL_PROCEDURE_DECLARATION = 230,
+ FORMAL_SIGNED_INTEGER_TYPE_DECLARATION = 231,
+ FUNCTION_BODY = 232,
+ FUNCTION_BODY_STUB = 233,
+ FUNCTION_DECLARATION = 234,
+ FUNCTION_RENAMING_DECLARATION = 235,
+ GENERIC_FUNCTION_DECLARATION = 236,
+ GENERIC_FUNCTION_INSTANTIATION = 237,
+ GENERIC_FUNCTION_RENAMING = 238,
+ GENERIC_PACKAGE_INSTANTIATION = 239,
+ GENERIC_PACKAGE_RENAMING = 240,
+ GENERIC_PROCEDURE_DECLARATION = 241,
+ GENERIC_PROCEDURE_INSTANTIATION = 242,
+ GENERIC_PROCEDURE_RENAMING = 243,
+ GUARD_OPT = 244,
+ IDENTIFIER_COLON_OPT = 245,
+ ID_OPT = 246,
+ INIT_OPT = 247,
+ ITERATION_SCHEME_OPT = 248,
+ LABEL_OPT = 249,
+ MARK_WITH_CONSTRAINT = 250,
+ MODIFIERS = 251,
+ MODULAR_TYPE_DECLARATION = 252,
+ MOD_CLAUSE_OPT = 253,
+ NOT_IN = 254,
+ ORDINARY_DERIVED_TYPE_DECLARATION = 255,
+ ORDINARY_FIXED_POINT_DECLARATION = 256,
+ OR_ELSE = 257,
+ OR_SELECT_OPT = 258,
+ PARENTHESIZED_PRIMARY = 259,
+ PRIVATE_DECLARATIVE_ITEMS_OPT = 260,
+ PRIVATE_TASK_ITEMS_OPT = 261,
+ PROCEDURE_BODY = 262,
+ PROCEDURE_BODY_STUB = 263,
+ PROCEDURE_DECLARATION = 264,
+ PROCEDURE_RENAMING_DECLARATION = 265,
+ PROT_MEMBER_DECLARATIONS = 266,
+ PROT_OP_BODIES_OPT = 267,
+ PROT_OP_DECLARATIONS = 268,
+ PROT_PRIVATE_OPT = 269,
+ RANGED_EXPRS = 270,
+ RANGE_CONSTRAINT = 271,
+ RECORD_TYPE_DECLARATION = 272,
+ SELECTOR_NAMES_OPT = 273,
+ SIGNED_INTEGER_TYPE_DECLARATION = 274,
+ TASK_ITEMS_OPT = 275,
+ UNARY_MINUS = 276,
+ UNARY_PLUS = 277,
+ VALUE = 278,
+ VALUES = 279,
+ VARIANTS = 280,
+ COMMENT_INTRO = 281,
+ OX = 282,
+ TIC_OR_CHARACTER_LITERAL = 283,
+ DIGIT = 284,
+ EXPONENT = 285,
+ EXTENDED_DIGIT = 286,
+ BASED_INTEGER = 287,
+ WS_ = 288,
+ COMMENT = 289,
+ CHARACTER_STRING = 290,
+ NULL_TREE_LOOKAHEAD = 3
+ };
+#ifdef __cplusplus
+};
+#endif
+#endif /*INC_AdaStoreWalkerTokenTypes_hpp_*/
diff --git a/languages/ada/AdaStoreWalkerTokenTypes.txt b/languages/ada/AdaStoreWalkerTokenTypes.txt
new file mode 100644
index 00000000..e9ba489c
--- /dev/null
+++ b/languages/ada/AdaStoreWalkerTokenTypes.txt
@@ -0,0 +1,289 @@
+// $ANTLR 2.7.7 (20070609): expandedada.store.g -> AdaStoreWalkerTokenTypes.txt$
+AdaStoreWalker // output token vocab name
+PRAGMA="pragma"=4
+IDENTIFIER=5
+SEMI=6
+LPAREN=7
+COMMA=8
+RPAREN=9
+RIGHT_SHAFT=10
+WITH="with"=11
+DOT=12
+USE="use"=13
+TYPE="type"=14
+TIC=15
+RANGE="range"=16
+DIGITS="digits"=17
+DELTA="delta"=18
+ACCESS="access"=19
+PRIVATE="private"=20
+PACKAGE="package"=21
+BODY="body"=22
+IS="is"=23
+PROCEDURE="procedure"=24
+FUNCTION="function"=25
+NEW="new"=26
+OTHERS="others"=27
+PIPE=28
+DOT_DOT=29
+ALL="all"=30
+COLON=31
+IN="in"=32
+OUT="out"=33
+RENAMES="renames"=34
+CHARACTER_LITERAL=35
+CHAR_STRING=36
+NuLL="null"=37
+RECORD="record"=38
+SEPARATE="separate"=39
+ABSTRACT="abstract"=40
+RETURN="return"=41
+TASK="task"=42
+PROTECTED="protected"=43
+BOX=44
+ASSIGN=45
+ENTRY="entry"=46
+FOR="for"=47
+END="end"=48
+AT="at"=49
+MOD="mod"=50
+SUBTYPE="subtype"=51
+EXCEPTION="exception"=52
+CONSTANT="constant"=53
+ARRAY="array"=54
+OF="of"=55
+ALIASED="aliased"=56
+CASE="case"=57
+WHEN="when"=58
+TAGGED="tagged"=59
+LIMITED="limited"=60
+GENERIC="generic"=61
+BEGIN="begin"=62
+LT_LT=63
+GT_GT=64
+IF="if"=65
+THEN="then"=66
+ELSIF="elsif"=67
+ELSE="else"=68
+LOOP="loop"=69
+WHILE="while"=70
+REVERSE="reverse"=71
+DECLARE="declare"=72
+EXIT="exit"=73
+GOTO="goto"=74
+ACCEPT="accept"=75
+DO="do"=76
+DELAY="delay"=77
+UNTIL="until"=78
+SELECT="select"=79
+ABORT="abort"=80
+OR="or"=81
+TERMINATE="terminate"=82
+RAISE="raise"=83
+REQUEUE="requeue"=84
+AND="and"=85
+XOR="xor"=86
+NOT="not"=87
+EQ=88
+NE=89
+LT_=90
+LE=91
+GT=92
+GE=93
+PLUS=94
+MINUS=95
+CONCAT=96
+STAR=97
+DIV=98
+REM="rem"=99
+ABS="abs"=100
+EXPON=101
+NUMERIC_LIT=102
+ABORTABLE_PART=103
+ABORT_STATEMENT=104
+ACCEPT_ALTERNATIVE=105
+ACCEPT_STATEMENT=106
+ALLOCATOR=107
+ASSIGNMENT_STATEMENT=108
+ASYNCHRONOUS_SELECT=109
+ATTRIBUTE_DEFINITION_CLAUSE=110
+AT_CLAUSE=111
+BLOCK_STATEMENT=112
+CASE_STATEMENT=113
+CASE_STATEMENT_ALTERNATIVE=114
+CODE_STATEMENT=115
+COMPONENT_DECLARATION=116
+CONDITIONAL_ENTRY_CALL=117
+CONTEXT_CLAUSE=118
+DECLARATIVE_PART=119
+DEFINING_IDENTIFIER_LIST=120
+DELAY_ALTERNATIVE=121
+DELAY_STATEMENT=122
+DELTA_CONSTRAINT=123
+DIGITS_CONSTRAINT=124
+DISCRIMINANT_ASSOCIATION=125
+DISCRIMINANT_CONSTRAINT=126
+DISCRIMINANT_SPECIFICATION=127
+ENTRY_BODY=128
+ENTRY_CALL_ALTERNATIVE=129
+ENTRY_CALL_STATEMENT=130
+ENTRY_DECLARATION=131
+ENTRY_INDEX_SPECIFICATION=132
+ENUMERATION_REPESENTATION_CLAUSE=133
+EXCEPTION_DECLARATION=134
+EXCEPTION_HANDLER=135
+EXCEPTION_RENAMING_DECLARATION=136
+EXIT_STATEMENT=137
+FORMAL_PACKAGE_DECLARATION=138
+GENERIC_FORMAL_PART=139
+GENERIC_PACKAGE_DECLARATION=140
+GOTO_STATEMENT=141
+HANDLED_SEQUENCE_OF_STATEMENTS=142
+HANDLED_STMTS_OPT=143
+IF_STATEMENT=144
+INCOMPLETE_TYPE_DECLARATION=145
+INDEXED_COMPONENT=146
+INDEX_CONSTRAINT=147
+LIBRARY_ITEM=148
+LOOP_STATEMENT=149
+NAME=150
+NULL_STATEMENT=151
+NUMBER_DECLARATION=152
+OBJECT_DECLARATION=153
+OBJECT_RENAMING_DECLARATION=154
+OPERATOR_SYMBOL=155
+PACKAGE_BODY=156
+PACKAGE_BODY_STUB=157
+PACKAGE_RENAMING_DECLARATION=158
+PACKAGE_SPECIFICATION=159
+PARAMETER_SPECIFICATION=160
+PRIVATE_EXTENSION_DECLARATION=161
+PRIVATE_TYPE_DECLARATION=162
+PROTECTED_BODY=163
+PROTECTED_BODY_STUB=164
+PROTECTED_TYPE_DECLARATION=165
+RAISE_STATEMENT=166
+RANGE_ATTRIBUTE_REFERENCE=167
+RECORD_REPRESENTATION_CLAUSE=168
+REQUEUE_STATEMENT=169
+RETURN_STATEMENT=170
+SELECTIVE_ACCEPT=171
+SEQUENCE_OF_STATEMENTS=172
+SINGLE_PROTECTED_DECLARATION=173
+SINGLE_TASK_DECLARATION=174
+STATEMENT=175
+SUBTYPE_DECLARATION=176
+SUBTYPE_INDICATION=177
+SUBTYPE_MARK=178
+SUBUNIT=179
+TASK_BODY=180
+TASK_BODY_STUB=181
+TASK_TYPE_DECLARATION=182
+TERMINATE_ALTERNATIVE=183
+TIMED_ENTRY_CALL=184
+TRIGGERING_ALTERNATIVE=185
+USE_CLAUSE=186
+USE_TYPE_CLAUSE=187
+VARIANT=188
+VARIANT_PART=189
+WITH_CLAUSE=190
+ABSTRACT_FUNCTION_DECLARATION=191
+ABSTRACT_PROCEDURE_DECLARATION=192
+ACCESS_TO_FUNCTION_DECLARATION=193
+ACCESS_TO_OBJECT_DECLARATION=194
+ACCESS_TO_PROCEDURE_DECLARATION=195
+ARRAY_OBJECT_DECLARATION=196
+ARRAY_TYPE_DECLARATION=197
+AND_THEN=198
+BASIC_DECLARATIVE_ITEMS_OPT=199
+BLOCK_BODY=200
+BLOCK_BODY_OPT=201
+CALL_STATEMENT=202
+COMPONENT_CLAUSES_OPT=203
+COMPONENT_ITEMS=204
+COND_CLAUSE=205
+DECIMAL_FIXED_POINT_DECLARATION=206
+DECLARE_OPT=207
+DERIVED_RECORD_EXTENSION=208
+DISCRETE_SUBTYPE_DEF_OPT=209
+DISCRIMINANT_SPECIFICATIONS=210
+DISCRIM_PART_OPT=211
+ELSE_OPT=212
+ELSIFS_OPT=213
+END_ID_OPT=214
+ENTRY_INDEX_OPT=215
+ENUMERATION_TYPE_DECLARATION=216
+EXCEPT_HANDLER_PART_OPT=217
+EXTENSION_OPT=218
+FLOATING_POINT_DECLARATION=219
+FORMAL_DECIMAL_FIXED_POINT_DECLARATION=220
+FORMAL_DISCRETE_TYPE_DECLARATION=221
+FORMAL_FLOATING_POINT_DECLARATION=222
+FORMAL_FUNCTION_DECLARATION=223
+FORMAL_MODULAR_TYPE_DECLARATION=224
+FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION=225
+FORMAL_ORDINARY_FIXED_POINT_DECLARATION=226
+FORMAL_PART_OPT=227
+FORMAL_PRIVATE_EXTENSION_DECLARATION=228
+FORMAL_PRIVATE_TYPE_DECLARATION=229
+FORMAL_PROCEDURE_DECLARATION=230
+FORMAL_SIGNED_INTEGER_TYPE_DECLARATION=231
+FUNCTION_BODY=232
+FUNCTION_BODY_STUB=233
+FUNCTION_DECLARATION=234
+FUNCTION_RENAMING_DECLARATION=235
+GENERIC_FUNCTION_DECLARATION=236
+GENERIC_FUNCTION_INSTANTIATION=237
+GENERIC_FUNCTION_RENAMING=238
+GENERIC_PACKAGE_INSTANTIATION=239
+GENERIC_PACKAGE_RENAMING=240
+GENERIC_PROCEDURE_DECLARATION=241
+GENERIC_PROCEDURE_INSTANTIATION=242
+GENERIC_PROCEDURE_RENAMING=243
+GUARD_OPT=244
+IDENTIFIER_COLON_OPT=245
+ID_OPT=246
+INIT_OPT=247
+ITERATION_SCHEME_OPT=248
+LABEL_OPT=249
+MARK_WITH_CONSTRAINT=250
+MODIFIERS=251
+MODULAR_TYPE_DECLARATION=252
+MOD_CLAUSE_OPT=253
+NOT_IN=254
+ORDINARY_DERIVED_TYPE_DECLARATION=255
+ORDINARY_FIXED_POINT_DECLARATION=256
+OR_ELSE=257
+OR_SELECT_OPT=258
+PARENTHESIZED_PRIMARY=259
+PRIVATE_DECLARATIVE_ITEMS_OPT=260
+PRIVATE_TASK_ITEMS_OPT=261
+PROCEDURE_BODY=262
+PROCEDURE_BODY_STUB=263
+PROCEDURE_DECLARATION=264
+PROCEDURE_RENAMING_DECLARATION=265
+PROT_MEMBER_DECLARATIONS=266
+PROT_OP_BODIES_OPT=267
+PROT_OP_DECLARATIONS=268
+PROT_PRIVATE_OPT=269
+RANGED_EXPRS=270
+RANGE_CONSTRAINT=271
+RECORD_TYPE_DECLARATION=272
+SELECTOR_NAMES_OPT=273
+SIGNED_INTEGER_TYPE_DECLARATION=274
+TASK_ITEMS_OPT=275
+UNARY_MINUS=276
+UNARY_PLUS=277
+VALUE=278
+VALUES=279
+VARIANTS=280
+COMMENT_INTRO=281
+OX=282
+TIC_OR_CHARACTER_LITERAL=283
+DIGIT=284
+EXPONENT=285
+EXTENDED_DIGIT=286
+BASED_INTEGER=287
+WS_=288
+COMMENT=289
+CHARACTER_STRING=290
diff --git a/languages/ada/AdaTokenTypes.hpp b/languages/ada/AdaTokenTypes.hpp
new file mode 100644
index 00000000..918b1cfd
--- /dev/null
+++ b/languages/ada/AdaTokenTypes.hpp
@@ -0,0 +1,306 @@
+#ifndef INC_AdaTokenTypes_hpp_
+#define INC_AdaTokenTypes_hpp_
+
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaTokenTypes.hpp"$ */
+
+#ifndef CUSTOM_API
+# define CUSTOM_API
+#endif
+
+#ifdef __cplusplus
+struct CUSTOM_API AdaTokenTypes {
+#endif
+ enum {
+ EOF_ = 1,
+ PRAGMA = 4,
+ IDENTIFIER = 5,
+ SEMI = 6,
+ LPAREN = 7,
+ COMMA = 8,
+ RPAREN = 9,
+ RIGHT_SHAFT = 10,
+ WITH = 11,
+ DOT = 12,
+ USE = 13,
+ TYPE = 14,
+ TIC = 15,
+ RANGE = 16,
+ DIGITS = 17,
+ DELTA = 18,
+ ACCESS = 19,
+ PRIVATE = 20,
+ PACKAGE = 21,
+ BODY = 22,
+ IS = 23,
+ PROCEDURE = 24,
+ FUNCTION = 25,
+ NEW = 26,
+ OTHERS = 27,
+ PIPE = 28,
+ DOT_DOT = 29,
+ ALL = 30,
+ COLON = 31,
+ IN = 32,
+ OUT = 33,
+ RENAMES = 34,
+ CHARACTER_LITERAL = 35,
+ CHAR_STRING = 36,
+ NuLL = 37,
+ RECORD = 38,
+ SEPARATE = 39,
+ ABSTRACT = 40,
+ RETURN = 41,
+ TASK = 42,
+ PROTECTED = 43,
+ BOX = 44,
+ ASSIGN = 45,
+ ENTRY = 46,
+ FOR = 47,
+ END = 48,
+ AT = 49,
+ MOD = 50,
+ SUBTYPE = 51,
+ EXCEPTION = 52,
+ CONSTANT = 53,
+ ARRAY = 54,
+ OF = 55,
+ ALIASED = 56,
+ CASE = 57,
+ WHEN = 58,
+ TAGGED = 59,
+ LIMITED = 60,
+ GENERIC = 61,
+ BEGIN = 62,
+ LT_LT = 63,
+ GT_GT = 64,
+ IF = 65,
+ THEN = 66,
+ ELSIF = 67,
+ ELSE = 68,
+ LOOP = 69,
+ WHILE = 70,
+ REVERSE = 71,
+ DECLARE = 72,
+ EXIT = 73,
+ GOTO = 74,
+ ACCEPT = 75,
+ DO = 76,
+ DELAY = 77,
+ UNTIL = 78,
+ SELECT = 79,
+ ABORT = 80,
+ OR = 81,
+ TERMINATE = 82,
+ RAISE = 83,
+ REQUEUE = 84,
+ AND = 85,
+ XOR = 86,
+ NOT = 87,
+ EQ = 88,
+ NE = 89,
+ LT_ = 90,
+ LE = 91,
+ GT = 92,
+ GE = 93,
+ PLUS = 94,
+ MINUS = 95,
+ CONCAT = 96,
+ STAR = 97,
+ DIV = 98,
+ REM = 99,
+ ABS = 100,
+ EXPON = 101,
+ NUMERIC_LIT = 102,
+ ABORTABLE_PART = 103,
+ ABORT_STATEMENT = 104,
+ ACCEPT_ALTERNATIVE = 105,
+ ACCEPT_STATEMENT = 106,
+ ALLOCATOR = 107,
+ ASSIGNMENT_STATEMENT = 108,
+ ASYNCHRONOUS_SELECT = 109,
+ ATTRIBUTE_DEFINITION_CLAUSE = 110,
+ AT_CLAUSE = 111,
+ BLOCK_STATEMENT = 112,
+ CASE_STATEMENT = 113,
+ CASE_STATEMENT_ALTERNATIVE = 114,
+ CODE_STATEMENT = 115,
+ COMPONENT_DECLARATION = 116,
+ CONDITIONAL_ENTRY_CALL = 117,
+ CONTEXT_CLAUSE = 118,
+ DECLARATIVE_PART = 119,
+ DEFINING_IDENTIFIER_LIST = 120,
+ DELAY_ALTERNATIVE = 121,
+ DELAY_STATEMENT = 122,
+ DELTA_CONSTRAINT = 123,
+ DIGITS_CONSTRAINT = 124,
+ DISCRIMINANT_ASSOCIATION = 125,
+ DISCRIMINANT_CONSTRAINT = 126,
+ DISCRIMINANT_SPECIFICATION = 127,
+ ENTRY_BODY = 128,
+ ENTRY_CALL_ALTERNATIVE = 129,
+ ENTRY_CALL_STATEMENT = 130,
+ ENTRY_DECLARATION = 131,
+ ENTRY_INDEX_SPECIFICATION = 132,
+ ENUMERATION_REPESENTATION_CLAUSE = 133,
+ EXCEPTION_DECLARATION = 134,
+ EXCEPTION_HANDLER = 135,
+ EXCEPTION_RENAMING_DECLARATION = 136,
+ EXIT_STATEMENT = 137,
+ FORMAL_PACKAGE_DECLARATION = 138,
+ GENERIC_FORMAL_PART = 139,
+ GENERIC_PACKAGE_DECLARATION = 140,
+ GOTO_STATEMENT = 141,
+ HANDLED_SEQUENCE_OF_STATEMENTS = 142,
+ HANDLED_STMTS_OPT = 143,
+ IF_STATEMENT = 144,
+ INCOMPLETE_TYPE_DECLARATION = 145,
+ INDEXED_COMPONENT = 146,
+ INDEX_CONSTRAINT = 147,
+ LIBRARY_ITEM = 148,
+ LOOP_STATEMENT = 149,
+ NAME = 150,
+ NULL_STATEMENT = 151,
+ NUMBER_DECLARATION = 152,
+ OBJECT_DECLARATION = 153,
+ OBJECT_RENAMING_DECLARATION = 154,
+ OPERATOR_SYMBOL = 155,
+ PACKAGE_BODY = 156,
+ PACKAGE_BODY_STUB = 157,
+ PACKAGE_RENAMING_DECLARATION = 158,
+ PACKAGE_SPECIFICATION = 159,
+ PARAMETER_SPECIFICATION = 160,
+ PRIVATE_EXTENSION_DECLARATION = 161,
+ PRIVATE_TYPE_DECLARATION = 162,
+ PROTECTED_BODY = 163,
+ PROTECTED_BODY_STUB = 164,
+ PROTECTED_TYPE_DECLARATION = 165,
+ RAISE_STATEMENT = 166,
+ RANGE_ATTRIBUTE_REFERENCE = 167,
+ RECORD_REPRESENTATION_CLAUSE = 168,
+ REQUEUE_STATEMENT = 169,
+ RETURN_STATEMENT = 170,
+ SELECTIVE_ACCEPT = 171,
+ SEQUENCE_OF_STATEMENTS = 172,
+ SINGLE_PROTECTED_DECLARATION = 173,
+ SINGLE_TASK_DECLARATION = 174,
+ STATEMENT = 175,
+ SUBTYPE_DECLARATION = 176,
+ SUBTYPE_INDICATION = 177,
+ SUBTYPE_MARK = 178,
+ SUBUNIT = 179,
+ TASK_BODY = 180,
+ TASK_BODY_STUB = 181,
+ TASK_TYPE_DECLARATION = 182,
+ TERMINATE_ALTERNATIVE = 183,
+ TIMED_ENTRY_CALL = 184,
+ TRIGGERING_ALTERNATIVE = 185,
+ USE_CLAUSE = 186,
+ USE_TYPE_CLAUSE = 187,
+ VARIANT = 188,
+ VARIANT_PART = 189,
+ WITH_CLAUSE = 190,
+ ABSTRACT_FUNCTION_DECLARATION = 191,
+ ABSTRACT_PROCEDURE_DECLARATION = 192,
+ ACCESS_TO_FUNCTION_DECLARATION = 193,
+ ACCESS_TO_OBJECT_DECLARATION = 194,
+ ACCESS_TO_PROCEDURE_DECLARATION = 195,
+ ARRAY_OBJECT_DECLARATION = 196,
+ ARRAY_TYPE_DECLARATION = 197,
+ AND_THEN = 198,
+ BASIC_DECLARATIVE_ITEMS_OPT = 199,
+ BLOCK_BODY = 200,
+ BLOCK_BODY_OPT = 201,
+ CALL_STATEMENT = 202,
+ COMPONENT_CLAUSES_OPT = 203,
+ COMPONENT_ITEMS = 204,
+ COND_CLAUSE = 205,
+ DECIMAL_FIXED_POINT_DECLARATION = 206,
+ DECLARE_OPT = 207,
+ DERIVED_RECORD_EXTENSION = 208,
+ DISCRETE_SUBTYPE_DEF_OPT = 209,
+ DISCRIMINANT_SPECIFICATIONS = 210,
+ DISCRIM_PART_OPT = 211,
+ ELSE_OPT = 212,
+ ELSIFS_OPT = 213,
+ END_ID_OPT = 214,
+ ENTRY_INDEX_OPT = 215,
+ ENUMERATION_TYPE_DECLARATION = 216,
+ EXCEPT_HANDLER_PART_OPT = 217,
+ EXTENSION_OPT = 218,
+ FLOATING_POINT_DECLARATION = 219,
+ FORMAL_DECIMAL_FIXED_POINT_DECLARATION = 220,
+ FORMAL_DISCRETE_TYPE_DECLARATION = 221,
+ FORMAL_FLOATING_POINT_DECLARATION = 222,
+ FORMAL_FUNCTION_DECLARATION = 223,
+ FORMAL_MODULAR_TYPE_DECLARATION = 224,
+ FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION = 225,
+ FORMAL_ORDINARY_FIXED_POINT_DECLARATION = 226,
+ FORMAL_PART_OPT = 227,
+ FORMAL_PRIVATE_EXTENSION_DECLARATION = 228,
+ FORMAL_PRIVATE_TYPE_DECLARATION = 229,
+ FORMAL_PROCEDURE_DECLARATION = 230,
+ FORMAL_SIGNED_INTEGER_TYPE_DECLARATION = 231,
+ FUNCTION_BODY = 232,
+ FUNCTION_BODY_STUB = 233,
+ FUNCTION_DECLARATION = 234,
+ FUNCTION_RENAMING_DECLARATION = 235,
+ GENERIC_FUNCTION_DECLARATION = 236,
+ GENERIC_FUNCTION_INSTANTIATION = 237,
+ GENERIC_FUNCTION_RENAMING = 238,
+ GENERIC_PACKAGE_INSTANTIATION = 239,
+ GENERIC_PACKAGE_RENAMING = 240,
+ GENERIC_PROCEDURE_DECLARATION = 241,
+ GENERIC_PROCEDURE_INSTANTIATION = 242,
+ GENERIC_PROCEDURE_RENAMING = 243,
+ GUARD_OPT = 244,
+ IDENTIFIER_COLON_OPT = 245,
+ ID_OPT = 246,
+ INIT_OPT = 247,
+ ITERATION_SCHEME_OPT = 248,
+ LABEL_OPT = 249,
+ MARK_WITH_CONSTRAINT = 250,
+ MODIFIERS = 251,
+ MODULAR_TYPE_DECLARATION = 252,
+ MOD_CLAUSE_OPT = 253,
+ NOT_IN = 254,
+ ORDINARY_DERIVED_TYPE_DECLARATION = 255,
+ ORDINARY_FIXED_POINT_DECLARATION = 256,
+ OR_ELSE = 257,
+ OR_SELECT_OPT = 258,
+ PARENTHESIZED_PRIMARY = 259,
+ PRIVATE_DECLARATIVE_ITEMS_OPT = 260,
+ PRIVATE_TASK_ITEMS_OPT = 261,
+ PROCEDURE_BODY = 262,
+ PROCEDURE_BODY_STUB = 263,
+ PROCEDURE_DECLARATION = 264,
+ PROCEDURE_RENAMING_DECLARATION = 265,
+ PROT_MEMBER_DECLARATIONS = 266,
+ PROT_OP_BODIES_OPT = 267,
+ PROT_OP_DECLARATIONS = 268,
+ PROT_PRIVATE_OPT = 269,
+ RANGED_EXPRS = 270,
+ RANGE_CONSTRAINT = 271,
+ RECORD_TYPE_DECLARATION = 272,
+ SELECTOR_NAMES_OPT = 273,
+ SIGNED_INTEGER_TYPE_DECLARATION = 274,
+ TASK_ITEMS_OPT = 275,
+ UNARY_MINUS = 276,
+ UNARY_PLUS = 277,
+ VALUE = 278,
+ VALUES = 279,
+ VARIANTS = 280,
+ COMMENT_INTRO = 281,
+ OX = 282,
+ TIC_OR_CHARACTER_LITERAL = 283,
+ DIGIT = 284,
+ EXPONENT = 285,
+ EXTENDED_DIGIT = 286,
+ BASED_INTEGER = 287,
+ WS_ = 288,
+ COMMENT = 289,
+ NULL_TREE_LOOKAHEAD = 3
+ };
+#ifdef __cplusplus
+};
+#endif
+#endif /*INC_AdaTokenTypes_hpp_*/
diff --git a/languages/ada/AdaTokenTypes.txt b/languages/ada/AdaTokenTypes.txt
new file mode 100644
index 00000000..2415ea0c
--- /dev/null
+++ b/languages/ada/AdaTokenTypes.txt
@@ -0,0 +1,288 @@
+// $ANTLR 2.7.7 (20070609): ada.g -> AdaTokenTypes.txt$
+Ada // output token vocab name
+PRAGMA="pragma"=4
+IDENTIFIER=5
+SEMI=6
+LPAREN=7
+COMMA=8
+RPAREN=9
+RIGHT_SHAFT=10
+WITH="with"=11
+DOT=12
+USE="use"=13
+TYPE="type"=14
+TIC=15
+RANGE="range"=16
+DIGITS="digits"=17
+DELTA="delta"=18
+ACCESS="access"=19
+PRIVATE="private"=20
+PACKAGE="package"=21
+BODY="body"=22
+IS="is"=23
+PROCEDURE="procedure"=24
+FUNCTION="function"=25
+NEW="new"=26
+OTHERS="others"=27
+PIPE=28
+DOT_DOT=29
+ALL="all"=30
+COLON=31
+IN="in"=32
+OUT="out"=33
+RENAMES="renames"=34
+CHARACTER_LITERAL=35
+CHAR_STRING=36
+NuLL="null"=37
+RECORD="record"=38
+SEPARATE="separate"=39
+ABSTRACT="abstract"=40
+RETURN="return"=41
+TASK="task"=42
+PROTECTED="protected"=43
+BOX=44
+ASSIGN=45
+ENTRY="entry"=46
+FOR="for"=47
+END="end"=48
+AT="at"=49
+MOD="mod"=50
+SUBTYPE="subtype"=51
+EXCEPTION="exception"=52
+CONSTANT="constant"=53
+ARRAY="array"=54
+OF="of"=55
+ALIASED="aliased"=56
+CASE="case"=57
+WHEN="when"=58
+TAGGED="tagged"=59
+LIMITED="limited"=60
+GENERIC="generic"=61
+BEGIN="begin"=62
+LT_LT=63
+GT_GT=64
+IF="if"=65
+THEN="then"=66
+ELSIF="elsif"=67
+ELSE="else"=68
+LOOP="loop"=69
+WHILE="while"=70
+REVERSE="reverse"=71
+DECLARE="declare"=72
+EXIT="exit"=73
+GOTO="goto"=74
+ACCEPT="accept"=75
+DO="do"=76
+DELAY="delay"=77
+UNTIL="until"=78
+SELECT="select"=79
+ABORT="abort"=80
+OR="or"=81
+TERMINATE="terminate"=82
+RAISE="raise"=83
+REQUEUE="requeue"=84
+AND="and"=85
+XOR="xor"=86
+NOT="not"=87
+EQ=88
+NE=89
+LT_=90
+LE=91
+GT=92
+GE=93
+PLUS=94
+MINUS=95
+CONCAT=96
+STAR=97
+DIV=98
+REM="rem"=99
+ABS="abs"=100
+EXPON=101
+NUMERIC_LIT=102
+ABORTABLE_PART=103
+ABORT_STATEMENT=104
+ACCEPT_ALTERNATIVE=105
+ACCEPT_STATEMENT=106
+ALLOCATOR=107
+ASSIGNMENT_STATEMENT=108
+ASYNCHRONOUS_SELECT=109
+ATTRIBUTE_DEFINITION_CLAUSE=110
+AT_CLAUSE=111
+BLOCK_STATEMENT=112
+CASE_STATEMENT=113
+CASE_STATEMENT_ALTERNATIVE=114
+CODE_STATEMENT=115
+COMPONENT_DECLARATION=116
+CONDITIONAL_ENTRY_CALL=117
+CONTEXT_CLAUSE=118
+DECLARATIVE_PART=119
+DEFINING_IDENTIFIER_LIST=120
+DELAY_ALTERNATIVE=121
+DELAY_STATEMENT=122
+DELTA_CONSTRAINT=123
+DIGITS_CONSTRAINT=124
+DISCRIMINANT_ASSOCIATION=125
+DISCRIMINANT_CONSTRAINT=126
+DISCRIMINANT_SPECIFICATION=127
+ENTRY_BODY=128
+ENTRY_CALL_ALTERNATIVE=129
+ENTRY_CALL_STATEMENT=130
+ENTRY_DECLARATION=131
+ENTRY_INDEX_SPECIFICATION=132
+ENUMERATION_REPESENTATION_CLAUSE=133
+EXCEPTION_DECLARATION=134
+EXCEPTION_HANDLER=135
+EXCEPTION_RENAMING_DECLARATION=136
+EXIT_STATEMENT=137
+FORMAL_PACKAGE_DECLARATION=138
+GENERIC_FORMAL_PART=139
+GENERIC_PACKAGE_DECLARATION=140
+GOTO_STATEMENT=141
+HANDLED_SEQUENCE_OF_STATEMENTS=142
+HANDLED_STMTS_OPT=143
+IF_STATEMENT=144
+INCOMPLETE_TYPE_DECLARATION=145
+INDEXED_COMPONENT=146
+INDEX_CONSTRAINT=147
+LIBRARY_ITEM=148
+LOOP_STATEMENT=149
+NAME=150
+NULL_STATEMENT=151
+NUMBER_DECLARATION=152
+OBJECT_DECLARATION=153
+OBJECT_RENAMING_DECLARATION=154
+OPERATOR_SYMBOL=155
+PACKAGE_BODY=156
+PACKAGE_BODY_STUB=157
+PACKAGE_RENAMING_DECLARATION=158
+PACKAGE_SPECIFICATION=159
+PARAMETER_SPECIFICATION=160
+PRIVATE_EXTENSION_DECLARATION=161
+PRIVATE_TYPE_DECLARATION=162
+PROTECTED_BODY=163
+PROTECTED_BODY_STUB=164
+PROTECTED_TYPE_DECLARATION=165
+RAISE_STATEMENT=166
+RANGE_ATTRIBUTE_REFERENCE=167
+RECORD_REPRESENTATION_CLAUSE=168
+REQUEUE_STATEMENT=169
+RETURN_STATEMENT=170
+SELECTIVE_ACCEPT=171
+SEQUENCE_OF_STATEMENTS=172
+SINGLE_PROTECTED_DECLARATION=173
+SINGLE_TASK_DECLARATION=174
+STATEMENT=175
+SUBTYPE_DECLARATION=176
+SUBTYPE_INDICATION=177
+SUBTYPE_MARK=178
+SUBUNIT=179
+TASK_BODY=180
+TASK_BODY_STUB=181
+TASK_TYPE_DECLARATION=182
+TERMINATE_ALTERNATIVE=183
+TIMED_ENTRY_CALL=184
+TRIGGERING_ALTERNATIVE=185
+USE_CLAUSE=186
+USE_TYPE_CLAUSE=187
+VARIANT=188
+VARIANT_PART=189
+WITH_CLAUSE=190
+ABSTRACT_FUNCTION_DECLARATION=191
+ABSTRACT_PROCEDURE_DECLARATION=192
+ACCESS_TO_FUNCTION_DECLARATION=193
+ACCESS_TO_OBJECT_DECLARATION=194
+ACCESS_TO_PROCEDURE_DECLARATION=195
+ARRAY_OBJECT_DECLARATION=196
+ARRAY_TYPE_DECLARATION=197
+AND_THEN=198
+BASIC_DECLARATIVE_ITEMS_OPT=199
+BLOCK_BODY=200
+BLOCK_BODY_OPT=201
+CALL_STATEMENT=202
+COMPONENT_CLAUSES_OPT=203
+COMPONENT_ITEMS=204
+COND_CLAUSE=205
+DECIMAL_FIXED_POINT_DECLARATION=206
+DECLARE_OPT=207
+DERIVED_RECORD_EXTENSION=208
+DISCRETE_SUBTYPE_DEF_OPT=209
+DISCRIMINANT_SPECIFICATIONS=210
+DISCRIM_PART_OPT=211
+ELSE_OPT=212
+ELSIFS_OPT=213
+END_ID_OPT=214
+ENTRY_INDEX_OPT=215
+ENUMERATION_TYPE_DECLARATION=216
+EXCEPT_HANDLER_PART_OPT=217
+EXTENSION_OPT=218
+FLOATING_POINT_DECLARATION=219
+FORMAL_DECIMAL_FIXED_POINT_DECLARATION=220
+FORMAL_DISCRETE_TYPE_DECLARATION=221
+FORMAL_FLOATING_POINT_DECLARATION=222
+FORMAL_FUNCTION_DECLARATION=223
+FORMAL_MODULAR_TYPE_DECLARATION=224
+FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION=225
+FORMAL_ORDINARY_FIXED_POINT_DECLARATION=226
+FORMAL_PART_OPT=227
+FORMAL_PRIVATE_EXTENSION_DECLARATION=228
+FORMAL_PRIVATE_TYPE_DECLARATION=229
+FORMAL_PROCEDURE_DECLARATION=230
+FORMAL_SIGNED_INTEGER_TYPE_DECLARATION=231
+FUNCTION_BODY=232
+FUNCTION_BODY_STUB=233
+FUNCTION_DECLARATION=234
+FUNCTION_RENAMING_DECLARATION=235
+GENERIC_FUNCTION_DECLARATION=236
+GENERIC_FUNCTION_INSTANTIATION=237
+GENERIC_FUNCTION_RENAMING=238
+GENERIC_PACKAGE_INSTANTIATION=239
+GENERIC_PACKAGE_RENAMING=240
+GENERIC_PROCEDURE_DECLARATION=241
+GENERIC_PROCEDURE_INSTANTIATION=242
+GENERIC_PROCEDURE_RENAMING=243
+GUARD_OPT=244
+IDENTIFIER_COLON_OPT=245
+ID_OPT=246
+INIT_OPT=247
+ITERATION_SCHEME_OPT=248
+LABEL_OPT=249
+MARK_WITH_CONSTRAINT=250
+MODIFIERS=251
+MODULAR_TYPE_DECLARATION=252
+MOD_CLAUSE_OPT=253
+NOT_IN=254
+ORDINARY_DERIVED_TYPE_DECLARATION=255
+ORDINARY_FIXED_POINT_DECLARATION=256
+OR_ELSE=257
+OR_SELECT_OPT=258
+PARENTHESIZED_PRIMARY=259
+PRIVATE_DECLARATIVE_ITEMS_OPT=260
+PRIVATE_TASK_ITEMS_OPT=261
+PROCEDURE_BODY=262
+PROCEDURE_BODY_STUB=263
+PROCEDURE_DECLARATION=264
+PROCEDURE_RENAMING_DECLARATION=265
+PROT_MEMBER_DECLARATIONS=266
+PROT_OP_BODIES_OPT=267
+PROT_OP_DECLARATIONS=268
+PROT_PRIVATE_OPT=269
+RANGED_EXPRS=270
+RANGE_CONSTRAINT=271
+RECORD_TYPE_DECLARATION=272
+SELECTOR_NAMES_OPT=273
+SIGNED_INTEGER_TYPE_DECLARATION=274
+TASK_ITEMS_OPT=275
+UNARY_MINUS=276
+UNARY_PLUS=277
+VALUE=278
+VALUES=279
+VARIANTS=280
+COMMENT_INTRO=281
+OX=282
+TIC_OR_CHARACTER_LITERAL=283
+DIGIT=284
+EXPONENT=285
+EXTENDED_DIGIT=286
+BASED_INTEGER=287
+WS_=288
+COMMENT=289
diff --git a/languages/ada/AdaTreeParserSuper.cpp b/languages/ada/AdaTreeParserSuper.cpp
new file mode 100644
index 00000000..be5f0623
--- /dev/null
+++ b/languages/ada/AdaTreeParserSuper.cpp
@@ -0,0 +1,9050 @@
+/* $ANTLR 2.7.7 (20070609): "ada.tree.g" -> "AdaTreeParserSuper.cpp"$ */
+#include "AdaTreeParserSuper.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 "ada.tree.g"
+#line 11 "AdaTreeParserSuper.cpp"
+AdaTreeParserSuper::AdaTreeParserSuper()
+ : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
+}
+
+void AdaTreeParserSuper::compilation_unit(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST compilation_unit_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ context_items_opt(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case LIBRARY_ITEM:
+ {
+ library_item(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBUNIT:
+ {
+ subunit(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == PRAGMA)) {
+ pragma(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop4;
+ }
+
+ }
+ _loop4:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::context_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST context_items_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t12 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = _t;
+ match(_t,CONTEXT_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case WITH_CLAUSE:
+ {
+ with_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop14;
+ }
+ }
+ }
+ _loop14:;
+ } // ( ... )*
+ _t = __t12;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::library_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST library_item_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t32 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
+ match(_t,LIBRARY_ITEM);
+ _t = _t->getFirstChild();
+ modifiers(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl_or_rename_or_inst_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
+ match(_t,PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t34;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
+ match(_t,GENERIC_PACKAGE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t35;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_SPECIFICATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t36 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
+ match(_t,PACKAGE_SPECIFICATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_spec_part(_t);
+ _t = _retTree;
+ _t = __t36;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
+ match(_t,PACKAGE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t37;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ generic_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t32;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subunit(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subunit_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t514 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
+ match(_t,SUBUNIT);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case FUNCTION_BODY:
+ case PROCEDURE_BODY:
+ {
+ subprogram_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ package_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case TASK_BODY:
+ {
+ task_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_BODY:
+ {
+ protected_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t514;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::pragma(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST pragma_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t6 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
+ match(_t,PRAGMA);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_0.member(_t->getType()))) {
+ pragma_arg(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop8;
+ }
+
+ }
+ _loop8:;
+ } // ( ... )*
+ _t = __t6;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::pragma_arg(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST pragma_arg_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RIGHT_SHAFT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
+ match(_t,RIGHT_SHAFT);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ _t = __t10;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::expression(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST expression_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case AND:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t472 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
+ match(_t,AND);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t472;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case AND_THEN:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t473 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
+ match(_t,AND_THEN);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t473;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OR:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t474 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
+ match(_t,OR);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t474;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OR_ELSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t475 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
+ match(_t,OR_ELSE);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t475;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case XOR:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t476 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
+ match(_t,XOR);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ relation(_t);
+ _t = _retTree;
+ _t = __t476;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case NOT_IN:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ relation(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::with_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST with_clause_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t16 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
+ match(_t,WITH_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt18=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
+ compound_name(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt18>=1 ) { goto _loop18; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt18++;
+ }
+ _loop18:;
+ } // ( ... )+
+ _t = __t16;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::use_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST use_clause_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case USE_TYPE_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
+ match(_t,USE_TYPE_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt24=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT || _t->getType() == TIC)) {
+ subtype_mark(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt24>=1 ) { goto _loop24; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt24++;
+ }
+ _loop24:;
+ } // ( ... )+
+ _t = __t22;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case USE_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t25 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
+ match(_t,USE_CLAUSE);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt27=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
+ compound_name(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt27>=1 ) { goto _loop27; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt27++;
+ }
+ _loop27:;
+ } // ( ... )+
+ _t = __t25;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::compound_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST compound_name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t20 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
+ match(_t,DOT);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ _t = __t20;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subtype_mark(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subtype_mark_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case TIC:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
+ match(_t,TIC);
+ _t = _t->getFirstChild();
+ compound_name(_t);
+ _t = _retTree;
+ attribute_id(_t);
+ _t = _retTree;
+ _t = __t29;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::attribute_id(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST attribute_id_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
+ match(_t,RANGE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DIGITS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
+ match(_t,DIGITS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DELTA:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
+ match(_t,DELTA);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
+ match(_t,ACCESS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::modifiers(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST modifiers_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
+ match(_t,MODIFIERS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
+ match(_t,ABSTRACT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
+ match(_t,ACCESS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ALIASED:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
+ match(_t,ALIASED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
+ match(_t,ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONSTANT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
+ match(_t,CONSTANT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IN:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
+ match(_t,IN);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LIMITED:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
+ match(_t,LIMITED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OUT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
+ match(_t,OUT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
+ match(_t,PRIVATE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
+ match(_t,PROTECTED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case REVERSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
+ match(_t,REVERSE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TAGGED:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
+ match(_t,TAGGED);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ goto _loop41;
+ }
+ }
+ }
+ _loop41:;
+ } // ( ... )*
+ _t = __t39;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subprog_decl_or_rename_or_inst_or_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subprog_decl_or_rename_or_inst_or_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::def_id(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST def_id_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ compound_name(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::pkg_body_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST pkg_body_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ declarative_part(_t);
+ _t = _retTree;
+ block_body_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::generic_inst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST generic_inst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ compound_name(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::pkg_spec_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST pkg_spec_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ basic_declarative_items_opt(_t);
+ _t = _retTree;
+ private_declarative_items_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::renames(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST renames_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case CHARACTER_STRING:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
+ match(_t,CHARACTER_STRING);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
+ match(_t,OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::generic_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST generic_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PACKAGE_RENAMING:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t277 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
+ match(_t,GENERIC_PACKAGE_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t277;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t278 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
+ match(_t,GENERIC_PACKAGE_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ pkg_spec_part(_t);
+ _t = _retTree;
+ _t = __t278;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t279 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
+ match(_t,GENERIC_PROCEDURE_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t279;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t280 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
+ match(_t,GENERIC_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t280;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_RENAMING:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t281 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST_in = _t;
+ match(_t,GENERIC_FUNCTION_RENAMING);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t281;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t282 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST_in = _t;
+ match(_t,GENERIC_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ generic_formal_part_opt(_t);
+ _t = _retTree;
+ def_id(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t282;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::id_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST id_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST_in = _t;
+ match(_t,ID_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case OPERATOR_SYMBOL:
+ {
+ def_designator(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t43;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::def_designator(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST def_designator_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ definable_operator_symbol(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::end_id_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST end_id_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST_in = _t;
+ match(_t,END);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case OPERATOR_SYMBOL:
+ {
+ def_designator(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t46;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subprog_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subprog_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST_in = _t;
+ match(_t,GENERIC_PROCEDURE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t49;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST_in = _t;
+ match(_t,PROCEDURE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t50;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST_in = _t;
+ match(_t,PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t51;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROCEDURE_BODY_STUB:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST_in = _t;
+ match(_t,PROCEDURE_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t52;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST_in = _t;
+ match(_t,ABSTRACT_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t53;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_FUNCTION_INSTANTIATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t54 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST_in = _t;
+ match(_t,GENERIC_FUNCTION_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t54;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST_in = _t;
+ match(_t,FUNCTION_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t55;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST_in = _t;
+ match(_t,FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t56;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_BODY_STUB:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST_in = _t;
+ match(_t,FUNCTION_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t57;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST_in = _t;
+ match(_t,ABSTRACT_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t58;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::formal_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST formal_part_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t84 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST_in = _t;
+ match(_t,FORMAL_PART_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == PARAMETER_SPECIFICATION)) {
+ parameter_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop86;
+ }
+
+ }
+ _loop86:;
+ } // ( ... )*
+ _t = __t84;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::function_tail(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST function_tail_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ formal_part_opt(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::value_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST value_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t468 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST_in = _t;
+ match(_t,VALUES);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt470=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_1.member(_t->getType()))) {
+ value(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt470>=1 ) { goto _loop470; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt470++;
+ }
+ _loop470:;
+ } // ( ... )+
+ _t = __t468;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::value(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST value_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case OTHERS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST_in = _t;
+ match(_t,OTHERS);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ _t = __t63;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RIGHT_SHAFT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST_in = _t;
+ match(_t,RIGHT_SHAFT);
+ _t = _t->getFirstChild();
+ ranged_expr_s(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t64;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case PIPE:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ ranged_expr_s(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::ranged_expr_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST ranged_expr_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t66 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST_in = _t;
+ match(_t,PIPE);
+ _t = _t->getFirstChild();
+ ranged_expr_s(_t);
+ _t = _retTree;
+ ranged_expr(_t);
+ _t = _retTree;
+ _t = __t66;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ ranged_expr(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::ranged_expr(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST ranged_expr_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST_in = _t;
+ match(_t,DOT_DOT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t68;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RANGE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST_in = _t;
+ match(_t,RANGE);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ _t = __t69;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::simple_expression(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST simple_expression_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PLUS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t488 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST_in = _t;
+ match(_t,PLUS);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t488;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MINUS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t489 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST_in = _t;
+ match(_t,MINUS);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t489;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONCAT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t490 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST_in = _t;
+ match(_t,CONCAT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ signed_term(_t);
+ _t = _retTree;
+ _t = __t490;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ signed_term(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ range_dots(_t);
+ _t = _retTree;
+ break;
+ }
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range_attrib_ref(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST_in = _t;
+ match(_t,RANGE_CONSTRAINT);
+ _t = _t->getFirstChild();
+ range(_t);
+ _t = _retTree;
+ _t = __t71;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range_dots(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_dots_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST_in = _t;
+ match(_t,DOT_DOT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t75;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range_attrib_ref(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_attrib_ref_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST_in = _t;
+ match(_t,RANGE_ATTRIBUTE_REFERENCE);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t77;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prefix(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prefix_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST_in = _t;
+ match(_t,DOT);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST_in = _t;
+ match(_t,ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t80;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST_in = _t;
+ match(_t,INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ prefix(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t82;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::parameter_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST parameter_specification_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST_in = _t;
+ match(_t,PARAMETER_SPECIFICATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t88;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::defining_identifier_list(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST defining_identifier_list_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t90 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST_in = _t;
+ match(_t,DEFINING_IDENTIFIER_LIST);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt92=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER)) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ else {
+ if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt92++;
+ }
+ _loop92:;
+ } // ( ... )+
+ _t = __t90;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::init_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST init_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t136 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST_in = _t;
+ match(_t,INIT_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t136;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t95 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST_in = _t;
+ match(_t,DOT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST_in = _t;
+ match(_t,ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST_in = _t;
+ match(_t,CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST_in = _t;
+ match(_t,OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t95;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t97 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST_in = _t;
+ match(_t,INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t97;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIC:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t98 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp91_AST_in = _t;
+ match(_t,TIC);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ attribute_id(_t);
+ _t = _retTree;
+ _t = __t98;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::definable_operator_symbol(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST definable_operator_symbol_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST_in = _t;
+ match(_t,OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::parenthesized_primary(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST parenthesized_primary_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t101 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST_in = _t;
+ match(_t,PARENTHESIZED_PRIMARY);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NuLL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST_in = _t;
+ match(_t,NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ extension_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t101;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::extension_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST extension_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t104 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp95_AST_in = _t;
+ match(_t,EXTENSION_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NuLL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST_in = _t;
+ match(_t,NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case VALUES:
+ {
+ value_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t104;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::spec_decl_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST spec_decl_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t109 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST_in = _t;
+ match(_t,GENERIC_PACKAGE_INSTANTIATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ generic_inst(_t);
+ _t = _retTree;
+ _t = __t109;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_SPECIFICATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t110 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST_in = _t;
+ match(_t,PACKAGE_SPECIFICATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_spec_part(_t);
+ _t = _retTree;
+ _t = __t110;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t111 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST_in = _t;
+ match(_t,PACKAGE_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ renames(_t);
+ _t = _retTree;
+ _t = __t111;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::basic_declarative_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST basic_declarative_items_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t114 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST_in = _t;
+ match(_t,BASIC_DECLARATIVE_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_2.member(_t->getType()))) {
+ basic_decl_item(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop116;
+ }
+
+ }
+ _loop116:;
+ } // ( ... )*
+ _t = __t114;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::private_declarative_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST private_declarative_items_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t118 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST_in = _t;
+ match(_t,PRIVATE_DECLARATIVE_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_2.member(_t->getType()))) {
+ basic_decl_item(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop120;
+ }
+
+ }
+ _loop120:;
+ } // ( ... )*
+ _t = __t118;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::basic_decl_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST basic_decl_item_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ spec_decl_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ {
+ task_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_TYPE_DECLARATION:
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ prot_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SUBTYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ decl_common(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::task_type_or_single_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST task_type_or_single_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case TASK_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t123 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST_in = _t;
+ match(_t,TASK_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ task_definition_opt(_t);
+ _t = _retTree;
+ _t = __t123;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t124 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp103_AST_in = _t;
+ match(_t,SINGLE_TASK_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ task_definition_opt(_t);
+ _t = _retTree;
+ _t = __t124;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_type_or_single_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_type_or_single_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROTECTED_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t164 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST_in = _t;
+ match(_t,PROTECTED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ protected_definition(_t);
+ _t = _retTree;
+ _t = __t164;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t165 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST_in = _t;
+ match(_t,SINGLE_PROTECTED_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ protected_definition(_t);
+ _t = _retTree;
+ _t = __t165;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::decl_common(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST decl_common_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENUMERATION_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t184 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST_in = _t;
+ match(_t,ENUMERATION_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp107_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ enum_id_s(_t);
+ _t = _retTree;
+ _t = __t184;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t185 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST_in = _t;
+ match(_t,SIGNED_INTEGER_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp109_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ range(_t);
+ _t = _retTree;
+ _t = __t185;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MODULAR_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t186 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST_in = _t;
+ match(_t,MODULAR_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp111_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ _t = __t186;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FLOATING_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t187 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST_in = _t;
+ match(_t,FLOATING_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp113_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t187;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t188 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST_in = _t;
+ match(_t,ORDINARY_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp115_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ _t = __t188;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t189 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST_in = _t;
+ match(_t,DECIMAL_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp117_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ expression(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t189;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_TYPE_DECLARATION:
+ {
+ array_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ access_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case INCOMPLETE_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t190 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST_in = _t;
+ match(_t,INCOMPLETE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp119_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrim_part_opt(_t);
+ _t = _retTree;
+ _t = __t190;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE_EXTENSION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t191 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp120_AST_in = _t;
+ match(_t,PRIVATE_EXTENSION_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t191;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DERIVED_RECORD_EXTENSION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t192 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST_in = _t;
+ match(_t,DERIVED_RECORD_EXTENSION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ record_definition(_t);
+ _t = _retTree;
+ _t = __t192;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t193 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp122_AST_in = _t;
+ match(_t,ORDINARY_DERIVED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t193;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PRIVATE_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t194 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp123_AST_in = _t;
+ match(_t,PRIVATE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ _t = __t194;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RECORD_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t195 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp124_AST_in = _t;
+ match(_t,RECORD_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_and_discrim(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ record_definition(_t);
+ _t = _retTree;
+ _t = __t195;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SUBTYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t196 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST_in = _t;
+ match(_t,SUBTYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp126_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t196;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GENERIC_PACKAGE_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ {
+ generic_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ case EXCEPTION_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t197 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp127_AST_in = _t;
+ match(_t,EXCEPTION_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ compound_name(_t);
+ _t = _retTree;
+ _t = __t197;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OBJECT_RENAMING_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t198 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp128_AST_in = _t;
+ match(_t,OBJECT_RENAMING_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ name(_t);
+ _t = _retTree;
+ _t = __t198;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EXCEPTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t199 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST_in = _t;
+ match(_t,EXCEPTION_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ _t = __t199;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NUMBER_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t200 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp130_AST_in = _t;
+ match(_t,NUMBER_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t200;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_OBJECT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t201 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp131_AST_in = _t;
+ match(_t,ARRAY_OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ array_type_definition(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t201;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OBJECT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t202 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp132_AST_in = _t;
+ match(_t,OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t202;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discrim_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discrim_part_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t127 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST_in = _t;
+ match(_t,DISCRIM_PART_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp134_AST_in = _t;
+ match(_t,BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DISCRIMINANT_SPECIFICATIONS:
+ {
+ discriminant_specifications(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t127;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::task_definition_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST task_definition_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ task_items_opt(_t);
+ _t = _retTree;
+ private_task_items_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::task_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST task_items_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t139 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp135_AST_in = _t;
+ match(_t,TASK_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ entrydecls_repspecs_opt(_t);
+ _t = _retTree;
+ _t = __t139;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::private_task_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST private_task_items_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t162 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp136_AST_in = _t;
+ match(_t,PRIVATE_TASK_ITEMS_OPT);
+ _t = _t->getFirstChild();
+ entrydecls_repspecs_opt(_t);
+ _t = _retTree;
+ _t = __t162;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discriminant_specifications(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discriminant_specifications_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t130 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST_in = _t;
+ match(_t,DISCRIMINANT_SPECIFICATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == DISCRIMINANT_SPECIFICATION)) {
+ discriminant_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop132;
+ }
+
+ }
+ _loop132:;
+ } // ( ... )*
+ _t = __t130;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discriminant_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discriminant_specification_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t134 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp138_AST_in = _t;
+ match(_t,DISCRIMINANT_SPECIFICATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_mark(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t134;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entrydecls_repspecs_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entrydecls_repspecs_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENTRY_DECLARATION:
+ {
+ entry_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop142;
+ }
+ }
+ }
+ _loop142:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t144 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp139_AST_in = _t;
+ match(_t,ENTRY_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp140_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrete_subtype_def_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t144;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::rep_spec(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST rep_spec_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t150 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST_in = _t;
+ match(_t,RECORD_REPRESENTATION_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ align_opt(_t);
+ _t = _retTree;
+ comp_loc_s(_t);
+ _t = _retTree;
+ _t = __t150;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case AT_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t151 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp142_AST_in = _t;
+ match(_t,AT_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t151;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t152 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp143_AST_in = _t;
+ match(_t,ATTRIBUTE_DEFINITION_CLAUSE);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t152;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t153 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp144_AST_in = _t;
+ match(_t,ENUMERATION_REPESENTATION_CLAUSE);
+ _t = _t->getFirstChild();
+ local_enum_name(_t);
+ _t = _retTree;
+ enumeration_aggregate(_t);
+ _t = _retTree;
+ _t = __t153;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discrete_subtype_def_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discrete_subtype_def_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t146 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST_in = _t;
+ match(_t,DISCRETE_SUBTYPE_DEF_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case SUBTYPE_INDICATION:
+ {
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t146;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discrete_subtype_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discrete_subtype_definition_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBTYPE_INDICATION:
+ {
+ subtype_ind(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subtype_ind(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subtype_ind_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t221 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp146_AST_in = _t;
+ match(_t,SUBTYPE_INDICATION);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ constraint_opt(_t);
+ _t = _retTree;
+ _t = __t221;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::align_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST align_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t155 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp147_AST_in = _t;
+ match(_t,MOD_CLAUSE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t155;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::comp_loc_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST comp_loc_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t158 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp148_AST_in = _t;
+ match(_t,COMPONENT_CLAUSES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ {
+ subtype_mark(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop160;
+ }
+ }
+ }
+ _loop160:;
+ } // ( ... )*
+ _t = __t158;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::local_enum_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST local_enum_name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::enumeration_aggregate(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST enumeration_aggregate_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_1.member(_t->getType()))) {
+ value(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop275;
+ }
+
+ }
+ _loop275:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::protected_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST protected_definition_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ prot_op_decl_s(_t);
+ _t = _retTree;
+ prot_private_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_private_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_private_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t167 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp150_AST_in = _t;
+ match(_t,PROT_PRIVATE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROT_MEMBER_DECLARATIONS:
+ {
+ prot_member_decl_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t167;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_member_decl_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_member_decl_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t178 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp151_AST_in = _t;
+ match(_t,PROT_MEMBER_DECLARATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENTRY_DECLARATION:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case FUNCTION_DECLARATION:
+ case PROCEDURE_DECLARATION:
+ {
+ prot_op_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMPONENT_DECLARATION:
+ {
+ comp_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop180;
+ }
+ }
+ }
+ _loop180:;
+ } // ( ... )*
+ _t = __t178;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_op_decl_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_op_decl_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t171 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp152_AST_in = _t;
+ match(_t,PROT_OP_DECLARATIONS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_3.member(_t->getType()))) {
+ prot_op_decl(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop173;
+ }
+
+ }
+ _loop173:;
+ } // ( ... )*
+ _t = __t171;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_op_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_op_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ENTRY_DECLARATION:
+ {
+ entry_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t175 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST_in = _t;
+ match(_t,PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t175;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t176 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp154_AST_in = _t;
+ match(_t,FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t176;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case RECORD_REPRESENTATION_CLAUSE:
+ {
+ rep_spec(_t);
+ _t = _retTree;
+ break;
+ }
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::comp_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST comp_decl_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t182 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp155_AST_in = _t;
+ match(_t,COMPONENT_DECLARATION);
+ _t = _t->getFirstChild();
+ defining_identifier_list(_t);
+ _t = _retTree;
+ component_subtype_def(_t);
+ _t = _retTree;
+ init_opt(_t);
+ _t = _retTree;
+ _t = __t182;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::component_subtype_def(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST component_subtype_def_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::enum_id_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST enum_id_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ { // ( ... )+
+ int _cnt206=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER || _t->getType() == CHARACTER_LITERAL)) {
+ enumeration_literal_specification(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt206>=1 ) { goto _loop206; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt206++;
+ }
+ _loop206:;
+ } // ( ... )+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range_constraint_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_constraint_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE_CONSTRAINT:
+ {
+ range_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::array_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST array_type_declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t212 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp156_AST_in = _t;
+ match(_t,ARRAY_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ array_type_definition(_t);
+ _t = _retTree;
+ _t = __t212;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::access_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST access_type_declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t245 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp158_AST_in = _t;
+ match(_t,ACCESS_TO_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp159_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t245;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t246 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp160_AST_in = _t;
+ match(_t,ACCESS_TO_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t246;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ACCESS_TO_OBJECT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t247 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp162_AST_in = _t;
+ match(_t,ACCESS_TO_OBJECT_DECLARATION);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp163_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t247;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::id_and_discrim(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST id_and_discrim_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp164_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ discrim_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::record_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST record_definition_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case COMPONENT_ITEMS:
+ {
+ component_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::array_type_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST array_type_definition_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ index_or_discrete_range_s(_t);
+ _t = _retTree;
+ component_subtype_def(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::enumeration_literal_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST enumeration_literal_specification_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp165_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp166_AST_in = _t;
+ match(_t,CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::index_or_discrete_range_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST index_or_discrete_range_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case RANGE:
+ case DOT_DOT:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ index_or_discrete_range(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMMA:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t214 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp167_AST_in = _t;
+ match(_t,COMMA);
+ _t = _t->getFirstChild();
+ index_or_discrete_range_s(_t);
+ _t = _retTree;
+ index_or_discrete_range(_t);
+ _t = _retTree;
+ _t = __t214;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::index_or_discrete_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST index_or_discrete_range_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t216 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp168_AST_in = _t;
+ match(_t,DOT_DOT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t216;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case RANGE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t217 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp169_AST_in = _t;
+ match(_t,RANGE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp170_AST_in = _t;
+ match(_t,BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t217;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ simple_expression(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::constraint_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST constraint_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case RANGE_CONSTRAINT:
+ {
+ range_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DIGITS_CONSTRAINT:
+ {
+ digits_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELTA_CONSTRAINT:
+ {
+ delta_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case INDEX_CONSTRAINT:
+ {
+ index_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DISCRIMINANT_CONSTRAINT:
+ {
+ discriminant_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::digits_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST digits_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t225 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp171_AST_in = _t;
+ match(_t,DIGITS_CONSTRAINT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t225;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::delta_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST delta_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t227 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp172_AST_in = _t;
+ match(_t,DELTA_CONSTRAINT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ range_constraint_opt(_t);
+ _t = _retTree;
+ _t = __t227;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::index_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST index_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t229 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp173_AST_in = _t;
+ match(_t,INDEX_CONSTRAINT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt231=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == DOT_DOT || _t->getType() == RANGE_ATTRIBUTE_REFERENCE || _t->getType() == SUBTYPE_INDICATION)) {
+ discrete_range(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt231>=1 ) { goto _loop231; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt231++;
+ }
+ _loop231:;
+ } // ( ... )+
+ _t = __t229;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discriminant_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discriminant_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t234 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp174_AST_in = _t;
+ match(_t,DISCRIMINANT_CONSTRAINT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt236=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == DISCRIMINANT_ASSOCIATION)) {
+ discriminant_association(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt236>=1 ) { goto _loop236; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt236++;
+ }
+ _loop236:;
+ } // ( ... )+
+ _t = __t234;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discrete_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discrete_range_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case SUBTYPE_INDICATION:
+ {
+ subtype_ind(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discriminant_association(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discriminant_association_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t238 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp175_AST_in = _t;
+ match(_t,DISCRIMINANT_ASSOCIATION);
+ _t = _t->getFirstChild();
+ selector_names_opt(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t238;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::selector_names_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST selector_names_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t240 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp176_AST_in = _t;
+ match(_t,SELECTOR_NAMES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == IDENTIFIER)) {
+ selector_name(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop242;
+ }
+
+ }
+ _loop242:;
+ } // ( ... )*
+ _t = __t240;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::selector_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST selector_name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::component_list(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST component_list_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ component_items(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case VARIANT_PART:
+ {
+ variant_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::component_items(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST component_items_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t253 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp178_AST_in = _t;
+ match(_t,COMPONENT_ITEMS);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case COMPONENT_DECLARATION:
+ {
+ comp_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop255;
+ }
+ }
+ }
+ _loop255:;
+ } // ( ... )*
+ _t = __t253;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::variant_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST variant_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t257 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp179_AST_in = _t;
+ match(_t,VARIANT_PART);
+ _t = _t->getFirstChild();
+ discriminant_direct_name(_t);
+ _t = _retTree;
+ variant_s(_t);
+ _t = _retTree;
+ _t = __t257;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discriminant_direct_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discriminant_direct_name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp180_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::variant_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST variant_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t260 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp181_AST_in = _t;
+ match(_t,VARIANTS);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt262=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == VARIANT)) {
+ variant(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt262>=1 ) { goto _loop262; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt262++;
+ }
+ _loop262:;
+ } // ( ... )+
+ _t = __t260;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::variant(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST variant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t264 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp182_AST_in = _t;
+ match(_t,VARIANT);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case COMPONENT_ITEMS:
+ {
+ component_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t264;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::choice_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST choice_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t267 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp183_AST_in = _t;
+ match(_t,PIPE);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ choice(_t);
+ _t = _retTree;
+ _t = __t267;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case OTHERS:
+ case DOT_DOT:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case AND_THEN:
+ case MARK_WITH_CONSTRAINT:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ choice(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::choice(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST choice_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case OTHERS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp184_AST_in = _t;
+ match(_t,OTHERS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ case MARK_WITH_CONSTRAINT:
+ {
+ discrete_with_range(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::discrete_with_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST discrete_with_range_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case MARK_WITH_CONSTRAINT:
+ {
+ mark_with_constraint(_t);
+ _t = _retTree;
+ break;
+ }
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::mark_with_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST mark_with_constraint_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t271 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp185_AST_in = _t;
+ match(_t,MARK_WITH_CONSTRAINT);
+ _t = _t->getFirstChild();
+ subtype_mark(_t);
+ _t = _retTree;
+ range_constraint(_t);
+ _t = _retTree;
+ _t = __t271;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::generic_formal_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST generic_formal_part_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t284 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp186_AST_in = _t;
+ match(_t,GENERIC_FORMAL_PART);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ {
+ use_clause(_t);
+ _t = _retTree;
+ break;
+ }
+ case FORMAL_PACKAGE_DECLARATION:
+ case PARAMETER_SPECIFICATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
+ case FORMAL_DISCRETE_TYPE_DECLARATION:
+ case FORMAL_FLOATING_POINT_DECLARATION:
+ case FORMAL_FUNCTION_DECLARATION:
+ case FORMAL_MODULAR_TYPE_DECLARATION:
+ case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
+ case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
+ case FORMAL_PRIVATE_EXTENSION_DECLARATION:
+ case FORMAL_PRIVATE_TYPE_DECLARATION:
+ case FORMAL_PROCEDURE_DECLARATION:
+ case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ generic_formal_parameter(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop286;
+ }
+ }
+ }
+ _loop286:;
+ } // ( ... )*
+ _t = __t284;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::generic_formal_parameter(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST generic_formal_parameter_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case FORMAL_DISCRETE_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t288 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp187_AST_in = _t;
+ match(_t,FORMAL_DISCRETE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t288;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t289 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST_in = _t;
+ match(_t,FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t289;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_MODULAR_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t290 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST_in = _t;
+ match(_t,FORMAL_MODULAR_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t290;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t291 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp190_AST_in = _t;
+ match(_t,FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t291;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t292 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp191_AST_in = _t;
+ match(_t,FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t292;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_FLOATING_POINT_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t293 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST_in = _t;
+ match(_t,FORMAL_FLOATING_POINT_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t293;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ARRAY_TYPE_DECLARATION:
+ {
+ formal_array_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ {
+ formal_access_type_declaration(_t);
+ _t = _retTree;
+ break;
+ }
+ case FORMAL_PRIVATE_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t294 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST_in = _t;
+ match(_t,FORMAL_PRIVATE_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ _t = __t294;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t295 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp194_AST_in = _t;
+ match(_t,FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t295;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PRIVATE_EXTENSION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t296 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp195_AST_in = _t;
+ match(_t,FORMAL_PRIVATE_EXTENSION_DECLARATION);
+ _t = _t->getFirstChild();
+ id_part(_t);
+ _t = _retTree;
+ modifiers(_t);
+ _t = _retTree;
+ subtype_ind(_t);
+ _t = _retTree;
+ _t = __t296;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t297 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST_in = _t;
+ match(_t,FORMAL_PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ subprogram_default_opt(_t);
+ _t = _retTree;
+ _t = __t297;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t298 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST_in = _t;
+ match(_t,FORMAL_FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ subprogram_default_opt(_t);
+ _t = _retTree;
+ _t = __t298;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FORMAL_PACKAGE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t299 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp198_AST_in = _t;
+ match(_t,FORMAL_PACKAGE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ compound_name(_t);
+ _t = _retTree;
+ formal_package_actual_part_opt(_t);
+ _t = _retTree;
+ _t = __t299;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PARAMETER_SPECIFICATION:
+ {
+ parameter_specification(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::formal_array_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST formal_array_type_declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ array_type_declaration(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::formal_access_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST formal_access_type_declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ access_type_declaration(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::id_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST id_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ def_id(_t);
+ _t = _retTree;
+ discrim_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subprogram_default_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subprogram_default_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp199_AST_in = _t;
+ match(_t,BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::formal_package_actual_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST formal_package_actual_part_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case BOX:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST_in = _t;
+ match(_t,BOX);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DEFINING_IDENTIFIER_LIST:
+ {
+ defining_identifier_list(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::procedure_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST procedure_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t309 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST_in = _t;
+ match(_t,PROCEDURE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t309;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::function_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST function_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t311 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp202_AST_in = _t;
+ match(_t,FUNCTION_BODY);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t311;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::body_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST body_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ declarative_part(_t);
+ _t = _retTree;
+ block_body(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::declarative_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST declarative_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t314 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp203_AST_in = _t;
+ match(_t,DECLARATIVE_PART);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PACKAGE_BODY:
+ case PACKAGE_BODY_STUB:
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case PROTECTED_BODY:
+ case PROTECTED_BODY_STUB:
+ case PROTECTED_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SINGLE_PROTECTED_DECLARATION:
+ case SINGLE_TASK_DECLARATION:
+ case SUBTYPE_DECLARATION:
+ case TASK_BODY:
+ case TASK_BODY_STUB:
+ case TASK_TYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ declarative_item(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop316;
+ }
+ }
+ }
+ _loop316:;
+ } // ( ... )*
+ _t = __t314;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::block_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST block_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t336 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST_in = _t;
+ match(_t,BLOCK_BODY);
+ _t = _t->getFirstChild();
+ handled_stmt_s(_t);
+ _t = _retTree;
+ _t = __t336;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::declarative_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST declarative_item_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PACKAGE_BODY_STUB:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t318 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST_in = _t;
+ match(_t,PACKAGE_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t318;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_BODY:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t319 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp206_AST_in = _t;
+ match(_t,PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t319;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PACKAGE_RENAMING_DECLARATION:
+ case PACKAGE_SPECIFICATION:
+ case GENERIC_PACKAGE_INSTANTIATION:
+ {
+ spec_decl_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case TASK_BODY_STUB:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t320 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp207_AST_in = _t;
+ match(_t,TASK_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t320;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TASK_BODY:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t321 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST_in = _t;
+ match(_t,TASK_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t321;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SINGLE_TASK_DECLARATION:
+ case TASK_TYPE_DECLARATION:
+ {
+ task_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROTECTED_BODY_STUB:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t322 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST_in = _t;
+ match(_t,PROTECTED_BODY_STUB);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ _t = __t322;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED_BODY:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t323 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp210_AST_in = _t;
+ match(_t,PROTECTED_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ prot_op_bodies_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t323;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case PROTECTED_TYPE_DECLARATION:
+ case SINGLE_PROTECTED_DECLARATION:
+ {
+ prot_type_or_single_decl(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABSTRACT_FUNCTION_DECLARATION:
+ case ABSTRACT_PROCEDURE_DECLARATION:
+ case FUNCTION_BODY:
+ case FUNCTION_BODY_STUB:
+ case FUNCTION_DECLARATION:
+ case FUNCTION_RENAMING_DECLARATION:
+ case GENERIC_FUNCTION_INSTANTIATION:
+ case GENERIC_PROCEDURE_INSTANTIATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_BODY_STUB:
+ case PROCEDURE_DECLARATION:
+ case PROCEDURE_RENAMING_DECLARATION:
+ {
+ subprog_decl_or_rename_or_inst_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case ATTRIBUTE_DEFINITION_CLAUSE:
+ case AT_CLAUSE:
+ case ENUMERATION_REPESENTATION_CLAUSE:
+ case EXCEPTION_DECLARATION:
+ case EXCEPTION_RENAMING_DECLARATION:
+ case GENERIC_PACKAGE_DECLARATION:
+ case INCOMPLETE_TYPE_DECLARATION:
+ case NUMBER_DECLARATION:
+ case OBJECT_DECLARATION:
+ case OBJECT_RENAMING_DECLARATION:
+ case PRIVATE_EXTENSION_DECLARATION:
+ case PRIVATE_TYPE_DECLARATION:
+ case RECORD_REPRESENTATION_CLAUSE:
+ case SUBTYPE_DECLARATION:
+ case USE_CLAUSE:
+ case USE_TYPE_CLAUSE:
+ case ACCESS_TO_FUNCTION_DECLARATION:
+ case ACCESS_TO_OBJECT_DECLARATION:
+ case ACCESS_TO_PROCEDURE_DECLARATION:
+ case ARRAY_OBJECT_DECLARATION:
+ case ARRAY_TYPE_DECLARATION:
+ case DECIMAL_FIXED_POINT_DECLARATION:
+ case DERIVED_RECORD_EXTENSION:
+ case ENUMERATION_TYPE_DECLARATION:
+ case FLOATING_POINT_DECLARATION:
+ case GENERIC_FUNCTION_DECLARATION:
+ case GENERIC_FUNCTION_RENAMING:
+ case GENERIC_PACKAGE_RENAMING:
+ case GENERIC_PROCEDURE_DECLARATION:
+ case GENERIC_PROCEDURE_RENAMING:
+ case MODULAR_TYPE_DECLARATION:
+ case ORDINARY_DERIVED_TYPE_DECLARATION:
+ case ORDINARY_FIXED_POINT_DECLARATION:
+ case RECORD_TYPE_DECLARATION:
+ case SIGNED_INTEGER_TYPE_DECLARATION:
+ {
+ decl_common(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::prot_op_bodies_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST prot_op_bodies_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t329 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp211_AST_in = _t;
+ match(_t,PROT_OP_BODIES_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case ENTRY_BODY:
+ {
+ entry_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ case FUNCTION_DECLARATION:
+ case PROCEDURE_BODY:
+ case PROCEDURE_DECLARATION:
+ {
+ subprog_decl_or_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop331;
+ }
+ }
+ }
+ _loop331:;
+ } // ( ... )*
+ _t = __t329;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::block_body_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST block_body_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t326 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST_in = _t;
+ match(_t,BLOCK_BODY_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case HANDLED_SEQUENCE_OF_STATEMENTS:
+ {
+ handled_stmt_s(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t326;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::handled_stmt_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST handled_stmt_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t338 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST_in = _t;
+ match(_t,HANDLED_SEQUENCE_OF_STATEMENTS);
+ _t = _t->getFirstChild();
+ statements(_t);
+ _t = _retTree;
+ except_handler_part_opt(_t);
+ _t = _retTree;
+ _t = __t338;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t398 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp214_AST_in = _t;
+ match(_t,ENTRY_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ entry_body_formal_part(_t);
+ _t = _retTree;
+ entry_barrier(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t398;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subprog_decl_or_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subprog_decl_or_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case PROCEDURE_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t333 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp215_AST_in = _t;
+ match(_t,PROCEDURE_DECLARATION);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ _t = __t333;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_DECLARATION:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t334 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST_in = _t;
+ match(_t,FUNCTION_DECLARATION);
+ _t = _t->getFirstChild();
+ def_designator(_t);
+ _t = _retTree;
+ function_tail(_t);
+ _t = _retTree;
+ _t = __t334;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::statements(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST statements_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t343 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST_in = _t;
+ match(_t,SEQUENCE_OF_STATEMENTS);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt345=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case STATEMENT:
+ {
+ statement(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ if ( _cnt345>=1 ) { goto _loop345; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+ }
+ _cnt345++;
+ }
+ _loop345:;
+ } // ( ... )+
+ _t = __t343;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::except_handler_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST except_handler_part_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t448 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp218_AST_in = _t;
+ match(_t,EXCEPT_HANDLER_PART_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == EXCEPTION_HANDLER)) {
+ exception_handler(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop450;
+ }
+
+ }
+ _loop450:;
+ } // ( ... )*
+ _t = __t448;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::handled_stmts_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST handled_stmts_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t340 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp219_AST_in = _t;
+ match(_t,HANDLED_STMTS_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case SEQUENCE_OF_STATEMENTS:
+ {
+ statements(_t);
+ _t = _retTree;
+ except_handler_part_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t340;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t347 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST_in = _t;
+ match(_t,STATEMENT);
+ _t = _t->getFirstChild();
+ def_label_opt(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NULL_STATEMENT:
+ {
+ null_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case EXIT_STATEMENT:
+ {
+ exit_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case RETURN_STATEMENT:
+ {
+ return_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case GOTO_STATEMENT:
+ {
+ goto_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELAY_STATEMENT:
+ {
+ delay_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ABORT_STATEMENT:
+ {
+ abort_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case RAISE_STATEMENT:
+ {
+ raise_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case REQUEUE_STATEMENT:
+ {
+ requeue_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ACCEPT_STATEMENT:
+ {
+ accept_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ASYNCHRONOUS_SELECT:
+ case CONDITIONAL_ENTRY_CALL:
+ case SELECTIVE_ACCEPT:
+ case TIMED_ENTRY_CALL:
+ {
+ select_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case IF_STATEMENT:
+ {
+ if_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case CASE_STATEMENT:
+ {
+ case_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case LOOP_STATEMENT:
+ {
+ loop_stmt(_t);
+ _t = _retTree;
+ id_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case BLOCK_STATEMENT:
+ {
+ block(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ASSIGNMENT_STATEMENT:
+ case CALL_STATEMENT:
+ {
+ call_or_assignment(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t347;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::def_label_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST def_label_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t350 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST_in = _t;
+ match(_t,LABEL_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp222_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t350;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::null_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST null_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp223_AST_in = _t;
+ match(_t,NULL_STATEMENT);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::exit_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST exit_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t385 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST_in = _t;
+ match(_t,EXIT_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ label_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ case WHEN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case WHEN:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST_in = _t;
+ match(_t,WHEN);
+ _t = _t->getNextSibling();
+ condition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t385;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::return_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST return_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t390 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp226_AST_in = _t;
+ match(_t,RETURN_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t390;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::goto_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST goto_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t393 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp227_AST_in = _t;
+ match(_t,GOTO_STATEMENT);
+ _t = _t->getFirstChild();
+ label_name(_t);
+ _t = _retTree;
+ _t = __t393;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::delay_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST delay_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t412 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp228_AST_in = _t;
+ match(_t,DELAY_STATEMENT);
+ _t = _t->getFirstChild();
+ modifiers(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t412;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::abort_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST abort_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t444 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST_in = _t;
+ match(_t,ABORT_STATEMENT);
+ _t = _t->getFirstChild();
+ { // ( ... )+
+ int _cnt446=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_tokenSet_4.member(_t->getType()))) {
+ name(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt446>=1 ) { goto _loop446; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt446++;
+ }
+ _loop446:;
+ } // ( ... )+
+ _t = __t444;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::raise_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST raise_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t460 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST_in = _t;
+ match(_t,RAISE_STATEMENT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t460;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::requeue_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST requeue_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t463 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp231_AST_in = _t;
+ match(_t,REQUEUE_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ABORT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp232_AST_in = _t;
+ match(_t,ABORT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t463;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::accept_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST accept_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t407 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp233_AST_in = _t;
+ match(_t,ACCEPT_STATEMENT);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ entry_index_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ handled_stmts_opt(_t);
+ _t = _retTree;
+ end_id_opt(_t);
+ _t = _retTree;
+ _t = __t407;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::select_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST select_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ASYNCHRONOUS_SELECT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t414 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST_in = _t;
+ match(_t,ASYNCHRONOUS_SELECT);
+ _t = _t->getFirstChild();
+ triggering_alternative(_t);
+ _t = _retTree;
+ abortable_part(_t);
+ _t = _retTree;
+ _t = __t414;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case SELECTIVE_ACCEPT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t415 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp235_AST_in = _t;
+ match(_t,SELECTIVE_ACCEPT);
+ _t = _t->getFirstChild();
+ selective_accept(_t);
+ _t = _retTree;
+ _t = __t415;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIMED_ENTRY_CALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t416 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp236_AST_in = _t;
+ match(_t,TIMED_ENTRY_CALL);
+ _t = _t->getFirstChild();
+ entry_call_alternative(_t);
+ _t = _retTree;
+ delay_alternative(_t);
+ _t = _retTree;
+ _t = __t416;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CONDITIONAL_ENTRY_CALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t417 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp237_AST_in = _t;
+ match(_t,CONDITIONAL_ENTRY_CALL);
+ _t = _t->getFirstChild();
+ entry_call_alternative(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t417;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::if_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST if_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t354 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp238_AST_in = _t;
+ match(_t,IF_STATEMENT);
+ _t = _t->getFirstChild();
+ cond_clause(_t);
+ _t = _retTree;
+ elsifs_opt(_t);
+ _t = _retTree;
+ else_opt(_t);
+ _t = _retTree;
+ _t = __t354;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::case_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST case_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t366 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp239_AST_in = _t;
+ match(_t,CASE_STATEMENT);
+ _t = _t->getFirstChild();
+ expression(_t);
+ _t = _retTree;
+ alternative_s(_t);
+ _t = _retTree;
+ _t = __t366;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::loop_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST loop_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t373 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp240_AST_in = _t;
+ match(_t,LOOP_STATEMENT);
+ _t = _t->getFirstChild();
+ iteration_scheme_opt(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t373;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::block(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST block_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t380 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp241_AST_in = _t;
+ match(_t,BLOCK_STATEMENT);
+ _t = _t->getFirstChild();
+ declare_opt(_t);
+ _t = _retTree;
+ block_body(_t);
+ _t = _retTree;
+ _t = __t380;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::call_or_assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST call_or_assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ASSIGNMENT_STATEMENT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t395 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp242_AST_in = _t;
+ match(_t,ASSIGNMENT_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ expression(_t);
+ _t = _retTree;
+ _t = __t395;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CALL_STATEMENT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t396 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp243_AST_in = _t;
+ match(_t,CALL_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ _t = __t396;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::cond_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST cond_clause_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t356 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp244_AST_in = _t;
+ match(_t,COND_CLAUSE);
+ _t = _t->getFirstChild();
+ condition(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t356;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::elsifs_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST elsifs_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t359 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp245_AST_in = _t;
+ match(_t,ELSIFS_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == COND_CLAUSE)) {
+ cond_clause(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop361;
+ }
+
+ }
+ _loop361:;
+ } // ( ... )*
+ _t = __t359;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::else_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST else_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t363 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp246_AST_in = _t;
+ match(_t,ELSE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case SEQUENCE_OF_STATEMENTS:
+ {
+ statements(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t363;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::condition(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST condition_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? 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 != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::alternative_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST alternative_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ { // ( ... )+
+ int _cnt369=0;
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == CASE_STATEMENT_ALTERNATIVE)) {
+ case_statement_alternative(_t);
+ _t = _retTree;
+ }
+ else {
+ if ( _cnt369>=1 ) { goto _loop369; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
+ }
+
+ _cnt369++;
+ }
+ _loop369:;
+ } // ( ... )+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::case_statement_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST case_statement_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t371 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp247_AST_in = _t;
+ match(_t,CASE_STATEMENT_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ choice_s(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t371;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::iteration_scheme_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST iteration_scheme_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t375 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp248_AST_in = _t;
+ match(_t,ITERATION_SCHEME_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case WHILE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t377 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp249_AST_in = _t;
+ match(_t,WHILE);
+ _t = _t->getFirstChild();
+ condition(_t);
+ _t = _retTree;
+ _t = __t377;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case FOR:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t378 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp250_AST_in = _t;
+ match(_t,FOR);
+ _t = _t->getFirstChild();
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp251_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ modifiers(_t);
+ _t = _retTree;
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ _t = __t378;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t375;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::declare_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST declare_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t382 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp252_AST_in = _t;
+ match(_t,DECLARE_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DECLARATIVE_PART:
+ {
+ declarative_part(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t382;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::label_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST label_name_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp253_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_body_formal_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_body_formal_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ entry_index_spec_opt(_t);
+ _t = _retTree;
+ formal_part_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_barrier(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_barrier_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ condition(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_index_spec_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_index_spec_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t401 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp254_AST_in = _t;
+ match(_t,ENTRY_INDEX_SPECIFICATION);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ def_id(_t);
+ _t = _retTree;
+ discrete_subtype_definition(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t401;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_call_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_call_stmt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t405 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp255_AST_in = _t;
+ match(_t,ENTRY_CALL_STATEMENT);
+ _t = _t->getFirstChild();
+ name(_t);
+ _t = _retTree;
+ _t = __t405;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_index_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_index_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t409 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp256_AST_in = _t;
+ match(_t,ENTRY_INDEX_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ expression(_t);
+ _t = _retTree;
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t409;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::triggering_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST triggering_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t419 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp257_AST_in = _t;
+ match(_t,TRIGGERING_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DELAY_STATEMENT:
+ {
+ delay_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ case ENTRY_CALL_STATEMENT:
+ {
+ entry_call_stmt(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t419;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::abortable_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST abortable_part_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t422 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp258_AST_in = _t;
+ match(_t,ABORTABLE_PART);
+ _t = _t->getFirstChild();
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t422;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::selective_accept(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST selective_accept_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ guard_opt(_t);
+ _t = _retTree;
+ select_alternative(_t);
+ _t = _retTree;
+ or_select_opt(_t);
+ _t = _retTree;
+ else_opt(_t);
+ _t = _retTree;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::entry_call_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST entry_call_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t424 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp259_AST_in = _t;
+ match(_t,ENTRY_CALL_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ entry_call_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t424;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::delay_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST delay_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t435 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp260_AST_in = _t;
+ match(_t,DELAY_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ delay_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t435;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::stmts_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST stmts_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PRAGMA:
+ {
+ pragma(_t);
+ _t = _retTree;
+ break;
+ }
+ case STATEMENT:
+ {
+ statement(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ goto _loop438;
+ }
+ }
+ }
+ _loop438:;
+ } // ( ... )*
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::guard_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST guard_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t427 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp261_AST_in = _t;
+ match(_t,GUARD_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case IN:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case OR:
+ case AND:
+ case XOR:
+ case NOT:
+ case EQ:
+ case NE:
+ case LT_:
+ case LE:
+ case GT:
+ case GE:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case AND_THEN:
+ case NOT_IN:
+ case OR_ELSE:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ condition(_t);
+ _t = _retTree;
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == PRAGMA)) {
+ pragma(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop430;
+ }
+
+ }
+ _loop430:;
+ } // ( ... )*
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t427;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::select_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST select_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ACCEPT_ALTERNATIVE:
+ {
+ accept_alternative(_t);
+ _t = _retTree;
+ break;
+ }
+ case DELAY_ALTERNATIVE:
+ {
+ delay_alternative(_t);
+ _t = _retTree;
+ break;
+ }
+ case TERMINATE_ALTERNATIVE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp262_AST_in = _t;
+ match(_t,TERMINATE_ALTERNATIVE);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::or_select_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST or_select_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t440 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp263_AST_in = _t;
+ match(_t,OR_SELECT_OPT);
+ _t = _t->getFirstChild();
+ { // ( ... )*
+ for (;;) {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ if ((_t->getType() == GUARD_OPT)) {
+ guard_opt(_t);
+ _t = _retTree;
+ select_alternative(_t);
+ _t = _retTree;
+ }
+ else {
+ goto _loop442;
+ }
+
+ }
+ _loop442:;
+ } // ( ... )*
+ _t = __t440;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::accept_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST accept_alternative_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t433 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp264_AST_in = _t;
+ match(_t,ACCEPT_ALTERNATIVE);
+ _t = _t->getFirstChild();
+ accept_stmt(_t);
+ _t = _retTree;
+ stmts_opt(_t);
+ _t = _retTree;
+ _t = __t433;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::exception_handler(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST exception_handler_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t452 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp265_AST_in = _t;
+ match(_t,EXCEPTION_HANDLER);
+ _t = _t->getFirstChild();
+ identifier_colon_opt(_t);
+ _t = _retTree;
+ except_choice_s(_t);
+ _t = _retTree;
+ statements(_t);
+ _t = _retTree;
+ _t = __t452;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::identifier_colon_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST identifier_colon_opt_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t454 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp266_AST_in = _t;
+ match(_t,IDENTIFIER_COLON_OPT);
+ _t = _t->getFirstChild();
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp267_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case 3:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t454;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::except_choice_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST except_choice_s_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PIPE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t457 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp268_AST_in = _t;
+ match(_t,PIPE);
+ _t = _t->getFirstChild();
+ except_choice_s(_t);
+ _t = _retTree;
+ exception_choice(_t);
+ _t = _retTree;
+ _t = __t457;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case OTHERS:
+ {
+ exception_choice(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::exception_choice(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST exception_choice_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ {
+ compound_name(_t);
+ _t = _retTree;
+ break;
+ }
+ case OTHERS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp269_AST_in = _t;
+ match(_t,OTHERS);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::operator_call(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST operator_call_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t466 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp270_AST_in = _t;
+ match(_t,OPERATOR_SYMBOL);
+ _t = _t->getFirstChild();
+ value_s(_t);
+ _t = _retTree;
+ _t = __t466;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::relation(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST relation_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IN:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t478 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp271_AST_in = _t;
+ match(_t,IN);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ range_or_mark(_t);
+ _t = _retTree;
+ _t = __t478;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NOT_IN:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t479 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp272_AST_in = _t;
+ match(_t,NOT_IN);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ range_or_mark(_t);
+ _t = _retTree;
+ _t = __t479;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EQ:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t480 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp273_AST_in = _t;
+ match(_t,EQ);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t480;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t481 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp274_AST_in = _t;
+ match(_t,NE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t481;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LT_:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t482 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp275_AST_in = _t;
+ match(_t,LT_);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t482;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case LE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t483 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp276_AST_in = _t;
+ match(_t,LE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t483;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t484 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp277_AST_in = _t;
+ match(_t,GT);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t484;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case GE:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t485 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp278_AST_in = _t;
+ match(_t,GE);
+ _t = _t->getFirstChild();
+ simple_expression(_t);
+ _t = _retTree;
+ simple_expression(_t);
+ _t = _retTree;
+ _t = __t485;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case PLUS:
+ case MINUS:
+ case CONCAT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ case UNARY_MINUS:
+ case UNARY_PLUS:
+ {
+ simple_expression(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::range_or_mark(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST range_or_mark_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case DOT_DOT:
+ case RANGE_ATTRIBUTE_REFERENCE:
+ {
+ range(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ {
+ subtype_mark(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::signed_term(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST signed_term_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case UNARY_PLUS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t492 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp279_AST_in = _t;
+ match(_t,UNARY_PLUS);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ _t = __t492;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case UNARY_MINUS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t493 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp280_AST_in = _t;
+ match(_t,UNARY_MINUS);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ _t = __t493;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case MOD:
+ case NOT:
+ case STAR:
+ case DIV:
+ case REM:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ term(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::term(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST term_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case STAR:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t495 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp281_AST_in = _t;
+ match(_t,STAR);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t495;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DIV:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t496 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp282_AST_in = _t;
+ match(_t,DIV);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t496;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case MOD:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t497 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp283_AST_in = _t;
+ match(_t,MOD);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t497;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case REM:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t498 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp284_AST_in = _t;
+ match(_t,REM);
+ _t = _t->getFirstChild();
+ term(_t);
+ _t = _retTree;
+ factor(_t);
+ _t = _retTree;
+ _t = __t498;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NOT:
+ case ABS:
+ case EXPON:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ factor(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::factor(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST factor_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case NOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t500 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp285_AST_in = _t;
+ match(_t,NOT);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ _t = __t500;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case ABS:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t501 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp286_AST_in = _t;
+ match(_t,ABS);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ _t = __t501;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case EXPON:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t502 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp287_AST_in = _t;
+ match(_t,EXPON);
+ _t = _t->getFirstChild();
+ primary(_t);
+ _t = _retTree;
+ primary(_t);
+ _t = _retTree;
+ _t = __t502;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case CHARACTER_LITERAL:
+ case CHAR_STRING:
+ case NuLL:
+ case NUMERIC_LIT:
+ case ALLOCATOR:
+ case INDEXED_COMPONENT:
+ case OPERATOR_SYMBOL:
+ case PARENTHESIZED_PRIMARY:
+ {
+ primary(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::primary(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST primary_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ case DOT:
+ case TIC:
+ case INDEXED_COMPONENT:
+ {
+ name_or_qualified(_t);
+ _t = _retTree;
+ break;
+ }
+ case PARENTHESIZED_PRIMARY:
+ {
+ parenthesized_primary(_t);
+ _t = _retTree;
+ break;
+ }
+ case ALLOCATOR:
+ {
+ allocator(_t);
+ _t = _retTree;
+ break;
+ }
+ case NuLL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp288_AST_in = _t;
+ match(_t,NuLL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case NUMERIC_LIT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp289_AST_in = _t;
+ match(_t,NUMERIC_LIT);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp290_AST_in = _t;
+ match(_t,CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHAR_STRING:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp291_AST_in = _t;
+ match(_t,CHAR_STRING);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ operator_call(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::name_or_qualified(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST name_or_qualified_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp292_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case DOT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t506 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp293_AST_in = _t;
+ match(_t,DOT);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case ALL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp294_AST_in = _t;
+ match(_t,ALL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case IDENTIFIER:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp295_AST_in = _t;
+ match(_t,IDENTIFIER);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case CHARACTER_LITERAL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp296_AST_in = _t;
+ match(_t,CHARACTER_LITERAL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ case OPERATOR_SYMBOL:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp297_AST_in = _t;
+ match(_t,OPERATOR_SYMBOL);
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t506;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case INDEXED_COMPONENT:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t508 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp298_AST_in = _t;
+ match(_t,INDEXED_COMPONENT);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ value_s(_t);
+ _t = _retTree;
+ _t = __t508;
+ _t = _t->getNextSibling();
+ break;
+ }
+ case TIC:
+ {
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t509 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp299_AST_in = _t;
+ match(_t,TIC);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ {
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PARENTHESIZED_PRIMARY:
+ {
+ parenthesized_primary(_t);
+ _t = _retTree;
+ break;
+ }
+ case IDENTIFIER:
+ case RANGE:
+ case DIGITS:
+ case DELTA:
+ case ACCESS:
+ {
+ attribute_id(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ _t = __t509;
+ _t = _t->getNextSibling();
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::allocator(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST allocator_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t512 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp300_AST_in = _t;
+ match(_t,ALLOCATOR);
+ _t = _t->getFirstChild();
+ name_or_qualified(_t);
+ _t = _retTree;
+ _t = __t512;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::subprogram_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST subprogram_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = ASTNULL;
+ switch ( _t->getType()) {
+ case PROCEDURE_BODY:
+ {
+ procedure_body(_t);
+ _t = _retTree;
+ break;
+ }
+ case FUNCTION_BODY:
+ {
+ function_body(_t);
+ _t = _retTree;
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::package_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST package_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t518 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp301_AST_in = _t;
+ match(_t,PACKAGE_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ pkg_body_part(_t);
+ _t = _retTree;
+ _t = __t518;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::task_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST task_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t520 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp302_AST_in = _t;
+ match(_t,TASK_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ body_part(_t);
+ _t = _retTree;
+ _t = __t520;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::protected_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
+ ANTLR_USE_NAMESPACE(antlr)RefAST protected_body_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
+
+ try { // for error handling
+ ANTLR_USE_NAMESPACE(antlr)RefAST __t522 = _t;
+ ANTLR_USE_NAMESPACE(antlr)RefAST tmp303_AST_in = _t;
+ match(_t,PROTECTED_BODY);
+ _t = _t->getFirstChild();
+ def_id(_t);
+ _t = _retTree;
+ prot_op_bodies_opt(_t);
+ _t = _retTree;
+ _t = __t522;
+ _t = _t->getNextSibling();
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ reportError(ex);
+ if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
+ _t = _t->getNextSibling();
+ }
+ _retTree = _t;
+}
+
+void AdaTreeParserSuper::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
+{
+}
+const char* AdaTreeParserSuper::tokenNames[] = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "\"pragma\"",
+ "IDENTIFIER",
+ "SEMI",
+ "LPAREN",
+ "COMMA",
+ "RPAREN",
+ "RIGHT_SHAFT",
+ "\"with\"",
+ "DOT",
+ "\"use\"",
+ "\"type\"",
+ "TIC",
+ "\"range\"",
+ "\"digits\"",
+ "\"delta\"",
+ "\"access\"",
+ "\"private\"",
+ "\"package\"",
+ "\"body\"",
+ "\"is\"",
+ "\"procedure\"",
+ "\"function\"",
+ "\"new\"",
+ "\"others\"",
+ "PIPE",
+ "DOT_DOT",
+ "\"all\"",
+ "COLON",
+ "\"in\"",
+ "\"out\"",
+ "\"renames\"",
+ "CHARACTER_LITERAL",
+ "CHAR_STRING",
+ "\"null\"",
+ "\"record\"",
+ "\"separate\"",
+ "\"abstract\"",
+ "\"return\"",
+ "\"task\"",
+ "\"protected\"",
+ "BOX",
+ "ASSIGN",
+ "\"entry\"",
+ "\"for\"",
+ "\"end\"",
+ "\"at\"",
+ "\"mod\"",
+ "\"subtype\"",
+ "\"exception\"",
+ "\"constant\"",
+ "\"array\"",
+ "\"of\"",
+ "\"aliased\"",
+ "\"case\"",
+ "\"when\"",
+ "\"tagged\"",
+ "\"limited\"",
+ "\"generic\"",
+ "\"begin\"",
+ "LT_LT",
+ "GT_GT",
+ "\"if\"",
+ "\"then\"",
+ "\"elsif\"",
+ "\"else\"",
+ "\"loop\"",
+ "\"while\"",
+ "\"reverse\"",
+ "\"declare\"",
+ "\"exit\"",
+ "\"goto\"",
+ "\"accept\"",
+ "\"do\"",
+ "\"delay\"",
+ "\"until\"",
+ "\"select\"",
+ "\"abort\"",
+ "\"or\"",
+ "\"terminate\"",
+ "\"raise\"",
+ "\"requeue\"",
+ "\"and\"",
+ "\"xor\"",
+ "\"not\"",
+ "EQ",
+ "NE",
+ "LT_",
+ "LE",
+ "GT",
+ "GE",
+ "PLUS",
+ "MINUS",
+ "CONCAT",
+ "STAR",
+ "DIV",
+ "\"rem\"",
+ "\"abs\"",
+ "EXPON",
+ "NUMERIC_LIT",
+ "ABORTABLE_PART",
+ "ABORT_STATEMENT",
+ "ACCEPT_ALTERNATIVE",
+ "ACCEPT_STATEMENT",
+ "ALLOCATOR",
+ "ASSIGNMENT_STATEMENT",
+ "ASYNCHRONOUS_SELECT",
+ "ATTRIBUTE_DEFINITION_CLAUSE",
+ "AT_CLAUSE",
+ "BLOCK_STATEMENT",
+ "CASE_STATEMENT",
+ "CASE_STATEMENT_ALTERNATIVE",
+ "CODE_STATEMENT",
+ "COMPONENT_DECLARATION",
+ "CONDITIONAL_ENTRY_CALL",
+ "CONTEXT_CLAUSE",
+ "DECLARATIVE_PART",
+ "DEFINING_IDENTIFIER_LIST",
+ "DELAY_ALTERNATIVE",
+ "DELAY_STATEMENT",
+ "DELTA_CONSTRAINT",
+ "DIGITS_CONSTRAINT",
+ "DISCRIMINANT_ASSOCIATION",
+ "DISCRIMINANT_CONSTRAINT",
+ "DISCRIMINANT_SPECIFICATION",
+ "ENTRY_BODY",
+ "ENTRY_CALL_ALTERNATIVE",
+ "ENTRY_CALL_STATEMENT",
+ "ENTRY_DECLARATION",
+ "ENTRY_INDEX_SPECIFICATION",
+ "ENUMERATION_REPESENTATION_CLAUSE",
+ "EXCEPTION_DECLARATION",
+ "EXCEPTION_HANDLER",
+ "EXCEPTION_RENAMING_DECLARATION",
+ "EXIT_STATEMENT",
+ "FORMAL_PACKAGE_DECLARATION",
+ "GENERIC_FORMAL_PART",
+ "GENERIC_PACKAGE_DECLARATION",
+ "GOTO_STATEMENT",
+ "HANDLED_SEQUENCE_OF_STATEMENTS",
+ "HANDLED_STMTS_OPT",
+ "IF_STATEMENT",
+ "INCOMPLETE_TYPE_DECLARATION",
+ "INDEXED_COMPONENT",
+ "INDEX_CONSTRAINT",
+ "LIBRARY_ITEM",
+ "LOOP_STATEMENT",
+ "NAME",
+ "NULL_STATEMENT",
+ "NUMBER_DECLARATION",
+ "OBJECT_DECLARATION",
+ "OBJECT_RENAMING_DECLARATION",
+ "OPERATOR_SYMBOL",
+ "PACKAGE_BODY",
+ "PACKAGE_BODY_STUB",
+ "PACKAGE_RENAMING_DECLARATION",
+ "PACKAGE_SPECIFICATION",
+ "PARAMETER_SPECIFICATION",
+ "PRIVATE_EXTENSION_DECLARATION",
+ "PRIVATE_TYPE_DECLARATION",
+ "PROTECTED_BODY",
+ "PROTECTED_BODY_STUB",
+ "PROTECTED_TYPE_DECLARATION",
+ "RAISE_STATEMENT",
+ "RANGE_ATTRIBUTE_REFERENCE",
+ "RECORD_REPRESENTATION_CLAUSE",
+ "REQUEUE_STATEMENT",
+ "RETURN_STATEMENT",
+ "SELECTIVE_ACCEPT",
+ "SEQUENCE_OF_STATEMENTS",
+ "SINGLE_PROTECTED_DECLARATION",
+ "SINGLE_TASK_DECLARATION",
+ "STATEMENT",
+ "SUBTYPE_DECLARATION",
+ "SUBTYPE_INDICATION",
+ "SUBTYPE_MARK",
+ "SUBUNIT",
+ "TASK_BODY",
+ "TASK_BODY_STUB",
+ "TASK_TYPE_DECLARATION",
+ "TERMINATE_ALTERNATIVE",
+ "TIMED_ENTRY_CALL",
+ "TRIGGERING_ALTERNATIVE",
+ "USE_CLAUSE",
+ "USE_TYPE_CLAUSE",
+ "VARIANT",
+ "VARIANT_PART",
+ "WITH_CLAUSE",
+ "ABSTRACT_FUNCTION_DECLARATION",
+ "ABSTRACT_PROCEDURE_DECLARATION",
+ "ACCESS_TO_FUNCTION_DECLARATION",
+ "ACCESS_TO_OBJECT_DECLARATION",
+ "ACCESS_TO_PROCEDURE_DECLARATION",
+ "ARRAY_OBJECT_DECLARATION",
+ "ARRAY_TYPE_DECLARATION",
+ "AND_THEN",
+ "BASIC_DECLARATIVE_ITEMS_OPT",
+ "BLOCK_BODY",
+ "BLOCK_BODY_OPT",
+ "CALL_STATEMENT",
+ "COMPONENT_CLAUSES_OPT",
+ "COMPONENT_ITEMS",
+ "COND_CLAUSE",
+ "DECIMAL_FIXED_POINT_DECLARATION",
+ "DECLARE_OPT",
+ "DERIVED_RECORD_EXTENSION",
+ "DISCRETE_SUBTYPE_DEF_OPT",
+ "DISCRIMINANT_SPECIFICATIONS",
+ "DISCRIM_PART_OPT",
+ "ELSE_OPT",
+ "ELSIFS_OPT",
+ "END_ID_OPT",
+ "ENTRY_INDEX_OPT",
+ "ENUMERATION_TYPE_DECLARATION",
+ "EXCEPT_HANDLER_PART_OPT",
+ "EXTENSION_OPT",
+ "FLOATING_POINT_DECLARATION",
+ "FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
+ "FORMAL_DISCRETE_TYPE_DECLARATION",
+ "FORMAL_FLOATING_POINT_DECLARATION",
+ "FORMAL_FUNCTION_DECLARATION",
+ "FORMAL_MODULAR_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
+ "FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
+ "FORMAL_PART_OPT",
+ "FORMAL_PRIVATE_EXTENSION_DECLARATION",
+ "FORMAL_PRIVATE_TYPE_DECLARATION",
+ "FORMAL_PROCEDURE_DECLARATION",
+ "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
+ "FUNCTION_BODY",
+ "FUNCTION_BODY_STUB",
+ "FUNCTION_DECLARATION",
+ "FUNCTION_RENAMING_DECLARATION",
+ "GENERIC_FUNCTION_DECLARATION",
+ "GENERIC_FUNCTION_INSTANTIATION",
+ "GENERIC_FUNCTION_RENAMING",
+ "GENERIC_PACKAGE_INSTANTIATION",
+ "GENERIC_PACKAGE_RENAMING",
+ "GENERIC_PROCEDURE_DECLARATION",
+ "GENERIC_PROCEDURE_INSTANTIATION",
+ "GENERIC_PROCEDURE_RENAMING",
+ "GUARD_OPT",
+ "IDENTIFIER_COLON_OPT",
+ "ID_OPT",
+ "INIT_OPT",
+ "ITERATION_SCHEME_OPT",
+ "LABEL_OPT",
+ "MARK_WITH_CONSTRAINT",
+ "MODIFIERS",
+ "MODULAR_TYPE_DECLARATION",
+ "MOD_CLAUSE_OPT",
+ "NOT_IN",
+ "ORDINARY_DERIVED_TYPE_DECLARATION",
+ "ORDINARY_FIXED_POINT_DECLARATION",
+ "OR_ELSE",
+ "OR_SELECT_OPT",
+ "PARENTHESIZED_PRIMARY",
+ "PRIVATE_DECLARATIVE_ITEMS_OPT",
+ "PRIVATE_TASK_ITEMS_OPT",
+ "PROCEDURE_BODY",
+ "PROCEDURE_BODY_STUB",
+ "PROCEDURE_DECLARATION",
+ "PROCEDURE_RENAMING_DECLARATION",
+ "PROT_MEMBER_DECLARATIONS",
+ "PROT_OP_BODIES_OPT",
+ "PROT_OP_DECLARATIONS",
+ "PROT_PRIVATE_OPT",
+ "RANGED_EXPRS",
+ "RANGE_CONSTRAINT",
+ "RECORD_TYPE_DECLARATION",
+ "SELECTOR_NAMES_OPT",
+ "SIGNED_INTEGER_TYPE_DECLARATION",
+ "TASK_ITEMS_OPT",
+ "UNARY_MINUS",
+ "UNARY_PLUS",
+ "VALUE",
+ "VALUES",
+ "VARIANTS",
+ "COMMENT_INTRO",
+ "OX",
+ "TIC_OR_CHARACTER_LITERAL",
+ "DIGIT",
+ "EXPONENT",
+ "EXTENDED_DIGIT",
+ "BASED_INTEGER",
+ "WS_",
+ "COMMENT",
+ "CHARACTER_STRING",
+ 0
+};
+
+const unsigned long AdaTreeParserSuper::_tokenSet_0_data_[] = { 37920UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER RIGHT_SHAFT DOT TIC "in" CHARACTER_LITERAL CHAR_STRING "null"
+// "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR
+// DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT OPERATOR_SYMBOL
+// AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS UNARY_PLUS
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaTreeParserSuper::_tokenSet_0(_tokenSet_0_data_,20);
+const unsigned long AdaTreeParserSuper::_tokenSet_1_data_[] = { 939627552UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER RIGHT_SHAFT DOT TIC "range" "others" PIPE DOT_DOT "in" CHARACTER_LITERAL
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT
+// OPERATOR_SYMBOL AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS
+// UNARY_PLUS
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaTreeParserSuper::_tokenSet_1(_tokenSet_1_data_,20);
+const unsigned long AdaTreeParserSuper::_tokenSet_2_data_[] = { 0UL, 0UL, 0UL, 49152UL, 3338801504UL, 2353094950UL, 151076927UL, 2416967168UL, 328577UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENUMERATION_REPESENTATION_CLAUSE
+// EXCEPTION_DECLARATION EXCEPTION_RENAMING_DECLARATION GENERIC_PACKAGE_DECLARATION
+// INCOMPLETE_TYPE_DECLARATION NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION
+// PACKAGE_RENAMING_DECLARATION PACKAGE_SPECIFICATION PRIVATE_EXTENSION_DECLARATION
+// PRIVATE_TYPE_DECLARATION PROTECTED_TYPE_DECLARATION RECORD_REPRESENTATION_CLAUSE
+// SINGLE_PROTECTED_DECLARATION SINGLE_TASK_DECLARATION SUBTYPE_DECLARATION
+// TASK_TYPE_DECLARATION USE_CLAUSE USE_TYPE_CLAUSE ABSTRACT_FUNCTION_DECLARATION
+// ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION
+// ACCESS_TO_PROCEDURE_DECLARATION ARRAY_OBJECT_DECLARATION ARRAY_TYPE_DECLARATION
+// DECIMAL_FIXED_POINT_DECLARATION DERIVED_RECORD_EXTENSION ENUMERATION_TYPE_DECLARATION
+// FLOATING_POINT_DECLARATION FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION
+// GENERIC_FUNCTION_DECLARATION GENERIC_FUNCTION_INSTANTIATION GENERIC_FUNCTION_RENAMING
+// GENERIC_PACKAGE_INSTANTIATION GENERIC_PACKAGE_RENAMING GENERIC_PROCEDURE_DECLARATION
+// GENERIC_PROCEDURE_INSTANTIATION GENERIC_PROCEDURE_RENAMING MODULAR_TYPE_DECLARATION
+// ORDINARY_DERIVED_TYPE_DECLARATION ORDINARY_FIXED_POINT_DECLARATION PROCEDURE_BODY_STUB
+// PROCEDURE_DECLARATION PROCEDURE_RENAMING_DECLARATION RECORD_TYPE_DECLARATION
+// SIGNED_INTEGER_TYPE_DECLARATION
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaTreeParserSuper::_tokenSet_2(_tokenSet_2_data_,20);
+const unsigned long AdaTreeParserSuper::_tokenSet_3_data_[] = { 16UL, 0UL, 0UL, 49152UL, 40UL, 256UL, 0UL, 1024UL, 256UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENTRY_DECLARATION ENUMERATION_REPESENTATION_CLAUSE
+// RECORD_REPRESENTATION_CLAUSE FUNCTION_DECLARATION PROCEDURE_DECLARATION
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaTreeParserSuper::_tokenSet_3(_tokenSet_3_data_,20);
+const unsigned long AdaTreeParserSuper::_tokenSet_4_data_[] = { 36896UL, 0UL, 0UL, 0UL, 262144UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER DOT TIC INDEXED_COMPONENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaTreeParserSuper::_tokenSet_4(_tokenSet_4_data_,12);
+
+
diff --git a/languages/ada/AdaTreeParserSuper.hpp b/languages/ada/AdaTreeParserSuper.hpp
new file mode 100644
index 00000000..a4d164f0
--- /dev/null
+++ b/languages/ada/AdaTreeParserSuper.hpp
@@ -0,0 +1,241 @@
+#ifndef INC_AdaTreeParserSuper_hpp_
+#define INC_AdaTreeParserSuper_hpp_
+
+#include <antlr/config.hpp>
+#include "AdaTreeParserSuperTokenTypes.hpp"
+/* $ANTLR 2.7.7 (20070609): "ada.tree.g" -> "AdaTreeParserSuper.hpp"$ */
+#include <antlr/TreeParser.hpp>
+
+class CUSTOM_API AdaTreeParserSuper : public ANTLR_USE_NAMESPACE(antlr)TreeParser, public AdaTreeParserSuperTokenTypes
+{
+#line 1 "ada.tree.g"
+#line 13 "AdaTreeParserSuper.hpp"
+public:
+ AdaTreeParserSuper();
+ static void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
+ int getNumTokens() const
+ {
+ return AdaTreeParserSuper::NUM_TOKENS;
+ }
+ const char* getTokenName( int type ) const
+ {
+ if( type > getNumTokens() ) return 0;
+ return AdaTreeParserSuper::tokenNames[type];
+ }
+ const char* const* getTokenNames() const
+ {
+ return AdaTreeParserSuper::tokenNames;
+ }
+ public: void compilation_unit(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void context_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void library_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subunit(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void pragma(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void pragma_arg(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void expression(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void with_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void use_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void compound_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subtype_mark(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void attribute_id(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void modifiers(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subprog_decl_or_rename_or_inst_or_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void def_id(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void pkg_body_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void generic_inst(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void pkg_spec_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void renames(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void generic_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void id_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void def_designator(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void end_id_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subprog_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void formal_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void function_tail(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void value_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void value(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void ranged_expr_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void ranged_expr(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void simple_expression(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range_dots(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range_attrib_ref(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prefix(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void parameter_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void defining_identifier_list(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void init_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void definable_operator_symbol(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void parenthesized_primary(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void extension_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void spec_decl_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void basic_declarative_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void private_declarative_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void basic_decl_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void task_type_or_single_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_type_or_single_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void decl_common(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discrim_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void task_definition_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void task_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void private_task_items_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discriminant_specifications(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discriminant_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entrydecls_repspecs_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void rep_spec(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discrete_subtype_def_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discrete_subtype_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subtype_ind(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void align_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void comp_loc_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void local_enum_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void enumeration_aggregate(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void protected_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_private_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_member_decl_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_op_decl_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_op_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void comp_decl(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void component_subtype_def(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void enum_id_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range_constraint_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void array_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void access_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void id_and_discrim(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void record_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void array_type_definition(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void enumeration_literal_specification(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void index_or_discrete_range_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void index_or_discrete_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void constraint_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void digits_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void delta_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void index_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discriminant_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discrete_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discriminant_association(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void selector_names_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void selector_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void component_list(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void component_items(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void variant_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discriminant_direct_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void variant_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void variant(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void choice_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void choice(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void discrete_with_range(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void mark_with_constraint(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void generic_formal_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void generic_formal_parameter(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void formal_array_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void formal_access_type_declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void id_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subprogram_default_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void formal_package_actual_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void procedure_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void function_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void body_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void declarative_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void block_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void declarative_item(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void prot_op_bodies_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void block_body_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void handled_stmt_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subprog_decl_or_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void statements(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void except_handler_part_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void handled_stmts_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void def_label_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void null_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void exit_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void return_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void goto_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void delay_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void abort_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void raise_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void requeue_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void accept_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void select_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void if_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void case_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void loop_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void block(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void call_or_assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void cond_clause(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void elsifs_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void else_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void condition(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void alternative_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void case_statement_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void iteration_scheme_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void declare_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void label_name(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_body_formal_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_barrier(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_index_spec_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_call_stmt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_index_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void triggering_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void abortable_part(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void selective_accept(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void entry_call_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void delay_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void stmts_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void guard_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void select_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void or_select_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void accept_alternative(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void exception_handler(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void identifier_colon_opt(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void except_choice_s(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void exception_choice(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void operator_call(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void relation(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void range_or_mark(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void signed_term(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void term(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void factor(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void primary(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void name_or_qualified(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void allocator(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void subprogram_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void package_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void task_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+ public: void protected_body(ANTLR_USE_NAMESPACE(antlr)RefAST _t);
+public:
+ ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
+ {
+ return returnAST;
+ }
+
+protected:
+ ANTLR_USE_NAMESPACE(antlr)RefAST returnAST;
+ ANTLR_USE_NAMESPACE(antlr)RefAST _retTree;
+private:
+ static const char* tokenNames[];
+#ifndef NO_STATIC_CONSTS
+ static const int NUM_TOKENS = 291;
+#else
+ enum {
+ NUM_TOKENS = 291
+ };
+#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;
+};
+
+#endif /*INC_AdaTreeParserSuper_hpp_*/
diff --git a/languages/ada/AdaTreeParserSuperTokenTypes.hpp b/languages/ada/AdaTreeParserSuperTokenTypes.hpp
new file mode 100644
index 00000000..924b7415
--- /dev/null
+++ b/languages/ada/AdaTreeParserSuperTokenTypes.hpp
@@ -0,0 +1,307 @@
+#ifndef INC_AdaTreeParserSuperTokenTypes_hpp_
+#define INC_AdaTreeParserSuperTokenTypes_hpp_
+
+/* $ANTLR 2.7.7 (20070609): "ada.tree.g" -> "AdaTreeParserSuperTokenTypes.hpp"$ */
+
+#ifndef CUSTOM_API
+# define CUSTOM_API
+#endif
+
+#ifdef __cplusplus
+struct CUSTOM_API AdaTreeParserSuperTokenTypes {
+#endif
+ enum {
+ EOF_ = 1,
+ PRAGMA = 4,
+ IDENTIFIER = 5,
+ SEMI = 6,
+ LPAREN = 7,
+ COMMA = 8,
+ RPAREN = 9,
+ RIGHT_SHAFT = 10,
+ WITH = 11,
+ DOT = 12,
+ USE = 13,
+ TYPE = 14,
+ TIC = 15,
+ RANGE = 16,
+ DIGITS = 17,
+ DELTA = 18,
+ ACCESS = 19,
+ PRIVATE = 20,
+ PACKAGE = 21,
+ BODY = 22,
+ IS = 23,
+ PROCEDURE = 24,
+ FUNCTION = 25,
+ NEW = 26,
+ OTHERS = 27,
+ PIPE = 28,
+ DOT_DOT = 29,
+ ALL = 30,
+ COLON = 31,
+ IN = 32,
+ OUT = 33,
+ RENAMES = 34,
+ CHARACTER_LITERAL = 35,
+ CHAR_STRING = 36,
+ NuLL = 37,
+ RECORD = 38,
+ SEPARATE = 39,
+ ABSTRACT = 40,
+ RETURN = 41,
+ TASK = 42,
+ PROTECTED = 43,
+ BOX = 44,
+ ASSIGN = 45,
+ ENTRY = 46,
+ FOR = 47,
+ END = 48,
+ AT = 49,
+ MOD = 50,
+ SUBTYPE = 51,
+ EXCEPTION = 52,
+ CONSTANT = 53,
+ ARRAY = 54,
+ OF = 55,
+ ALIASED = 56,
+ CASE = 57,
+ WHEN = 58,
+ TAGGED = 59,
+ LIMITED = 60,
+ GENERIC = 61,
+ BEGIN = 62,
+ LT_LT = 63,
+ GT_GT = 64,
+ IF = 65,
+ THEN = 66,
+ ELSIF = 67,
+ ELSE = 68,
+ LOOP = 69,
+ WHILE = 70,
+ REVERSE = 71,
+ DECLARE = 72,
+ EXIT = 73,
+ GOTO = 74,
+ ACCEPT = 75,
+ DO = 76,
+ DELAY = 77,
+ UNTIL = 78,
+ SELECT = 79,
+ ABORT = 80,
+ OR = 81,
+ TERMINATE = 82,
+ RAISE = 83,
+ REQUEUE = 84,
+ AND = 85,
+ XOR = 86,
+ NOT = 87,
+ EQ = 88,
+ NE = 89,
+ LT_ = 90,
+ LE = 91,
+ GT = 92,
+ GE = 93,
+ PLUS = 94,
+ MINUS = 95,
+ CONCAT = 96,
+ STAR = 97,
+ DIV = 98,
+ REM = 99,
+ ABS = 100,
+ EXPON = 101,
+ NUMERIC_LIT = 102,
+ ABORTABLE_PART = 103,
+ ABORT_STATEMENT = 104,
+ ACCEPT_ALTERNATIVE = 105,
+ ACCEPT_STATEMENT = 106,
+ ALLOCATOR = 107,
+ ASSIGNMENT_STATEMENT = 108,
+ ASYNCHRONOUS_SELECT = 109,
+ ATTRIBUTE_DEFINITION_CLAUSE = 110,
+ AT_CLAUSE = 111,
+ BLOCK_STATEMENT = 112,
+ CASE_STATEMENT = 113,
+ CASE_STATEMENT_ALTERNATIVE = 114,
+ CODE_STATEMENT = 115,
+ COMPONENT_DECLARATION = 116,
+ CONDITIONAL_ENTRY_CALL = 117,
+ CONTEXT_CLAUSE = 118,
+ DECLARATIVE_PART = 119,
+ DEFINING_IDENTIFIER_LIST = 120,
+ DELAY_ALTERNATIVE = 121,
+ DELAY_STATEMENT = 122,
+ DELTA_CONSTRAINT = 123,
+ DIGITS_CONSTRAINT = 124,
+ DISCRIMINANT_ASSOCIATION = 125,
+ DISCRIMINANT_CONSTRAINT = 126,
+ DISCRIMINANT_SPECIFICATION = 127,
+ ENTRY_BODY = 128,
+ ENTRY_CALL_ALTERNATIVE = 129,
+ ENTRY_CALL_STATEMENT = 130,
+ ENTRY_DECLARATION = 131,
+ ENTRY_INDEX_SPECIFICATION = 132,
+ ENUMERATION_REPESENTATION_CLAUSE = 133,
+ EXCEPTION_DECLARATION = 134,
+ EXCEPTION_HANDLER = 135,
+ EXCEPTION_RENAMING_DECLARATION = 136,
+ EXIT_STATEMENT = 137,
+ FORMAL_PACKAGE_DECLARATION = 138,
+ GENERIC_FORMAL_PART = 139,
+ GENERIC_PACKAGE_DECLARATION = 140,
+ GOTO_STATEMENT = 141,
+ HANDLED_SEQUENCE_OF_STATEMENTS = 142,
+ HANDLED_STMTS_OPT = 143,
+ IF_STATEMENT = 144,
+ INCOMPLETE_TYPE_DECLARATION = 145,
+ INDEXED_COMPONENT = 146,
+ INDEX_CONSTRAINT = 147,
+ LIBRARY_ITEM = 148,
+ LOOP_STATEMENT = 149,
+ NAME = 150,
+ NULL_STATEMENT = 151,
+ NUMBER_DECLARATION = 152,
+ OBJECT_DECLARATION = 153,
+ OBJECT_RENAMING_DECLARATION = 154,
+ OPERATOR_SYMBOL = 155,
+ PACKAGE_BODY = 156,
+ PACKAGE_BODY_STUB = 157,
+ PACKAGE_RENAMING_DECLARATION = 158,
+ PACKAGE_SPECIFICATION = 159,
+ PARAMETER_SPECIFICATION = 160,
+ PRIVATE_EXTENSION_DECLARATION = 161,
+ PRIVATE_TYPE_DECLARATION = 162,
+ PROTECTED_BODY = 163,
+ PROTECTED_BODY_STUB = 164,
+ PROTECTED_TYPE_DECLARATION = 165,
+ RAISE_STATEMENT = 166,
+ RANGE_ATTRIBUTE_REFERENCE = 167,
+ RECORD_REPRESENTATION_CLAUSE = 168,
+ REQUEUE_STATEMENT = 169,
+ RETURN_STATEMENT = 170,
+ SELECTIVE_ACCEPT = 171,
+ SEQUENCE_OF_STATEMENTS = 172,
+ SINGLE_PROTECTED_DECLARATION = 173,
+ SINGLE_TASK_DECLARATION = 174,
+ STATEMENT = 175,
+ SUBTYPE_DECLARATION = 176,
+ SUBTYPE_INDICATION = 177,
+ SUBTYPE_MARK = 178,
+ SUBUNIT = 179,
+ TASK_BODY = 180,
+ TASK_BODY_STUB = 181,
+ TASK_TYPE_DECLARATION = 182,
+ TERMINATE_ALTERNATIVE = 183,
+ TIMED_ENTRY_CALL = 184,
+ TRIGGERING_ALTERNATIVE = 185,
+ USE_CLAUSE = 186,
+ USE_TYPE_CLAUSE = 187,
+ VARIANT = 188,
+ VARIANT_PART = 189,
+ WITH_CLAUSE = 190,
+ ABSTRACT_FUNCTION_DECLARATION = 191,
+ ABSTRACT_PROCEDURE_DECLARATION = 192,
+ ACCESS_TO_FUNCTION_DECLARATION = 193,
+ ACCESS_TO_OBJECT_DECLARATION = 194,
+ ACCESS_TO_PROCEDURE_DECLARATION = 195,
+ ARRAY_OBJECT_DECLARATION = 196,
+ ARRAY_TYPE_DECLARATION = 197,
+ AND_THEN = 198,
+ BASIC_DECLARATIVE_ITEMS_OPT = 199,
+ BLOCK_BODY = 200,
+ BLOCK_BODY_OPT = 201,
+ CALL_STATEMENT = 202,
+ COMPONENT_CLAUSES_OPT = 203,
+ COMPONENT_ITEMS = 204,
+ COND_CLAUSE = 205,
+ DECIMAL_FIXED_POINT_DECLARATION = 206,
+ DECLARE_OPT = 207,
+ DERIVED_RECORD_EXTENSION = 208,
+ DISCRETE_SUBTYPE_DEF_OPT = 209,
+ DISCRIMINANT_SPECIFICATIONS = 210,
+ DISCRIM_PART_OPT = 211,
+ ELSE_OPT = 212,
+ ELSIFS_OPT = 213,
+ END_ID_OPT = 214,
+ ENTRY_INDEX_OPT = 215,
+ ENUMERATION_TYPE_DECLARATION = 216,
+ EXCEPT_HANDLER_PART_OPT = 217,
+ EXTENSION_OPT = 218,
+ FLOATING_POINT_DECLARATION = 219,
+ FORMAL_DECIMAL_FIXED_POINT_DECLARATION = 220,
+ FORMAL_DISCRETE_TYPE_DECLARATION = 221,
+ FORMAL_FLOATING_POINT_DECLARATION = 222,
+ FORMAL_FUNCTION_DECLARATION = 223,
+ FORMAL_MODULAR_TYPE_DECLARATION = 224,
+ FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION = 225,
+ FORMAL_ORDINARY_FIXED_POINT_DECLARATION = 226,
+ FORMAL_PART_OPT = 227,
+ FORMAL_PRIVATE_EXTENSION_DECLARATION = 228,
+ FORMAL_PRIVATE_TYPE_DECLARATION = 229,
+ FORMAL_PROCEDURE_DECLARATION = 230,
+ FORMAL_SIGNED_INTEGER_TYPE_DECLARATION = 231,
+ FUNCTION_BODY = 232,
+ FUNCTION_BODY_STUB = 233,
+ FUNCTION_DECLARATION = 234,
+ FUNCTION_RENAMING_DECLARATION = 235,
+ GENERIC_FUNCTION_DECLARATION = 236,
+ GENERIC_FUNCTION_INSTANTIATION = 237,
+ GENERIC_FUNCTION_RENAMING = 238,
+ GENERIC_PACKAGE_INSTANTIATION = 239,
+ GENERIC_PACKAGE_RENAMING = 240,
+ GENERIC_PROCEDURE_DECLARATION = 241,
+ GENERIC_PROCEDURE_INSTANTIATION = 242,
+ GENERIC_PROCEDURE_RENAMING = 243,
+ GUARD_OPT = 244,
+ IDENTIFIER_COLON_OPT = 245,
+ ID_OPT = 246,
+ INIT_OPT = 247,
+ ITERATION_SCHEME_OPT = 248,
+ LABEL_OPT = 249,
+ MARK_WITH_CONSTRAINT = 250,
+ MODIFIERS = 251,
+ MODULAR_TYPE_DECLARATION = 252,
+ MOD_CLAUSE_OPT = 253,
+ NOT_IN = 254,
+ ORDINARY_DERIVED_TYPE_DECLARATION = 255,
+ ORDINARY_FIXED_POINT_DECLARATION = 256,
+ OR_ELSE = 257,
+ OR_SELECT_OPT = 258,
+ PARENTHESIZED_PRIMARY = 259,
+ PRIVATE_DECLARATIVE_ITEMS_OPT = 260,
+ PRIVATE_TASK_ITEMS_OPT = 261,
+ PROCEDURE_BODY = 262,
+ PROCEDURE_BODY_STUB = 263,
+ PROCEDURE_DECLARATION = 264,
+ PROCEDURE_RENAMING_DECLARATION = 265,
+ PROT_MEMBER_DECLARATIONS = 266,
+ PROT_OP_BODIES_OPT = 267,
+ PROT_OP_DECLARATIONS = 268,
+ PROT_PRIVATE_OPT = 269,
+ RANGED_EXPRS = 270,
+ RANGE_CONSTRAINT = 271,
+ RECORD_TYPE_DECLARATION = 272,
+ SELECTOR_NAMES_OPT = 273,
+ SIGNED_INTEGER_TYPE_DECLARATION = 274,
+ TASK_ITEMS_OPT = 275,
+ UNARY_MINUS = 276,
+ UNARY_PLUS = 277,
+ VALUE = 278,
+ VALUES = 279,
+ VARIANTS = 280,
+ COMMENT_INTRO = 281,
+ OX = 282,
+ TIC_OR_CHARACTER_LITERAL = 283,
+ DIGIT = 284,
+ EXPONENT = 285,
+ EXTENDED_DIGIT = 286,
+ BASED_INTEGER = 287,
+ WS_ = 288,
+ COMMENT = 289,
+ CHARACTER_STRING = 290,
+ NULL_TREE_LOOKAHEAD = 3
+ };
+#ifdef __cplusplus
+};
+#endif
+#endif /*INC_AdaTreeParserSuperTokenTypes_hpp_*/
diff --git a/languages/ada/AdaTreeParserSuperTokenTypes.txt b/languages/ada/AdaTreeParserSuperTokenTypes.txt
new file mode 100644
index 00000000..dfd0b0df
--- /dev/null
+++ b/languages/ada/AdaTreeParserSuperTokenTypes.txt
@@ -0,0 +1,289 @@
+// $ANTLR 2.7.7 (20070609): ada.tree.g -> AdaTreeParserSuperTokenTypes.txt$
+AdaTreeParserSuper // output token vocab name
+PRAGMA="pragma"=4
+IDENTIFIER=5
+SEMI=6
+LPAREN=7
+COMMA=8
+RPAREN=9
+RIGHT_SHAFT=10
+WITH="with"=11
+DOT=12
+USE="use"=13
+TYPE="type"=14
+TIC=15
+RANGE="range"=16
+DIGITS="digits"=17
+DELTA="delta"=18
+ACCESS="access"=19
+PRIVATE="private"=20
+PACKAGE="package"=21
+BODY="body"=22
+IS="is"=23
+PROCEDURE="procedure"=24
+FUNCTION="function"=25
+NEW="new"=26
+OTHERS="others"=27
+PIPE=28
+DOT_DOT=29
+ALL="all"=30
+COLON=31
+IN="in"=32
+OUT="out"=33
+RENAMES="renames"=34
+CHARACTER_LITERAL=35
+CHAR_STRING=36
+NuLL="null"=37
+RECORD="record"=38
+SEPARATE="separate"=39
+ABSTRACT="abstract"=40
+RETURN="return"=41
+TASK="task"=42
+PROTECTED="protected"=43
+BOX=44
+ASSIGN=45
+ENTRY="entry"=46
+FOR="for"=47
+END="end"=48
+AT="at"=49
+MOD="mod"=50
+SUBTYPE="subtype"=51
+EXCEPTION="exception"=52
+CONSTANT="constant"=53
+ARRAY="array"=54
+OF="of"=55
+ALIASED="aliased"=56
+CASE="case"=57
+WHEN="when"=58
+TAGGED="tagged"=59
+LIMITED="limited"=60
+GENERIC="generic"=61
+BEGIN="begin"=62
+LT_LT=63
+GT_GT=64
+IF="if"=65
+THEN="then"=66
+ELSIF="elsif"=67
+ELSE="else"=68
+LOOP="loop"=69
+WHILE="while"=70
+REVERSE="reverse"=71
+DECLARE="declare"=72
+EXIT="exit"=73
+GOTO="goto"=74
+ACCEPT="accept"=75
+DO="do"=76
+DELAY="delay"=77
+UNTIL="until"=78
+SELECT="select"=79
+ABORT="abort"=80
+OR="or"=81
+TERMINATE="terminate"=82
+RAISE="raise"=83
+REQUEUE="requeue"=84
+AND="and"=85
+XOR="xor"=86
+NOT="not"=87
+EQ=88
+NE=89
+LT_=90
+LE=91
+GT=92
+GE=93
+PLUS=94
+MINUS=95
+CONCAT=96
+STAR=97
+DIV=98
+REM="rem"=99
+ABS="abs"=100
+EXPON=101
+NUMERIC_LIT=102
+ABORTABLE_PART=103
+ABORT_STATEMENT=104
+ACCEPT_ALTERNATIVE=105
+ACCEPT_STATEMENT=106
+ALLOCATOR=107
+ASSIGNMENT_STATEMENT=108
+ASYNCHRONOUS_SELECT=109
+ATTRIBUTE_DEFINITION_CLAUSE=110
+AT_CLAUSE=111
+BLOCK_STATEMENT=112
+CASE_STATEMENT=113
+CASE_STATEMENT_ALTERNATIVE=114
+CODE_STATEMENT=115
+COMPONENT_DECLARATION=116
+CONDITIONAL_ENTRY_CALL=117
+CONTEXT_CLAUSE=118
+DECLARATIVE_PART=119
+DEFINING_IDENTIFIER_LIST=120
+DELAY_ALTERNATIVE=121
+DELAY_STATEMENT=122
+DELTA_CONSTRAINT=123
+DIGITS_CONSTRAINT=124
+DISCRIMINANT_ASSOCIATION=125
+DISCRIMINANT_CONSTRAINT=126
+DISCRIMINANT_SPECIFICATION=127
+ENTRY_BODY=128
+ENTRY_CALL_ALTERNATIVE=129
+ENTRY_CALL_STATEMENT=130
+ENTRY_DECLARATION=131
+ENTRY_INDEX_SPECIFICATION=132
+ENUMERATION_REPESENTATION_CLAUSE=133
+EXCEPTION_DECLARATION=134
+EXCEPTION_HANDLER=135
+EXCEPTION_RENAMING_DECLARATION=136
+EXIT_STATEMENT=137
+FORMAL_PACKAGE_DECLARATION=138
+GENERIC_FORMAL_PART=139
+GENERIC_PACKAGE_DECLARATION=140
+GOTO_STATEMENT=141
+HANDLED_SEQUENCE_OF_STATEMENTS=142
+HANDLED_STMTS_OPT=143
+IF_STATEMENT=144
+INCOMPLETE_TYPE_DECLARATION=145
+INDEXED_COMPONENT=146
+INDEX_CONSTRAINT=147
+LIBRARY_ITEM=148
+LOOP_STATEMENT=149
+NAME=150
+NULL_STATEMENT=151
+NUMBER_DECLARATION=152
+OBJECT_DECLARATION=153
+OBJECT_RENAMING_DECLARATION=154
+OPERATOR_SYMBOL=155
+PACKAGE_BODY=156
+PACKAGE_BODY_STUB=157
+PACKAGE_RENAMING_DECLARATION=158
+PACKAGE_SPECIFICATION=159
+PARAMETER_SPECIFICATION=160
+PRIVATE_EXTENSION_DECLARATION=161
+PRIVATE_TYPE_DECLARATION=162
+PROTECTED_BODY=163
+PROTECTED_BODY_STUB=164
+PROTECTED_TYPE_DECLARATION=165
+RAISE_STATEMENT=166
+RANGE_ATTRIBUTE_REFERENCE=167
+RECORD_REPRESENTATION_CLAUSE=168
+REQUEUE_STATEMENT=169
+RETURN_STATEMENT=170
+SELECTIVE_ACCEPT=171
+SEQUENCE_OF_STATEMENTS=172
+SINGLE_PROTECTED_DECLARATION=173
+SINGLE_TASK_DECLARATION=174
+STATEMENT=175
+SUBTYPE_DECLARATION=176
+SUBTYPE_INDICATION=177
+SUBTYPE_MARK=178
+SUBUNIT=179
+TASK_BODY=180
+TASK_BODY_STUB=181
+TASK_TYPE_DECLARATION=182
+TERMINATE_ALTERNATIVE=183
+TIMED_ENTRY_CALL=184
+TRIGGERING_ALTERNATIVE=185
+USE_CLAUSE=186
+USE_TYPE_CLAUSE=187
+VARIANT=188
+VARIANT_PART=189
+WITH_CLAUSE=190
+ABSTRACT_FUNCTION_DECLARATION=191
+ABSTRACT_PROCEDURE_DECLARATION=192
+ACCESS_TO_FUNCTION_DECLARATION=193
+ACCESS_TO_OBJECT_DECLARATION=194
+ACCESS_TO_PROCEDURE_DECLARATION=195
+ARRAY_OBJECT_DECLARATION=196
+ARRAY_TYPE_DECLARATION=197
+AND_THEN=198
+BASIC_DECLARATIVE_ITEMS_OPT=199
+BLOCK_BODY=200
+BLOCK_BODY_OPT=201
+CALL_STATEMENT=202
+COMPONENT_CLAUSES_OPT=203
+COMPONENT_ITEMS=204
+COND_CLAUSE=205
+DECIMAL_FIXED_POINT_DECLARATION=206
+DECLARE_OPT=207
+DERIVED_RECORD_EXTENSION=208
+DISCRETE_SUBTYPE_DEF_OPT=209
+DISCRIMINANT_SPECIFICATIONS=210
+DISCRIM_PART_OPT=211
+ELSE_OPT=212
+ELSIFS_OPT=213
+END_ID_OPT=214
+ENTRY_INDEX_OPT=215
+ENUMERATION_TYPE_DECLARATION=216
+EXCEPT_HANDLER_PART_OPT=217
+EXTENSION_OPT=218
+FLOATING_POINT_DECLARATION=219
+FORMAL_DECIMAL_FIXED_POINT_DECLARATION=220
+FORMAL_DISCRETE_TYPE_DECLARATION=221
+FORMAL_FLOATING_POINT_DECLARATION=222
+FORMAL_FUNCTION_DECLARATION=223
+FORMAL_MODULAR_TYPE_DECLARATION=224
+FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION=225
+FORMAL_ORDINARY_FIXED_POINT_DECLARATION=226
+FORMAL_PART_OPT=227
+FORMAL_PRIVATE_EXTENSION_DECLARATION=228
+FORMAL_PRIVATE_TYPE_DECLARATION=229
+FORMAL_PROCEDURE_DECLARATION=230
+FORMAL_SIGNED_INTEGER_TYPE_DECLARATION=231
+FUNCTION_BODY=232
+FUNCTION_BODY_STUB=233
+FUNCTION_DECLARATION=234
+FUNCTION_RENAMING_DECLARATION=235
+GENERIC_FUNCTION_DECLARATION=236
+GENERIC_FUNCTION_INSTANTIATION=237
+GENERIC_FUNCTION_RENAMING=238
+GENERIC_PACKAGE_INSTANTIATION=239
+GENERIC_PACKAGE_RENAMING=240
+GENERIC_PROCEDURE_DECLARATION=241
+GENERIC_PROCEDURE_INSTANTIATION=242
+GENERIC_PROCEDURE_RENAMING=243
+GUARD_OPT=244
+IDENTIFIER_COLON_OPT=245
+ID_OPT=246
+INIT_OPT=247
+ITERATION_SCHEME_OPT=248
+LABEL_OPT=249
+MARK_WITH_CONSTRAINT=250
+MODIFIERS=251
+MODULAR_TYPE_DECLARATION=252
+MOD_CLAUSE_OPT=253
+NOT_IN=254
+ORDINARY_DERIVED_TYPE_DECLARATION=255
+ORDINARY_FIXED_POINT_DECLARATION=256
+OR_ELSE=257
+OR_SELECT_OPT=258
+PARENTHESIZED_PRIMARY=259
+PRIVATE_DECLARATIVE_ITEMS_OPT=260
+PRIVATE_TASK_ITEMS_OPT=261
+PROCEDURE_BODY=262
+PROCEDURE_BODY_STUB=263
+PROCEDURE_DECLARATION=264
+PROCEDURE_RENAMING_DECLARATION=265
+PROT_MEMBER_DECLARATIONS=266
+PROT_OP_BODIES_OPT=267
+PROT_OP_DECLARATIONS=268
+PROT_PRIVATE_OPT=269
+RANGED_EXPRS=270
+RANGE_CONSTRAINT=271
+RECORD_TYPE_DECLARATION=272
+SELECTOR_NAMES_OPT=273
+SIGNED_INTEGER_TYPE_DECLARATION=274
+TASK_ITEMS_OPT=275
+UNARY_MINUS=276
+UNARY_PLUS=277
+VALUE=278
+VALUES=279
+VARIANTS=280
+COMMENT_INTRO=281
+OX=282
+TIC_OR_CHARACTER_LITERAL=283
+DIGIT=284
+EXPONENT=285
+EXTENDED_DIGIT=286
+BASED_INTEGER=287
+WS_=288
+COMMENT=289
+CHARACTER_STRING=290
diff --git a/languages/ada/Makefile.am b/languages/ada/Makefile.am
new file mode 100644
index 00000000..4a7eb0c1
--- /dev/null
+++ b/languages/ada/Makefile.am
@@ -0,0 +1,41 @@
+# Here resides the Ada support part.
+KDE_CXXFLAGS = $(USE_EXCEPTIONS)
+
+INCLUDES = -I$(top_srcdir)/lib/antlr -I$(top_srcdir)/lib/interfaces \
+ -I$(top_srcdir)/lib/interfaces/extensions -I$(top_srcdir)/lib/interfaces/external -I$(top_srcdir)/lib/util \
+ $(all_includes)
+SUBDIRS = app_templates file_templates doc
+
+
+kde_module_LTLIBRARIES = libkdevadasupport.la
+libkdevadasupport_la_LDFLAGS = $(LEXLIB) $(all_libraries) $(KDE_PLUGIN)
+libkdevadasupport_la_LIBADD = $(top_builddir)/lib/libkdevelop.la $(top_builddir)/lib/antlr/src/libantlr.la
+
+libkdevadasupport_la_SOURCES = adasupportpart.cpp problemreporter.cpp backgroundparser.cpp addclassdlg.ui addclass.cpp configproblemreporter.ui ada_utils.cpp adasupport.cpp AdaLexer.cpp AdaParser.cpp AdaTreeParserSuper.cpp AdaStoreWalker.cpp
+
+METASOURCES = AUTO
+
+EXTRA_DIST = ada.g ada.tree.g ada.store.g
+
+## The following three rules assume that you have Java installed,
+## ANTLR installed, and you have the antlr jar in your CLASSPATH.
+
+#AdaLexer.hpp AdaLexer.cpp AdaParser.hpp AdaParser.cpp: ada.g
+# antlr ada.g
+
+#AdaTreeParserSuper.hpp AdaTreeParserSuper.cpp: ada.tree.g
+# antlr ada.tree.g
+
+#AdaStoreWalker.hpp AdaStoreWalker.cpp: ada.store.g
+# antlr -glib ada.tree.g ada.store.g
+
+genparser:
+ antlr ada.g && antlr ada.tree.g && antlr -glib ada.tree.g ada.store.g
+
+servicedir = $(kde_servicesdir)
+service_DATA = kdevadasupport.desktop
+
+rcdir = $(kde_datadir)/kdevadasupport
+rc_DATA = kdevadasupport.rc
+
+KDE_OPTIONS = nofinal
diff --git a/languages/ada/README b/languages/ada/README
new file mode 100644
index 00000000..0146b60f
--- /dev/null
+++ b/languages/ada/README
@@ -0,0 +1 @@
+Please read the README.dox file. \ No newline at end of file
diff --git a/languages/ada/README.dox b/languages/ada/README.dox
new file mode 100644
index 00000000..e71e6d45
--- /dev/null
+++ b/languages/ada/README.dox
@@ -0,0 +1,31 @@
+/** \class AdaSupportPart
+Ada Language Support
+
+The ANTLR Ada core support files are:
+ - ada.g -- contains AdaLexer and AdaParser, requires AdaAST.hpp and adasupport.cpp
+ - ada.tree.g -- contains the AdaTreeParserSuper
+ - AdaAST.hpp -- definition of the AST node used by ada.g
+ - adasupport.hpp -- general purpose utilities
+ - adasupport.cpp -- implementation of general purpose utilities and implementation of AdaParser class methods from ada.g
+
+These are ANTLR master files.
+They only depend on the ANTLR C++ runtime support and on the C++ STL.
+They should be kept free of all other dependencies.
+In particular, they do not depend on Kdevelop, KDE, or Qt.
+
+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/CppCodeGenerator.java.gz</a>.
+
+\unmaintained This part is currently un-maintained.
+
+\authors <a href="mailto:okellogg AT users.sourceforge.net">Oliver Kellogg</a>
+\authors <a href="mailto:roberto AT kdevelop.org">Roberto Raggi</a>
+\authors <a href="mailto:cloudtemple AT mksat.net">Alexander Dymo</a>
+
+\feature Consult \ref LangSupportStatus for a up to date features/status of this programming language support part.
+
+\requirement Ada compiler
+
+*/
diff --git a/languages/ada/ada.g b/languages/ada/ada.g
new file mode 100644
index 00000000..5f97952b
--- /dev/null
+++ b/languages/ada/ada.g
@@ -0,0 +1,1982 @@
+/*
+ * Ada95 Grammar for ANTLR, target language C++
+ *
+ * Copyright (C) 2003 Oliver M. Kellogg <okellogg@users.sourceforge.net>
+ * Modifications (C) 2005 Daniel Zuberbuehler <dzubi@users.sourceforge.net>
+ *
+ * Adapted from lexer9x.l/grammar9x.y,
+ *
+ ******* A YACC grammar for Ada 9X *********************************
+ * Copyright (C) Intermetrics, Inc. 1994 Cambridge, MA USA *
+ * Copying permitted if accompanied by this statement. *
+ * Derivative works are permitted if accompanied by this statement.*
+ * This grammar is thought to be correct as of May 1, 1994 *
+ * but as usual there is *no warranty* to that effect. *
+ *******************************************************************
+ *
+ * $Id$
+ *
+ * Not all rules from the Ada95 Reference Manual (RM) Annex P,
+ * Syntax Summary, are mirrored as rules here.
+ * The tree nodes follow the RM grammar as closely as sensible.
+ * This applies in particular to the terminals. OTOH, trivially
+ * reconstructable non-terminal rules are not reflected in the tree.
+ * FIXME: Document the exact rationale of the tree design.
+ *
+ */
+
+
+header "pre_include_hpp" {
+#include <antlr/SemanticException.hpp> // antlr wants this
+#include "AdaAST.hpp"
+#include "preambles.h"
+}
+
+options {
+ language="Cpp";
+}
+
+//-----------------------------------------------------------------------------
+// Define a Parser, calling it AdaParser
+//-----------------------------------------------------------------------------
+class AdaParser extends Parser;
+options {
+ k = 2; // token lookahead
+ exportVocab=Ada; // Call its vocabulary "Ada"
+ // codeGenMakeSwitchThreshold = 2; // Some optimizations
+ // codeGenBitsetTestThreshold = 3;
+ defaultErrorHandler = false; // Generate parser error handlers
+ buildAST = true;
+ ASTLabelType = "RefAdaAST";
+}
+
+{
+ ANTLR_PARSER_PREAMBLE
+
+public:
+ // Ada support stuff
+ void push_def_id (const RefAdaAST& defid);
+ const RefAdaAST& pop_def_id ();
+ bool end_id_matches_def_id (const RefAdaAST& endid);
+ bool definable_operator (const char *string); // operator_symbol sans "/="
+ bool is_operator_symbol (const char *string);
+}
+
+// Compilation Unit: This is the start rule for this parser.
+// The rules in this grammar are listed in the order in which
+// compilation_unit introduces them, depth first, with the
+// exception of the expression related rules which are listed
+// towards the end.
+compilation_unit
+ : context_items_opt ( library_item | subunit ) ( pragma )*
+ ;
+
+// The pragma related rules are pulled up here to get them out of the way.
+
+pragma : PRAGMA^ IDENTIFIER pragma_args_opt SEMI!
+ ;
+
+pragma_args_opt : ( LPAREN! pragma_arg ( COMMA! pragma_arg )* RPAREN! )?
+ ;
+
+pragma_arg : ( IDENTIFIER RIGHT_SHAFT^ )? expression
+ ;
+
+context_items_opt : ( pragma | with_clause | use_clause )*
+ { #context_items_opt =
+ #(#[CONTEXT_CLAUSE, "CONTEXT_CLAUSE"], #context_items_opt); }
+ // RM Annex P neglects pragmas; we include them.
+ // The node should really be named CONTEXT_ITEMS_OPT but we
+ // stick with the RM wording.
+ ;
+
+with_clause : w:WITH^ c_name_list SEMI!
+ { Set(#w, WITH_CLAUSE); }
+ ;
+
+c_name_list : compound_name ( COMMA! compound_name )*
+ ;
+
+compound_name : IDENTIFIER ( DOT^ IDENTIFIER )*
+ // Strangely, the RM never defines this rule, which however is
+ // required for tightening up the syntax of certain names
+ // (library unit names etc.)
+ ;
+
+use_clause : u:USE^
+ ( TYPE! subtype_mark ( COMMA! subtype_mark )*
+ { Set(#u, USE_TYPE_CLAUSE); }
+ | c_name_list { Set(#u, USE_CLAUSE); }
+ )
+ SEMI!
+ ;
+
+subtype_mark : compound_name ( TIC^ attribute_id )?
+ // { #subtype_mark = #(#[SUBTYPE_MARK, "SUBTYPE_MARK"], #subtype_mark); }
+ ;
+
+attribute_id : RANGE
+ | DIGITS
+ | DELTA
+ | ACCESS
+ | IDENTIFIER
+ ;
+
+library_item : private_opt
+ /* Slightly loose; PRIVATE can only precede
+ {generic|package|subprog}_decl.
+ Semantic check required to ensure it.*/
+ ( lib_pkg_spec_or_body
+ | subprog_decl_or_rename_or_inst_or_body[true]
+ | generic_decl[true]
+ )
+ { #library_item = #(#[LIBRARY_ITEM, "LIBRARY_ITEM"], #library_item); }
+ ;
+
+private_opt : ( PRIVATE )?
+ { #private_opt = #(#[MODIFIERS, "MODIFIERS"], #private_opt); }
+ ;
+
+lib_pkg_spec_or_body
+ : pkg:PACKAGE^
+ ( BODY! def_id[true] IS! pkg_body_part SEMI!
+ { Set(#pkg, PACKAGE_BODY); }
+ | def_id[true] spec_decl_part[#pkg]
+ )
+ ;
+
+subprog_decl [boolean lib_level]
+ { RefAdaAST t; }
+ : p:PROCEDURE^ def_id[lib_level]
+ ( generic_subp_inst
+ { Set(#p, GENERIC_PROCEDURE_INSTANTIATION); }
+ | formal_part_opt
+ ( renames { Set(#p, PROCEDURE_RENAMING_DECLARATION); }
+ | is_separate_or_abstract_or_decl[#p]
+ )
+ SEMI!
+ )
+ | f:FUNCTION^ def_designator[lib_level]
+ ( generic_subp_inst
+ { Set(#f, GENERIC_FUNCTION_INSTANTIATION); }
+ | function_tail
+ ( renames { Set(#f, FUNCTION_RENAMING_DECLARATION); }
+ | is_separate_or_abstract_or_decl[#f]
+ )
+ SEMI!
+ )
+ ;
+
+def_id [boolean lib_level]
+ : { lib_level }? cn:compound_name { push_def_id(#cn); }
+ | { !lib_level }? n:IDENTIFIER { push_def_id(#n); }
+ ;
+
+generic_subp_inst : IS! generic_inst SEMI!
+ ;
+
+generic_inst : NEW! compound_name ( LPAREN! value_s RPAREN! )?
+ { pop_def_id(); }
+ ;
+
+parenth_values : LPAREN! value ( COMMA! value )* RPAREN!
+ ;
+
+value : ( OTHERS^ RIGHT_SHAFT! expression
+ | ranged_expr_s ( RIGHT_SHAFT^ expression )?
+ )
+ // { #value = #(#[VALUE, "VALUE"], #value); }
+ ;
+
+ranged_expr_s : ranged_expr ( PIPE^ ranged_expr )*
+ // { #ranged_expr_s =
+ // #(#[RANGED_EXPRS, "RANGED_EXPRS"], #ranged_expr_s); }
+ ;
+
+ranged_expr : expression
+ ( DOT_DOT^ simple_expression
+ | RANGE^ range
+ )?
+ ;
+
+range_constraint : r:RANGE^ range
+ { Set(#r, RANGE_CONSTRAINT); }
+ ;
+
+range : ( (range_dots) => range_dots
+ | range_attrib_ref
+ )
+ // Current assumption is we don't need an extra node for range,
+ // otherwise uncomment the following line:
+ // { #range = #(#[RANGE_EXPR, "RANGE_EXPR"], #range); }
+ ;
+
+range_dots : simple_expression DOT_DOT^ simple_expression
+ ;
+
+range_attrib_ref : // "name TIC RANGE" is ambiguous; instead:
+ prefix TIC! r:RANGE^ ( LPAREN! expression RPAREN! )?
+ { Set(#r, RANGE_ATTRIBUTE_REFERENCE); }
+ ;
+
+// Here, the definition of `prefix' deviates from the RM.
+// This gives us some more strictness than `name' (which the RM uses to
+// define `prefix'.)
+prefix : IDENTIFIER
+ ( DOT^ ( ALL | IDENTIFIER )
+ | p:LPAREN^ value_s RPAREN!
+ { Set(#p, INDEXED_COMPONENT); }
+ )*
+ ;
+
+formal_part_opt : ( LPAREN! parameter_specification
+ ( SEMI! parameter_specification )*
+ RPAREN! )?
+ { #formal_part_opt = #([FORMAL_PART_OPT, "FORMAL_PART_OPT"],
+ #formal_part_opt); }
+ ;
+
+parameter_specification : def_ids_colon mode_opt subtype_mark init_opt
+ { #parameter_specification =
+ #(#[PARAMETER_SPECIFICATION,
+ "PARAMETER_SPECIFICATION"], #parameter_specification); }
+ ;
+
+def_ids_colon : defining_identifier_list COLON!
+ ;
+
+defining_identifier_list : IDENTIFIER ( COMMA! IDENTIFIER )*
+ { #defining_identifier_list =
+ #(#[DEFINING_IDENTIFIER_LIST,
+ "DEFINING_IDENTIFIER_LIST"], #defining_identifier_list); }
+ ;
+
+mode_opt : ( IN ( OUT )? | OUT | ACCESS )?
+ { #mode_opt = #(#[MODIFIERS, "MODIFIERS"], #mode_opt); }
+ ;
+
+renames { RefAdaAST dummy; }
+ : RENAMES! ( name
+ | dummy=definable_operator_symbol
+ )
+ { pop_def_id(); }
+ ;
+
+name { RefAdaAST dummy; }
+ : IDENTIFIER
+ ( DOT^ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | dummy=is_operator
+ )
+ | p:LPAREN^ value_s RPAREN!
+ { Set(#p, INDEXED_COMPONENT); }
+ | TIC^ attribute_id // must be in here because of e.g.
+ // Character'Pos (x)
+ )*
+ // { #name = #(#[NAME, "NAME"], #name); }
+ ;
+
+is_operator returns [RefAdaAST d]
+ : { is_operator_symbol(LT(1)->getText().c_str()) }?
+ op:CHAR_STRING { #op->setType(OPERATOR_SYMBOL); d=#op; }
+ ;
+
+definable_operator_symbol returns [RefAdaAST d]
+ : { definable_operator(LT(1)->getText().c_str()) }?
+ op:CHAR_STRING { #op->setType(OPERATOR_SYMBOL); d=#op; }
+ ;
+
+parenthesized_primary : pp:LPAREN^
+ ( NuLL RECORD!
+ | value_s extension_opt
+ )
+ RPAREN!
+ { Set(#pp, PARENTHESIZED_PRIMARY); }
+ ;
+
+extension_opt : ( WITH! ( NuLL RECORD! | value_s ) )?
+ { #extension_opt =
+ #(#[EXTENSION_OPT, "EXTENSION_OPT"], #extension_opt); }
+ ;
+
+is_separate_or_abstract_or_decl! [RefAdaAST t]
+ : IS! separate_or_abstract[t]
+ | { pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, PROCEDURE_DECLARATION);
+ else
+ Set(t, FUNCTION_DECLARATION);
+ }
+ ;
+
+separate_or_abstract! [RefAdaAST t]
+ : SEPARATE!
+ { pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, PROCEDURE_BODY_STUB);
+ else
+ Set(t, FUNCTION_BODY_STUB);
+ }
+ | ABSTRACT!
+ { pop_def_id();
+ if (t->getType() == AdaTokenTypes::PROCEDURE)
+ Set(t, ABSTRACT_PROCEDURE_DECLARATION);
+ else
+ Set(t, ABSTRACT_FUNCTION_DECLARATION);
+ }
+ ;
+
+def_designator [boolean lib_level]
+ { RefAdaAST d; }
+ : { lib_level }? n:compound_name { push_def_id(#n); }
+ | { !lib_level }? d=designator { push_def_id(d); }
+ ;
+
+designator returns [RefAdaAST d]
+ { RefAdaAST op; }
+ : op=definable_operator_symbol { d = op; }
+ | n:IDENTIFIER { d = #n; }
+ ;
+
+function_tail : func_formal_part_opt RETURN! subtype_mark
+ ;
+
+// formal_part_opt is not strict enough for functions, i.e. it permits
+// "in out" and "out" as modes, thus we make an extra rule:
+func_formal_part_opt : ( LPAREN! func_param ( SEMI! func_param )* RPAREN! )?
+ { #func_formal_part_opt =
+ #([FORMAL_PART_OPT,
+ "FORMAL_PART_OPT"], #func_formal_part_opt); }
+ ;
+
+func_param : def_ids_colon in_access_opt subtype_mark init_opt
+ { #func_param =
+ #(#[PARAMETER_SPECIFICATION,
+ "PARAMETER_SPECIFICATION"], #func_param); }
+ ;
+
+in_access_opt : ( IN | ACCESS )?
+ { #in_access_opt = #(#[MODIFIERS, "MODIFIERS"], #in_access_opt); }
+ ;
+
+spec_decl_part [RefAdaAST pkg]
+ : ( IS! ( generic_inst { Set(pkg, GENERIC_PACKAGE_INSTANTIATION); }
+ | pkg_spec_part { Set(pkg, PACKAGE_SPECIFICATION); }
+ )
+ | renames { Set(pkg, PACKAGE_RENAMING_DECLARATION); }
+ )
+ SEMI!
+ ;
+
+pkg_spec_part : basic_declarative_items_opt
+ private_declarative_items_opt
+ end_id_opt
+ ;
+
+private_declarative_items_opt : ( PRIVATE! ( basic_decl_item | pragma )* )?
+ { #private_declarative_items_opt =
+ #(#[PRIVATE_DECLARATIVE_ITEMS_OPT,
+ "PRIVATE_DECLARATIVE_ITEMS_OPT"],
+ #private_declarative_items_opt); }
+ ;
+
+basic_declarative_items_opt : ( basic_decl_item | pragma )*
+ { #basic_declarative_items_opt =
+ #(#[BASIC_DECLARATIVE_ITEMS_OPT,
+ "BASIC_DECLARATIVE_ITEMS_OPT"],
+ #basic_declarative_items_opt); }
+ ;
+
+basic_declarative_items : ( basic_decl_item | pragma )+
+ { #basic_declarative_items =
+ #(#[BASIC_DECLARATIVE_ITEMS_OPT,
+ "BASIC_DECLARATIVE_ITEMS_OPT"],
+ #basic_declarative_items); }
+ ;
+
+basic_decl_item
+ : pkg:PACKAGE^ def_id[false] spec_decl_part[#pkg]
+ | tsk:TASK^ task_type_or_single_decl[#tsk]
+ | pro:PROTECTED^ prot_type_or_single_decl[#pro] SEMI!
+ | subprog_decl[false]
+ | decl_common
+ ;
+
+task_type_or_single_decl [RefAdaAST tsk]
+ : TYPE! def_id[false] discrim_part_opt task_definition_opt
+ { Set(tsk, TASK_TYPE_DECLARATION); }
+ | def_id[false] task_definition_opt
+ { Set(tsk, SINGLE_TASK_DECLARATION); }
+ ;
+
+task_definition_opt
+ : IS! task_items_opt private_task_items_opt end_id_opt SEMI!
+ | SEMI! { pop_def_id(); }
+ ;
+
+discrim_part_opt
+ : ( discrim_part_text )?
+ { #discrim_part_opt =
+ #(#[DISCRIM_PART_OPT,
+ "DISCRIM_PART_OPT"], #discrim_part_opt); }
+ ;
+
+discrim_part_text : LPAREN! (BOX | discriminant_specifications) RPAREN!
+ ;
+
+known_discrim_part
+ : LPAREN! discriminant_specifications RPAREN!
+ { #known_discrim_part =
+ #(#[DISCRIM_PART_OPT,
+ "DISCRIM_PART_OPT"], #known_discrim_part); }
+ ;
+
+empty_discrim_opt : /* empty */
+ { #empty_discrim_opt =
+ #(#[DISCRIM_PART_OPT,
+ "DISCRIM_PART_OPT"], #empty_discrim_opt); }
+ ;
+
+discrim_part
+ : discrim_part_text
+ { #discrim_part =
+ #(#[DISCRIM_PART_OPT,
+ "DISCRIM_PART_OPT"], #discrim_part); }
+ ;
+
+discriminant_specifications : discriminant_specification
+ ( SEMI! discriminant_specification )*
+ { #discriminant_specifications =
+ #(#[DISCRIMINANT_SPECIFICATIONS,
+ "DISCRIMINANT_SPECIFICATIONS"],
+ #discriminant_specifications); }
+ ;
+
+discriminant_specification : def_ids_colon access_opt subtype_mark init_opt
+ { #discriminant_specification =
+ #(#[DISCRIMINANT_SPECIFICATION,
+ "DISCRIMINANT_SPECIFICATION"],
+ #discriminant_specification); }
+ ;
+
+access_opt : ( ACCESS )?
+ { #access_opt = #(#[MODIFIERS, "MODIFIERS"], #access_opt); }
+ ;
+
+init_opt : ( ASSIGN! expression )?
+ { #init_opt = #(#[INIT_OPT, "INIT_OPT"], #init_opt); }
+ ; // `expression' is of course much too loose;
+ // semantic checks are required in the usage contexts.
+
+task_items_opt : ( pragma )* entrydecls_repspecs_opt
+ { #task_items_opt =
+ #(#[TASK_ITEMS_OPT, "TASK_ITEMS_OPT"], #task_items_opt); }
+ ;
+
+entrydecls_repspecs_opt : ( entry_declaration ( pragma | rep_spec )* )*
+ ;
+
+entry_declaration : e:ENTRY^ IDENTIFIER
+ discrete_subtype_def_opt formal_part_opt SEMI!
+ { Set (#e, ENTRY_DECLARATION); }
+ ;
+
+discrete_subtype_def_opt : ( (LPAREN discrete_subtype_definition RPAREN) =>
+ LPAREN! discrete_subtype_definition RPAREN!
+ | /* empty */
+ )
+ { #discrete_subtype_def_opt =
+ #(#[DISCRETE_SUBTYPE_DEF_OPT,
+ "DISCRETE_SUBTYPE_DEF_OPT"], #discrete_subtype_def_opt); }
+ ;
+
+discrete_subtype_definition : ( (range) => range
+ | subtype_ind
+ )
+ // Looks alot like discrete_range, but it's not
+ // (as soon as we start doing semantics.)
+ /* TBC: No need for extra node, just use the inner nodes?
+ { #discrete_subtype_definition =
+ #(#[DISCRETE_SUBTYPE_DEFINITION,
+ "DISCRETE_SUBTYPE_DEFINITION"],
+ #discrete_subtype_definition); }
+ */
+ ;
+
+rep_spec : r:FOR^ subtype_mark USE! rep_spec_part[#r] SEMI!
+ ;
+
+rep_spec_part [RefAdaAST t]
+ : RECORD! align_opt comp_loc_s END! RECORD! // record_type_spec
+ { Set(t, RECORD_REPRESENTATION_CLAUSE); }
+ | AT! expression // address_spec (Ada83)
+ { Set(t, AT_CLAUSE); }
+ | expression // attrib_def. Semantic check must ensure that the
+ // respective subtype_mark contains an attribute reference.
+ { Set(t, ATTRIBUTE_DEFINITION_CLAUSE); }
+ ;
+
+align_opt : ( AT! MOD! expression SEMI! )?
+ { #align_opt = #(#[MOD_CLAUSE_OPT, "MOD_CLAUSE_OPT"], #align_opt); }
+ ;
+
+comp_loc_s : ( pragma | subtype_mark AT! expression RANGE! range SEMI! )*
+ { #comp_loc_s = #(#[COMPONENT_CLAUSES_OPT, "COMPONENT_CLAUSES_OPT"],
+ #comp_loc_s); }
+ ;
+
+private_task_items_opt : ( PRIVATE! ( pragma )* entrydecls_repspecs_opt )?
+ { #private_task_items_opt =
+ #(#[PRIVATE_TASK_ITEMS_OPT,
+ "PRIVATE_TASK_ITEMS_OPT"], #private_task_items_opt); }
+ // Maybe we could just reuse TASK_ITEMS_OPT here instead of
+ // making a separate node type.
+ ;
+
+prot_type_or_single_decl [RefAdaAST pro]
+ : TYPE! def_id[false] discrim_part_opt protected_definition
+ { Set(pro, PROTECTED_TYPE_DECLARATION); }
+ | def_id[false] protected_definition
+ { Set(pro, SINGLE_PROTECTED_DECLARATION); }
+ ;
+
+prot_private_opt : ( PRIVATE! ( prot_op_decl | comp_decl )* )?
+ { #prot_private_opt =
+ #(#[PROT_PRIVATE_OPT,
+ "PROT_PRIVATE_OPT"], #prot_private_opt); }
+ ;
+
+protected_definition
+ : IS! prot_op_decl_s prot_private_opt end_id_opt
+ ;
+
+prot_op_decl_s : ( prot_op_decl )*
+ { #prot_op_decl_s = #(#[PROT_OP_DECLARATIONS,
+ "PROT_OP_DECLARATIONS"], #prot_op_decl_s); }
+ ;
+
+prot_op_decl : entry_declaration
+ | p:PROCEDURE^ def_id[false] formal_part_opt SEMI!
+ { pop_def_id(); Set(#p, PROCEDURE_DECLARATION); }
+ | f:FUNCTION^ def_designator[false] function_tail SEMI!
+ { pop_def_id(); Set(#f, FUNCTION_DECLARATION); }
+ | rep_spec
+ | pragma
+ ;
+
+prot_member_decl_s : ( prot_op_decl | comp_decl )*
+ { #prot_member_decl_s =
+ #(#[PROT_MEMBER_DECLARATIONS,
+ "PROT_MEMBER_DECLARATIONS"], #prot_member_decl_s); }
+ ;
+
+comp_decl : def_ids_colon component_subtype_def init_opt SEMI!
+ { #comp_decl =
+ #(#[COMPONENT_DECLARATION,
+ "COMPONENT_DECLARATION"], #comp_decl); }
+ ;
+
+// decl_common is shared between declarative_item and basic_decl_item.
+// decl_common only contains specifications.
+decl_common
+ : t:TYPE^ IDENTIFIER
+ ( IS! type_def[#t]
+ | ( discrim_part
+ ( IS! derived_or_private_or_record[#t, true]
+ | { Set(#t, INCOMPLETE_TYPE_DECLARATION); }
+ )
+ | empty_discrim_opt
+ { Set(#t, INCOMPLETE_TYPE_DECLARATION); }
+ // NB: In this case, the discrim_part_opt does not
+ // appear in the INCOMPLETE_TYPE_DECLARATION node.
+ )
+ /* The artificial derived_or_private_or_record rule
+ gives us some syntax-level control over where a
+ discrim_part may appear.
+ However, a semantic check is still necessary to make
+ sure the discrim_part is not given for a derived type
+ of an elementary type, or for the full view of a
+ private type that turns out to be such. */
+ )
+ SEMI!
+ | s:SUBTYPE^ IDENTIFIER IS! subtype_ind SEMI! // subtype_decl
+ { Set(#s, SUBTYPE_DECLARATION); }
+ | generic_decl[false]
+ | use_clause
+ | r:FOR^ ( (local_enum_name USE LPAREN) => local_enum_name USE!
+ enumeration_aggregate
+ { Set(#r, ENUMERATION_REPESENTATION_CLAUSE); }
+ | subtype_mark USE! rep_spec_part[#r]
+ )
+ SEMI!
+ | (IDENTIFIER COLON EXCEPTION RENAMES) =>
+ IDENTIFIER erd:COLON^ EXCEPTION! RENAMES! compound_name SEMI!
+ { Set(#erd, EXCEPTION_RENAMING_DECLARATION); }
+ | (IDENTIFIER COLON subtype_mark RENAMES) =>
+ IDENTIFIER ord:COLON^ subtype_mark RENAMES! name SEMI!
+ { Set(#ord, OBJECT_RENAMING_DECLARATION); }
+ | defining_identifier_list od:COLON^ // object_declaration
+ ( EXCEPTION!
+ { Set(#od, EXCEPTION_DECLARATION); }
+ | (CONSTANT ASSIGN) => CONSTANT! ASSIGN! expression
+ { Set(#od, NUMBER_DECLARATION); }
+ | aliased_constant_opt
+ ( array_type_definition[#od] init_opt
+ { Set(#od, ARRAY_OBJECT_DECLARATION); }
+ // Not an RM rule, but simplifies distinction
+ // from the non-array object_declaration.
+ | subtype_ind init_opt
+ { Set(#od, OBJECT_DECLARATION); }
+ )
+ )
+ SEMI!
+ ;
+
+type_def [RefAdaAST t]
+ : LPAREN! enum_id_s RPAREN!
+ { Set(t, ENUMERATION_TYPE_DECLARATION); }
+ | RANGE! range
+ { Set(t, SIGNED_INTEGER_TYPE_DECLARATION); }
+ | MOD! expression
+ { Set(t, MODULAR_TYPE_DECLARATION); }
+ | DIGITS! expression range_constraint_opt
+ { Set(t, FLOATING_POINT_DECLARATION); }
+ | DELTA! expression
+ ( RANGE! range
+ { Set(t, ORDINARY_FIXED_POINT_DECLARATION); }
+ | DIGITS! expression range_constraint_opt
+ { Set(t, DECIMAL_FIXED_POINT_DECLARATION); }
+ )
+ | array_type_definition[t]
+ | access_type_definition[t]
+ | empty_discrim_opt derived_or_private_or_record[t, false]
+ ;
+
+enum_id_s : enumeration_literal_specification
+ ( COMMA! enumeration_literal_specification )*
+ ;
+
+enumeration_literal_specification : IDENTIFIER | CHARACTER_LITERAL
+ ;
+
+range_constraint_opt : ( range_constraint )?
+ ;
+
+array_type_definition [RefAdaAST t]
+ : ARRAY! LPAREN! index_or_discrete_range_s RPAREN!
+ OF! component_subtype_def
+ { Set(t, ARRAY_TYPE_DECLARATION); }
+ ;
+
+index_or_discrete_range_s
+ : index_or_discrete_range ( COMMA^ index_or_discrete_range )*
+ ;
+
+index_or_discrete_range
+ : simple_expression
+ ( DOT_DOT^ simple_expression // constrained
+ | RANGE^ ( BOX // unconstrained
+ | range // constrained
+ )
+ )?
+ ;
+
+component_subtype_def : aliased_opt subtype_ind
+ ;
+
+aliased_opt : ( ALIASED )?
+ { #aliased_opt = #(#[MODIFIERS, "MODIFIERS"], #aliased_opt); }
+ ;
+
+subtype_ind : subtype_mark constraint_opt
+ { #subtype_ind = #(#[SUBTYPE_INDICATION, "SUBTYPE_INDICATION"],
+ #subtype_ind); }
+ ;
+
+constraint_opt : ( range_constraint
+ | digits_constraint
+ | delta_constraint
+ | (index_constraint) => index_constraint
+ | discriminant_constraint
+ )?
+ ;
+
+digits_constraint : d:DIGITS^ expression range_constraint_opt
+ { Set(#d, DIGITS_CONSTRAINT); }
+ ;
+
+delta_constraint : d:DELTA^ expression range_constraint_opt
+ { Set(#d, DELTA_CONSTRAINT); }
+ ;
+
+index_constraint : p:LPAREN^ discrete_range ( COMMA! discrete_range )* RPAREN!
+ { Set(#p, INDEX_CONSTRAINT); }
+ ;
+
+discrete_range
+ : (range) => range
+ | subtype_ind
+ ;
+
+discriminant_constraint : p:LPAREN^ discriminant_association
+ ( COMMA! discriminant_association )* RPAREN!
+ { Set(#p, DISCRIMINANT_CONSTRAINT); }
+ ;
+
+discriminant_association : selector_names_opt expression
+ { #discriminant_association =
+ #(#[DISCRIMINANT_ASSOCIATION,
+ "DISCRIMINANT_ASSOCIATION"], #discriminant_association); }
+ ;
+
+selector_names_opt : ( (association_head) => association_head
+ | /* empty */
+ )
+ { #selector_names_opt =
+ #(#[SELECTOR_NAMES_OPT,
+ "SELECTOR_NAMES_OPT"], #selector_names_opt); }
+ ;
+
+association_head : selector_name ( PIPE! selector_name )* RIGHT_SHAFT!
+ ;
+
+selector_name : IDENTIFIER // TBD: sem pred
+ ;
+
+access_type_definition [RefAdaAST t]
+ : ACCESS!
+ ( protected_opt
+ ( PROCEDURE! formal_part_opt
+ { Set(t, ACCESS_TO_PROCEDURE_DECLARATION); }
+ | FUNCTION! func_formal_part_opt RETURN! subtype_mark
+ { Set(t, ACCESS_TO_FUNCTION_DECLARATION); }
+ )
+ | constant_all_opt subtype_ind
+ { Set(t, ACCESS_TO_OBJECT_DECLARATION); }
+ )
+ ;
+
+protected_opt : ( PROTECTED )?
+ { #protected_opt = #(#[MODIFIERS, "MODIFIERS"], #protected_opt); }
+ ;
+
+constant_all_opt : ( CONSTANT | ALL )?
+ { #constant_all_opt =
+ #(#[MODIFIERS, "MODIFIERS"], #constant_all_opt); }
+ ;
+
+derived_or_private_or_record [RefAdaAST t, boolean has_discrim]
+ : ( ( ABSTRACT )? NEW subtype_ind WITH ) =>
+ abstract_opt NEW! subtype_ind WITH!
+ ( PRIVATE! { Set(t, PRIVATE_EXTENSION_DECLARATION); }
+ | record_definition[has_discrim]
+ { Set(t, DERIVED_RECORD_EXTENSION); }
+ )
+ | NEW! subtype_ind { Set(t, ORDINARY_DERIVED_TYPE_DECLARATION); }
+ | abstract_tagged_limited_opt
+ ( PRIVATE! { Set(t, PRIVATE_TYPE_DECLARATION); }
+ | record_definition[has_discrim]
+ { Set(t, RECORD_TYPE_DECLARATION); }
+ )
+ ;
+
+abstract_opt : ( ABSTRACT )?
+ { #abstract_opt = #(#[MODIFIERS, "MODIFIERS"], #abstract_opt); }
+ ;
+
+record_definition [boolean has_discrim]
+ : RECORD! component_list[has_discrim] END! RECORD!
+ | NuLL! RECORD! // Thus the component_list is optional in the tree.
+ ;
+
+component_list [boolean has_discrim]
+ : NuLL! SEMI! // Thus the component_list is optional in the tree.
+ | component_items ( variant_part { has_discrim }? )?
+ | empty_component_items variant_part { has_discrim }?
+ ;
+
+component_items : ( pragma | comp_decl )+
+ { #component_items =
+ #(#[COMPONENT_ITEMS,
+ "COMPONENT_ITEMS"], #component_items); }
+ ;
+
+empty_component_items :
+ { #empty_component_items =
+ #(#[COMPONENT_ITEMS,
+ "COMPONENT_ITEMS"], #empty_component_items); }
+ ;
+
+variant_part : c:CASE^ discriminant_direct_name IS! variant_s END! CASE! SEMI!
+ { Set (#c, VARIANT_PART); }
+ ;
+
+discriminant_direct_name : IDENTIFIER // TBD: symtab lookup.
+ ;
+
+variant_s : ( variant )+
+ { #variant_s = #(#[VARIANTS, "VARIANTS"], #variant_s); }
+ ;
+
+variant : w:WHEN^ choice_s RIGHT_SHAFT! component_list[true]
+ { Set (#w, VARIANT); }
+ ;
+
+choice_s : choice ( PIPE^ choice )*
+ ;
+
+choice : OTHERS
+ | (discrete_with_range) => discrete_with_range
+ | expression // ( DOT_DOT^ simple_expression )?
+ ; // No, that's already in discrete_with_range
+
+discrete_with_range : (mark_with_constraint) => mark_with_constraint
+ | range
+ ;
+
+mark_with_constraint : subtype_mark range_constraint
+ { #mark_with_constraint =
+ #(#[MARK_WITH_CONSTRAINT,
+ "MARK_WITH_CONSTRAINT"], #mark_with_constraint); }
+ ;
+
+abstract_tagged_limited_opt
+ : ( ABSTRACT TAGGED! | TAGGED )?
+ ( LIMITED )?
+ { #abstract_tagged_limited_opt =
+ #(#[MODIFIERS, "MODIFIERS"], #abstract_tagged_limited_opt); }
+ ;
+
+local_enum_name : IDENTIFIER // to be refined: do a symbol table lookup
+ ;
+
+enumeration_aggregate : parenth_values
+ ;
+
+aliased_constant_opt : ( ALIASED )? ( CONSTANT )?
+ { #aliased_constant_opt =
+ #(#[MODIFIERS, "MODIFIERS"], #aliased_constant_opt); }
+ ;
+
+generic_decl [boolean lib_level]
+ : g:GENERIC^ generic_formal_part_opt
+ ( PACKAGE! def_id[lib_level]
+ ( renames { Set(#g, GENERIC_PACKAGE_RENAMING); }
+ | IS! pkg_spec_part { Set(#g, GENERIC_PACKAGE_DECLARATION); }
+ )
+ | PROCEDURE! def_id[lib_level] formal_part_opt
+ ( renames { Set(#g, GENERIC_PROCEDURE_RENAMING); }
+ // ^^^ Semantic check must ensure that the (generic_formal)*
+ // after GENERIC is not given here.
+ | { Set(#g, GENERIC_PROCEDURE_DECLARATION); pop_def_id(); }
+ )
+ | FUNCTION! def_designator[lib_level] function_tail
+ ( renames { Set(#g, GENERIC_FUNCTION_RENAMING); }
+ // ^^^ Semantic check must ensure that the (generic_formal)*
+ // after GENERIC is not given here.
+ | { Set(#g, GENERIC_FUNCTION_DECLARATION); pop_def_id(); }
+ )
+ )
+ SEMI!
+ ;
+
+generic_formal_part_opt : ( use_clause | pragma | generic_formal_parameter )*
+ { #generic_formal_part_opt =
+ #(#[GENERIC_FORMAL_PART,
+ "GENERIC_FORMAL_PART"],
+ #generic_formal_part_opt); }
+ ;
+
+generic_formal_parameter :
+ ( t:TYPE^ def_id[false]
+ ( IS!
+ ( LPAREN! BOX! RPAREN!
+ { Set (#t, FORMAL_DISCRETE_TYPE_DECLARATION); }
+ | RANGE! BOX!
+ { Set (#t, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION); }
+ | MOD! BOX!
+ { Set (#t, FORMAL_MODULAR_TYPE_DECLARATION); }
+ | DELTA! BOX!
+ ( DIGITS! BOX!
+ { Set (#t, FORMAL_DECIMAL_FIXED_POINT_DECLARATION); }
+ | { Set (#t, FORMAL_ORDINARY_FIXED_POINT_DECLARATION); }
+ )
+ | DIGITS! BOX!
+ { Set (#t, FORMAL_FLOATING_POINT_DECLARATION); }
+ | array_type_definition[#t]
+ | access_type_definition[#t]
+ | empty_discrim_opt discriminable_type_definition[#t]
+ )
+ | discrim_part IS! discriminable_type_definition[#t]
+ )
+ { pop_def_id(); }
+ | w:WITH^ ( PROCEDURE! def_id[false] formal_part_opt subprogram_default_opt
+ { Set(#w, FORMAL_PROCEDURE_DECLARATION); }
+ | FUNCTION! def_designator[false] function_tail subprogram_default_opt
+ { Set(#w, FORMAL_FUNCTION_DECLARATION); }
+ | PACKAGE! def_id[false] IS! NEW! compound_name formal_package_actual_part_opt
+ { Set(#w, FORMAL_PACKAGE_DECLARATION); }
+ )
+ { pop_def_id(); }
+ | parameter_specification
+ )
+ SEMI!
+ ;
+
+discriminable_type_definition [RefAdaAST t]
+ : ( ( ABSTRACT )? NEW subtype_ind WITH ) =>
+ abstract_opt NEW! subtype_ind WITH! PRIVATE!
+ { Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION); }
+ | NEW! subtype_ind
+ { Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION); }
+ | abstract_tagged_limited_opt PRIVATE!
+ { Set (t, FORMAL_PRIVATE_TYPE_DECLARATION); }
+ ;
+
+subprogram_default_opt : ( IS! ( BOX | name ) )?
+ ;
+
+formal_package_actual_part_opt
+ : ( LPAREN! ( BOX | defining_identifier_list ) RPAREN! )?
+ ;
+
+subprog_decl_or_rename_or_inst_or_body [boolean lib_level]
+ { RefAdaAST t; }
+ : p:PROCEDURE^ def_id[lib_level]
+ ( generic_subp_inst
+ { Set(#p, GENERIC_PROCEDURE_INSTANTIATION); }
+ | formal_part_opt
+ ( renames { Set(#p, PROCEDURE_RENAMING_DECLARATION); }
+ | IS! ( separate_or_abstract[#p]
+ | body_part { Set(#p, PROCEDURE_BODY); }
+ )
+ | { pop_def_id();
+ Set(#p, PROCEDURE_DECLARATION); }
+ )
+ SEMI!
+ )
+ | f:FUNCTION^ def_designator[lib_level]
+ ( generic_subp_inst
+ { Set(#f, GENERIC_FUNCTION_INSTANTIATION); }
+ | function_tail
+ ( renames { Set(#f, FUNCTION_RENAMING_DECLARATION); }
+ | IS! ( separate_or_abstract[#f]
+ | body_part { Set(#f, FUNCTION_BODY); }
+ )
+ | { pop_def_id();
+ Set(#f, FUNCTION_DECLARATION); }
+ )
+ SEMI!
+ )
+ ;
+
+body_part : declarative_part block_body end_id_opt
+ ;
+
+declarative_part : ( pragma | declarative_item )*
+ { #declarative_part =
+ #(#[DECLARATIVE_PART, "DECLARATIVE_PART"],
+ #declarative_part); }
+ ;
+
+// A declarative_item may appear in the declarative part of any body.
+declarative_item :
+ ( pkg:PACKAGE^ ( body_is
+ ( separate { Set(#pkg, PACKAGE_BODY_STUB); }
+ | pkg_body_part
+ { Set(#pkg, PACKAGE_BODY); }
+ )
+ SEMI!
+ | def_id[false] spec_decl_part[#pkg]
+ )
+ | tsk:TASK^ ( body_is
+ ( separate { Set(#tsk, TASK_BODY_STUB); }
+ | body_part { Set(#tsk, TASK_BODY); }
+ )
+ SEMI!
+ | task_type_or_single_decl[#tsk]
+ )
+ | pro:PROTECTED^
+ ( body_is
+ ( separate { Set(#pro, PROTECTED_BODY_STUB); }
+ | prot_op_bodies_opt end_id_opt
+ { Set(#pro, PROTECTED_BODY); }
+ )
+ | prot_type_or_single_decl[#pro]
+ )
+ SEMI!
+ | subprog_decl_or_rename_or_inst_or_body[false]
+ | decl_common
+ )
+ /* DECLARATIVE_ITEM is just a pass-thru node so we omit it.
+ Objections anybody?
+ { #declarative_item =
+ #(#[DECLARATIVE_ITEM,
+ "DECLARATIVE_ITEM"], #declarative_item); }
+ */
+ ;
+
+body_is : BODY! def_id[false] IS!
+ ;
+
+separate : SEPARATE! { pop_def_id(); }
+ ;
+
+pkg_body_part : declarative_part block_body_opt end_id_opt
+ ;
+
+block_body_opt : ( BEGIN! handled_stmt_s )?
+ { #block_body_opt =
+ #(#[BLOCK_BODY_OPT,
+ "BLOCK_BODY_OPT"], #block_body_opt); }
+ ;
+
+prot_op_bodies_opt : ( entry_body
+ | subprog_decl_or_body
+ | pragma
+ )*
+ { #prot_op_bodies_opt =
+ #(#[PROT_OP_BODIES_OPT,
+ "PROT_OP_BODIES_OPT"], #prot_op_bodies_opt); }
+ ;
+
+subprog_decl_or_body
+ : p:PROCEDURE^ def_id[false] formal_part_opt
+ ( IS! body_part { Set(#p, PROCEDURE_BODY); }
+ | { pop_def_id(); Set(#p, PROCEDURE_DECLARATION); }
+ )
+ SEMI!
+ | f:FUNCTION^ def_designator[false] function_tail
+ ( IS! body_part { Set(#f, FUNCTION_BODY); }
+ | { pop_def_id(); Set(#f, FUNCTION_DECLARATION); }
+ )
+ SEMI!
+ ;
+
+block_body : b:BEGIN^ handled_stmt_s
+ { Set(#b, BLOCK_BODY); }
+ ;
+
+handled_stmt_s : statements except_handler_part_opt
+ { #handled_stmt_s =
+ #(#[HANDLED_SEQUENCE_OF_STATEMENTS,
+ "HANDLED_SEQUENCE_OF_STATEMENTS"], #handled_stmt_s); }
+ ;
+
+handled_stmts_opt : ( statements except_handler_part_opt )?
+ { #handled_stmts_opt =
+ #(#[HANDLED_STMTS_OPT,
+ "HANDLED_STMTS_OPT"], #handled_stmts_opt); }
+ ;
+
+statements : ( pragma | statement )+
+ { #statements = #(#[SEQUENCE_OF_STATEMENTS,
+ "SEQUENCE_OF_STATEMENTS"], #statements); }
+ ;
+
+statement : def_label_opt
+ ( null_stmt
+ | exit_stmt
+ | return_stmt
+ | goto_stmt
+ | delay_stmt
+ | abort_stmt
+ | raise_stmt
+ | requeue_stmt
+ | accept_stmt
+ | select_stmt
+ | if_stmt
+ | case_stmt
+ | loop_stmt SEMI!
+ | block END! SEMI!
+ | statement_identifier
+ ( loop_stmt id_opt SEMI!
+ | block end_id_opt SEMI!
+ )
+ | call_or_assignment
+ // | code_stmt // TBD: resolve ambiguity
+ )
+ { #statement = #(#[STATEMENT, "STATEMENT"], #statement); }
+ ;
+
+def_label_opt : ( LT_LT! IDENTIFIER GT_GT! )?
+ { #def_label_opt = #(#[LABEL_OPT, "LABEL_OPT"], #def_label_opt); }
+ ;
+
+null_stmt : s:NuLL SEMI!
+ { Set(#s, NULL_STATEMENT); }
+ ;
+
+if_stmt : s:IF^ cond_clause elsifs_opt
+ else_opt
+ END! IF! SEMI!
+ { Set(#s, IF_STATEMENT); }
+ ;
+
+cond_clause : condition c:THEN^ statements
+ { Set(#c, COND_CLAUSE); }
+ ;
+
+condition : expression
+ // { #condition = #(#[CONDITION, "CONDITION"], #condition); }
+ ;
+
+elsifs_opt : ( ELSIF! cond_clause )*
+ { #elsifs_opt = #(#[ELSIFS_OPT, "ELSIFS_OPT"], #elsifs_opt); }
+ ;
+
+else_opt : ( ELSE! statements )?
+ { #else_opt = #(#[ELSE_OPT, "ELSE_OPT"], #else_opt); }
+ ;
+
+case_stmt : s:CASE^ expression IS! alternative_s END! CASE! SEMI!
+ { Set(#s, CASE_STATEMENT); }
+ ;
+
+alternative_s : ( case_statement_alternative )+
+ ;
+
+case_statement_alternative : s:WHEN^ choice_s RIGHT_SHAFT! statements
+ { Set(#s, CASE_STATEMENT_ALTERNATIVE); }
+ ;
+
+loop_stmt : iteration_scheme_opt
+ l:LOOP^ statements END! LOOP! // basic_loop
+ { Set(#l, LOOP_STATEMENT); }
+ ;
+
+iteration_scheme_opt : ( WHILE^ condition
+ | FOR^ IDENTIFIER IN! reverse_opt discrete_subtype_definition
+ )?
+ { #iteration_scheme_opt =
+ #(#[ITERATION_SCHEME_OPT,
+ "ITERATION_SCHEME_OPT"], #iteration_scheme_opt); }
+ ;
+
+reverse_opt : ( REVERSE )?
+ { #reverse_opt = #(#[MODIFIERS, "MODIFIERS"], #reverse_opt); }
+ ;
+
+id_opt_aux { RefAdaAST endid; } :
+ endid=definable_operator_symbol { end_id_matches_def_id (endid) }?
+ | n:compound_name { end_id_matches_def_id (#n) }?
+ /* Ordinarily we would need to be stricter here, i.e.
+ match compound_name only for the library-level case
+ (and IDENTIFIER otherwise), but end_id_matches_def_id
+ does the right thing for us. */
+ | { pop_def_id(); }
+ ;
+
+id_opt : id_opt_aux
+ { #id_opt = #(#[ID_OPT, "ID_OPT"], #id_opt); }
+ ;
+
+end_id_opt : e:END^ id_opt_aux
+ { Set(#e, END_ID_OPT); }
+ ;
+
+/* Note: This rule should really be `statement_identifier_opt'.
+ However, manual disambiguation of `loop_stmt' from `block'
+ in the presence of the statement_identifier in `statement'
+ results in this rule. The case of loop_stmt/block given
+ without the statement_identifier is directly coded in
+ `statement'. */
+statement_identifier! : n:IDENTIFIER COLON!
+ { push_def_id(#n); }
+ ;
+
+/*
+statement_identifier_opt : ( n:IDENTIFIER COLON! { push_def_id(#n); } )?
+ { #statement_identifier_opt =
+ #(#[STATEMENT_IDENTIFIER_OPT,
+ "STATEMENT_IDENTIFIER_OPT"], #statement_identifier_opt); }
+ ;
+ */
+
+block : declare_opt block_body
+ { #block = #(#[BLOCK_STATEMENT, "BLOCK_STATEMENT"], #block); }
+ ;
+
+declare_opt : ( DECLARE! declarative_part )?
+ { #declare_opt = #(#[DECLARE_OPT, "DECLARE_OPT"], #declare_opt); }
+ ;
+
+exit_stmt : s:EXIT^ ( label_name )? ( WHEN condition )? SEMI!
+ { Set(#s, EXIT_STATEMENT); }
+ ;
+
+label_name : IDENTIFIER
+ ;
+
+return_stmt : s:RETURN^ ( expression )? SEMI!
+ { Set(#s, RETURN_STATEMENT); }
+ ;
+
+goto_stmt : s:GOTO^ label_name SEMI!
+ { Set(#s, GOTO_STATEMENT); }
+ ;
+
+call_or_assignment : // procedure_call is in here.
+ name ( ASSIGN! expression
+ { #call_or_assignment =
+ #(#[ASSIGNMENT_STATEMENT,
+ "ASSIGNMENT_STATEMENT"], #call_or_assignment); }
+ | { #call_or_assignment =
+ #(#[CALL_STATEMENT,
+ "CALL_STATEMENT"], #call_or_assignment); }
+ /* Preliminary. Use semantic analysis to produce
+ {PROCEDURE|ENTRY}_CALL_STATEMENT. */
+ )
+ SEMI!
+ ;
+
+entry_body : e:ENTRY^ def_id[false] entry_body_formal_part entry_barrier IS!
+ body_part SEMI!
+ { Set (#e, ENTRY_BODY); }
+ ;
+
+entry_body_formal_part : entry_index_spec_opt formal_part_opt
+ ;
+
+entry_index_spec_opt :
+ ( (LPAREN FOR) =>
+ LPAREN! FOR! def_id[false] IN! discrete_subtype_definition RPAREN!
+ | /* empty */
+ )
+ { #entry_index_spec_opt =
+ #(#[ENTRY_INDEX_SPECIFICATION,
+ "ENTRY_INDEX_SPECIFICATION"], #entry_index_spec_opt); }
+ ;
+
+entry_barrier : WHEN! condition
+ ;
+
+entry_call_stmt : name SEMI! // Semantic analysis required, for example
+ // to ensure `name' is an entry.
+ { #entry_call_stmt =
+ #(#[ENTRY_CALL_STATEMENT,
+ "ENTRY_CALL_STATEMENT"], #entry_call_stmt); }
+ ;
+
+accept_stmt : a:ACCEPT^ def_id[false] entry_index_opt formal_part_opt
+ ( DO! handled_stmts_opt end_id_opt SEMI!
+ | SEMI! { pop_def_id(); }
+ )
+ { Set (#a, ACCEPT_STATEMENT); }
+ ;
+
+entry_index_opt : ( (LPAREN expression RPAREN) => LPAREN! expression RPAREN!
+ // Looks alot like parenthesized_expr_opt, but it's not.
+ // We need the syn pred for the usage context in accept_stmt.
+ // The formal_part_opt that follows the entry_index_opt there
+ // creates ambiguity (due to the opening LPAREN.)
+ | /* empty */
+ )
+ { #entry_index_opt =
+ #(#[ENTRY_INDEX_OPT,
+ "ENTRY_INDEX_OPT"], #entry_index_opt); }
+ ;
+
+delay_stmt : d:DELAY^ until_opt expression SEMI!
+ { Set (#d, DELAY_STATEMENT); }
+ ;
+
+until_opt : ( UNTIL )?
+ { #until_opt = #(#[MODIFIERS, "MODIFIERS"], #until_opt); }
+ ;
+
+// SELECT_STATEMENT itself is not modeled since it is trivially
+// reconstructed:
+// select_statement ::= selective_accept | timed_entry_call
+// | conditional_entry_call | asynchronous_select
+//
+select_stmt : s:SELECT^
+ ( (triggering_alternative THEN ABORT) =>
+ triggering_alternative THEN! ABORT! abortable_part
+ { Set (#s, ASYNCHRONOUS_SELECT); }
+ | selective_accept
+ { Set (#s, SELECTIVE_ACCEPT); }
+ | entry_call_alternative
+ ( OR! delay_alternative { Set (#s, TIMED_ENTRY_CALL); }
+ | ELSE! statements { Set (#s, CONDITIONAL_ENTRY_CALL); }
+ )
+ )
+ END! SELECT! SEMI!
+ // { Set (#s, SELECT_STATEMENT); }
+ ;
+
+triggering_alternative : ( delay_stmt | entry_call_stmt ) stmts_opt
+ { #triggering_alternative =
+ #(#[TRIGGERING_ALTERNATIVE,
+ "TRIGGERING_ALTERNATIVE"], #triggering_alternative); }
+ ;
+
+abortable_part : stmts_opt
+ { #abortable_part =
+ #(#[ABORTABLE_PART,
+ "ABORTABLE_PART"], #abortable_part); }
+ ;
+
+entry_call_alternative : entry_call_stmt stmts_opt
+ { #entry_call_alternative =
+ #(#[ENTRY_CALL_ALTERNATIVE,
+ "ENTRY_CALL_ALTERNATIVE"], #entry_call_alternative); }
+ ;
+
+selective_accept : guard_opt select_alternative or_select_opt else_opt
+ ;
+
+guard_opt : ( w:WHEN^ condition RIGHT_SHAFT! ( pragma )* )?
+ { Set(#w, GUARD_OPT); }
+ ;
+
+select_alternative // Not modeled since it's just a pass-through.
+ : accept_alternative
+ | delay_alternative
+ | t:TERMINATE SEMI! { Set(#t, TERMINATE_ALTERNATIVE); }
+ ;
+
+accept_alternative : accept_stmt stmts_opt
+ { #accept_alternative =
+ #(#[ACCEPT_ALTERNATIVE,
+ "ACCEPT_ALTERNATIVE"], #accept_alternative); }
+ ;
+
+delay_alternative : delay_stmt stmts_opt
+ { #delay_alternative =
+ #(#[DELAY_ALTERNATIVE,
+ "DELAY_ALTERNATIVE"], #delay_alternative); }
+ ;
+
+stmts_opt : ( pragma | statement )*
+ ;
+
+or_select_opt : ( OR! guard_opt select_alternative )*
+ { #or_select_opt =
+ #(#[OR_SELECT_OPT, "OR_SELECT_OPT"], #or_select_opt); }
+ ;
+
+abort_stmt : a:ABORT^ name ( COMMA! name )* SEMI!
+ { Set (#a, ABORT_STATEMENT); }
+ ;
+
+except_handler_part_opt : ( EXCEPTION! ( exception_handler )+ )?
+ { #except_handler_part_opt =
+ #(#[EXCEPT_HANDLER_PART_OPT,
+ "EXCEPT_HANDLER_PART_OPT"], #except_handler_part_opt); }
+ ;
+
+exception_handler : w:WHEN^ identifier_colon_opt except_choice_s RIGHT_SHAFT!
+ statements
+ { Set (#w, EXCEPTION_HANDLER); }
+ ;
+
+identifier_colon_opt : ( IDENTIFIER COLON! )?
+ { #identifier_colon_opt =
+ #(#[IDENTIFIER_COLON_OPT,
+ "IDENTIFIER_COLON_OPT"], #identifier_colon_opt); }
+ ;
+
+except_choice_s : exception_choice ( PIPE^ exception_choice )*
+ ;
+
+exception_choice : compound_name
+ | OTHERS
+ ;
+
+raise_stmt : r:RAISE^ ( compound_name )? SEMI!
+ { Set (#r, RAISE_STATEMENT); }
+ ;
+
+requeue_stmt : r:REQUEUE^ name ( WITH! ABORT )? SEMI!
+ { Set (#r, REQUEUE_STATEMENT); }
+ ;
+
+operator_call : cs:CHAR_STRING^ operator_call_tail[#cs]
+ ;
+
+operator_call_tail [RefAdaAST opstr]
+ : LPAREN! { is_operator_symbol(opstr->getText().c_str()) }?
+ value_s RPAREN! { opstr->setType(OPERATOR_SYMBOL); }
+ ;
+
+value_s : value ( COMMA! value )*
+ { #value_s = #(#[VALUES, "VALUES"], #value_s); }
+ ;
+
+/*
+literal : NUMERIC_LIT
+ | CHARACTER_LITERAL
+ | CHAR_STRING
+ | NuLL
+ ;
+ */
+
+expression : relation
+ ( a:AND^ ( THEN! { Set (#a, AND_THEN); } )? relation
+ | o:OR^ ( ELSE! { Set (#o, OR_ELSE); } )? relation
+ | XOR^ relation
+ )*
+ ;
+
+relation : simple_expression
+ ( IN^ range_or_mark
+ | n:NOT^ IN! range_or_mark { Set (#n, NOT_IN); }
+ | EQ^ simple_expression
+ | NE^ simple_expression
+ | LT_^ simple_expression
+ | LE^ simple_expression
+ | GT^ simple_expression
+ | GE^ simple_expression
+ )?
+ ;
+
+range_or_mark : (range) => range
+ | subtype_mark
+ ;
+
+simple_expression : signed_term
+ ( PLUS^ signed_term
+ | MINUS^ signed_term
+ | CONCAT^ signed_term
+ )*
+ ;
+
+signed_term
+ : p:PLUS^ term { Set(#p, UNARY_PLUS); }
+ | m:MINUS^ term { Set(#m, UNARY_MINUS); }
+ | term
+ ;
+
+term : factor ( STAR^ factor
+ | DIV^ factor
+ | MOD^ factor
+ | REM^ factor
+ )*
+ ;
+
+factor : ( NOT^ primary
+ | ABS^ primary
+ | primary ( EXPON^ primary )?
+ )
+ ;
+
+primary : ( name_or_qualified
+ | parenthesized_primary
+ | allocator
+ | NuLL
+ | NUMERIC_LIT
+ | CHARACTER_LITERAL
+ | cs:CHAR_STRING^ ( operator_call_tail[#cs] )?
+ )
+ ;
+
+// Temporary, to be turned into just `qualified'.
+// We get away with it because `qualified' is always mentioned
+// together with `name'.
+// Only exception: `code_stmt', which is not yet implemented.
+name_or_qualified { RefAdaAST dummy; }
+ : IDENTIFIER
+ ( DOT^ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | dummy=is_operator
+ )
+ | p:LPAREN^ value_s RPAREN!
+ { Set(#p, INDEXED_COMPONENT); }
+ | TIC^ ( parenthesized_primary | attribute_id )
+ )*
+ ;
+
+allocator : n:NEW^ name_or_qualified
+ { Set(#n, ALLOCATOR); }
+ ;
+
+subunit : sep:SEPARATE^ LPAREN! compound_name RPAREN!
+ { Set(#sep, SUBUNIT); }
+ ( subprogram_body
+ | package_body
+ | task_body
+ | protected_body
+ )
+ ;
+
+subprogram_body
+ : p:PROCEDURE^ def_id[false] formal_part_opt IS! body_part SEMI!
+ { pop_def_id(); Set(#p, PROCEDURE_BODY); }
+ | f:FUNCTION^ def_designator[false] function_tail IS! body_part SEMI!
+ { pop_def_id(); Set(#f, FUNCTION_BODY); }
+ ;
+
+package_body : p:PACKAGE^ body_is pkg_body_part SEMI!
+ { Set(#p, PACKAGE_BODY); }
+ ;
+
+task_body : t:TASK^ body_is body_part SEMI!
+ { Set(#t, TASK_BODY); }
+ ;
+
+protected_body : p:PROTECTED^ body_is prot_op_bodies_opt end_id_opt SEMI!
+ { Set(#p, PROTECTED_BODY); }
+ ;
+
+// TBD
+// code_stmt : qualified SEMI!
+// ;
+
+//----------------------------------------------------------------------------
+// The Ada scanner
+//----------------------------------------------------------------------------
+{
+#include "preambles.h"
+}
+class AdaLexer extends Lexer;
+
+options {
+ charVocabulary = '\3'..'\377';
+ exportVocab = Ada; // call the vocabulary "Ada"
+ testLiterals = false; // don't automatically test for literals
+ k = 4; // number of characters of lookahead
+ caseSensitive = false;
+ caseSensitiveLiterals = false;
+ ///defaultErrorHandler = true;
+}
+
+tokens {
+ // part 1: keywords
+ ABORT = "abort" ;
+ ABS = "abs" ;
+ ABSTRACT = "abstract" ;
+ ACCEPT = "accept" ;
+ ACCESS = "access" ;
+ ALIASED = "aliased" ;
+ ALL = "all" ;
+ AND = "and" ;
+ ARRAY = "array" ;
+ AT = "at" ;
+ BEGIN = "begin" ;
+ BODY = "body" ;
+ CASE = "case" ;
+ CONSTANT = "constant" ;
+ DECLARE = "declare" ;
+ DELAY = "delay" ;
+ DELTA = "delta" ;
+ DIGITS = "digits" ;
+ DO = "do" ;
+ ELSE = "else" ;
+ ELSIF = "elsif" ;
+ END = "end" ;
+ ENTRY = "entry" ;
+ EXCEPTION = "exception" ;
+ EXIT = "exit" ;
+ FOR = "for" ;
+ FUNCTION = "function" ;
+ GENERIC = "generic" ;
+ GOTO = "goto" ;
+ IF = "if" ;
+ IN = "in" ;
+ IS = "is" ;
+ LIMITED = "limited" ;
+ LOOP = "loop" ;
+ MOD = "mod" ;
+ NEW = "new" ;
+ NOT = "not" ;
+ NuLL = "null" ;
+ OF = "of" ;
+ OR = "or" ;
+ OTHERS = "others" ;
+ OUT = "out" ;
+ PACKAGE = "package" ;
+ PRAGMA = "pragma" ;
+ PRIVATE = "private" ;
+ PROCEDURE = "procedure" ;
+ PROTECTED = "protected" ;
+ RAISE = "raise" ;
+ RANGE = "range" ;
+ RECORD = "record" ;
+ REM = "rem" ;
+ RENAMES = "renames" ;
+ REQUEUE = "requeue" ;
+ RETURN = "return" ;
+ REVERSE = "reverse" ;
+ SELECT = "select" ;
+ SEPARATE = "separate" ;
+ SUBTYPE = "subtype" ;
+ TAGGED = "tagged" ;
+ TASK = "task" ;
+ TERMINATE = "terminate" ;
+ THEN = "then" ;
+ TYPE = "type" ;
+ UNTIL = "until" ;
+ USE = "use" ;
+ WHEN = "when" ;
+ WHILE = "while" ;
+ WITH = "with" ;
+ XOR = "xor" ;
+
+ // part 2: RM tokens (synthetic)
+ ABORTABLE_PART;
+ ABORT_STATEMENT;
+ /*ABSTRACT_SUBPROGRAM_DECLARATION; =>
+ ABSTRACT_{FUNCTION|PROCEDURE}_DECLARATION */
+ ACCEPT_ALTERNATIVE;
+ ACCEPT_STATEMENT;
+ /* ACCESS_TO_FUNCTION_DEFINITION => ACCESS_TO_FUNCTION_DECLARATION */
+ /* ACCESS_TO_OBJECT_DEFINITION => ACCESS_TO_OBJECT_DECLARATION */
+ /* ACCESS_TO_PROCEDURE_DEFINITION => ACCESS_TO_PROCEDURE_DECLARATION */
+ /* ACCESS_TYPE_DEFINITION => ACCESS_TYPE_DECLARATION */
+ ALLOCATOR;
+ /* ARRAY_TYPE_DEFINITION => ARRAY_TYPE_DECLARATION */
+ ASSIGNMENT_STATEMENT;
+ ASYNCHRONOUS_SELECT;
+ ATTRIBUTE_DEFINITION_CLAUSE;
+ AT_CLAUSE;
+ BLOCK_STATEMENT;
+ CASE_STATEMENT;
+ CASE_STATEMENT_ALTERNATIVE;
+ CODE_STATEMENT;
+ COMPONENT_DECLARATION;
+ // COMPONENT_LIST; // not currently used as an explicit node
+ // CONDITION; // not currently used
+ CONDITIONAL_ENTRY_CALL;
+ CONTEXT_CLAUSE;
+ /* DECIMAL_FIXED_POINT_DEFINITION => DECIMAL_FIXED_POINT_DECLARATION */
+ // DECLARATIVE_ITEM; // not currently used
+ DECLARATIVE_PART;
+ DEFINING_IDENTIFIER_LIST;
+ DELAY_ALTERNATIVE;
+ DELAY_STATEMENT;
+ DELTA_CONSTRAINT;
+ /* DERIVED_TYPE_DEFINITION; =>
+ DERIVED_RECORD_EXTENSION, ORDINARY_DERIVED_TYPE_DECLARATION */
+ DIGITS_CONSTRAINT;
+ // DISCRETE_RANGE; // Not used; instead, directly use its RHS alternatives.
+ DISCRIMINANT_ASSOCIATION;
+ DISCRIMINANT_CONSTRAINT;
+ DISCRIMINANT_SPECIFICATION;
+ ENTRY_BODY;
+ ENTRY_CALL_ALTERNATIVE;
+ ENTRY_CALL_STATEMENT;
+ ENTRY_DECLARATION;
+ ENTRY_INDEX_SPECIFICATION;
+ ENUMERATION_REPESENTATION_CLAUSE;
+ /* ENUMERATION_TYPE_DEFINITION => ENUMERATION_TYPE_DECLARATION */
+ EXCEPTION_DECLARATION;
+ EXCEPTION_HANDLER;
+ EXCEPTION_RENAMING_DECLARATION;
+ EXIT_STATEMENT;
+ /* FLOATING_POINT_DEFINITION => FLOATING_POINT_DECLARATION */
+ /* FORMAL_ACCESS_TYPE_DEFINITION => FORMAL_ACCESS_TYPE_DECLARATION */
+ /* FORMAL_ARRAY_TYPE_DEFINITION => FORMAL_ARRAY_TYPE_DECLARATION */
+ /* FORMAL_DECIMAL_FIXED_POINT_DEFINITION =>
+ FORMAL_DECIMAL_FIXED_POINT_DECLARATION */
+ /* FORMAL_DERIVED_TYPE_DEFINITION =>
+ FORMAL_{ORDINARY_DERIVED_TYPE|PRIVATE_EXTENSION}_DECLARATION */
+ /* FORMAL_DISCRETE_TYPE_DEFINITION => FORMAL_DISCRETE_TYPE_DECLARATION */
+ /* FORMAL_FLOATING_POINT_DEFINITION =>
+ FORMAL_FLOATING_POINT_DECLARATION */
+ /* FORMAL_MODULAR_TYPE_DEFINITION => FORMAL_MODULAR_TYPE_DECLARATION */
+ /* FORMAL_ORDINARY_FIXED_POINT_DEFINITION =>
+ FORMAL_ORDINARY_FIXED_POINT_DECLARATION */
+ FORMAL_PACKAGE_DECLARATION;
+ /* FORMAL_PRIVATE_TYPE_DEFINITION => FORMAL_PRIVATE_TYPE_DECLARATION */
+ /* FORMAL_SIGNED_INTEGER_TYPE_DEFINITION =>
+ FORMAL_SIGNED_INTEGER_TYPE_DECLARATION */
+ /* FORMAL_SUBPROGRAM_DECLARATION; =>
+ FORMAL_{FUNCTION|PROCEDURE}_DECLARATION */
+ /* FORMAL_TYPE_DECLARATION; not used, replaced by the corresponding
+ finer grained declarations */
+ /* FORMAL_TYPE_DEFINITION; not used at all; we use declarations
+ not definitions */
+ /* FULL_TYPE_DECLARATION; not used, replaced by the corresponding
+ finer grained declarations */
+ GENERIC_FORMAL_PART;
+ /* GENERIC_INSTANTIATION; =>
+ GENERIC_{FUNCTION|PACKAGE|PROCEDURE}_INSTANTIATION */
+ GENERIC_PACKAGE_DECLARATION;
+ /* GENERIC_RENAMING_DECLARATION; =>
+ GENERIC_{FUNCTION|PACKAGE|PROCEDURE}_RENAMING */
+ /* GENERIC_SUBPROGRAM_DECLARATION; =>
+ GENERIC_{FUNCTION|PROCEDURE}_DECLARATION */
+ GOTO_STATEMENT;
+ HANDLED_SEQUENCE_OF_STATEMENTS;
+ HANDLED_STMTS_OPT;
+ IF_STATEMENT;
+ INCOMPLETE_TYPE_DECLARATION;
+ INDEXED_COMPONENT;
+ INDEX_CONSTRAINT;
+ LIBRARY_ITEM;
+ LOOP_STATEMENT;
+ /* MODULAR_TYPE_DEFINITION => MODULAR_TYPE_DECLARATION */
+ NAME;
+ NULL_STATEMENT;
+ NUMBER_DECLARATION;
+ OBJECT_DECLARATION;
+ OBJECT_RENAMING_DECLARATION;
+ OPERATOR_SYMBOL;
+ /* ORDINARY_FIXED_POINT_DEFINITION => ORDINARY_FIXED_POINT_DECLARATION */
+ PACKAGE_BODY;
+ PACKAGE_BODY_STUB;
+ PACKAGE_RENAMING_DECLARATION;
+ PACKAGE_SPECIFICATION;
+ PARAMETER_SPECIFICATION;
+ // PREFIX; // not used
+ // PRIMARY; // not used
+ PRIVATE_EXTENSION_DECLARATION;
+ PRIVATE_TYPE_DECLARATION;
+ // PROCEDURE_CALL_STATEMENT; // NYI, using CALL_STATEMENT for now.
+ PROTECTED_BODY;
+ PROTECTED_BODY_STUB;
+ PROTECTED_TYPE_DECLARATION;
+ RAISE_STATEMENT;
+ RANGE_ATTRIBUTE_REFERENCE;
+ RECORD_REPRESENTATION_CLAUSE;
+ /* RECORD_TYPE_DEFINITION => RECORD_TYPE_DECLARATION */
+ REQUEUE_STATEMENT;
+ RETURN_STATEMENT;
+ SELECTIVE_ACCEPT;
+ /* SELECT_ALTERNATIVE; Not used - instead, we use the finer grained rules
+ ACCEPT_ALTERNATIVE | DELAY_ALTERNATIVE
+ | TERMINATE_ALTERNATIVE */
+ /* SELECT_STATEMENT; Not used - instead, we use the finer grained rules
+ SELECTIVE_ACCEPT | TIMED_ENTRY_CALL
+ | CONDITIONAL_ENTRY_CALL | ASYNCHRONOUS_SELECT */
+ SEQUENCE_OF_STATEMENTS;
+ /* SIGNED_INTEGER_TYPE_DEFINITION => SIGNED_INTEGER_TYPE_DECLARATION */
+ SINGLE_PROTECTED_DECLARATION;
+ SINGLE_TASK_DECLARATION;
+ STATEMENT;
+ /* SUBPROGRAM_BODY; => {FUNCTION|PROCEDURE}_BODY */
+ /* SUBPROGRAM_BODY_STUB; => {FUNCTION|PROCEDURE}_BODY_STUB */
+ /* SUBPROGRAM_DECLARATION; => {FUNCTION|PROCEDURE}_DECLARATION */
+ /* SUBPROGRAM_RENAMING_DECLARATION; =>
+ {FUNCTION|PROCEDURE}_RENAMING_DECLARATION */
+ SUBTYPE_DECLARATION;
+ SUBTYPE_INDICATION;
+ SUBTYPE_MARK;
+ SUBUNIT;
+ TASK_BODY;
+ TASK_BODY_STUB;
+ TASK_TYPE_DECLARATION;
+ TERMINATE_ALTERNATIVE;
+ TIMED_ENTRY_CALL;
+ TRIGGERING_ALTERNATIVE;
+ /* TYPE_DECLARATION; not used, replaced by the corresponding
+ finer grained declarations */
+ USE_CLAUSE;
+ USE_TYPE_CLAUSE;
+ VARIANT;
+ VARIANT_PART;
+ WITH_CLAUSE;
+
+ // part 3: Non-RM synthetic tokens.
+ // They exist mainly to normalize the node structure with respect to
+ // optional items. (Without them, the presence or absence of an optional
+ // item would change the node layout, but we want a fixed layout.)
+ ABSTRACT_FUNCTION_DECLARATION;
+ ABSTRACT_PROCEDURE_DECLARATION;
+ ACCESS_TO_FUNCTION_DECLARATION;
+ ACCESS_TO_OBJECT_DECLARATION;
+ ACCESS_TO_PROCEDURE_DECLARATION;
+ /* ACCESS_TYPE_DECLARATION; not used, replaced by
+ ACCESS_TO_{FUNCTION|OBJECT|PROCEDURE}_DECLARATION
+ */
+ ARRAY_OBJECT_DECLARATION;
+ ARRAY_TYPE_DECLARATION;
+ AND_THEN;
+ BASIC_DECLARATIVE_ITEMS_OPT;
+ BLOCK_BODY;
+ BLOCK_BODY_OPT;
+ CALL_STATEMENT; // See {PROCEDURE|ENTRY}_CALL_STATEMENT
+ COMPONENT_CLAUSES_OPT;
+ COMPONENT_ITEMS;
+ COND_CLAUSE;
+ DECIMAL_FIXED_POINT_DECLARATION;
+ DECLARE_OPT;
+ DERIVED_RECORD_EXTENSION;
+ // DERIVED_TYPE_DECLARATION; // not used
+ DISCRETE_SUBTYPE_DEF_OPT;
+ DISCRIMINANT_SPECIFICATIONS;
+ DISCRIM_PART_OPT;
+ ELSE_OPT;
+ ELSIFS_OPT;
+ END_ID_OPT;
+ ENTRY_INDEX_OPT;
+ ENUMERATION_TYPE_DECLARATION;
+ EXCEPT_HANDLER_PART_OPT;
+ EXTENSION_OPT;
+ FLOATING_POINT_DECLARATION;
+ /* FORMAL_ACCESS_TYPE_DECLARATION => ACCESS_TYPE_DECLARATION */
+ /* FORMAL_ARRAY_TYPE_DECLARATION => ARRAY_TYPE_DECLARATION */
+ FORMAL_DECIMAL_FIXED_POINT_DECLARATION;
+ FORMAL_DISCRETE_TYPE_DECLARATION;
+ FORMAL_FLOATING_POINT_DECLARATION;
+ FORMAL_FUNCTION_DECLARATION;
+ FORMAL_MODULAR_TYPE_DECLARATION;
+ FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION;
+ FORMAL_ORDINARY_FIXED_POINT_DECLARATION;
+ FORMAL_PART_OPT;
+ FORMAL_PRIVATE_EXTENSION_DECLARATION;
+ FORMAL_PRIVATE_TYPE_DECLARATION;
+ FORMAL_PROCEDURE_DECLARATION;
+ FORMAL_SIGNED_INTEGER_TYPE_DECLARATION;
+ FUNCTION_BODY;
+ FUNCTION_BODY_STUB;
+ FUNCTION_DECLARATION;
+ FUNCTION_RENAMING_DECLARATION;
+ GENERIC_FUNCTION_DECLARATION;
+ GENERIC_FUNCTION_INSTANTIATION;
+ GENERIC_FUNCTION_RENAMING;
+ GENERIC_PACKAGE_INSTANTIATION;
+ GENERIC_PACKAGE_RENAMING;
+ GENERIC_PROCEDURE_DECLARATION;
+ GENERIC_PROCEDURE_INSTANTIATION;
+ GENERIC_PROCEDURE_RENAMING;
+ GUARD_OPT;
+ IDENTIFIER_COLON_OPT;
+ ID_OPT;
+ INIT_OPT;
+ ITERATION_SCHEME_OPT;
+ LABEL_OPT;
+ MARK_WITH_CONSTRAINT;
+ MODIFIERS; /* Possible values: abstract access aliased all constant in
+ limited out private protected reverse tagged */
+ MODULAR_TYPE_DECLARATION;
+ MOD_CLAUSE_OPT;
+ // NAME_OR_QUALIFIED;
+ NOT_IN;
+ ORDINARY_DERIVED_TYPE_DECLARATION;
+ ORDINARY_FIXED_POINT_DECLARATION;
+ OR_ELSE;
+ OR_SELECT_OPT;
+ PARENTHESIZED_PRIMARY;
+ // PARENTHESIZED_VALUES;
+ // PARENTHESIZED_VALUES_OPT;
+ PRIVATE_DECLARATIVE_ITEMS_OPT;
+ PRIVATE_TASK_ITEMS_OPT;
+ PROCEDURE_BODY;
+ PROCEDURE_BODY_STUB;
+ PROCEDURE_DECLARATION;
+ PROCEDURE_RENAMING_DECLARATION;
+ PROT_MEMBER_DECLARATIONS;
+ PROT_OP_BODIES_OPT;
+ PROT_OP_DECLARATIONS;
+ PROT_PRIVATE_OPT;
+ RANGED_EXPRS; // ugh, what an ugly name
+ RANGE_CONSTRAINT;
+ RECORD_TYPE_DECLARATION;
+ SELECTOR_NAMES_OPT;
+ SIGNED_INTEGER_TYPE_DECLARATION;
+ TASK_ITEMS_OPT;
+ UNARY_MINUS;
+ UNARY_PLUS;
+ VALUE;
+ VALUES;
+ VARIANTS;
+}
+
+{
+ ANTLR_LEXER_PREAMBLE
+ private:
+ bool lastTokenWasTicCompatible;
+}
+
+//----------------------------------------------------------------------------
+// OPERATORS
+//----------------------------------------------------------------------------
+COMMENT_INTRO : "--" {lastTokenWasTicCompatible=false;};
+DOT_DOT : ".." {lastTokenWasTicCompatible=false;};
+LT_LT : "<<" {lastTokenWasTicCompatible=false;};
+OX : "<>" {lastTokenWasTicCompatible=false;};
+GT_GT : ">>" {lastTokenWasTicCompatible=false;};
+ASSIGN : ":=" {lastTokenWasTicCompatible=false;};
+RIGHT_SHAFT : "=>" {lastTokenWasTicCompatible=false;};
+NE : "/=" {lastTokenWasTicCompatible=false;};
+LE : "<=" {lastTokenWasTicCompatible=false;};
+GE : ">=" {lastTokenWasTicCompatible=false;};
+EXPON : "**" {lastTokenWasTicCompatible=false;};
+PIPE : '|' {lastTokenWasTicCompatible=false;};
+CONCAT : '&' {lastTokenWasTicCompatible=false;};
+DOT : '.' {lastTokenWasTicCompatible=false;};
+EQ : '=' {lastTokenWasTicCompatible=false;};
+LT_ : '<' {lastTokenWasTicCompatible=false;};
+GT : '>' {lastTokenWasTicCompatible=false;};
+PLUS : '+' {lastTokenWasTicCompatible=false;};
+MINUS : '-' {lastTokenWasTicCompatible=false;};
+STAR : '*' {lastTokenWasTicCompatible=false;};
+DIV : '/' {lastTokenWasTicCompatible=false;};
+LPAREN : '(' {lastTokenWasTicCompatible=false;};
+RPAREN : ')' {lastTokenWasTicCompatible=true;};
+COLON : ':' {lastTokenWasTicCompatible=false;};
+COMMA : ',' {lastTokenWasTicCompatible=false;};
+SEMI : ';' {lastTokenWasTicCompatible=false;};
+
+
+// Literals.
+
+// Rule for IDENTIFIER: 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 keyword or really an identifier.
+IDENTIFIER
+ options {testLiterals=true;}
+ : ( 'a'..'z' ) ( ('_')? ( 'a'..'z'|'0'..'9' ) )*
+ ;
+
+TIC_OR_CHARACTER_LITERAL :
+ "'"! { $setType(TIC); } (
+ { ! lastTokenWasTicCompatible }? . "'"!
+ { $setType(CHARACTER_LITERAL); }
+ )?
+ {lastTokenWasTicCompatible=false;};
+
+CHAR_STRING : '"'! ("\"\"" | ~('"'))* '"'!
+ {lastTokenWasTicCompatible=true;};
+
+NUMERIC_LIT : ( DIGIT )+
+ ( '#' BASED_INTEGER ( '.' BASED_INTEGER )? '#'
+ | ( '_' ( DIGIT )+ )+ // INTEGER
+ )?
+ ( { LA(2)!='.' }? //&& LA(3)!='.' }?
+ ( '.' ( DIGIT )+ ( '_' ( DIGIT )+ )* ( EXPONENT )?
+ | EXPONENT
+ )
+ )?
+ {lastTokenWasTicCompatible=false;};
+
+// a couple protected methods to assist in matching the various numbers
+
+protected
+DIGIT : ( '0'..'9' ) {lastTokenWasTicCompatible=false;};
+
+protected
+EXPONENT : ('e') ('+'|'-')? ( DIGIT )+ {lastTokenWasTicCompatible=false;};
+
+protected
+EXTENDED_DIGIT : ( DIGIT | 'a'..'f' ) {lastTokenWasTicCompatible=false;};
+
+protected
+BASED_INTEGER : ( EXTENDED_DIGIT ) ( ('_')? EXTENDED_DIGIT )* {lastTokenWasTicCompatible=false;};
+
+
+// Whitespace -- ignored
+WS_ : ( ' '
+ | '\t'
+ | '\f'
+ // handle newlines
+ | ( "\r\n" // Evil DOS
+ | '\r' // Macintosh
+ | '\n' // Unix (the right way)
+ )
+ { newline(); }
+ )
+ { $setType(antlr::Token::SKIP); }
+ ;
+
+// Single-line comments
+COMMENT : COMMENT_INTRO (~('\n'|'\r'))* ('\n'|'\r'('\n')?)
+ { $setType(antlr::Token::SKIP);
+ newline();
+ lastTokenWasTicCompatible=false; }
+ ;
+
diff --git a/languages/ada/ada.store.g b/languages/ada/ada.store.g
new file mode 100644
index 00000000..dbca7312
--- /dev/null
+++ b/languages/ada/ada.store.g
@@ -0,0 +1,610 @@
+/* $Id$
+ * ANTLR Ada tree walker for building the Kdevelop class store
+ * Copyright (C) 2003 Oliver Kellogg <okellogg@users.sourceforge.net>
+ */
+
+header "pre_include_hpp" {
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qfileinfo.h>
+
+#include <codemodel.h>
+#include "AdaAST.hpp"
+#include "ada_utils.hpp"
+}
+
+header "post_include_hpp" {
+#include <codemodel.h>
+#include <kdebug.h>
+}
+
+options {
+ language="Cpp";
+}
+
+class AdaStoreWalker extends AdaTreeParserSuper;
+options {
+ importVocab = Ada;
+ ASTLabelType = "RefAdaAST";
+}
+
+{
+private:
+ QString m_fileName;
+ QValueList<NamespaceDom> m_scopeStack;
+ CodeModel* m_model;
+ QValueList<QStringList> m_imports;
+ NamespaceDom m_currentContainer;
+ int m_currentAccess;
+ bool m_addToStore; /* auxiliary variable: for the moment, this is `true'
+ only when we are in specs, not bodies. */
+ bool m_isSubprogram; // auxiliary to def_id()
+ FileDom m_file;
+
+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_scopeStack.clear ();
+ m_imports.clear ();
+ m_currentContainer = m_model->globalNamespace ();
+ m_scopeStack.append (m_currentContainer);
+ m_currentAccess = CodeModelItem::Public;
+ m_addToStore = false;
+ m_isSubprogram = false;
+ if (m_model->hasFile(m_fileName))
+ m_model->removeFile (m_model->fileByName(m_fileName));
+ m_file = m_model->create<FileModel>();
+ m_file->setName(m_fileName);
+ m_model->addFile(m_file);
+ }
+
+ void wipeout () { m_model->wipeout (); }
+// void out () { m_store->out (); }
+ void removeWithReferences (const QString& fileName) {
+ m_model->removeFile (m_model->fileByName(fileName));
+ }
+ NamespaceDom insertScopeContainer
+ (NamespaceDom scope, const QStringList & scopes ) {
+ QStringList::ConstIterator it = scopes.begin();
+ QString prefix( *it );
+ NamespaceDom ns = scope->namespaceByName( prefix );
+// kdDebug() << "insertScopeContainer begin with prefix " << prefix << endl;
+ if (!ns.data()) {
+// kdDebug() << "insertScopeContainer: ns is empty" << endl;
+ ns = m_model->create<NamespaceModel>();
+// kdDebug() << "insertScopeContainer: ns created" << endl;
+ ns->setName( prefix );
+// kdDebug() << "insertScopeContainer: ns name set" << endl;
+ scope->addNamespace( ns );
+// kdDebug() << "insertScopeContainer: ns added to a scope" << endl;
+
+ if (scope == m_model->globalNamespace())
+ m_file->addNamespace( ns );
+ }
+// kdDebug() << "insertScopeContainer: while" << endl;
+ while ( ++it != scopes.end() ) {
+ QString nameSegment( *it );
+ prefix += "." + nameSegment;
+// kdDebug() << "insertScopeContainer: while prefix = " << prefix << endl;
+ NamespaceDom inner = scope->namespaceByName( prefix );
+ if (!inner.data() ) {
+// kdDebug() << "insertScopeContainer: inner is empty " << endl;
+ inner = m_model->create<NamespaceModel>();
+// kdDebug() << "insertScopeContainer: inner created " << endl;
+ inner->setName( nameSegment );
+ ns->addNamespace( inner );
+// kdDebug() << "insertScopeContainer: inner added " << endl;
+ }
+ ns = inner;
+ }
+ return ns;
+ }
+ NamespaceDom defineScope( RefAdaAST namenode ) {
+ QStringList scopes( qnamelist( namenode ) );
+// kdDebug() << "defineScope: " << scopes.join(" ") << endl;
+ NamespaceDom psc = insertScopeContainer( m_currentContainer, scopes );
+// kdDebug() << "defineScope psc created" << endl;
+ psc->setStartPosition(namenode->getLine(), namenode->getColumn());
+// kdDebug() << "defineScope start position set" << endl;
+ psc->setFileName(m_fileName);
+// kdDebug() << "defineScope file name set" << endl;
+ // psc->setEndPosition (endLine, 0);
+// kdDebug() << "defineScope return" << endl;
+ return psc;
+ }
+}
+
+/*
+ * Only those rules that require specific action for the kdevelop
+ * class store are overloaded here.
+ */
+
+compilation_unit
+ : { init(); }
+ context_items_opt ( library_item | subunit ) ( pragma )*
+ ;
+
+
+with_clause
+ : #(WITH_CLAUSE ( compound_name
+ // TBD: slurp in the actual files
+ )+ )
+ ;
+
+/*
+compound_name
+ : IDENTIFIER
+ | #(DOT compound_name IDENTIFIER)
+ ;
+ */
+
+use_clause
+ : #(USE_TYPE_CLAUSE ( subtype_mark )+ )
+ | #(USE_CLAUSE ( c:compound_name
+ { m_imports.back ().push_back (qtext (#c)); }
+ )+ )
+ ;
+
+
+library_item :
+ #(LIBRARY_ITEM
+ #(MODIFIERS ( PRIVATE { m_currentAccess = CodeModelItem::Protected; } )? )
+ ( lib_subprog_decl_or_rename_or_inst_or_body
+ | #(PACKAGE_BODY pb:def_id pkg_body_part)
+ | #(GENERIC_PACKAGE_INSTANTIATION gpi:def_id
+ {
+ defineScope( #gpi );
+ }
+ generic_inst
+ )
+ | #(PACKAGE_SPECIFICATION ps:def_id
+ {
+ NamespaceDom psc = defineScope( #ps );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+ }
+ pkg_spec_part
+ {
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0) {
+ kdDebug() << "adastore: m_scopeStack is empty!" << endl;
+ m_scopeStack.append( m_model->globalNamespace() );
+ }
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setEndPosition (endLine, 0);
+ m_addToStore = false;
+ }
+ )
+ | #(PACKAGE_RENAMING_DECLARATION prd:def_id
+ {
+ defineScope( #prd );
+ }
+ renames
+ )
+ | generic_decl
+ )
+ )
+ ;
+
+
+subprog_def_id
+ : { m_isSubprogram = true; }
+ def_id
+ { m_isSubprogram = false; }
+ ;
+
+subprog_decl
+ : #(GENERIC_PROCEDURE_INSTANTIATION subprog_def_id generic_inst)
+ | #(PROCEDURE_RENAMING_DECLARATION subprog_def_id formal_part_opt renames)
+ | #(PROCEDURE_DECLARATION subprog_def_id formal_part_opt)
+ | #(PROCEDURE_BODY_STUB subprog_def_id formal_part_opt)
+ | #(ABSTRACT_PROCEDURE_DECLARATION subprog_def_id formal_part_opt)
+ | #(GENERIC_FUNCTION_INSTANTIATION def_designator generic_inst)
+ | #(FUNCTION_RENAMING_DECLARATION def_designator function_tail renames)
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ | #(FUNCTION_BODY_STUB def_designator function_tail)
+ | #(ABSTRACT_FUNCTION_DECLARATION subprog_def_id function_tail)
+ ;
+
+
+def_id
+ : cn:compound_name
+ {
+// kdDebug() << "cn:compound_name started " << endl;
+ if (m_addToStore) {
+// kdDebug() << "cn:compound_name m_addToStore " << endl;
+ if (m_isSubprogram) {
+// kdDebug() << "cn:compound_name m_isSubprogram " << endl;
+ FunctionDom method = m_model->create<FunctionModel>();
+ method->setName (qtext (cn));
+ method->setFileName(m_fileName);
+// kdDebug() << "cn:compound_name method->setStartPosition(" << endl;
+ method->setStartPosition(#cn->getLine(), #cn->getColumn());
+
+ if (m_currentContainer == m_model->globalNamespace())
+ m_file->addFunction(method);
+ else
+ m_currentContainer->addFunction(method);
+ //FIXME: adymo: is this valid for CodeModel
+/* ParsedMethod *old = m_currentContainer->getMethod (method);
+ if (old) {
+ delete (method);
+ method = old;
+ } else {
+ m_currentContainer->addMethod (method);
+ }*/
+ } else {
+ // TBC: what about other declarations?
+ }
+ }
+ }
+ ;
+
+/*
+generic_inst : compound_name ( value_s )?
+ ;
+ */
+
+/*
+formal_part_opt : #(FORMAL_PART_OPT ( parameter_specification )* )
+ ;
+ */
+
+/*
+parameter_specification
+ : #(PARAMETER_SPECIFICATION defining_identifier_list modifiers
+ subtype_mark init_opt)
+ ;
+ */
+
+/*
+defining_identifier_list : #(DEFINING_IDENTIFIER_LIST ( IDENTIFIER )+ )
+ ;
+ */
+
+/*
+renames : CHARACTER_STRING // CHARACTER_STRING should not really be there.
+ | OPERATOR_SYMBOL // OPERATOR_SYMBOL should be used instead.
+ | name
+ ;
+ */
+
+/*
+name : IDENTIFIER
+ | #(DOT name
+ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | OPERATOR_SYMBOL
+ )
+ )
+ | #(INDEXED_COMPONENT name value_s)
+ | #(TIC name attribute_id)
+ ;
+ */
+
+def_designator
+ : cn:compound_name
+ {
+// kdDebug() << "def_designator cn:compound_name started" << endl;
+ if (m_addToStore) {
+// kdDebug() << "def_designator cn:compound_name m_addToStore" << endl;
+ FunctionDom method = m_model->create<FunctionModel>();
+ method->setName (qtext (cn));
+ method->setFileName(m_fileName);
+// kdDebug() << "def_designator cn:compound_name method->setStartPosition(" << endl;
+ method->setStartPosition(#cn->getLine(), #cn->getColumn());
+
+ if (m_currentContainer == m_model->globalNamespace())
+ m_file->addFunction(method);
+ else
+ m_currentContainer->addFunction(method);
+ //FIXME: adymo: is this valid for CodeModel
+/* ParsedMethod *old = m_currentContainer->getMethod (method);
+ if (old) {
+ delete method;
+ method = old;
+ } else {
+ m_currentContainer->addMethod (method);
+ }*/
+ }
+ }
+ | definable_operator_symbol
+ ;
+
+/*
+function_tail : formal_part_opt subtype_mark
+ ;
+ */
+
+spec_decl_part
+ : #(GENERIC_PACKAGE_INSTANTIATION def_id generic_inst)
+ | #(PACKAGE_SPECIFICATION ps:def_id
+ {
+ NamespaceDom psc = defineScope( #ps );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+ }
+ pkg_spec_part
+ {
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0) {
+ kdDebug() << "adastore: m_scopeStack is empty!" << endl;
+ m_scopeStack.append( m_model->globalNamespace() );
+ }
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setDeclarationEndsOnLine (endLine);
+ m_addToStore = false;
+ }
+ )
+ | #(PACKAGE_RENAMING_DECLARATION def_id renames)
+ ;
+
+pkg_spec_part :
+ basic_declarative_items_opt
+ private_declarative_items_opt
+ end_id_opt
+ ;
+
+private_declarative_items_opt
+ : ( { m_currentAccess = CodeModelItem::Protected; }
+ ( basic_decl_item | pragma )+
+ { m_currentAccess = CodeModelItem::Public; }
+ )?
+ ;
+
+/*
+task_type_or_single_decl
+ : #(TASK_TYPE_DECLARATION def_id discrim_part_opt task_definition_opt)
+ | #(SINGLE_TASK_DECLARATION def_id task_definition_opt)
+ ;
+ */
+
+/*
+discriminant_specification
+ : #(DISCRIMINANT_SPECIFICATION defining_identifier_list
+ modifiers subtype_mark init_opt)
+ ;
+ */
+
+/*
+entry_declaration
+ : #(ENTRY_DECLARATION IDENTIFIER
+ discrete_subtype_def_opt formal_part_opt)
+ ;
+ */
+
+/*
+prot_op_decl
+ : entry_declaration
+ | #(PROCEDURE_DECLARATION def_id formal_part_opt)
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ | rep_spec
+ | pragma
+ ;
+ */
+
+/*
+prot_member_decl_s
+ : #(PROT_MEMBER_DECLARATIONS ( prot_op_decl | comp_decl )* )
+ ;
+
+comp_decl
+ : #(COMPONENT_DECLARATION defining_identifier_list component_subtype_def init_opt)
+ ;
+ */
+
+/*
+// decl_common is shared between declarative_item and basic_decl_item.
+// decl_common only contains specifications.
+decl_common
+ : // type_def:
+ #(ENUMERATION_TYPE_DECLARATION IDENTIFIER enum_id_s)
+ | #(SIGNED_INTEGER_TYPE_DECLARATION IDENTIFIER range)
+ | #(MODULAR_TYPE_DECLARATION IDENTIFIER expression)
+ | #(FLOATING_POINT_DECLARATION IDENTIFIER expression range_constraint_opt)
+ | #(ORDINARY_FIXED_POINT_DECLARATION IDENTIFIER expression range)
+ | #(DECIMAL_FIXED_POINT_DECLARATION IDENTIFIER expression expression range_constraint_opt)
+ | array_type_declaration
+ | access_type_declaration
+ //
+ | #(INCOMPLETE_TYPE_DECLARATION IDENTIFIER discrim_part_opt)
+ // derived_or_private_or_record
+ | #(PRIVATE_EXTENSION_DECLARATION id_and_discrim modifiers subtype_ind)
+ | #(DERIVED_RECORD_EXTENSION id_and_discrim modifiers subtype_ind record_definition)
+ | #(ORDINARY_DERIVED_TYPE_DECLARATION id_and_discrim subtype_ind)
+ | #(PRIVATE_TYPE_DECLARATION id_and_discrim modifiers)
+ | #(RECORD_TYPE_DECLARATION id_and_discrim modifiers record_definition)
+ //
+ | #(SUBTYPE_DECLARATION IDENTIFIER subtype_ind)
+ | generic_decl
+ | use_clause
+ | rep_spec // enumeration_representation_clause only
+ | #(EXCEPTION_RENAMING_DECLARATION def_id compound_name)
+ | #(OBJECT_RENAMING_DECLARATION def_id subtype_mark name)
+ | #(EXCEPTION_DECLARATION defining_identifier_list)
+ | #(NUMBER_DECLARATION defining_identifier_list expression)
+ | #(ARRAY_OBJECT_DECLARATION defining_identifier_list modifiers
+ array_type_definition init_opt)
+ | #(OBJECT_DECLARATION defining_identifier_list modifiers
+ subtype_ind init_opt)
+ ;
+ */
+
+/*
+id_and_discrim
+ : IDENTIFIER discrim_part_opt
+ ;
+ */
+
+/*
+enumeration_literal_specification : IDENTIFIER | CHARACTER_LITERAL
+ ;
+ */
+
+/*
+array_type_declaration
+ : #(ARRAY_TYPE_DECLARATION IDENTIFIER array_type_definition)
+ ;
+ */
+
+/*
+access_type_declaration
+ : #(ACCESS_TO_PROCEDURE_DECLARATION IDENTIFIER modifiers formal_part_opt)
+ | #(ACCESS_TO_FUNCTION_DECLARATION IDENTIFIER modifiers function_tail)
+ | #(ACCESS_TO_OBJECT_DECLARATION IDENTIFIER modifiers subtype_ind)
+ ;
+ */
+
+
+generic_decl
+ : #(GENERIC_PACKAGE_RENAMING generic_formal_part_opt def_id renames)
+ | #(GENERIC_PACKAGE_DECLARATION generic_formal_part_opt gpd:def_id
+ {
+ NamespaceDom psc = defineScope( #gpd );
+ m_currentContainer = psc;
+ m_scopeStack.append( psc );
+ m_addToStore = true;
+ }
+ pkg_spec_part
+ {
+ m_scopeStack.remove(m_scopeStack.last());
+ if (m_scopeStack.count() == 0)
+ m_scopeStack.append( m_model->globalNamespace() );
+ m_currentContainer = m_scopeStack.last();
+ // m_currentContainer->setDeclarationEndsOnLine (endLine);
+ m_addToStore = false;
+ }
+ )
+ | #(GENERIC_PROCEDURE_RENAMING generic_formal_part_opt def_id
+ formal_part_opt renames)
+ | #(GENERIC_PROCEDURE_DECLARATION generic_formal_part_opt subprog_def_id
+ formal_part_opt)
+ | #(GENERIC_FUNCTION_RENAMING generic_formal_part_opt def_designator
+ function_tail renames)
+ | #(GENERIC_FUNCTION_DECLARATION generic_formal_part_opt subprog_def_id
+ function_tail)
+ ;
+
+/*
+generic_formal_part_opt
+ : #(GENERIC_FORMAL_PART
+ ( pragma | use_clause | generic_formal_parameter )*
+ )
+ ;
+ */
+
+/*
+generic_formal_parameter
+ : // FORMAL_TYPE_DECLARATIONs:
+ #(FORMAL_DISCRETE_TYPE_DECLARATION def_id)
+ | #(FORMAL_SIGNED_INTEGER_TYPE_DECLARATION def_id)
+ | #(FORMAL_MODULAR_TYPE_DECLARATION def_id)
+ | #(FORMAL_DECIMAL_FIXED_POINT_DECLARATION def_id)
+ | #(FORMAL_ORDINARY_FIXED_POINT_DECLARATION def_id)
+ | #(FORMAL_FLOATING_POINT_DECLARATION def_id)
+ | formal_array_type_declaration
+ | formal_access_type_declaration
+ | #(FORMAL_PRIVATE_TYPE_DECLARATION id_part modifiers)
+ | #(FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION id_part subtype_ind)
+ | #(FORMAL_PRIVATE_EXTENSION_DECLARATION id_part modifiers subtype_ind)
+ | #(FORMAL_PROCEDURE_DECLARATION def_id formal_part_opt
+ subprogram_default_opt)
+ | #(FORMAL_FUNCTION_DECLARATION def_designator function_tail
+ subprogram_default_opt)
+ | #(FORMAL_PACKAGE_DECLARATION def_id compound_name formal_package_actual_part_opt)
+ | parameter_specification
+ ;
+ */
+
+lib_subprog_decl_or_rename_or_inst_or_body
+ : { m_addToStore = true; }
+ ( subprog_decl
+ | procedure_body
+ | function_body
+ )
+ { m_addToStore = false; }
+ ;
+
+subprog_decl_or_rename_or_inst_or_body
+ : subprog_decl
+ | procedure_body
+ | function_body
+ ;
+
+
+/*
+// A declarative_item may appear in the declarative part of any body.
+declarative_item
+ : #(PACKAGE_BODY_STUB def_id)
+ | #(PACKAGE_BODY def_id pkg_body_part)
+ | spec_decl_part
+ | #(TASK_BODY_STUB def_id)
+ | #(TASK_BODY def_id body_part)
+ | task_type_or_single_decl
+ | #(PROTECTED_BODY_STUB def_id)
+ | #(PROTECTED_BODY def_id prot_op_bodies_opt)
+ | prot_type_or_single_decl
+ | subprog_decl_or_rename_or_inst_or_body
+ | decl_common
+ ;
+ */
+
+
+subprog_decl_or_body
+ : procedure_body
+ | #(PROCEDURE_DECLARATION subprog_def_id formal_part_opt)
+ | function_body
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ ;
+
+/*
+// Temporary, to be turned into just `qualified'.
+// We get away with it because `qualified' is always mentioned
+// together with `name'.
+// Only exception: `code_stmt', which is not yet implemented.
+name_or_qualified
+ : IDENTIFIER
+ | #(DOT name_or_qualified
+ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | OPERATOR_SYMBOL
+ )
+ )
+ | #(INDEXED_COMPONENT name_or_qualified value_s)
+ | #(TIC name_or_qualified
+ ( parenthesized_primary
+ | attribute_id
+ )
+ )
+ ;
+ */
+
+package_body
+ : #(PACKAGE_BODY id:def_id
+ /* TBD
+ { QString name (qtext (id));
+ }
+ */
+ pkg_body_part)
+ ;
+
+/*
+task_body : #(TASK_BODY def_id body_part)
+ ;
+ */
+
+/*
+protected_body : #(PROTECTED_BODY def_id prot_op_bodies_opt)
+ ;
+ */
+
diff --git a/languages/ada/ada.tree.g b/languages/ada/ada.tree.g
new file mode 100644
index 00000000..df167dcd
--- /dev/null
+++ b/languages/ada/ada.tree.g
@@ -0,0 +1,964 @@
+/*
+ * ANTLR Ada95 tree super grammar (base class)
+ *
+ * Oliver M. Kellogg <okellogg@users.sourceforge.net>
+ *
+ * $Id$
+ *
+ */
+
+
+options {
+ language="Cpp";
+}
+
+class AdaTreeParserSuper extends TreeParser;
+options {
+ importVocab=Ada;
+}
+
+// Compilation Unit: This is the start rule.
+
+compilation_unit
+ : context_items_opt ( library_item | subunit ) ( pragma )*
+ ;
+
+pragma : #(PRAGMA IDENTIFIER ( pragma_arg )* )
+ ;
+
+pragma_arg
+ : #(RIGHT_SHAFT IDENTIFIER expression)
+ | expression
+ ;
+
+context_items_opt
+ : #(CONTEXT_CLAUSE ( pragma | with_clause | use_clause )* )
+ ;
+
+with_clause
+ : #(WITH_CLAUSE ( compound_name )+ )
+ ;
+
+compound_name
+ : IDENTIFIER
+ | #(DOT compound_name IDENTIFIER)
+ ;
+
+use_clause
+ : #(USE_TYPE_CLAUSE ( subtype_mark )+ )
+ | #(USE_CLAUSE ( compound_name )+ )
+ ;
+
+subtype_mark
+ : compound_name
+ | #(TIC compound_name attribute_id)
+ ;
+
+attribute_id : RANGE
+ | DIGITS
+ | DELTA
+ | ACCESS
+ | IDENTIFIER
+ ;
+
+library_item :
+ #(LIBRARY_ITEM modifiers
+ ( subprog_decl_or_rename_or_inst_or_body
+ | #(PACKAGE_BODY def_id pkg_body_part)
+ | #(GENERIC_PACKAGE_INSTANTIATION def_id generic_inst)
+ | #(PACKAGE_SPECIFICATION def_id pkg_spec_part)
+ | #(PACKAGE_RENAMING_DECLARATION def_id renames)
+ | generic_decl
+ )
+ )
+ ;
+
+modifiers : #(MODIFIERS
+ ( ABSTRACT
+ | ACCESS
+ | ALIASED
+ | ALL
+ | CONSTANT
+ | IN
+ | LIMITED
+ | OUT
+ | PRIVATE
+ | PROTECTED
+ | REVERSE
+ | TAGGED
+ )*
+ // We can afford to be this loose because the parser
+ // has already fended off illegal usages, i.e. we can
+ // be sure that we are only dealing with permissible
+ // values for each usage context here.
+ // Only exception: PRIVATE as the prefix of private
+ // {generic|package|subprogram} library-level decl.
+ // The parser has let this in for bodies as well
+ // (which is not legal), so we need a semantic check.
+ )
+ ;
+
+id_opt : #(ID_OPT ( def_designator )? )
+ ;
+
+end_id_opt : #(END ( def_designator )? )
+ ;
+
+subprog_decl
+ : #(GENERIC_PROCEDURE_INSTANTIATION def_id generic_inst)
+ | #(PROCEDURE_RENAMING_DECLARATION def_id formal_part_opt renames)
+ | #(PROCEDURE_DECLARATION def_id formal_part_opt)
+ | #(PROCEDURE_BODY_STUB def_id formal_part_opt)
+ | #(ABSTRACT_PROCEDURE_DECLARATION def_id formal_part_opt)
+ | #(GENERIC_FUNCTION_INSTANTIATION def_designator generic_inst)
+ | #(FUNCTION_RENAMING_DECLARATION def_designator function_tail renames)
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ | #(FUNCTION_BODY_STUB def_designator function_tail)
+ | #(ABSTRACT_FUNCTION_DECLARATION def_id function_tail)
+ ;
+
+def_id : compound_name // Can afford looseness because parser is tight.
+ ;
+
+generic_inst : compound_name ( value_s )?
+ ;
+
+value : #(OTHERS expression)
+ | #(RIGHT_SHAFT ranged_expr_s expression)
+ | ranged_expr_s
+ ;
+
+ranged_expr_s
+ : #(PIPE ranged_expr_s ranged_expr)
+ | ranged_expr
+ ;
+
+ranged_expr
+ : #(DOT_DOT expression simple_expression)
+ | #(RANGE expression range)
+ | expression
+ ;
+
+range_constraint : #(RANGE_CONSTRAINT range)
+ ;
+
+range : ( range_dots
+ | range_attrib_ref
+ )
+ ;
+
+range_dots : #(DOT_DOT simple_expression simple_expression)
+ ;
+
+range_attrib_ref : #(RANGE_ATTRIBUTE_REFERENCE prefix ( expression )? )
+ ;
+
+prefix : IDENTIFIER
+ | #(DOT prefix ( ALL | IDENTIFIER ) )
+ | #(INDEXED_COMPONENT prefix value_s )
+ ;
+
+formal_part_opt : #(FORMAL_PART_OPT ( parameter_specification )* )
+ ;
+
+parameter_specification
+ : #(PARAMETER_SPECIFICATION defining_identifier_list modifiers
+ subtype_mark init_opt)
+ ;
+
+defining_identifier_list : #(DEFINING_IDENTIFIER_LIST ( IDENTIFIER )+ )
+ ;
+
+renames : CHARACTER_STRING // CHARACTER_STRING should not really be there.
+ | OPERATOR_SYMBOL // OPERATOR_SYMBOL should be used instead.
+ | name
+ ;
+
+name : IDENTIFIER
+ | #(DOT name
+ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | OPERATOR_SYMBOL
+ )
+ )
+ | #(INDEXED_COMPONENT name value_s)
+ | #(TIC name attribute_id)
+ ;
+
+definable_operator_symbol : OPERATOR_SYMBOL
+ ;
+
+parenthesized_primary
+ : #(PARENTHESIZED_PRIMARY ( NuLL | value_s extension_opt ) )
+ ;
+
+extension_opt : #(EXTENSION_OPT ( NuLL | value_s )? )
+ ;
+
+def_designator
+ : compound_name
+ | definable_operator_symbol
+ ;
+
+function_tail : formal_part_opt subtype_mark
+ ;
+
+spec_decl_part
+ : #(GENERIC_PACKAGE_INSTANTIATION def_id generic_inst)
+ | #(PACKAGE_SPECIFICATION def_id pkg_spec_part)
+ | #(PACKAGE_RENAMING_DECLARATION def_id renames)
+ ;
+
+pkg_spec_part
+ : basic_declarative_items_opt
+ private_declarative_items_opt
+ end_id_opt
+ ;
+
+basic_declarative_items_opt
+ : #(BASIC_DECLARATIVE_ITEMS_OPT ( basic_decl_item )* )
+ ;
+
+private_declarative_items_opt
+ : #(PRIVATE_DECLARATIVE_ITEMS_OPT ( basic_decl_item )* )
+ ;
+
+basic_decl_item
+ : spec_decl_part
+ | task_type_or_single_decl
+ | prot_type_or_single_decl
+ | subprog_decl
+ | decl_common
+ ;
+
+task_type_or_single_decl
+ : #(TASK_TYPE_DECLARATION def_id discrim_part_opt task_definition_opt)
+ | #(SINGLE_TASK_DECLARATION def_id task_definition_opt)
+ ;
+
+task_definition_opt
+ : task_items_opt private_task_items_opt
+ ;
+
+discrim_part_opt
+ : #(DISCRIM_PART_OPT ( BOX | discriminant_specifications )? )
+ ;
+
+discriminant_specifications
+ : #(DISCRIMINANT_SPECIFICATIONS ( discriminant_specification )* )
+ ;
+
+discriminant_specification
+ : #(DISCRIMINANT_SPECIFICATION defining_identifier_list
+ modifiers subtype_mark init_opt)
+ ;
+
+init_opt : #(INIT_OPT ( expression )? )
+ ; // `expression' is of course much too loose;
+ // semantic checks are required in the usage contexts.
+
+task_items_opt
+ : #(TASK_ITEMS_OPT entrydecls_repspecs_opt)
+ ;
+
+entrydecls_repspecs_opt
+ : ( entry_declaration | pragma | rep_spec )*
+ ;
+
+entry_declaration
+ : #(ENTRY_DECLARATION IDENTIFIER
+ discrete_subtype_def_opt formal_part_opt)
+ ;
+
+discrete_subtype_def_opt
+ : #(DISCRETE_SUBTYPE_DEF_OPT ( discrete_subtype_definition )? )
+ ;
+
+discrete_subtype_definition // TBD
+ : range
+ | subtype_ind
+ ;
+
+rep_spec : #(RECORD_REPRESENTATION_CLAUSE subtype_mark align_opt comp_loc_s)
+ | #(AT_CLAUSE subtype_mark expression)
+ | #(ATTRIBUTE_DEFINITION_CLAUSE subtype_mark expression)
+ // attrib_def. Semantic check must ensure that the
+ // subtype_mark contains an attribute reference.
+ | #(ENUMERATION_REPESENTATION_CLAUSE local_enum_name enumeration_aggregate)
+ ;
+
+align_opt : #(MOD_CLAUSE_OPT ( expression )? )
+ ;
+
+comp_loc_s
+ : #(COMPONENT_CLAUSES_OPT
+ ( pragma
+ | subtype_mark expression range
+ )*
+ )
+ ;
+
+private_task_items_opt
+ : #(PRIVATE_TASK_ITEMS_OPT entrydecls_repspecs_opt )
+ ;
+
+prot_type_or_single_decl
+ : #(PROTECTED_TYPE_DECLARATION def_id discrim_part_opt protected_definition)
+ | #(SINGLE_PROTECTED_DECLARATION def_id protected_definition)
+ ;
+
+prot_private_opt : #(PROT_PRIVATE_OPT ( prot_member_decl_s )? )
+ ;
+
+protected_definition
+ : prot_op_decl_s prot_private_opt end_id_opt
+ ;
+
+prot_op_decl_s
+ : #(PROT_OP_DECLARATIONS ( prot_op_decl )* )
+ ;
+
+prot_op_decl
+ : entry_declaration
+ | #(PROCEDURE_DECLARATION def_id formal_part_opt)
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ | rep_spec
+ | pragma
+ ;
+
+prot_member_decl_s
+ : #(PROT_MEMBER_DECLARATIONS ( prot_op_decl | comp_decl )* )
+ ;
+
+comp_decl
+ : #(COMPONENT_DECLARATION defining_identifier_list component_subtype_def init_opt)
+ ;
+
+// decl_common is shared between declarative_item and basic_decl_item.
+// decl_common only contains specifications.
+decl_common
+ : // type_def:
+ #(ENUMERATION_TYPE_DECLARATION IDENTIFIER enum_id_s)
+ | #(SIGNED_INTEGER_TYPE_DECLARATION IDENTIFIER range)
+ | #(MODULAR_TYPE_DECLARATION IDENTIFIER expression)
+ | #(FLOATING_POINT_DECLARATION IDENTIFIER expression range_constraint_opt)
+ | #(ORDINARY_FIXED_POINT_DECLARATION IDENTIFIER expression range)
+ | #(DECIMAL_FIXED_POINT_DECLARATION IDENTIFIER expression expression range_constraint_opt)
+ | array_type_declaration
+ | access_type_declaration
+ //
+ | #(INCOMPLETE_TYPE_DECLARATION IDENTIFIER discrim_part_opt)
+ // derived_or_private_or_record
+ | #(PRIVATE_EXTENSION_DECLARATION id_and_discrim modifiers subtype_ind)
+ | #(DERIVED_RECORD_EXTENSION id_and_discrim modifiers subtype_ind record_definition)
+ | #(ORDINARY_DERIVED_TYPE_DECLARATION id_and_discrim subtype_ind)
+ | #(PRIVATE_TYPE_DECLARATION id_and_discrim modifiers)
+ | #(RECORD_TYPE_DECLARATION id_and_discrim modifiers record_definition)
+ //
+ | #(SUBTYPE_DECLARATION IDENTIFIER subtype_ind)
+ | generic_decl
+ | use_clause
+ | rep_spec // enumeration_representation_clause only
+ | #(EXCEPTION_RENAMING_DECLARATION def_id compound_name)
+ | #(OBJECT_RENAMING_DECLARATION def_id subtype_mark name)
+ | #(EXCEPTION_DECLARATION defining_identifier_list)
+ | #(NUMBER_DECLARATION defining_identifier_list expression)
+ | #(ARRAY_OBJECT_DECLARATION defining_identifier_list modifiers
+ array_type_definition init_opt)
+ | #(OBJECT_DECLARATION defining_identifier_list modifiers
+ subtype_ind init_opt)
+ ;
+
+id_and_discrim
+ : IDENTIFIER discrim_part_opt
+ ;
+
+enum_id_s : ( enumeration_literal_specification )+
+ ;
+
+enumeration_literal_specification : IDENTIFIER | CHARACTER_LITERAL
+ ;
+
+array_type_definition
+ : index_or_discrete_range_s component_subtype_def
+ ;
+
+range_constraint_opt : ( range_constraint )?
+ ;
+
+array_type_declaration
+ : #(ARRAY_TYPE_DECLARATION IDENTIFIER array_type_definition)
+ ;
+
+index_or_discrete_range_s
+ : index_or_discrete_range
+ | #(COMMA index_or_discrete_range_s index_or_discrete_range)
+ ;
+
+index_or_discrete_range
+ : #(DOT_DOT simple_expression simple_expression)
+ | #(RANGE simple_expression ( BOX | range) )
+ | simple_expression
+ ;
+
+component_subtype_def : modifiers subtype_ind // mod=aliased_opt
+ ;
+
+subtype_ind
+ : #(SUBTYPE_INDICATION subtype_mark constraint_opt)
+ ;
+
+constraint_opt
+ : ( range_constraint
+ | digits_constraint
+ | delta_constraint
+ | index_constraint
+ | discriminant_constraint
+ )?
+ ;
+
+digits_constraint
+ : #(DIGITS_CONSTRAINT expression range_constraint_opt)
+ ;
+
+delta_constraint
+ : #(DELTA_CONSTRAINT expression range_constraint_opt)
+ ;
+
+index_constraint
+ : #(INDEX_CONSTRAINT ( discrete_range )+ )
+ ;
+
+discrete_range
+ : range
+ | subtype_ind
+ ;
+
+discriminant_constraint
+ : #(DISCRIMINANT_CONSTRAINT ( discriminant_association )+ )
+ ;
+
+discriminant_association
+ : #(DISCRIMINANT_ASSOCIATION selector_names_opt expression)
+ ;
+
+selector_names_opt
+ : #(SELECTOR_NAMES_OPT ( selector_name )* )
+ ;
+
+selector_name : IDENTIFIER // TBD: sem pred
+ ;
+
+access_type_declaration
+ : #(ACCESS_TO_PROCEDURE_DECLARATION IDENTIFIER modifiers formal_part_opt)
+ | #(ACCESS_TO_FUNCTION_DECLARATION IDENTIFIER modifiers function_tail)
+ | #(ACCESS_TO_OBJECT_DECLARATION IDENTIFIER modifiers subtype_ind)
+ ;
+
+record_definition : ( component_list )?
+ ;
+
+component_list
+ : component_items ( variant_part )?
+ ;
+
+component_items
+ : #(COMPONENT_ITEMS ( pragma | comp_decl )* )
+ ;
+
+variant_part
+ : #(VARIANT_PART discriminant_direct_name variant_s)
+ ;
+
+discriminant_direct_name : IDENTIFIER // TBD: symtab lookup.
+ ;
+
+variant_s : #(VARIANTS ( variant )+ )
+ ;
+
+variant : #(VARIANT choice_s ( component_list )? )
+ ;
+
+choice_s : #(PIPE choice_s choice )
+ | choice
+ ;
+
+choice : OTHERS
+ | discrete_with_range
+ | expression
+ ;
+
+discrete_with_range : mark_with_constraint | range
+ ;
+
+mark_with_constraint
+ : #(MARK_WITH_CONSTRAINT subtype_mark range_constraint)
+ ;
+
+local_enum_name : IDENTIFIER // to be refined: do a symbol table lookup
+ ;
+
+enumeration_aggregate : ( value )*
+ ;
+
+generic_decl
+ : #(GENERIC_PACKAGE_RENAMING generic_formal_part_opt def_id renames)
+ | #(GENERIC_PACKAGE_DECLARATION generic_formal_part_opt def_id
+ pkg_spec_part)
+ | #(GENERIC_PROCEDURE_RENAMING generic_formal_part_opt def_id
+ formal_part_opt renames)
+ | #(GENERIC_PROCEDURE_DECLARATION generic_formal_part_opt def_id
+ formal_part_opt)
+ | #(GENERIC_FUNCTION_RENAMING generic_formal_part_opt def_designator
+ function_tail renames)
+ | #(GENERIC_FUNCTION_DECLARATION generic_formal_part_opt def_id
+ function_tail)
+ ;
+
+generic_formal_part_opt
+ : #(GENERIC_FORMAL_PART
+ ( pragma | use_clause | generic_formal_parameter )*
+ )
+ ;
+
+generic_formal_parameter
+ : // FORMAL_TYPE_DECLARATIONs:
+ #(FORMAL_DISCRETE_TYPE_DECLARATION def_id)
+ | #(FORMAL_SIGNED_INTEGER_TYPE_DECLARATION def_id)
+ | #(FORMAL_MODULAR_TYPE_DECLARATION def_id)
+ | #(FORMAL_DECIMAL_FIXED_POINT_DECLARATION def_id)
+ | #(FORMAL_ORDINARY_FIXED_POINT_DECLARATION def_id)
+ | #(FORMAL_FLOATING_POINT_DECLARATION def_id)
+ | formal_array_type_declaration
+ | formal_access_type_declaration
+ | #(FORMAL_PRIVATE_TYPE_DECLARATION id_part modifiers)
+ | #(FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION id_part subtype_ind)
+ | #(FORMAL_PRIVATE_EXTENSION_DECLARATION id_part modifiers subtype_ind)
+ | #(FORMAL_PROCEDURE_DECLARATION def_id formal_part_opt
+ subprogram_default_opt)
+ | #(FORMAL_FUNCTION_DECLARATION def_designator function_tail
+ subprogram_default_opt)
+ | #(FORMAL_PACKAGE_DECLARATION def_id compound_name formal_package_actual_part_opt)
+ | parameter_specification
+ ;
+
+
+id_part : def_id discrim_part_opt
+ ;
+
+formal_array_type_declaration : array_type_declaration
+ ;
+
+formal_access_type_declaration : access_type_declaration
+ ;
+
+subprogram_default_opt : ( BOX | name )?
+ // #(SUBPROGRAM_DEFAULT_OPT ( BOX | name )? )
+ ;
+
+formal_package_actual_part_opt
+ : ( BOX | defining_identifier_list )?
+ ;
+
+subprog_decl_or_rename_or_inst_or_body
+ : subprog_decl
+ | procedure_body
+ | function_body
+ ;
+
+procedure_body
+ : #(PROCEDURE_BODY def_id formal_part_opt body_part)
+ ;
+
+function_body
+ : #(FUNCTION_BODY def_designator function_tail body_part)
+ ;
+
+body_part : declarative_part block_body end_id_opt
+ ;
+
+declarative_part
+ : #(DECLARATIVE_PART ( pragma | declarative_item )* )
+ ;
+
+// A declarative_item may appear in the declarative part of any body.
+declarative_item
+ : #(PACKAGE_BODY_STUB def_id)
+ | #(PACKAGE_BODY def_id pkg_body_part)
+ | spec_decl_part
+ | #(TASK_BODY_STUB def_id)
+ | #(TASK_BODY def_id body_part end_id_opt)
+ | task_type_or_single_decl
+ | #(PROTECTED_BODY_STUB def_id)
+ | #(PROTECTED_BODY def_id prot_op_bodies_opt end_id_opt)
+ | prot_type_or_single_decl
+ | subprog_decl_or_rename_or_inst_or_body
+ | decl_common
+ ;
+
+pkg_body_part : declarative_part block_body_opt end_id_opt
+ ;
+
+block_body_opt
+ : #(BLOCK_BODY_OPT ( handled_stmt_s )? )
+ ;
+
+prot_op_bodies_opt
+ : #(PROT_OP_BODIES_OPT
+ ( pragma | entry_body | subprog_decl_or_body )*
+ )
+ ;
+
+subprog_decl_or_body
+ : procedure_body
+ | #(PROCEDURE_DECLARATION def_id formal_part_opt)
+ | function_body
+ | #(FUNCTION_DECLARATION def_designator function_tail)
+ ;
+
+block_body : #(BLOCK_BODY handled_stmt_s)
+ ;
+
+handled_stmt_s
+ : #(HANDLED_SEQUENCE_OF_STATEMENTS statements except_handler_part_opt)
+ ;
+
+handled_stmts_opt
+ : #(HANDLED_STMTS_OPT ( statements except_handler_part_opt )? )
+ ;
+
+statements
+ : #(SEQUENCE_OF_STATEMENTS ( pragma | statement )+ )
+ ;
+
+statement : #(STATEMENT def_label_opt
+ ( null_stmt
+ | exit_stmt
+ | return_stmt
+ | goto_stmt
+ | delay_stmt
+ | abort_stmt
+ | raise_stmt
+ | requeue_stmt
+ | accept_stmt
+ | select_stmt
+ | if_stmt
+ | case_stmt
+ | loop_stmt id_opt
+ | block end_id_opt
+ | call_or_assignment
+ // | code_stmt // not yet implemented in parser
+ )
+ )
+ ;
+
+def_label_opt : #(LABEL_OPT ( IDENTIFIER )? )
+ ;
+
+null_stmt : NULL_STATEMENT
+ ;
+
+if_stmt : #(IF_STATEMENT cond_clause elsifs_opt else_opt)
+ ;
+
+cond_clause : #(COND_CLAUSE condition statements)
+ ;
+
+condition : expression
+ ;
+
+elsifs_opt : #(ELSIFS_OPT ( cond_clause )* )
+ ;
+
+else_opt : #(ELSE_OPT ( statements )? )
+ ;
+
+case_stmt : #(CASE_STATEMENT expression alternative_s)
+ ;
+
+alternative_s : ( case_statement_alternative )+
+ ;
+
+case_statement_alternative
+ : #(CASE_STATEMENT_ALTERNATIVE choice_s statements)
+ ;
+
+loop_stmt
+ : #(LOOP_STATEMENT iteration_scheme_opt statements)
+ ;
+
+iteration_scheme_opt
+ : #(ITERATION_SCHEME_OPT
+ ( #(WHILE condition)
+ | #(FOR IDENTIFIER modifiers discrete_subtype_definition)
+ )? // mod=reverse_opt
+ )
+ ;
+
+block : #(BLOCK_STATEMENT declare_opt block_body)
+ ;
+
+declare_opt
+ : #(DECLARE_OPT ( declarative_part )? )
+ ;
+
+exit_stmt
+ : #(EXIT_STATEMENT ( label_name )? ( WHEN condition )? ) // TBD !!!
+ ;
+
+label_name : IDENTIFIER
+ ;
+
+return_stmt
+ : #(RETURN_STATEMENT ( expression )? )
+ ;
+
+goto_stmt : #(GOTO_STATEMENT label_name)
+ ;
+
+call_or_assignment
+ : #(ASSIGNMENT_STATEMENT name expression)
+ | #(CALL_STATEMENT name)
+ ;
+
+entry_body
+ : #(ENTRY_BODY def_id entry_body_formal_part entry_barrier body_part)
+ ;
+
+entry_body_formal_part : entry_index_spec_opt formal_part_opt
+ ;
+
+entry_index_spec_opt
+ : #(ENTRY_INDEX_SPECIFICATION ( def_id discrete_subtype_definition )? )
+ ;
+
+entry_barrier : condition
+ ;
+
+entry_call_stmt
+ : #(ENTRY_CALL_STATEMENT name)
+ ;
+
+accept_stmt
+ : #(ACCEPT_STATEMENT def_id entry_index_opt formal_part_opt
+ handled_stmts_opt end_id_opt )
+ ;
+
+entry_index_opt
+ : #(ENTRY_INDEX_OPT ( expression )? )
+ ;
+
+delay_stmt
+ : #(DELAY_STATEMENT modifiers expression) //mod=until_opt
+ ;
+
+// SELECT_STATEMENT itself is not modeled since it is trivially
+// reconstructed:
+// select_statement ::= selective_accept | timed_entry_call
+// | conditional_entry_call | asynchronous_select
+//
+select_stmt
+ : #(ASYNCHRONOUS_SELECT triggering_alternative abortable_part)
+ | #(SELECTIVE_ACCEPT selective_accept)
+ | #(TIMED_ENTRY_CALL entry_call_alternative delay_alternative)
+ | #(CONDITIONAL_ENTRY_CALL entry_call_alternative statements)
+ ;
+
+triggering_alternative
+ : #(TRIGGERING_ALTERNATIVE
+ ( delay_stmt | entry_call_stmt ) stmts_opt
+ )
+ ;
+
+abortable_part
+ : #(ABORTABLE_PART stmts_opt)
+ ;
+
+entry_call_alternative
+ : #(ENTRY_CALL_ALTERNATIVE entry_call_stmt stmts_opt)
+ ;
+
+selective_accept : guard_opt select_alternative or_select_opt else_opt
+ ;
+
+guard_opt : #(GUARD_OPT ( condition ( pragma )* )? )
+ ;
+
+select_alternative
+ : accept_alternative
+ | delay_alternative
+ | TERMINATE_ALTERNATIVE
+ ;
+
+accept_alternative
+ : #(ACCEPT_ALTERNATIVE accept_stmt stmts_opt)
+ ;
+
+delay_alternative
+ : #(DELAY_ALTERNATIVE delay_stmt stmts_opt)
+ ;
+
+stmts_opt : ( pragma | statement )*
+ ;
+
+or_select_opt
+ : #(OR_SELECT_OPT ( guard_opt select_alternative )* )
+ ;
+
+abort_stmt
+ : #(ABORT_STATEMENT ( name )+ )
+ ;
+
+except_handler_part_opt
+ : #(EXCEPT_HANDLER_PART_OPT ( exception_handler )* )
+ ;
+
+exception_handler
+ : #(EXCEPTION_HANDLER identifier_colon_opt except_choice_s
+ statements
+ )
+ ;
+
+identifier_colon_opt
+ : #(IDENTIFIER_COLON_OPT ( IDENTIFIER )? )
+ ;
+
+except_choice_s
+ : #(PIPE except_choice_s exception_choice)
+ | exception_choice
+ ;
+
+exception_choice : compound_name
+ | OTHERS
+ ;
+
+raise_stmt
+ : #(RAISE_STATEMENT ( compound_name )? )
+ ;
+
+requeue_stmt
+ : #(REQUEUE_STATEMENT name ( ABORT )? )
+ ;
+
+operator_call : #(OPERATOR_SYMBOL value_s)
+ ;
+
+value_s : #(VALUES ( value )+ )
+ ;
+
+expression
+ : #(AND expression relation)
+ | #(AND_THEN expression relation)
+ | #(OR expression relation)
+ | #(OR_ELSE expression relation)
+ | #(XOR expression relation)
+ | relation
+ ;
+
+relation
+ : #(IN simple_expression range_or_mark)
+ | #(NOT_IN simple_expression range_or_mark)
+ | #(EQ simple_expression simple_expression)
+ | #(NE simple_expression simple_expression)
+ | #(LT_ simple_expression simple_expression)
+ | #(LE simple_expression simple_expression)
+ | #(GT simple_expression simple_expression)
+ | #(GE simple_expression simple_expression)
+ | simple_expression
+ ;
+
+range_or_mark
+ : range
+ | subtype_mark
+ ;
+
+simple_expression
+ : #(PLUS simple_expression signed_term)
+ | #(MINUS simple_expression signed_term)
+ | #(CONCAT simple_expression signed_term)
+ | signed_term
+ ;
+
+signed_term
+ : #(UNARY_PLUS term)
+ | #(UNARY_MINUS term)
+ | term
+ ;
+
+term : #(STAR term factor)
+ | #(DIV term factor)
+ | #(MOD term factor)
+ | #(REM term factor)
+ | factor
+ ;
+
+factor : #(NOT primary)
+ | #(ABS primary)
+ | #(EXPON primary primary)
+ | primary
+ ;
+
+primary :
+ ( name_or_qualified
+ | parenthesized_primary
+ | allocator
+ | NuLL
+ | NUMERIC_LIT
+ | CHARACTER_LITERAL
+ | CHAR_STRING
+ | operator_call
+ )
+ ;
+
+// Temporary, to be turned into just `qualified'.
+// We get away with it because `qualified' is always mentioned
+// together with `name'.
+// Only exception: `code_stmt', which is not yet implemented.
+name_or_qualified
+ : IDENTIFIER
+ | #(DOT name_or_qualified
+ ( ALL
+ | IDENTIFIER
+ | CHARACTER_LITERAL
+ | OPERATOR_SYMBOL
+ )
+ )
+ | #(INDEXED_COMPONENT name_or_qualified value_s)
+ | #(TIC name_or_qualified
+ ( parenthesized_primary
+ | attribute_id
+ )
+ )
+ ;
+
+allocator : #(ALLOCATOR name_or_qualified)
+ ;
+
+subunit : #(SUBUNIT compound_name
+ ( subprogram_body
+ | package_body
+ | task_body
+ | protected_body
+ )
+ )
+ ;
+
+subprogram_body
+ : procedure_body
+ | function_body
+ ;
+
+package_body : #(PACKAGE_BODY def_id pkg_body_part)
+ ;
+
+task_body : #(TASK_BODY def_id body_part)
+ ;
+
+protected_body : #(PROTECTED_BODY def_id prot_op_bodies_opt)
+ ;
+
+// TBD
+// code_stmt : #(CODE_STATEMENT qualified)
+// ;
+
diff --git a/languages/ada/ada_utils.cpp b/languages/ada/ada_utils.cpp
new file mode 100644
index 00000000..9630f058
--- /dev/null
+++ b/languages/ada/ada_utils.cpp
@@ -0,0 +1,69 @@
+/*
+ */
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qfile.h>
+#include <qregexp.h>
+
+#include <kdebug.h>
+
+#include "ada_utils.hpp"
+#include "adasupport.hpp"
+
+QString qtext (const RefAdaAST& n)
+{
+ return QString::fromLatin1 (text (n).c_str ());
+}
+
+QStringList qnamelist (const RefAdaAST& n)
+{
+ QString txt = qtext (n);
+ // kdDebug() << "qnamelist: input is " << txt << endl;
+ return QStringList::split ('.', txt);
+}
+
+QString ada_spec_filename (const QString& comp_unit_name)
+{
+ QString fn (comp_unit_name.lower ());
+
+ fn.replace (QRegExp("."), "-");
+ fn += ".ads";
+ return fn;
+}
+
+QString fq_specfilename (const QString& comp_unit_name)
+{
+ QString fname = ada_spec_filename (comp_unit_name);
+
+ if (QFile::exists (fname))
+ return fname;
+
+ QString adaincpath = getenv ("ADA_INCLUDE_PATH");
+ if (adaincpath.isNull ())
+ return QString::null;
+
+ QStringList dirs = QStringList::split (':', adaincpath);
+ QString fq_filename;
+ for (QStringList::Iterator it = dirs.begin (); it != dirs.end (); it++) {
+ fq_filename = *it;
+ if (! fq_filename.endsWith ("/"))
+ fq_filename += "/";
+ fq_filename += fname;
+ if (QFile::exists (fq_filename))
+ return fq_filename;
+ }
+ if (fname.startsWith ("ada-") ||
+ fname.startsWith ("text_io") ||
+ fname.startsWith ("system") ||
+ fname.startsWith ("unchecked_")) {
+ kdDebug () << "resolution of Ada predefined library is TBD" << endl;
+ } else {
+ kdDebug () << "Cannot find file " << fname << endl;
+ }
+ return QString::null;
+}
+
diff --git a/languages/ada/ada_utils.hpp b/languages/ada/ada_utils.hpp
new file mode 100644
index 00000000..b1df43dd
--- /dev/null
+++ b/languages/ada/ada_utils.hpp
@@ -0,0 +1,15 @@
+/*
+ */
+#ifndef ADA_UTILS_H
+#define ADA_UTILS_H
+
+#include <qstring.h>
+#include "AdaAST.hpp"
+
+QString qtext (const RefAdaAST& n);
+QStringList qnamelist (const RefAdaAST& n);
+QString ada_spec_filename (const QString& comp_unit_name);
+QString fq_specfilename (const QString& comp_unit_name);
+
+#endif
+
diff --git a/languages/ada/adasupport.cpp b/languages/ada/adasupport.cpp
new file mode 100644
index 00000000..6b877b7b
--- /dev/null
+++ b/languages/ada/adasupport.cpp
@@ -0,0 +1,168 @@
+#include <ctype.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stack>
+#include <string>
+#include <antlr/AST.hpp>
+#include "AdaParser.hpp"
+#include "AdaTokenTypes.hpp"
+#include "adasupport.hpp"
+
+#define eq !strcmp
+
+using namespace std;
+
+const RefAdaAST AdaAST::nullAdaAST(antlr::nullAST.get() );
+
+using namespace std;
+
+string text (const RefAdaAST& n)
+{
+ if (n == 0 || n == AdaAST::nullAdaAST)
+ return "";
+ string retval;
+ int type = n->getType();
+ if (type == AdaTokenTypes::DOT) {
+ const RefAdaAST& sibs = n->down ();
+ retval = text (sibs);
+ retval.append (".");
+ retval.append (text (sibs->right()));
+ } else {
+ retval = n->getText();
+ }
+ /*
+ const RefAdaAST& r = n->right();
+ if (r != 0 && r->getType () == AdaTokenTypes::DOT) {
+ retval.append (".");
+ retval.append (text (r->right()));
+ }
+ */
+ return retval;
+}
+
+int txteq (RefAdaAST n1, RefAdaAST n2)
+{
+ if (!n1 || !n2 || n1 == antlr::nullAST || n2 == antlr::nullAST)
+ return 0;
+ const char* s1 = n1->getText().c_str();
+ const char* s2 = n2->getText().c_str();
+ if (strcasecmp (s1, s2) != 0)
+ return 0;
+ n1 = n1->right ();
+ n2 = n2->right ();
+ if (!n1 || !n2 || n1 == antlr::nullAST || n2 == antlr::nullAST)
+ return 1;
+ if (n1->getType () == AdaTokenTypes::DOT)
+ if (n2->getType () == AdaTokenTypes::DOT)
+ return txteq (n1->right (), n2->right ());
+ else
+ return 0;
+ else if (n2->getType () == AdaTokenTypes::DOT)
+ return 0;
+ return 1;
+}
+
+std::stack<RefAdaAST> defid_stack;
+
+void AdaParser::push_def_id (const RefAdaAST& defid)
+{
+#ifdef __DEBUG__
+ string txt (text (defid));
+ printf ("push_def_id: pushing %s\n", txt.c_str());
+#endif
+ defid_stack.push (defid);
+}
+
+const RefAdaAST& AdaParser::pop_def_id ()
+{
+ if (defid_stack.size() == 0) {
+ fprintf (stderr, "pop_def_id() called on empty stack\n");
+ // return static_cast<RefAdaAST>(antlr::nullAST);
+ return AdaAST::nullAdaAST;
+ }
+ RefAdaAST& top = defid_stack.top ();
+#ifdef __DEBUG__
+ string txt (text (top));
+ printf ("pop_def_id: popping %s\n", txt.c_str());
+#endif
+ defid_stack.pop ();
+ return top;
+}
+
+bool AdaParser::end_id_matches_def_id (const RefAdaAST& endid)
+{
+ if (defid_stack.size() == 0)
+ return false;
+ RefAdaAST& top = defid_stack.top ();
+ string defid (text (top));
+ defid_stack.pop();
+ if (endid == 0 || endid == antlr::nullAST)
+ return false;
+ string txt (text (endid));
+ if (strcasecmp (defid.c_str (), txt.c_str ()) != 0) {
+ string errtxt ("End id ");
+ errtxt.append (txt);
+ errtxt.append (" does not match ");
+ errtxt.append (defid);
+ reportError (errtxt);
+ return false;
+ }
+#ifdef __DEBUG__
+ printf ("end_id_matches_def_id: popped %s\n", txt.c_str());
+#endif
+ return true;
+}
+
+char * strtolower (char *string)
+{
+ char *p = string;
+ if (!p)
+ return NULL;
+ while (*p)
+ {
+ if (isupper (*p))
+ *p = tolower (*p);
+ p++;
+ }
+ return string;
+}
+
+char * extracted_operator (const char *string)
+{
+ int len = strlen (string);
+ static char op[10];
+
+ if (len < 4 && len > 5 || *string != '"' || *(string + len - 1) != '"')
+ return NULL;
+
+ strcpy (op, string + 1);
+ op[len - 2] = '\0'; /* discard ending quotation mark */
+ strtolower (op);
+ return op;
+}
+
+bool AdaParser::definable_operator (const char *string)
+{ // operator_symbol sans "/="
+ char *op = extracted_operator (string);
+ if (op == NULL)
+ return false;
+ return
+ (eq (op, "=") ||
+ eq (op, "<") || eq (op, ">") ||
+ eq (op, "<=") || eq (op, ">=") ||
+ eq (op, "&") || eq (op, "**") ||
+ eq (op, "*") || eq (op, "/") || eq (op, "+") || eq (op, "-") ||
+ eq (op, "abs") || eq (op, "rem") || eq (op, "mod") ||
+ eq (op, "and") || eq (op, "or") || eq (op, "xor") || eq (op, "not"));
+}
+
+bool AdaParser::is_operator_symbol (const char *string)
+{
+ char *op;
+ if (definable_operator (string))
+ return true;
+ op = extracted_operator (string);
+ return (eq (op, "/="));
+}
+
diff --git a/languages/ada/adasupport.hpp b/languages/ada/adasupport.hpp
new file mode 100644
index 00000000..9d65e0e5
--- /dev/null
+++ b/languages/ada/adasupport.hpp
@@ -0,0 +1,13 @@
+/*
+ */
+#ifndef ADASUPPORT_H
+#define ADASUPPORT_H
+
+#include <string>
+#include "AdaAST.hpp"
+
+std::string text (const RefAdaAST& n);
+int txteq (RefAdaAST n1, RefAdaAST n2);
+
+#endif
+
diff --git a/languages/ada/adasupportpart.cpp b/languages/ada/adasupportpart.cpp
new file mode 100644
index 00000000..39ead02a
--- /dev/null
+++ b/languages/ada/adasupportpart.cpp
@@ -0,0 +1,376 @@
+
+#include <qfileinfo.h>
+#include <qlistview.h>
+#include <qstringlist.h>
+#include <qtimer.h>
+#include <qvbox.h>
+#include <qprogressbar.h>
+#include <qwhatsthis.h>
+
+#include <kgenericfactory.h>
+#include <kapplication.h>
+#include <kdebug.h>
+#include <klocale.h>
+#include <kstatusbar.h>
+#include <kdialogbase.h>
+#include <kiconloader.h>
+
+#include <fstream>
+#include <sstream>
+
+#include "kdevgenericfactory.h"
+#include "kdevcore.h"
+#include "kdevproject.h"
+#include "kdevmainwindow.h"
+#include "kdevpartcontroller.h"
+#include "codemodel.h"
+#include "adasupportpart.h"
+#include "problemreporter.h"
+#include "backgroundparser.h"
+
+#include "AdaLexer.hpp"
+#include "AdaParser.hpp"
+#include "AdaStoreWalker.hpp"
+#include "AdaAST.hpp"
+
+#include <kdevplugininfo.h>
+
+enum { KDEV_DB_VERSION = 6 };
+enum { KDEV_PCS_VERSION = 6 };
+
+typedef KDevGenericFactory<AdaSupportPart> AdaSupportPartFactory;
+
+static const KDevPluginInfo data("kdevadasupport");
+K_EXPORT_COMPONENT_FACTORY (libkdevadasupport, AdaSupportPartFactory (data))
+
+
+struct AdaSupportPartData {
+ ProblemReporter* problemReporter;
+
+ AdaSupportPartData () : problemReporter (0) {}
+};
+
+AdaSupportPart::AdaSupportPart (QObject *parent, const char *name, const QStringList &)
+ : KDevLanguageSupport (&data, parent, name ? name : "AdaSupportPart"), d (new AdaSupportPartData())
+{
+ setInstance (AdaSupportPartFactory::instance ());
+
+ d->problemReporter = new ProblemReporter (this);
+// connect (core (), SIGNAL (configWidget (KDialogBase*)),
+// d->problemReporter, SLOT (configWidget (KDialogBase*)));
+ d->problemReporter->setIcon( SmallIcon("info") );
+ 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."));
+
+ setXMLFile ("adasupportpart.rc");
+
+ 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 (configWidget (KDialogBase*)), this, SLOT (configWidget (KDialogBase*)));
+ connect( core(), SIGNAL(configWidget(KDialogBase*)),
+ d->problemReporter, SLOT(configWidget(KDialogBase*)) );
+
+ // a small hack (robe)
+ //classStore ()->globalScope ()->setName ("(default packages)");
+ //classStore ()->addScope (classStore ()->globalScope ());
+ //classStore ()->globalScope ()->setName (QString::null);
+}
+
+
+AdaSupportPart::~AdaSupportPart ()
+{
+ mainWindow ()->removeView (d->problemReporter);
+ delete (d->problemReporter);
+ d->problemReporter = 0;
+
+ delete (d);
+ d = 0;
+}
+
+
+KDevLanguageSupport::Features AdaSupportPart::features ()
+{
+ return KDevLanguageSupport::Features
+ ( // TBD: Classes |
+ Functions | Namespaces);
+}
+
+void AdaSupportPart::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( changedFilesInProject( const QStringList & ) ),
+ this, SLOT( changedFilesInProject( const QStringList & ) ) );
+
+ QTimer::singleShot (0, this, SLOT (initialParse ()));
+}
+
+
+void AdaSupportPart::projectClosed ()
+{
+ saveProjectSourceInfo();
+}
+
+
+void AdaSupportPart::initialParse ()
+{
+ kdDebug () << "------------------------------------------> initialParse ()" << endl;
+
+ if (project ())
+ {
+ mainWindow()->statusBar()->message( i18n("Updating...") );
+ kapp->processEvents( );
+ kapp->setOverrideCursor (waitCursor);
+
+ int n = 0;
+ QStringList files = project ()->allFiles ();
+
+ QProgressBar* bar = new QProgressBar( files.count( ), mainWindow( )->statusBar( ) );
+ bar->setMinimumWidth( 120 );
+ bar->setCenterIndicator( true );
+ mainWindow( )->statusBar( )->addWidget( bar );
+ bar->show( );
+
+ for (QStringList::Iterator it = files.begin (); it != files.end (); ++it) {
+ bar->setProgress( n++ );
+
+ QString fn = project ()->projectDirectory () + "/" + *it;
+ maybeParse (fn);
+ kapp->processEvents (500);
+ }
+
+ emit updatedSourceInfo();
+
+ mainWindow( )->statusBar( )->removeWidget( bar );
+ delete bar;
+
+ kapp->restoreOverrideCursor ();
+ mainWindow( )->statusBar( )->message( i18n( "Done" ), 2000 );
+/* mainWindow ()->statusBar ()->message
+ (i18n ("Found 1 problem", "Found %n problems", d->problemReporter->childCount ()));*/
+ }
+}
+
+QStringList AdaSupportPart::fileExtensions ()
+{
+ return QStringList () << "ads" << "adb";
+}
+
+void AdaSupportPart::maybeParse (const QString &fileName)
+{
+ kdDebug () << "AdaSupportPart::maybeParse: " << fileName << endl;
+
+ if (!fileExtensions ().contains (QFileInfo (fileName).extension ()))
+ return;
+
+// mainWindow ()->statusBar ()->message (i18n ("Parsing file: %1").arg (fileName));
+ parse (fileName);
+}
+
+
+void AdaSupportPart::addedFilesToProject (const QStringList &fileList)
+{
+ QStringList::ConstIterator it;
+
+ for (it = fileList.begin (); it != fileList.end (); ++it)
+ {
+ QString path = project ()->projectDirectory () + "/" + (*it);
+ maybeParse (path);
+ emit addedSourceInfo( path );
+ }
+}
+
+
+void AdaSupportPart::removedFilesFromProject (const QStringList &fileList)
+{
+ QStringList::ConstIterator it;
+
+ for (it = fileList.begin (); it != fileList.end (); ++it)
+ {
+ kdDebug () << "AdaSupportPart::removedFileFromProject () -- " << (*it) << endl;
+ QString path = project ()->projectDirectory () + "/" + (*it);
+
+ if( codeModel()->hasFile(path) )
+ {
+ emit aboutToRemoveSourceInfo( path );
+ codeModel()->removeFile( codeModel()->fileByName(path) );
+ }
+ }
+
+// emit updatedSourceInfo();
+}
+
+
+void AdaSupportPart::parse (const QString &fileName)
+{
+ kdDebug () << "AdaSupportPart::parse () -- " << fileName << endl;
+
+ std::ifstream stream (QFile::encodeName( fileName ).data());
+ QCString _fn = fileName.utf8 ();
+ std::string fn (_fn.data ());
+
+ AdaLexer lexer (stream);
+ lexer.setFilename (fn);
+ lexer.setProblemReporter (d->problemReporter);
+
+ AdaParser parser (lexer);
+ parser.setFilename (fn);
+ parser.setProblemReporter (d->problemReporter);
+
+ // make an ast factory
+ antlr::ASTFactory ast_factory;
+ // initialize and put it in the parser...
+ parser.initializeASTFactory (ast_factory);
+ parser.setASTFactory (&ast_factory);
+ // parser.setASTNodeType ("RefAdaAST");
+
+ try {
+ // old: parser.setASTNodeFactory (AdaAST::factory);
+ lexer.resetErrors ();
+ parser.resetErrors ();
+
+ parser.compilation_unit ();
+ int errors = lexer.numberOfErrors () + parser.numberOfErrors ();
+
+ RefAdaAST ast = RefAdaAST (parser.getAST ());
+
+ if (errors == 0 && ast != antlr::nullAST) {
+ kdDebug () << "-------------------> start StoreWalker" << endl;
+ AdaStoreWalker walker;
+ walker.setFileName (fileName);
+ walker.setCodeModel (codeModel ());
+ walker.compilation_unit (ast);
+ }
+ } catch (antlr::ANTLRException& ex) {
+ kdDebug () << "*exception*: " << ex.toString ().c_str () << endl;
+ d->problemReporter->reportError (QString::fromLatin1( ex.getMessage ().c_str() ),
+ fileName,
+ lexer.getLine (),
+ lexer.getColumn ());
+ }
+}
+
+void AdaSupportPart::parseContents (const QString& contents, const QString& fileName)
+{
+ kdDebug () << "AdaSupportPart::parseContents () -- " << fileName << endl;
+
+ QCString _fn = QFile::encodeName (fileName);
+ std::string fn (_fn.data ());
+
+ QCString text = contents.utf8 ();
+ std::istringstream stream ((const char *)text);
+
+ AdaLexer lexer (stream);
+ lexer.setFilename (fn);
+ lexer.setProblemReporter (d->problemReporter);
+
+ AdaParser parser (lexer);
+ parser.setFilename (fn);
+ parser.setProblemReporter (d->problemReporter);
+
+ try {
+ lexer.resetErrors ();
+ parser.resetErrors ();
+
+ parser.compilation_unit ();
+ int errors = lexer.numberOfErrors () + parser.numberOfErrors ();
+ Q_UNUSED( errors );
+
+ } catch (antlr::ANTLRException& ex) {
+ kdDebug () << "*exception*: " << ex.toString ().c_str () << endl;
+ d->problemReporter->reportError (QString::fromLatin1( ex.getMessage().c_str() ),
+ fileName,
+ lexer.getLine (),
+ lexer.getColumn ());
+ }
+}
+
+
+
+void AdaSupportPart::savedFile (const KURL& fileName)
+{
+ kdDebug () << "AdaSupportPart::savedFile ()" << endl;
+
+ if (project ()->allFiles ().contains (fileName.path().mid (project ()->projectDirectory ().length () + 1))) {
+ maybeParse (fileName.path());
+ emit updatedSourceInfo();
+ }
+}
+
+KMimeType::List AdaSupportPart::mimeTypes( )
+{
+ KMimeType::List list;
+
+ list << KMimeType::mimeType( "text/x-adasrc" );
+
+ return list;
+}
+
+//@todo adymo: implement source info loading and saving
+//hint: check javasupport for an example
+// and modify initialParse() method
+void AdaSupportPart::saveProjectSourceInfo( )
+{
+/* const FileList fileList = codeModel()->fileList();
+
+ if( !project() || fileList.isEmpty() )
+ return;
+
+ QFile f( project()->projectDirectory() + "/" + project()->projectName() + ".pcs" );
+ if( !f.open( IO_WriteOnly ) )
+ return;
+
+ QDataStream stream( &f );
+ QMap<QString, Q_ULONG> offsets;
+
+ QString pcs( "PCS" );
+ stream << pcs << KDEV_PCS_VERSION;
+
+ stream << int( fileList.size() );
+ for( FileList::ConstIterator it=fileList.begin(); it!=fileList.end(); ++it ){
+ const FileDom dom = (*it);
+#if QT_VERSION >= 0x030100
+ stream << dom->name() << m_timestamp[ dom->name() ].toTime_t();
+#else
+ stream << dom->name() << toTime_t(m_timestamp[ dom->name() ]);
+#endif
+ offsets.insert( dom->name(), stream.device()->at() );
+ stream << (Q_ULONG)0; // dummy offset
+ }
+
+ for( FileList::ConstIterator it=fileList.begin(); it!=fileList.end(); ++it ){
+ const FileDom dom = (*it);
+ int offset = stream.device()->at();
+
+ dom->write( stream );
+
+ int end = stream.device()->at();
+
+ stream.device()->at( offsets[dom->name()] );
+ stream << offset;
+ stream.device()->at( end );
+ }*/
+}
+
+void AdaSupportPart::changedFilesInProject( const QStringList & fileList )
+{
+ QStringList files = fileList;
+
+ for ( QStringList::ConstIterator it = files.begin(); it != files.end(); ++it )
+ {
+ QString path = project ()->projectDirectory () + "/" + *it ;
+
+ maybeParse( path );
+ emit addedSourceInfo( path );
+ }
+}
+
+
+#include "adasupportpart.moc"
diff --git a/languages/ada/adasupportpart.h b/languages/ada/adasupportpart.h
new file mode 100644
index 00000000..d9f2c45d
--- /dev/null
+++ b/languages/ada/adasupportpart.h
@@ -0,0 +1,50 @@
+//
+#ifndef __ADASUPPORTPART_H__
+#define __ADASUPPORTPART_H__
+
+#include "kdevlanguagesupport.h"
+
+#include <qwaitcondition.h>
+
+class AdaSupportPartData;
+class KDialogBase;
+class QStringList;
+
+class AdaSupportPart : public KDevLanguageSupport
+{
+ Q_OBJECT
+public:
+ AdaSupportPart (QObject *parent, const char *name, const QStringList &);
+ ~AdaSupportPart ();
+
+ void parseContents (const QString& contents, const QString& fileName);
+
+protected:
+ Features features ();
+ KMimeType::List mimeTypes ();
+ QStringList fileExtensions ();
+
+private slots:
+ void projectOpened ();
+ void projectClosed ();
+
+ void addedFilesToProject (const QStringList &fileList);
+ void removedFilesFromProject (const QStringList &fileList);
+ void changedFilesInProject( const QStringList &fileList );
+
+ void initialParse ();
+ void savedFile (const KURL&);
+
+private:
+ void maybeParse (const QString &fileName);
+ void parse (const QString &fileName);
+
+ void saveProjectSourceInfo( );
+private:
+ AdaSupportPartData* d;
+
+friend class ProblemReporter;
+};
+
+
+#endif
diff --git a/languages/ada/addclass.cpp b/languages/ada/addclass.cpp
new file mode 100644
index 00000000..5a5ccb13
--- /dev/null
+++ b/languages/ada/addclass.cpp
@@ -0,0 +1,351 @@
+#include <sys/stat.h>
+#include <sys/types.h>
+
+
+#include <qcheckbox.h>
+#include <qradiobutton.h>
+#include <qtextedit.h>
+#include <qtextstream.h>
+#include <qregexp.h>
+#include <qfile.h>
+#include <qfileinfo.h>
+
+
+#include <klineedit.h>
+#include <kcombobox.h>
+#include <keditlistbox.h>
+#include <kdebug.h>
+
+
+#include "addclassdlg.h"
+
+
+#include "addclass.h"
+
+
+AddClassInfo::AddClassInfo()
+ : interfaceOpt(false), abstractOpt(false), finalOpt(false),
+ createConstructor(true), createMain(false)
+{
+}
+
+
+QString AddClassInfo::adaFileName() const
+{
+ QString dest = className;
+ dest.replace(QRegExp("\\."), "/");
+ return sourceDir + "/" + dest + ".ada";
+}
+
+
+AddClass::AddClass()
+{
+}
+
+
+void AddClass::setInfo(const AddClassInfo &info)
+{
+ m_info = info;
+}
+
+
+AddClassInfo &AddClass::info()
+{
+ return m_info;
+}
+
+
+void AddClass::setBaseClasses(const QStringList &classes)
+{
+ m_baseClasses = classes;
+}
+
+
+bool AddClass::showDialog()
+{
+ AddClassDlg dlg;
+
+ QString dir = m_info.projectDir;
+ if (m_info.sourceDir.isEmpty())
+ m_info.sourceDir = "src";
+ if (dir.isEmpty())
+ dir = m_info.sourceDir;
+ else
+ dir = dir + "/" + m_info.sourceDir;
+
+ dlg.SourcePath->setText(dir);
+ dlg.ClassName->setText(m_info.className);
+ dlg.Extends->insertStringList(m_baseClasses);
+ dlg.Extends->setEditText(m_info.extends);
+ dlg.Interface->setChecked(m_info.interfaceOpt);
+ dlg.Abstract->setChecked(m_info.abstractOpt);
+ dlg.Final->setChecked(m_info.finalOpt);
+
+ switch (m_info.visibility)
+ {
+ case AddClassInfo::ProtectedClass:
+ dlg.Protected->setChecked(true);
+ break;
+ case AddClassInfo::PrivateClass:
+ dlg.Private->setChecked(true);
+ break;
+ default:
+ dlg.Public->setChecked(true);
+ break;
+ }
+
+ dlg.Implements->insertStringList(m_info.implements);
+ dlg.Constructor->setChecked(m_info.createConstructor);
+ dlg.Main->setChecked(m_info.createMain);
+ dlg.Documentation->setText(m_info.documentation);
+ dlg.License->setEditText(m_info.license);
+
+ if (dlg.exec() == QDialog::Accepted)
+ {
+ m_info.projectDir = "";
+ m_info.sourceDir = dlg.SourcePath->text();
+ m_info.className = dlg.ClassName->text();
+ m_info.extends = dlg.Extends->currentText();
+ m_info.interfaceOpt = dlg.Interface->isChecked();
+ m_info.abstractOpt = dlg.Abstract->isChecked();
+ m_info.finalOpt = dlg.Final->isChecked();
+
+ if (dlg.Protected->isChecked())
+ m_info.visibility = AddClassInfo::ProtectedClass;
+ else if (dlg.Private->isChecked())
+ m_info.visibility = AddClassInfo::PrivateClass;
+ else
+ m_info.visibility = AddClassInfo::PublicClass;
+
+ m_info.implements = dlg.Implements->items();
+ m_info.createConstructor = dlg.Constructor->isChecked();
+ m_info.createMain = dlg.Main->isChecked();
+ m_info.documentation = dlg.Documentation->text();
+ m_info.license = dlg.License->currentText();
+
+ return true;
+ }
+
+ return false;
+}
+
+
+static bool makeDirs(const QString &dest)
+{
+ QStringList dirs = QStringList::split("/", dest);
+
+ QString d = "";
+
+ for (QStringList::Iterator it=dirs.begin(); it != dirs.end(); ++it)
+ {
+ d = d + "/" + *it;
+
+ QFileInfo fi(d);
+
+ if (fi.exists() && !fi.isDir())
+ {
+ /// @todo message to user!
+ return false;
+ }
+
+ if (!fi.exists())
+ if (::mkdir(QFile::encodeName(d), 0755) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+
+bool AddClass::generate()
+{
+ QString code;
+
+ // license
+
+ if (!m_info.license.isEmpty())
+ {
+ code += "/*\n";
+
+ if (m_info.license == "GPL")
+ {
+ code +=
+ " * This program is free software; you can redistribute it and/or modify\n"
+ " * it under the terms of the GNU General Public License as published by\n"
+ " * the Free Software Foundation; either version 2 of the License, or\n"
+ " * (at your option) any later version.\n";
+ }
+ else if (m_info.license == "LGPL")
+ {
+ code +=
+ " * This program is free software; you can redistribute it and/or modify\n"
+ " * it under the terms of the GNU Library General Public License as\n"
+ " * published by the Free Software Foundation; either version 2 of the\n"
+ " * License, or (at your option) any later version.\n";
+ }
+ else if (m_info.license == "QPL")
+ {
+ code +=
+ " * This program may be distributed under the terms of the Q Public\n"
+ " * License as defined by Trolltech AS of Norway and appearing in the\n"
+ " * file LICENSE.QPL included in the packaging of this file.\n"
+ " *\n"
+ " * This program is distributed in the hope that it will be useful,\n"
+ " * but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n";
+ }
+ else
+ {
+ code += " * This program is licensed under the " + m_info.license + ".\n";
+ code += " * Please see the documentation for details.\n";
+ }
+
+ code += " */\n\n\n";
+ }
+
+ // find class and package name
+ QString className, packageName;
+
+ int i = m_info.className.findRev('.');
+ if (i == -1)
+ {
+ packageName = "";
+ className = m_info.className;
+ }
+ else
+ {
+ packageName = m_info.className.left(i);
+ className = m_info.className.mid(i+1);
+ }
+
+ // package
+ if (!packageName.isEmpty())
+ code += "package " + packageName + ";\n\n\n";
+
+ // documentation
+
+ if (!m_info.documentation.isEmpty())
+ {
+ code += "/**\n";
+
+ QTextStream ts(&m_info.documentation, IO_ReadOnly);
+
+ while (!ts.eof())
+ code += " * " + ts.readLine() + "\n";
+
+ code += " */\n\n";
+ }
+
+ // visibility
+
+ switch (m_info.visibility)
+ {
+ case AddClassInfo::PrivateClass:
+ code += "private";
+ break;
+ case AddClassInfo::ProtectedClass:
+ code += "protected";
+ break;
+ default:
+ code += "public";
+ break;
+ }
+
+ // abstract, final
+
+ if (!m_info.interfaceOpt)
+ {
+ if (m_info.abstractOpt)
+ code += " abstract";
+ if (m_info.finalOpt)
+ code += " final";
+ }
+
+ // generate class/interface declaration
+
+ if (m_info.interfaceOpt)
+ code += " interface ";
+ else
+ code += " class ";
+
+ // classname
+
+ code += className;
+
+ // extends
+
+ if (!m_info.extends.isEmpty())
+ code += " extends " + m_info.extends;
+
+ // implements
+
+ if ((m_info.implements.count() > 0) && !m_info.interfaceOpt)
+ {
+ code += " implements ";
+ unsigned int c=0;
+ for (QStringList::Iterator it = m_info.implements.begin(); it != m_info.implements.end(); ++it, c++)
+ {
+ code += *it;
+ if (c+1 < m_info.implements.count())
+ code += ", ";
+ }
+ }
+
+ // body start
+
+ code += "\n{\n\n";
+
+ // default constructor
+
+ if (m_info.createConstructor && !m_info.interfaceOpt)
+ {
+ code += " " + className + "()\n";
+ code += " {\n";
+ if (!m_info.extends.isEmpty())
+ code += " super();\n";
+ code += " }\n\n";
+ }
+
+ // main method
+
+ if (m_info.createMain && !m_info.interfaceOpt)
+ {
+ code += " public static void main(String[] args)\n";
+ code += " {\n";
+ code += " }\n\n";
+ }
+
+ // body end
+
+ code += "};\n";
+
+ // create directories
+
+ QString dest = packageName;
+ dest.replace(QRegExp("\\."), "/");
+ dest = m_info.sourceDir + "/" + dest;
+
+ if (!makeDirs(dest))
+ return false;
+
+ // write out the file
+
+ if (QFile::exists(m_info.adaFileName()))
+ {
+ /// @todo ask before overwriting!
+ }
+
+ QFile of(m_info.adaFileName());
+ if (!of.open(IO_WriteOnly))
+ {
+ /// @todo message to user
+ return false;
+ }
+
+ QTextStream os(&of);
+ os << code;
+
+ of.close();
+
+ return true;
+}
diff --git a/languages/ada/addclass.h b/languages/ada/addclass.h
new file mode 100644
index 00000000..7bcfd370
--- /dev/null
+++ b/languages/ada/addclass.h
@@ -0,0 +1,55 @@
+#ifndef __ADDCLASS_H__
+#define __ADDCLASS_H__
+
+
+#include <qstring.h>
+#include <qstringlist.h>
+
+
+class AddClassInfo
+{
+public:
+
+ AddClassInfo();
+
+ enum Visibility { PublicClass, ProtectedClass, PrivateClass};
+
+ QString className;
+ QString extends;
+ bool interfaceOpt, abstractOpt, finalOpt;
+ QString projectDir, sourceDir;
+ Visibility visibility;
+ QStringList implements;
+ bool createConstructor, createMain;
+ QString documentation;
+ QString license;
+
+ QString adaFileName() const;
+
+};
+
+
+class AddClass
+{
+public:
+
+ AddClass();
+
+ void setInfo(const AddClassInfo &info);
+ AddClassInfo &info();
+
+ void setBaseClasses(const QStringList &classes);
+ bool showDialog();
+
+ bool generate();
+
+
+private:
+
+ AddClassInfo m_info;
+ QStringList m_baseClasses;
+
+};
+
+
+#endif
diff --git a/languages/ada/addclassdlg.ui b/languages/ada/addclassdlg.ui
new file mode 100644
index 00000000..49900786
--- /dev/null
+++ b/languages/ada/addclassdlg.ui
@@ -0,0 +1,434 @@
+<!DOCTYPE UI><UI version="3.0" stdsetdef="1">
+<class>AddClassDlg</class>
+<widget class="QDialog">
+ <property name="name">
+ <cstring>AddClassDlg</cstring>
+ </property>
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>656</width>
+ <height>684</height>
+ </rect>
+ </property>
+ <property name="caption">
+ <string>Add Class</string>
+ </property>
+ <grid>
+ <property name="name">
+ <cstring>unnamed</cstring>
+ </property>
+ <widget class="KEditListBox" row="1" column="0" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>Implements</cstring>
+ </property>
+ <property name="lineWidth">
+ <number>1</number>
+ </property>
+ <property name="title">
+ <string>&amp;Implements</string>
+ </property>
+ </widget>
+ <widget class="QGroupBox" row="0" column="0" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>GroupBox1</cstring>
+ </property>
+ <property name="title">
+ <string>&amp;Class</string>
+ </property>
+ <grid>
+ <property name="name">
+ <cstring>unnamed</cstring>
+ </property>
+
+ <widget class="KComboBox" row="2" column="1" rowspan="1" colspan="5">
+ <property name="name">
+ <cstring>Extends</cstring>
+ </property>
+ <property name="editable">
+ <bool>true</bool>
+ </property>
+ <property name="autoCompletion">
+ <bool>false</bool>
+ </property>
+ </widget>
+ <spacer row="4" column="4" rowspan="1" colspan="2">
+ <property name="name">
+ <cstring>Spacer2</cstring>
+ </property>
+ <property name="orientation">
+ <enum>Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>Expanding</enum>
+ </property>
+ </spacer>
+ <widget class="QCheckBox" row="3" column="2">
+ <property name="name">
+ <cstring>Abstract</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Abstract</string>
+ </property>
+ </widget>
+ <widget class="QCheckBox" row="3" column="1">
+ <property name="name">
+ <cstring>Interface</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Interface</string>
+ </property>
+ </widget>
+ <widget class="QLabel" row="1" column="0">
+ <property name="name">
+ <cstring>TextLabel1</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Name:</string>
+ </property>
+ <property name="buddy" stdset="0">
+ <cstring>ClassName</cstring>
+ </property>
+ </widget>
+ <widget class="QButtonGroup" row="4" column="1" rowspan="1" colspan="3">
+ <property name="name">
+ <cstring>ButtonGroup1</cstring>
+ </property>
+ <property name="lineWidth">
+ <number>0</number>
+ </property>
+ <property name="title">
+ <string></string>
+ </property>
+ <hbox>
+ <property name="name">
+ <cstring>unnamed</cstring>
+ </property>
+ <property name="margin">
+ <number>0</number>
+ </property>
+
+ <widget class="QRadioButton">
+ <property name="name">
+ <cstring>Public</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Public</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ <widget class="QRadioButton">
+ <property name="name">
+ <cstring>Protected</cstring>
+ </property>
+ <property name="text">
+ <string>P&amp;rotected</string>
+ </property>
+ </widget>
+ <widget class="QRadioButton">
+ <property name="name">
+ <cstring>Private</cstring>
+ </property>
+ <property name="text">
+ <string>Pri&amp;vate</string>
+ </property>
+ </widget>
+ </hbox>
+ </widget>
+ <widget class="QCheckBox" row="3" column="3">
+ <property name="name">
+ <cstring>Final</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Final</string>
+ </property>
+ </widget>
+ <widget class="KLineEdit" row="1" column="1" rowspan="1" colspan="5">
+ <property name="name">
+ <cstring>ClassName</cstring>
+ </property>
+ </widget>
+ <spacer row="3" column="4" rowspan="1" colspan="2">
+ <property name="name">
+ <cstring>Spacer1</cstring>
+ </property>
+ <property name="orientation">
+ <enum>Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>Expanding</enum>
+ </property>
+ </spacer>
+ <widget class="QLabel" row="2" column="0">
+ <property name="name">
+ <cstring>TextLabel2</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Extends:</string>
+ </property>
+ <property name="buddy" stdset="0">
+ <cstring>Extends</cstring>
+ </property>
+ </widget>
+ <widget class="QPushButton" row="0" column="5">
+ <property name="name">
+ <cstring>BrowseSourcePath</cstring>
+ </property>
+ <property name="sizePolicy">
+ <sizepolicy>
+ <hsizetype>1</hsizetype>
+ <vsizetype>1</vsizetype>
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ </widget>
+ <widget class="KLineEdit" row="0" column="1" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>SourcePath</cstring>
+ </property>
+ </widget>
+ <widget class="QLabel" row="0" column="0">
+ <property name="name">
+ <cstring>TextLabel1_2</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Source path:</string>
+ </property>
+ <property name="buddy" stdset="0">
+ <cstring>SourcePath</cstring>
+ </property>
+ </widget>
+ </grid>
+ </widget>
+ <widget class="QGroupBox" row="2" column="0" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>GroupBox3</cstring>
+ </property>
+ <property name="title">
+ <string>&amp;Options</string>
+ </property>
+ <hbox>
+ <property name="name">
+ <cstring>unnamed</cstring>
+ </property>
+
+ <widget class="QCheckBox">
+ <property name="name">
+ <cstring>Constructor</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Create default constructor</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ <widget class="QCheckBox">
+ <property name="name">
+ <cstring>Main</cstring>
+ </property>
+ <property name="text">
+ <string>Create &amp;main method</string>
+ </property>
+ </widget>
+ </hbox>
+ </widget>
+ <widget class="QGroupBox" row="3" column="0" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>GroupBox4</cstring>
+ </property>
+ <property name="title">
+ <string>&amp;Documentation</string>
+ </property>
+ <grid>
+ <property name="name">
+ <cstring>unnamed</cstring>
+ </property>
+
+ <widget class="QLabel" row="1" column="0">
+ <property name="name">
+ <cstring>TextLabel5</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;License:</string>
+ </property>
+ <property name="buddy" stdset="0">
+ <cstring>License</cstring>
+ </property>
+ </widget>
+ <widget class="KComboBox" row="1" column="1">
+ <item>
+ <property name="text">
+ <string>LGPL</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>GPL</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>QPL</string>
+ </property>
+ </item>
+ <property name="name">
+ <cstring>License</cstring>
+ </property>
+ <property name="editable">
+ <bool>true</bool>
+ </property>
+ </widget>
+ <widget class="QTextEdit" row="0" column="0" rowspan="1" colspan="3">
+ <property name="name">
+ <cstring>Documentation</cstring>
+ </property>
+ </widget>
+ <spacer row="1" column="2">
+ <property name="name">
+ <cstring>Spacer4</cstring>
+ </property>
+ <property name="orientation">
+ <enum>Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>Expanding</enum>
+ </property>
+ </spacer>
+ </grid>
+ </widget>
+ <widget class="Line" row="4" column="0" rowspan="1" colspan="4">
+ <property name="name">
+ <cstring>Line1</cstring>
+ </property>
+ <property name="frameShape">
+ <enum>HLine</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>Sunken</enum>
+ </property>
+ <property name="orientation">
+ <enum>Horizontal</enum>
+ </property>
+ </widget>
+ <widget class="QPushButton" row="5" column="3">
+ <property name="name">
+ <cstring>PushButton3</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Help</string>
+ </property>
+ </widget>
+ <spacer row="5" column="2">
+ <property name="name">
+ <cstring>Spacer5</cstring>
+ </property>
+ <property name="orientation">
+ <enum>Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>Expanding</enum>
+ </property>
+ </spacer>
+ <widget class="QPushButton" row="5" column="0">
+ <property name="name">
+ <cstring>PushButton1</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Add</string>
+ </property>
+ <property name="default">
+ <bool>true</bool>
+ </property>
+ </widget>
+ <widget class="QPushButton" row="5" column="1">
+ <property name="name">
+ <cstring>PushButton2</cstring>
+ </property>
+ <property name="text">
+ <string>&amp;Cancel</string>
+ </property>
+ </widget>
+ </grid>
+</widget>
+<connections>
+ <connection>
+ <sender>Interface</sender>
+ <signal>toggled(bool)</signal>
+ <receiver>Abstract</receiver>
+ <slot>setDisabled(bool)</slot>
+ </connection>
+ <connection>
+ <sender>Interface</sender>
+ <signal>toggled(bool)</signal>
+ <receiver>Final</receiver>
+ <slot>setDisabled(bool)</slot>
+ </connection>
+ <connection>
+ <sender>PushButton1</sender>
+ <signal>clicked()</signal>
+ <receiver>AddClassDlg</receiver>
+ <slot>accept()</slot>
+ </connection>
+ <connection>
+ <sender>PushButton2</sender>
+ <signal>clicked()</signal>
+ <receiver>AddClassDlg</receiver>
+ <slot>reject()</slot>
+ </connection>
+ <connection>
+ <sender>Interface</sender>
+ <signal>toggled(bool)</signal>
+ <receiver>Constructor</receiver>
+ <slot>setDisabled(bool)</slot>
+ </connection>
+ <connection>
+ <sender>Interface</sender>
+ <signal>toggled(bool)</signal>
+ <receiver>Main</receiver>
+ <slot>setDisabled(bool)</slot>
+ </connection>
+ <connection>
+ <sender>Interface</sender>
+ <signal>toggled(bool)</signal>
+ <receiver>Implements</receiver>
+ <slot>setDisabled(bool)</slot>
+ </connection>
+</connections>
+<tabstops>
+ <tabstop>SourcePath</tabstop>
+ <tabstop>BrowseSourcePath</tabstop>
+ <tabstop>ClassName</tabstop>
+ <tabstop>Extends</tabstop>
+ <tabstop>Interface</tabstop>
+ <tabstop>Abstract</tabstop>
+ <tabstop>Final</tabstop>
+ <tabstop>Public</tabstop>
+ <tabstop>Protected</tabstop>
+ <tabstop>Private</tabstop>
+ <tabstop>Constructor</tabstop>
+ <tabstop>Main</tabstop>
+ <tabstop>License</tabstop>
+ <tabstop>PushButton1</tabstop>
+ <tabstop>PushButton2</tabstop>
+ <tabstop>PushButton3</tabstop>
+</tabstops>
+<slots>
+ <slot>Public_toggled( bool )</slot>
+</slots>
+<includes>
+ <include location="global" impldecl="in implementation">keditlistbox.h</include>
+ <include location="global" impldecl="in implementation">kcombobox.h</include>
+ <include location="global" impldecl="in implementation">klineedit.h</include>
+ <include location="global" impldecl="in implementation">kdialog.h</include>
+</includes>
+<layoutdefaults spacing="6" margin="11"/>
+<layoutfunctions spacing="KDialog::spacingHint" margin="KDialog::marginHint"/>
+</UI>
diff --git a/languages/ada/app_templates/Makefile.am b/languages/ada/app_templates/Makefile.am
new file mode 100644
index 00000000..3da5006f
--- /dev/null
+++ b/languages/ada/app_templates/Makefile.am
@@ -0,0 +1,5 @@
+SUBDIRS = adahello
+
+profilesdir = $(kde_datadir)/kdevelop/profiles/IDE/CompiledLanguageIDE/AdaIDE
+profiles_DATA = ada.appwizard
+
diff --git a/languages/ada/app_templates/ada.appwizard b/languages/ada/app_templates/ada.appwizard
new file mode 100644
index 00000000..2c31ec96
--- /dev/null
+++ b/languages/ada/app_templates/ada.appwizard
@@ -0,0 +1,2 @@
+[General]
+List=adahello
diff --git a/languages/ada/app_templates/adahello/.kdev_ignore b/languages/ada/app_templates/adahello/.kdev_ignore
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/languages/ada/app_templates/adahello/.kdev_ignore
diff --git a/languages/ada/app_templates/adahello/Makefile.am b/languages/ada/app_templates/adahello/Makefile.am
new file mode 100644
index 00000000..45e04df7
--- /dev/null
+++ b/languages/ada/app_templates/adahello/Makefile.am
@@ -0,0 +1,16 @@
+dataFiles = main.adb app.kdevelop ada-Makefile app.kdevelop.filelist
+
+### no need to change below:
+template_DATA = adahello.kdevtemplate
+templatedir = ${appwizarddatadir}/templates
+
+appwizarddatadir = ${kde_datadir}/kdevappwizard
+adahello.tar.gz:
+ $(TAR) -cf adahello.tar -C $(srcdir) ${dataFiles}
+ $(GZIP_COMMAND) -f9 adahello.tar
+
+archivedir = ${appwizarddatadir}
+archive_DATA = adahello.tar.gz adahello.png
+
+CLEANFILES = *.tar.gz
+
diff --git a/languages/ada/app_templates/adahello/ada-Makefile b/languages/ada/app_templates/adahello/ada-Makefile
new file mode 100644
index 00000000..134ffab6
--- /dev/null
+++ b/languages/ada/app_templates/adahello/ada-Makefile
@@ -0,0 +1,2 @@
+all:
+ gnatmake src/%{APPNAMELC}.adb -o %{APPNAMELC}
diff --git a/languages/ada/app_templates/adahello/ada-Makefile.am b/languages/ada/app_templates/adahello/ada-Makefile.am
new file mode 100644
index 00000000..02520f20
--- /dev/null
+++ b/languages/ada/app_templates/adahello/ada-Makefile.am
@@ -0,0 +1,5 @@
+# not a GNU package. You can remove this line, if
+# have all needed files, that a GNU package needs
+AUTOMAKE_OPTIONS = foreign 1.4
+
+SUBDIRS = src
diff --git a/languages/ada/app_templates/adahello/ada-Makefile.cvs b/languages/ada/app_templates/adahello/ada-Makefile.cvs
new file mode 100644
index 00000000..d1607023
--- /dev/null
+++ b/languages/ada/app_templates/adahello/ada-Makefile.cvs
@@ -0,0 +1,8 @@
+default: all
+
+all:
+ aclocal
+ autoheader
+ automake
+ autoconf
+
diff --git a/languages/ada/app_templates/adahello/adahello b/languages/ada/app_templates/adahello/adahello
new file mode 100644
index 00000000..73d82f8d
--- /dev/null
+++ b/languages/ada/app_templates/adahello/adahello
@@ -0,0 +1,10 @@
+# KDE Config File
+[General]
+Name=Simple Hello world program
+Name[fr]=Un simple programme de test Hello world
+Icon=adahello.png
+Category=Ada
+Comment=Generates a simple Hello world program in Ada
+Comment[fr]=Gnre un simple programme de test du type Hello world dans le language ADA.
+FileTemplates=adb,AdaStyle
+ShowFilesAfterGeneration=src/APPNAMELC.adb
diff --git a/languages/ada/app_templates/adahello/adahello.kdevtemplate b/languages/ada/app_templates/adahello/adahello.kdevtemplate
new file mode 100644
index 00000000..380f739b
--- /dev/null
+++ b/languages/ada/app_templates/adahello/adahello.kdevtemplate
@@ -0,0 +1,132 @@
+# 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=adahello.png
+Category=Ada
+Comment=Generates a simple Hello world program in Ada
+Comment[ca]=Genera un simple programa de Hello world en Ada
+Comment[da]=Genererer et simpelt Goddag verden program i Ada
+Comment[de]=Erstellt ein einfaches "Hello World"-Program in Ada
+Comment[el]=Δημιουργεί ένα απλό πρόγραμμα Γεια σου Κόσμε σε Ada
+Comment[es]=Genera un programa «Hola mundo» sencillo en Ada
+Comment[et]=Lihtsa "Tere, maailm" programmi loomine ADA-s
+Comment[eu]="Kaixo mundua" programa sinple bat sortzen du Adan
+Comment[fa]=یک برنامۀ سادۀ Hello world در آدا تولید می‌کند
+Comment[fr]=Génère un programme « Bonjour monde » simple en Ada
+Comment[ga]=Cruthaíonn sé seo feidhmchlár simplí "Hello World" in Ada
+Comment[gl]=Xera un programa sinxelo Hello world en Ada
+Comment[hu]=Létrehoz egy egyszerű Hello world programot ADA nyelven
+Comment[it]=Genera un semplice programma di "Hello world" in Ada
+Comment[ja]=Ada で簡単な Hello world プログラムを作成します
+Comment[ms]=Menjana program Hello World mudah dalam Ada
+Comment[nds]=Stellt in Ada en eenfach "Moin Welt"-Programm op
+Comment[ne]=एडामा साधारण हेल्लो वोल्ड कार्यक्रम उत्पन्न गर्दछ
+Comment[nl]=Genereert een eenvoudig Hello World programma in Ada
+Comment[pl]=Generuje prosty program Witaj świecie w Adzie
+Comment[pt]=Gera um programa simples de Olá Mundo em Ada
+Comment[pt_BR]=Gera um programa simples de Olá Mundo em Ada
+Comment[ru]=Создание простой программы Hello world на Ada
+Comment[sk]=Vygeneruje jednoduchý "Ahoj svet" program v Ada
+Comment[sl]=Ustvari preprost program Hello world v Adi
+Comment[sr]=Прави једноставан „Здраво свете“ у Ada-и
+Comment[sr@Latn]=Pravi jednostavan „Zdravo svete“ u Ada-i
+Comment[sv]=Skapar ett enkelt Hello world-program i Ada
+Comment[tr]=Ada dilinde basit bir Merhaba Dünya programı üretir.
+Comment[zh_CN]=以 Ada 语言生成简单的 Hello world 程序
+Comment[zh_TW]=產生 Ada 的 Hello world 程式
+FileTemplates=adb,AdaStyle
+ShowFilesAfterGeneration=%{dest}/src/%{APPNAMELC}.adb
+Archive=adahello.tar.gz
+
+[GNU]
+Type=include
+File=%{kdevelop}/template-common/gnu.kdevtemplate
+
+[FILE1]
+Type=install
+EscapeXML=true
+Source=%{src}/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+
+[FILE2]
+Type=install
+Source=%{src}/ada-Makefile
+Dest=%{dest}/Makefile
+
+[FILE3]
+Type=install
+Source=%{src}/app.kdevelop.filelist
+Dest=%{dest}/%{APPNAMELC}.kdevelop.filelist
+
+[MkDir1]
+Type=mkdir
+Dir=%{dest}/src
+
+[FILE4]
+Type=install
+Source=%{src}/main.adb
+Dest=%{dest}/src/%{APPNAMELC}.adb
+
+[MSG]
+Type=message
+Comment=A simple "Hello world" program in ADA was created in %{dest}
+Comment[ca]=Un simple programa de "Hello world" en ADA ha estat creat en %{dest}
+Comment[da]=Et simpelt "Goddag verden" program i ADA blev oprettet i %{dest}
+Comment[de]=Ein einfaches "Hello world" Programm in Ada wurde in %{dest} erstellt
+Comment[el]=Ένα απλό πρόγραμμα "Γεια σου Κόσμε" σε ADA δημιουργήθηκε στο %{dest}
+Comment[es]=Un programa «Hola mundo» sencillo en ADA ha sido creado en %{dest}
+Comment[et]=Lihtne "Tere, maailm" programm ADA-s loodi asukohta %{dest}
+Comment[eu]="Kaixo mundua" programa sinple bat sortu da ADAn hemen: %{dest}
+Comment[fa]=یک برنامۀ سادۀ «Hello world» در آدا در %{dest} ایجاد شد
+Comment[fr]=Un programme « Bonjour monde » simple en ADA a été créé dans %{dest}
+Comment[ga]=Cruthaíodh ríomhchlár simplí "Hello World" ADA i %{dest}
+Comment[gl]=Creouse un programa sinxelo "Ola mundo" en ADA en %{dest}
+Comment[hu]=Létrejött egy egyszerű Hello world program ADA nyelven itt: %{dest}
+Comment[it]=È stato creato un semplice programma di "Hello world" in ADA in %{dest}
+Comment[ja]=Ada で記述された "Hello world" プログラムを %{dest} に作成しました
+Comment[ms]=Program "Hello World" mudah dalam ada telah dicipta dalam %{dest}
+Comment[nds]=In %{dest} wöör en eenfach "Moin Welt"-Programm in Ada opstellt
+Comment[ne]=एउटा साधारण "हेल्लो वोल्ड" कार्यक्रम एडामा %{dest} सिर्जना गरिएको थियो
+Comment[nl]=Een eenvoudig "Hello World" programma in Ada is aangemaakt in %{dest}
+Comment[pl]=Prosty program "Witaj świecie" w języku ADA został utworzony w %{dest}
+Comment[pt]=Foi criado um programa simples "Olá mundo" em ADA em %{dest}
+Comment[pt_BR]=Foi criado um programa simples "Olá mundo" em ADA em %{dest}
+Comment[ru]=Простая программа "Hello world" на ADA создана в %{dest}
+Comment[sk]=Jednoduchý "Ahoj svet" program v Ada bol vytvorený v %{dest}
+Comment[sl]=Preprost program »Hello world« v jeziku ADA je bil ustvarjen v %{dest}
+Comment[sr]=Једноставан „Здраво свете“ програм у Ada-и је направљен у %{dest}
+Comment[sr@Latn]=Jednostavan „Zdravo svete“ program u Ada-i je napravljen u %{dest}
+Comment[sv]=Ett enkelt "Hello world"-program in Ada skapades i %{dest}
+Comment[tr]=ADA'da basit bir "Merhaba Dünya" programı %{dest} içinde yaratılmıştır.
+Comment[zh_CN]=在 %{dest} 中创建了 Ada 语言的“Hello world”程序
+Comment[zh_TW]=Ada 的 Hello world 程式已產生在 ${dest}
diff --git a/languages/ada/app_templates/adahello/adahello.png b/languages/ada/app_templates/adahello/adahello.png
new file mode 100644
index 00000000..888d4f13
--- /dev/null
+++ b/languages/ada/app_templates/adahello/adahello.png
Binary files differ
diff --git a/languages/ada/app_templates/adahello/app.kdevelop b/languages/ada/app_templates/adahello/app.kdevelop
new file mode 100644
index 00000000..b430f6e8
--- /dev/null
+++ b/languages/ada/app_templates/adahello/app.kdevelop
@@ -0,0 +1,84 @@
+<?xml version="1.0"?>
+<kdevelop>
+ <general>
+ <author>%{AUTHOR}</author>
+ <email>%{EMAIL}</email>
+ <version>%{VERSION}</version>
+ <projectmanagement>KDevCustomProject</projectmanagement>
+ <primarylanguage>Ada</primarylanguage>
+ <keywords>
+ <keyword>Ada</keyword>
+ <keyword>Code</keyword>
+ </keywords>
+ </general>
+ <kdevcustomproject>
+ <run>
+ <directoryradio>build</directoryradio>
+ <customdirectory>/</customdirectory>
+ <mainprogram>%{APPNAMELC}</mainprogram>
+ <programargs/>
+ <terminal>false</terminal>
+ <autocompile>false</autocompile>
+ <envvars/>
+ </run>
+ <build>
+ <buildtool>make</buildtool>
+ <builddir/>
+ </build>
+ </kdevcustomproject>
+ <kdevdoctreeview>
+ <ignoretocs>
+ <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>pascal_bugs_fp</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="ads"/>
+ <type ext="adb"/>
+ <type ext="ada"/>
+ </useglobaltypes>
+ </kdevfilecreate>
+</kdevelop>
diff --git a/languages/ada/app_templates/adahello/app.kdevelop.filelist b/languages/ada/app_templates/adahello/app.kdevelop.filelist
new file mode 100644
index 00000000..e5b69ca2
--- /dev/null
+++ b/languages/ada/app_templates/adahello/app.kdevelop.filelist
@@ -0,0 +1 @@
+src/%{APPNAMELC}.adb \ No newline at end of file
diff --git a/languages/ada/app_templates/adahello/configure.in b/languages/ada/app_templates/adahello/configure.in
new file mode 100644
index 00000000..a8f81958
--- /dev/null
+++ b/languages/ada/app_templates/adahello/configure.in
@@ -0,0 +1,10 @@
+AC_INIT(configure.in)
+
+AM_INIT_AUTOMAKE(%{APPNAMELC}, %{VERSION})
+AM_CONFIG_HEADER(config.h)
+
+AC_LANG_ADA
+AC_PROG_ADA
+AC_ADA_LIBRARY_LDFLAGS
+
+AC_OUTPUT(Makefile src/Makefile)
diff --git a/languages/ada/app_templates/adahello/main.adb b/languages/ada/app_templates/adahello/main.adb
new file mode 100644
index 00000000..e2c6f5da
--- /dev/null
+++ b/languages/ada/app_templates/adahello/main.adb
@@ -0,0 +1,8 @@
+with Text_IO;
+
+procedure Main is
+
+begin
+ Text_IO.Put_Line ("Hello World");
+end Main;
+
diff --git a/languages/ada/app_templates/adahello/src-Makefile.am b/languages/ada/app_templates/adahello/src-Makefile.am
new file mode 100644
index 00000000..06291dbf
--- /dev/null
+++ b/languages/ada/app_templates/adahello/src-Makefile.am
@@ -0,0 +1,8 @@
+bin_PROGRAMS = %{APPNAMELC}
+%{APPNAMELC}_SOURCES = %{APPNAMELC}.adb
+
+# set the include path found by configure
+INCLUDES= $(all_includes)
+
+# the library search path.
+%{APPNAMELC}_LDFLAGS = $(all_libraries)
diff --git a/languages/ada/backgroundparser.cpp b/languages/ada/backgroundparser.cpp
new file mode 100644
index 00000000..f94f3216
--- /dev/null
+++ b/languages/ada/backgroundparser.cpp
@@ -0,0 +1,77 @@
+/***************************************************************************
+ * 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 "backgroundparser.h"
+#include "problemreporter.h"
+#include "AdaLexer.hpp"
+#include "AdaParser.hpp"
+#include "AdaAST.hpp"
+#include <kdebug.h>
+#include <qfile.h>
+
+#include <config.h>
+
+#include <sstream>
+
+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()
+{
+ QCString _fn = QFile::encodeName(m_fileName);
+ std::string fn( _fn.data() );
+
+ std::istringstream stream( m_source.utf8().data() );
+
+ AdaLexer lexer( stream );
+ lexer.setFilename( fn );
+ lexer.setProblemReporter( m_reporter );
+
+ AdaParser parser( lexer );
+ parser.setFilename( fn );
+ parser.setProblemReporter( m_reporter );
+
+ // make an ast factory
+ antlr::ASTFactory ast_factory;
+ // initialize and put it in the parser...
+ parser.initializeASTFactory (ast_factory);
+ parser.setASTFactory (&ast_factory);
+ // parser.setASTNodeType ("RefAdaAST");
+
+ try{
+ lexer.resetErrors();
+ parser.resetErrors();
+
+ parser.compilation_unit();
+
+ } catch( antlr::ANTLRException& ex ){
+ kdDebug() << "*exception*: " << ex.toString().c_str() << endl;
+ m_reporter->reportError( QString::fromLatin1( ex.getMessage().c_str() ),
+ m_fileName,
+ lexer.getLine(),
+ lexer.getColumn() );
+ }
+
+ kdDebug() << "BackgroundParser::run() FINISHED." << endl;
+}
+
+
+
diff --git a/languages/ada/backgroundparser.h b/languages/ada/backgroundparser.h
new file mode 100644
index 00000000..0b4eef16
--- /dev/null
+++ b/languages/ada/backgroundparser.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2002 by Roberto Raggi
+ * roberto@kdevelop.org
+ * Copyright (C) 2003 Oliver Kellogg
+ * okellogg@users.sourceforge.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 BACKGROUNDPARSER_H
+#define BACKGROUNDPARSER_H
+
+#include <qthread.h>
+#include <qstring.h>
+#include <kdebug.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/ada/configproblemreporter.ui b/languages/ada/configproblemreporter.ui
new file mode 100644
index 00000000..75f35b1f
--- /dev/null
+++ b/languages/ada/configproblemreporter.ui
@@ -0,0 +1,89 @@
+<!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>304</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>Right</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>
+ <include location="local" impldecl="in implementation">configproblemreporter.ui.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/ada/configproblemreporter.ui.h b/languages/ada/configproblemreporter.ui.h
new file mode 100644
index 00000000..a336965c
--- /dev/null
+++ b/languages/ada/configproblemreporter.ui.h
@@ -0,0 +1,39 @@
+/****************************************************************************
+** ui.h extension file, included from the uic-generated form implementation.
+**
+** If you wish to add, delete or rename slots use Qt Designer which will
+** update this file, preserving your code. Create an init() slot in place of
+** a constructor, and a destroy() slot in place of a destructor.
+*****************************************************************************/
+
+#include <kconfig.h>
+#include <kapplication.h>
+
+void ConfigureProblemReporter::init()
+{
+ KConfig* config = kapp->config();
+ config->setGroup( "General Options" );
+ bgParserCheckbox->setChecked( config->readBoolEntry("EnableAdaBgParser", true) );
+ delaySlider->setEnabled( bgParserCheckbox->isChecked() );
+ delaySlider->setValue( config->readNumEntry("BgParserDelay", 500) );
+}
+
+void ConfigureProblemReporter::destroy()
+{
+}
+
+void ConfigureProblemReporter::accept()
+{
+ KConfig* config = kapp->config();
+ config->setGroup( "General Options" );
+ config->writeEntry( "EnableAdaBgParser", bgParserCheckbox->isChecked() );
+ if( bgParserCheckbox->isChecked() )
+ config->writeEntry( "BgParserDelay", delaySlider->value() );
+ config->sync();
+}
+
+
+void ConfigureProblemReporter::bgParserCheckbox_toggled( bool b )
+{
+ delaySlider->setEnabled( b );
+}
diff --git a/languages/ada/configure.in.in b/languages/ada/configure.in.in
new file mode 100644
index 00000000..be677e4b
--- /dev/null
+++ b/languages/ada/configure.in.in
@@ -0,0 +1,4 @@
+AC_LANG_SAVE
+AC_LANG_CPLUSPLUS
+AC_CHECK_HEADERS(sstream)
+AC_LANG_RESTORE
diff --git a/languages/ada/doc/Makefile.am b/languages/ada/doc/Makefile.am
new file mode 100644
index 00000000..ff5f8a32
--- /dev/null
+++ b/languages/ada/doc/Makefile.am
@@ -0,0 +1,6 @@
+tocdir = ${kde_datadir}/kdevdocumentation/tocs
+toc_DATA = ada.toc ada_bugs_gcc.toc
+
+#indexdir = ${kde_datadir}/devdoctreeview/indices
+#index_DATA =
+
diff --git a/languages/ada/doc/ada.toc b/languages/ada/doc/ada.toc
new file mode 100644
index 00000000..434a5b6a
--- /dev/null
+++ b/languages/ada/doc/ada.toc
@@ -0,0 +1,130 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>Ada</title>
+<base href="http://www.adahome.com/rm95"/>
+<tocsect1 name="General" url="rm9x-01.html">
+ <tocsect2 name="Scope" url="rm9x-01-01.html"></tocsect2>
+ <tocsect2 name="Normative References" url="rm9x-01-02.html"></tocsect2>
+ <tocsect2 name="Definitions" url="rm9x-01-03.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Lexical Elements" url="rm9x-02.html">
+ <tocsect2 name="Character Set" url="rm9x-02-01.html"></tocsect2>
+ <tocsect2 name="Lexical Elements, Separators, and Delimiters" url="rm9x-02-02.html"></tocsect2>
+ <tocsect2 name="Identifiers" url="rm9x-02-03.html"></tocsect2>
+ <tocsect2 name="Numeric Literals" url="rm9x-02-04.html"></tocsect2>
+ <tocsect2 name="Character Literals" url="rm9x-02-05.html"></tocsect2>
+ <tocsect2 name="String Literals" url="rm9x-02-06.html"></tocsect2>
+ <tocsect2 name="Comments" url="rm9x-02-07.html"></tocsect2>
+ <tocsect2 name="Pragmas" url="rm9x-02-08.html"></tocsect2>
+ <tocsect2 name="Reserved Words" url="rm9x-02-09.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Declarations and Types" url="rm9x-03.html">
+ <tocsect2 name="Declarations" url="rm9x-03-01.html"></tocsect2>
+ <tocsect2 name="Types and Subtypes" url="rm9x-03-02.html"></tocsect2>
+ <tocsect2 name="Objects and Named Numbers" url="rm9x-03-03.html"></tocsect2>
+ <tocsect2 name="Derived Types and Classes" url="rm9x-03-04.html"></tocsect2>
+ <tocsect2 name="Scalar Types" url="rm9x-03-05.html"></tocsect2>
+ <tocsect2 name="Array Types" url="rm9x-03-06.html"></tocsect2>
+ <tocsect2 name="Discriminants" url="rm9x-03-07.html"></tocsect2>
+ <tocsect2 name="Record Types" url="rm9x-03-08.html"></tocsect2>
+ <tocsect2 name="Tagged Types and Type Extensions" url="rm9x-03-09.html"></tocsect2>
+ <tocsect2 name="Access Types" url="rm9x-03-10.html"></tocsect2>
+ <tocsect2 name="Declarative Parts" url="rm9x-03-11.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Names and Expressions" url="rm9x-04.html">
+ <tocsect2 name="Names" url="rm9x-04-01.html"></tocsect2>
+ <tocsect2 name="Literals" url="rm9x-04-02.html"></tocsect2>
+ <tocsect2 name="Aggregates" url="rm9x-04-03.html"></tocsect2>
+ <tocsect2 name="Expressions" url="rm9x-04-04.html"></tocsect2>
+ <tocsect2 name="Operators and Expression Evaluation" url="rm9x-04-05.html"></tocsect2>
+ <tocsect2 name="Type Conversions" url="rm9x-04-06.html"></tocsect2>
+ <tocsect2 name="Qualified Expressions" url="rm9x-04-07.html"></tocsect2>
+ <tocsect2 name="Allocators" url="rm9x-04-08.html"></tocsect2>
+ <tocsect2 name="Static Expressions and Static Subtypes" url="rm9x-04-09.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Statements" url="rm9x-05.html">
+ <tocsect2 name="Simple and Compound Statements - Sequences of Statements" url="rm9x-05-01.html"></tocsect2>
+ <tocsect2 name="Assignment Statements" url="rm9x-05-02.html"></tocsect2>
+ <tocsect2 name="If Statements" url="rm9x-05-03.html"></tocsect2>
+ <tocsect2 name="Case Statements" url="rm9x-05-04.html"></tocsect2>
+ <tocsect2 name="Loop Statements" url="rm9x-05-05.html"></tocsect2>
+ <tocsect2 name="Block Statements" url="rm9x-05-06.html"></tocsect2>
+ <tocsect2 name="Exit Statements" url="rm9x-05-07.html"></tocsect2>
+ <tocsect2 name="Goto Statements" url="rm9x-05-08.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Subprograms" url="rm9x-06.html">
+ <tocsect2 name="Subprogram Declarations" url="rm9x-06-01.html"></tocsect2>
+ <tocsect2 name="Formal Parameter Modes" url="rm9x-06-02.html"></tocsect2>
+ <tocsect2 name="Subprogram Bodies" url="rm9x-06-03.html"></tocsect2>
+ <tocsect2 name="Subprogram Calls" url="rm9x-06-04.html"></tocsect2>
+ <tocsect2 name="Return Statements" url="rm9x-06-05.html"></tocsect2>
+ <tocsect2 name="Overloading of Operators" url="rm9x-06-06.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Packages" url="rm9x-07.html">
+ <tocsect2 name="Package Specifications and Declarations" url="rm9x-07-01.html"></tocsect2>
+ <tocsect2 name="Package Bodies" url="rm9x-07-02.html"></tocsect2>
+ <tocsect2 name="Private Types and Private Extensions" url="rm9x-07-03.html"></tocsect2>
+ <tocsect2 name="Deferred Constants" url="rm9x-07-04.html"></tocsect2>
+ <tocsect2 name="Limited Types" url="rm9x-07-05.html"></tocsect2>
+ <tocsect2 name="User-Defined Assignment and Finalization" url="rm9x-07-06.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Visibility Rules" url="rm9x-08.html">
+ <tocsect2 name="Declarative Region" url="rm9x-08-01.html"></tocsect2>
+ <tocsect2 name="Scope of Declarations" url="rm9x-08-02.html"></tocsect2>
+ <tocsect2 name="Visibility" url="rm9x-08-03.html"></tocsect2>
+ <tocsect2 name="Use Clauses" url="rm9x-08-04.html"></tocsect2>
+ <tocsect2 name="Renaming Declarations" url="rm9x-08-05.html"></tocsect2>
+ <tocsect2 name="The Context of Overload Resolution" url="rm9x-08-06.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Tasks and Synchronization" url="rm9x-09.html">
+ <tocsect2 name="Task Units and Task Objects" url="rm9x-09-01.html"></tocsect2>
+ <tocsect2 name="Task Execution - Task Activation" url="rm9x-09-02.html"></tocsect2>
+ <tocsect2 name="Task Dependence - Termination of Tasks" url="rm9x-09-03.html"></tocsect2>
+ <tocsect2 name="Protected Units and Protected Objects" url="rm9x-09-04.html"></tocsect2>
+ <tocsect2 name="Intertask Communication" url="rm9x-09-05.html"></tocsect2>
+ <tocsect2 name="Delay Statements, Duration, and Time" url="rm9x-09-06.html"></tocsect2>
+ <tocsect2 name="Select Statements" url="rm9x-09-07.html"></tocsect2>
+ <tocsect2 name="Abort of a Task - Abort of a Sequence of Statements" url="rm9x-09-08.html"></tocsect2>
+ <tocsect2 name="Task and Entry Attributes" url="rm9x-09-09.html"></tocsect2>
+ <tocsect2 name="Shared Variables" url="rm9x-09-10.html"></tocsect2>
+ <tocsect2 name="Example of Tasking and Synchronization " url="rm9x-09-11.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Program Structure and Compilation Issues" url="rm9x-10.html">
+ <tocsect2 name="Separate Compilation" url="rm9x-10-01.html"></tocsect2>
+ <tocsect2 name="Program Execution" url="rm9x-10-02.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Exceptions" url="rm9x-11.html">
+ <tocsect2 name="Exception Declarations" url="rm9x-11-01.html"></tocsect2>
+ <tocsect2 name="Exception Handlers" url="rm9x-11-02.html"></tocsect2>
+ <tocsect2 name="Raise Statements" url="rm9x-11-03.html"></tocsect2>
+ <tocsect2 name="Exception Handling" url="rm9x-11-04.html"></tocsect2>
+ <tocsect2 name="Suppressing Checks" url="rm9x-11-05.html"></tocsect2>
+ <tocsect2 name="Exceptions and Optimization" url="rm9x-11-06.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Generic Units" url="rm9x-12.html">
+ <tocsect2 name="Generic Declarations" url="rm9x-12-01.html"></tocsect2>
+ <tocsect2 name="Generic Bodies" url="rm9x-12-02.html"></tocsect2>
+ <tocsect2 name="Generic Instantiation" url="rm9x-12-03.html"></tocsect2>
+ <tocsect2 name="Formal Objects" url="rm9x-12-04.html"></tocsect2>
+ <tocsect2 name="Formal Types" url="rm9x-12-05.html"></tocsect2>
+ <tocsect2 name="Formal Subprograms" url="rm9x-12-06.html"></tocsect2>
+ <tocsect2 name="Formal Packages" url="rm9x-12-07.html"></tocsect2>
+ <tocsect2 name="Example of a Generic Package" url="rm9x-12-08.html"></tocsect2>
+</tocsect1>
+<tocsect1 name="Representation Issues" url="rm9x-13.html">
+ <tocsect2 name="Representation Items" url="rm9x-13-01.html"></tocsect2>
+ <tocsect2 name="Pragma Pack" url="rm9x-13" url="rm9x-13-02.html"></tocsect2>
+ <tocsect2 name="Representation Attributes" url="rm9x-13-03.html"></tocsect2>
+ <tocsect2 name="Enumeration Representation Clauses" url="rm9x-13-04.html"></tocsect2>
+ <tocsect2 name="Record Layout" url="rm9x-13-05.html"></tocsect2>
+ <tocsect2 name="Change of Representation" url="rm9x-13-06.html"></tocsect2>
+ <tocsect2 name="The Package System" url="rm9x-13-07.html"></tocsect2>
+ <tocsect2 name="Machine Code Insertions" url="rm9x-13-08.html"></tocsect2>
+ <tocsect2 name="Unchecked Type Conversions" url="rm9x-13-09.html"></tocsect2>
+ <tocsect2 name="Unchecked Access Value Creation" url="rm9x-13-10.html"></tocsect2>
+ <tocsect2 name="Storage Management" url="rm9x-13-11.html"></tocsect2>
+ <tocsect2 name="Pragma Restrictions" url="rm9x-13-12.html"></tocsect2>
+ <tocsect2 name="Streams" url="rm9x-13-13.html"></tocsect2>
+ <tocsect2 name="Freezing Rules" url="rm9x-13-14.html"></tocsect2>
+</tocsect1>
+</kdeveloptoc>
diff --git a/languages/ada/doc/ada_bugs_gcc.toc b/languages/ada/doc/ada_bugs_gcc.toc
new file mode 100644
index 00000000..9c543f0c
--- /dev/null
+++ b/languages/ada/doc/ada_bugs_gcc.toc
@@ -0,0 +1,7 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>Ada bugs (GCC)</title>
+<base href="http://gcc.gnu.org/bugzilla/"/>
+<tocsect1 name="Query" url="query.cgi">
+</tocsect1>
+</kdeveloptoc>
diff --git a/languages/ada/file_templates/Makefile.am b/languages/ada/file_templates/Makefile.am
new file mode 100644
index 00000000..58bbd907
--- /dev/null
+++ b/languages/ada/file_templates/Makefile.am
@@ -0,0 +1,3 @@
+templatedir = $(kde_datadir)/kdevfilecreate/file-templates
+template_DATA = adb ads
+
diff --git a/languages/ada/file_templates/adb b/languages/ada/file_templates/adb
new file mode 100644
index 00000000..0306105a
--- /dev/null
+++ b/languages/ada/file_templates/adb
@@ -0,0 +1,12 @@
+--
+--
+-- Ada Body: $MODULE$
+--
+-- Description:
+--
+--
+-- Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+--
+-- Copyright: See COPYING file that comes with this distribution
+--
+--
diff --git a/languages/ada/file_templates/ads b/languages/ada/file_templates/ads
new file mode 100644
index 00000000..46463d47
--- /dev/null
+++ b/languages/ada/file_templates/ads
@@ -0,0 +1,12 @@
+--
+--
+-- Ada Spec: $MODULE$
+--
+-- Description:
+--
+--
+-- Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+--
+-- Copyright: See COPYING file that comes with this distribution
+--
+--
diff --git a/languages/ada/kdevadasupport.desktop b/languages/ada/kdevadasupport.desktop
new file mode 100644
index 00000000..4f99e10c
--- /dev/null
+++ b/languages/ada/kdevadasupport.desktop
@@ -0,0 +1,87 @@
+[Desktop Entry]
+Type=Service
+Exec=blubb
+Comment=Ada Language Support
+Comment[ca]=Suport per al llenguatge Ada
+Comment[da]=Ada sprogunderstøttelse
+Comment[de]=Sprachunterstützung für Ada
+Comment[el]=Υποστήριξη γλώσσας Ada
+Comment[es]=Soporte para lenguaje Ada
+Comment[et]=ADA keele toetus
+Comment[eu]=Ada lenguaiaren euskarria
+Comment[fa]=پشتیبانی زبان آدا
+Comment[fr]=Prise en charge du langage ADA
+Comment[ga]=Tacaíocht Ada
+Comment[gl]=Soporte da linguaxe Ada
+Comment[hi]=एडीए भाषा समर्थन
+Comment[hu]=Ada nyelvi támogatás
+Comment[is]=Stuðningur við Ada forritunarmálið
+Comment[it]=Supporto al linguaggio Ada
+Comment[ja]=Ada 言語サポート
+Comment[ms]=Sokongan Bahasa Ada
+Comment[nds]=Spraakünnerstütten för Ada
+Comment[ne]=एडा भाषा समर्थन
+Comment[nl]=Ondersteuning voor Ada
+Comment[pl]=Obsługa języka Ada
+Comment[pt]=Suporte à Linguagem Ada
+Comment[pt_BR]=Suporte à Linguagem Ada
+Comment[ru]=Поддержка языка Ada
+Comment[sk]=Podpora jazyka Ada
+Comment[sl]=Podpora jeziku ada
+Comment[sr]=Ada језичка подршка
+Comment[sr@Latn]=Ada jezička podrška
+Comment[sv]=Stöd för språket Ada
+Comment[ta]=அடா மொழி ஆதரவு
+Comment[tg]=Ёри намудани забони Ada
+Comment[tr]=Ada Dil Desteği
+Comment[zh_CN]=Ada 语言支持
+Comment[zh_TW]=Ada 語言支援
+Name=KDevAdaSupport
+Name[da]=KDevelop Ada-understøttelse
+Name[de]=Unterstützung für Ada (KDevelop)
+Name[hi]=के-डेव-एडीए-समर्थन
+Name[nds]=Ada-Ünnerstütten för KDevelop
+Name[ne]=केडीई विकास एडा समर्थन
+Name[pl]=KDevObsługaAdy
+Name[sk]=KDevAdaPodpora
+Name[sv]=KDevelop Ada-stöd
+Name[ta]=கெடெவ் அடா ஆதரவு
+Name[zh_TW]=KDevelop Ada 支援
+GenericName=Ada Language Support
+GenericName[ca]=Suport per al llenguatge Ada
+GenericName[da]=Ada sprogunderstøttelse
+GenericName[de]=Sprachunterstützung für Ada
+GenericName[el]=Υποστήριξη γλώσσας Ada
+GenericName[es]=Soporte para lenguaje Ada
+GenericName[et]=ADA keele toetus
+GenericName[eu]=Ada lenguaiaren euskarria
+GenericName[fa]=پشتیبانی زبان آدا
+GenericName[fr]=Prise en charge du langage ADA
+GenericName[ga]=Tacaíocht Ada
+GenericName[gl]=Soporte da linguaxe Ada
+GenericName[hi]=एडीए भाषा समर्थन
+GenericName[hu]=Ada-támogatás
+GenericName[it]=Supporto al linguaggio Ada
+GenericName[ja]=Ada 言語サポート
+GenericName[ms]=Sokongan Bahasa Ada
+GenericName[nds]=Ünnerstütten för de Spraak Ada
+GenericName[ne]=एडा भाषा समर्थन
+GenericName[nl]=Ondersteuning voor Ada
+GenericName[pl]=Obsługa języka Ada
+GenericName[pt]=Suporte à Linguagem Ada
+GenericName[pt_BR]=Suporte à Linguagem Ada
+GenericName[ru]=Поддержка языка Ada
+GenericName[sk]=Podpora jazyka Ada
+GenericName[sl]=Podpora jeziku ada
+GenericName[sr]=Ada језичка подршка
+GenericName[sr@Latn]=Ada jezička podrška
+GenericName[sv]=Stöd för språket Ada
+GenericName[ta]=அடா மொழி ஆதரவு
+GenericName[tg]=Ёри намудани забони Ada
+GenericName[tr]=Ada Dil Desteği
+GenericName[zh_CN]=Ada 语言支持
+GenericName[zh_TW]=Ada 語言支援
+ServiceTypes=KDevelop/LanguageSupport
+X-KDE-Library=libkdevadasupport
+X-KDevelop-Version=5
+X-KDevelop-Language=Ada
diff --git a/languages/ada/kdevadasupport.rc b/languages/ada/kdevadasupport.rc
new file mode 100644
index 00000000..23b705db
--- /dev/null
+++ b/languages/ada/kdevadasupport.rc
@@ -0,0 +1,11 @@
+<!DOCTYPE kpartgui>
+<kpartplugin name="KDevAdaSupport" version="1">
+<MenuBar>
+ <Menu name="tools"><Text>&amp;Tools</Text>
+ <Action name="plugin_action"/>
+ </Menu>
+</MenuBar>
+<ToolBar name="extraToolBar">
+ <Action name="plugin_action"/>
+</ToolBar>
+</kpartplugin>
diff --git a/languages/ada/preambles.h b/languages/ada/preambles.h
new file mode 100644
index 00000000..e9ea460b
--- /dev/null
+++ b/languages/ada/preambles.h
@@ -0,0 +1,89 @@
+/*
+ * Two macros are defined here: ANTLR_PARSER_PREAMBLE and ANTLR_LEXER_PREAMBLE.
+ * They encapsulate the application specific extensions for the classes
+ * AdaParser and AdaLexer which are defined in ada.g.
+ * This keeps ada.g independent of the application.
+ *
+ * Kdevelop version:
+ * (C) 2003 Oliver M. Kellogg (okellogg@users.sourceforge.net)
+ */
+#ifndef _PREAMBLES_H_
+#define _PREAMBLES_H_
+
+#include <string>
+#include "problemreporter.h"
+
+#define ANTLR_PARSER_PREAMBLE \
+ 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::RecognitionException& ex) { \
+ m_problemReporter->reportError \
+ (ex.toString().c_str (), \
+ ex.getFilename().c_str (), \
+ ex.getLine (), \
+ ex.getColumn ()); \
+ ++m_numberOfErrors; \
+ } \
+ \
+ void reportError (const std::string& errorMessage) { \
+ m_problemReporter->reportError \
+ (errorMessage.c_str(), \
+ getFilename ().c_str(), \
+ LT(1)->getLine (), \
+ LT(1)->getColumn ()); \
+ ++m_numberOfErrors; \
+ } \
+ \
+ void reportMessage (const std::string& message) { \
+ m_problemReporter->reportMessage \
+ (message.c_str (), \
+ getFilename ().c_str (), \
+ LT(1)->getLine (), \
+ LT(1)->getColumn ()); \
+ }
+
+#define ANTLR_LEXER_PREAMBLE \
+ 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::RecognitionException& ex) { \
+ m_problemReporter->reportError \
+ (ex.toString ().c_str (), \
+ ex.getFilename ().c_str (), \
+ ex.getLine (), \
+ ex.getColumn ()); \
+ ++m_numberOfErrors; \
+ } \
+ \
+ void reportError (const std::string& errorMessage) { \
+ m_problemReporter->reportError \
+ (errorMessage.c_str (), \
+ getFilename().c_str (), \
+ getLine (), \
+ getColumn ()); \
+ ++m_numberOfErrors; \
+ } \
+ \
+ void reportWarning (const std::string& warnMessage) { \
+ m_problemReporter->reportWarning \
+ (warnMessage.c_str (), \
+ getFilename ().c_str (), \
+ getLine (), \
+ getColumn ()); \
+ }
+
+#endif // _PREAMBLES_H_
+
diff --git a/languages/ada/problemreporter.cpp b/languages/ada/problemreporter.cpp
new file mode 100644
index 00000000..36ac6186
--- /dev/null
+++ b/languages/ada/problemreporter.cpp
@@ -0,0 +1,282 @@
+/*
+ Copyright (C) 2002 by Roberto Raggi <roberto@kdevelop.org>
+ Copyright (C) 2003 Oliver Kellogg <okellogg@users.sourceforge.net>
+
+ 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 "adasupportpart.h"
+#include "kdevpartcontroller.h"
+#include "kdevmainwindow.h"
+#include "configproblemreporter.h"
+#include "backgroundparser.h"
+
+#include <qfileinfo.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 <qwhatsthis.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( AdaSupportPart* part, QWidget* parent, const char* name )
+ : QListView( parent, name ),
+ m_adaSupport( part ),
+ m_editor( 0 ),
+ m_document( 0 ),
+ m_markIface( 0 ),
+ m_bgParser( 0 )
+{
+ QWhatsThis::add(this, i18n("<b>Problem reporter</b><p>This window shows errors reported by a language parser."));
+
+ 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() << "ProblemReporter::reparse()" << endl;
+
+ if( !m_editor )
+ return;
+
+ m_timer->stop();
+
+ if( m_bgParser ) {
+ if( m_bgParser->running() ) {
+ m_timer->changeInterval( m_delay );
+ return;
+ }
+
+ delete( m_bgParser );
+ m_bgParser = 0;
+ }
+
+ QListViewItem* current = firstChild();
+ while( current ){
+ QListViewItem* i = current;
+ current = current->nextSibling();
+
+ if( i->text(2) == m_filename )
+ delete( i );
+ }
+
+ 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;
+ }
+ }
+
+/* Temporarily deactivated (crashes)*/
+ if (!m_adaSupport->fileExtensions ().contains (QFileInfo (m_filename).extension ()))
+ {
+ m_bgParser = new BackgroundParser( this, m_editor->text(), m_filename );
+ m_bgParser->start();
+ }
+ /**/
+}
+
+void ProblemReporter::slotSelected( QListViewItem* item )
+{
+ KURL url( item->text(2) );
+ int line = item->text( 3 ).toInt();
+ // int column = item->text( 4 ).toInt();
+ m_adaSupport->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() << "ProblemReporter::configure()" << endl;
+ KConfig* config = kapp->config();
+ config->setGroup( "General Options" );
+ m_active = config->readBoolEntry( "EnableAdaBgParser", TRUE );
+ m_delay = config->readNumEntry( "BgParserDelay", 500 );
+}
+
+void ProblemReporter::configWidget( KDialogBase* dlg )
+{
+ kdDebug() << "ProblemReporter::configWidget()" << endl;
+ QVBox *vbox = dlg->addVBoxPage(i18n("Ada Parsing"), i18n("Ada Parsing"), BarIcon( "source", KIcon::SizeMedium ));
+ 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() << "ProblemReporter::slotPartRemoved()" << endl;
+ if( part == m_document ){
+ m_document = 0;
+ m_editor = 0;
+ m_timer->stop();
+ }
+}
+
+#include "problemreporter.moc"
diff --git a/languages/ada/problemreporter.h b/languages/ada/problemreporter.h
new file mode 100644
index 00000000..b42a6ad3
--- /dev/null
+++ b/languages/ada/problemreporter.h
@@ -0,0 +1,79 @@
+/*
+ Copyright (C) 2002 by Roberto Raggi <roberto@kdevelop.org>
+ Copyright (C) 2003 Oliver Kellogg <okellogg@users.sourceforge.net>
+
+ 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 AdaSupportPart;
+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( AdaSupportPart* 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:
+ AdaSupportPart* m_adaSupport;
+ 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