summaryrefslogtreecommitdiffstats
path: root/languages/ada/AdaLexer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'languages/ada/AdaLexer.cpp')
-rw-r--r--languages/ada/AdaLexer.cpp1507
1 files changed, 1507 insertions, 0 deletions
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);
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-26 06:58:37 +0000