diff --git a/sqlitedbbrowser.pro b/sqlitedbbrowser.pro index c23a240a..49dfb3d5 100644 --- a/sqlitedbbrowser.pro +++ b/sqlitedbbrowser.pro @@ -1,6 +1,7 @@ TEMPLATE = subdirs -SUBDIRS = src +SUBDIRS = libs/antlr-2.7.7/antlr.pro +SUBDIRS += src diff --git a/src/grammar/README b/src/grammar/README new file mode 100644 index 00000000..42fec62b --- /dev/null +++ b/src/grammar/README @@ -0,0 +1,6 @@ +To generate c++ code from the grammar(sqlit3.g) you need +antlr 2.7.7. Download it from www.antlr2.org. + +Either put the antlr.jar into your system classpath or +start it like this: +java -cp .:/pathto/antlr.jar antlr.Tool sqlite3.g diff --git a/src/grammar/Sqlite3Lexer.cpp b/src/grammar/Sqlite3Lexer.cpp new file mode 100644 index 00000000..ccb95d84 --- /dev/null +++ b/src/grammar/Sqlite3Lexer.cpp @@ -0,0 +1,1260 @@ +/* $ANTLR 2.7.7 (20121001): "sqlite3.g" -> "Sqlite3Lexer.cpp"$ */ +#include "Sqlite3Lexer.hpp" +#include +#include +#include +#include +#include +#include +#include + +Sqlite3Lexer::Sqlite3Lexer(ANTLR_USE_NAMESPACE(std)istream& in) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false) +{ + initLiterals(); +} + +Sqlite3Lexer::Sqlite3Lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false) +{ + initLiterals(); +} + +Sqlite3Lexer::Sqlite3Lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state) + : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false) +{ + initLiterals(); +} + +void Sqlite3Lexer::initLiterals() +{ + literals["DEFAULT"] = 16; + literals["IF"] = 25; + literals["CURRENT_DATE"] = 14; + literals["LIKE"] = 23; + literals["AS"] = 5; + literals["TEMPORARY"] = 35; + literals["UNIQUE"] = 38; + literals["CHECK"] = 8; + literals["COLLATE"] = 10; + literals["NOT"] = 27; + literals["ELSE"] = 18; + literals["REFERENCES"] = 33; + literals["CREATE"] = 9; + literals["THEN"] = 37; + literals["EXISTS"] = 30; + literals["CASE"] = 7; + literals["REGEXP"] = 34; + literals["ON"] = 31; + literals["CURRENT_TIME"] = 13; + literals["GLOB"] = 21; + literals["CURRENT_TIMESTAMP"] = 15; + literals["ASC"] = 6; + literals["ESCAPE"] = 20; + literals["DESC"] = 17; + literals["TABLE"] = 24; + literals["TEMP"] = 36; + literals["END"] = 19; + literals["KEY"] = 22; + literals["WHEN"] = 39; + literals["CONSTRAINT"] = 12; + literals["MATCH"] = 29; + literals["AUTOINCREMENT"] = 4; + literals["IS"] = 26; + literals["NULL"] = 28; + literals["CONFLICT"] = 11; + literals["PRIMARY"] = 32; +} + +ANTLR_USE_NAMESPACE(antlr)RefToken Sqlite3Lexer::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 0x5f /* '_' */ : + 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' */ : + { + mID(true); + theRetToken=_returnToken; + break; + } + case 0x22 /* '\"' */ : + case 0x5b /* '[' */ : + case 0x60 /* '`' */ : + { + mQUOTEDID(true); + theRetToken=_returnToken; + break; + } + case 0x2e /* '.' */ : + 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(true); + theRetToken=_returnToken; + break; + } + case 0x2b /* '+' */ : + { + mPLUS(true); + theRetToken=_returnToken; + break; + } + case 0x2d /* '-' */ : + { + mMINUS(true); + theRetToken=_returnToken; + break; + } + case 0x9 /* '\t' */ : + case 0xa /* '\n' */ : + case 0xd /* '\r' */ : + case 0x20 /* ' ' */ : + { + mWS(true); + theRetToken=_returnToken; + break; + } + case 0x27 /* '\'' */ : + { + mSTRING(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 0x2a /* '*' */ : + { + mSTAR(true); + theRetToken=_returnToken; + break; + } + case 0x7e /* '~' */ : + { + mTILDE(true); + theRetToken=_returnToken; + break; + } + case 0x26 /* '&' */ : + { + mAMPERSAND(true); + theRetToken=_returnToken; + break; + } + case 0x21 /* '!' */ : + { + mUNEQUAL(true); + theRetToken=_returnToken; + break; + } + default: + if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) { + mSL_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) { + mML_COMMENT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x7c /* '|' */ ) && (LA(2) == 0x7c /* '|' */ )) { + mOROP(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mEQUAL2(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mGREATEREQUAL(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) { + mLOWEREQUAL(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mUNEQUAL2(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3c /* '<' */ )) { + mBITWISELEFT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ )) { + mBITWISERIGHT(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x7c /* '|' */ ) && (true)) { + mBITOR(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3d /* '=' */ ) && (true)) { + mEQUAL(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3e /* '>' */ ) && (true)) { + mGREATER(true); + theRetToken=_returnToken; + } + else if ((LA(1) == 0x3c /* '<' */ ) && (true)) { + mLOWER(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(); + _ttype = testLiteralsTable(_ttype); + _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 Sqlite3Lexer::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'); + 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 Sqlite3Lexer::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; + + 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 Sqlite3Lexer::mID(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ID; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + { + 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 0x5f /* '_' */ : + { + match('_' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0x61 /* 'a' */ : + case 0x62 /* 'b' */ : + case 0x63 /* 'c' */ : + case 0x64 /* 'd' */ : + case 0x65 /* 'e' */ : + case 0x66 /* 'f' */ : + case 0x67 /* 'g' */ : + case 0x68 /* 'h' */ : + case 0x69 /* 'i' */ : + case 0x6a /* 'j' */ : + case 0x6b /* 'k' */ : + case 0x6c /* 'l' */ : + case 0x6d /* 'm' */ : + case 0x6e /* 'n' */ : + case 0x6f /* 'o' */ : + case 0x70 /* 'p' */ : + case 0x71 /* 'q' */ : + case 0x72 /* 'r' */ : + case 0x73 /* 's' */ : + case 0x74 /* 't' */ : + case 0x75 /* 'u' */ : + case 0x76 /* 'v' */ : + case 0x77 /* 'w' */ : + case 0x78 /* 'x' */ : + case 0x79 /* 'y' */ : + case 0x7a /* 'z' */ : + { + matchRange('a','z'); + break; + } + case 0x30 /* '0' */ : + case 0x31 /* '1' */ : + case 0x32 /* '2' */ : + case 0x33 /* '3' */ : + case 0x34 /* '4' */ : + case 0x35 /* '5' */ : + case 0x36 /* '6' */ : + case 0x37 /* '7' */ : + case 0x38 /* '8' */ : + case 0x39 /* '9' */ : + { + matchRange('0','9'); + break; + } + case 0x5f /* '_' */ : + { + match('_' /* charlit */ ); + break; + } + default: + { + goto _loop6; + } + } + } + _loop6:; + } // ( ... )* + 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 Sqlite3Lexer::mQUOTEDID(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = QUOTEDID; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + switch ( LA(1)) { + case 0x60 /* '`' */ : + { + match('`' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((_tokenSet_0.member(LA(1)))) { + { + match(_tokenSet_0); + } + } + else { + goto _loop10; + } + + } + _loop10:; + } // ( ... )* + match('`' /* charlit */ ); + break; + } + case 0x5b /* '[' */ : + { + match('[' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((_tokenSet_1.member(LA(1)))) { + { + match(_tokenSet_1); + } + } + else { + goto _loop13; + } + + } + _loop13:; + } // ( ... )* + match(']' /* charlit */ ); + break; + } + case 0x22 /* '\"' */ : + { + match('\"' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((_tokenSet_2.member(LA(1)))) { + { + match(_tokenSet_2); + } + } + else { + goto _loop16; + } + + } + _loop16:; + } // ( ... )* + match('\"' /* charlit */ ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + 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 Sqlite3Lexer::mNUMERIC(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = NUMERIC; + 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' */ : + { + { // ( ... )+ + int _cnt20=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt20>=1 ) { goto _loop20; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt20++; + } + _loop20:; + } // ( ... )+ + { + if ((LA(1) == 0x2e /* '.' */ )) { + match('.' /* charlit */ ); + { // ( ... )* + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + goto _loop23; + } + + } + _loop23:; + } // ( ... )* + } + else { + } + + } + break; + } + case 0x2e /* '.' */ : + { + match('.' /* charlit */ ); + _ttype=DOT; + { // ( ... )+ + int _cnt25=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt25>=1 ) { goto _loop25; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt25++; + } + _loop25:; + } // ( ... )+ + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + { + if ((LA(1) == 0x65 /* 'e' */ )) { + match('e' /* charlit */ ); + { + switch ( LA(1)) { + case 0x2b /* '+' */ : + { + mPLUS(false); + break; + } + case 0x2d /* '-' */ : + { + mMINUS(false); + 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 _cnt29=0; + for (;;) { + if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) { + mDIGIT(false); + } + else { + if ( _cnt29>=1 ) { goto _loop29; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());} + } + + _cnt29++; + } + _loop29:; + } // ( ... )+ + } + else { + } + + } + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mPLUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = PLUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('+' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mMINUS(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = MINUS; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('-' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mSL_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SL_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("//"); + { // ( ... )* + for (;;) { + if ((_tokenSet_3.member(LA(1)))) { + matchNot('\n' /* charlit */ ); + } + else { + goto _loop32; + } + + } + _loop32:; + } // ( ... )* + match('\n' /* charlit */ ); + _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline(); + 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 Sqlite3Lexer::mML_COMMENT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = ML_COMMENT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("/*"); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + newline(); + break; + } + case 0x0 /* '\0' */ : + case 0x1 /* '\1' */ : + case 0x2 /* '\2' */ : + case 0x3 /* '\3' */ : + case 0x4 /* '\4' */ : + case 0x5 /* '\5' */ : + case 0x6 /* '\6' */ : + case 0x7 /* '\7' */ : + case 0x8 /* '\10' */ : + case 0x9 /* '\t' */ : + case 0xb /* '\13' */ : + case 0xc /* '\14' */ : + case 0xd /* '\r' */ : + case 0xe /* '\16' */ : + case 0xf /* '\17' */ : + case 0x10 /* '\20' */ : + case 0x11 /* '\21' */ : + case 0x12 /* '\22' */ : + case 0x13 /* '\23' */ : + case 0x14 /* '\24' */ : + case 0x15 /* '\25' */ : + case 0x16 /* '\26' */ : + case 0x17 /* '\27' */ : + case 0x18 /* '\30' */ : + case 0x19 /* '\31' */ : + case 0x1a /* '\32' */ : + case 0x1b /* '\33' */ : + case 0x1c /* '\34' */ : + case 0x1d /* '\35' */ : + case 0x1e /* '\36' */ : + case 0x1f /* '\37' */ : + case 0x20 /* ' ' */ : + case 0x21 /* '!' */ : + case 0x22 /* '\"' */ : + case 0x23 /* '#' */ : + case 0x24 /* '$' */ : + case 0x25 /* '%' */ : + case 0x26 /* '&' */ : + case 0x27 /* '\'' */ : + case 0x28 /* '(' */ : + case 0x29 /* ')' */ : + case 0x2b /* '+' */ : + case 0x2c /* ',' */ : + case 0x2d /* '-' */ : + case 0x2e /* '.' */ : + case 0x2f /* '/' */ : + 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 0x3a /* ':' */ : + case 0x3b /* ';' */ : + case 0x3c /* '<' */ : + case 0x3d /* '=' */ : + case 0x3e /* '>' */ : + case 0x3f /* '?' */ : + case 0x40 /* '@' */ : + case 0x41 /* 'A' */ : + case 0x42 /* 'B' */ : + case 0x43 /* 'C' */ : + case 0x44 /* 'D' */ : + case 0x45 /* 'E' */ : + case 0x46 /* 'F' */ : + case 0x47 /* 'G' */ : + case 0x48 /* 'H' */ : + case 0x49 /* 'I' */ : + case 0x4a /* 'J' */ : + case 0x4b /* 'K' */ : + case 0x4c /* 'L' */ : + case 0x4d /* 'M' */ : + case 0x4e /* 'N' */ : + case 0x4f /* 'O' */ : + case 0x50 /* 'P' */ : + case 0x51 /* 'Q' */ : + case 0x52 /* 'R' */ : + case 0x53 /* 'S' */ : + case 0x54 /* 'T' */ : + case 0x55 /* 'U' */ : + case 0x56 /* 'V' */ : + case 0x57 /* 'W' */ : + case 0x58 /* 'X' */ : + case 0x59 /* 'Y' */ : + case 0x5a /* 'Z' */ : + case 0x5b /* '[' */ : + case 0x5c /* '\\' */ : + case 0x5d /* ']' */ : + case 0x5e /* '^' */ : + case 0x5f /* '_' */ : + case 0x60 /* '`' */ : + 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' */ : + case 0x7b /* '{' */ : + case 0x7c /* '|' */ : + case 0x7d /* '}' */ : + case 0x7e /* '~' */ : + case 0x7f: + { + { + match(_tokenSet_4); + } + break; + } + default: + if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */ && LA(2) <= 0x7f)))&&( LA(2)!='/' )) { + match('*' /* charlit */ ); + } + else { + goto _loop36; + } + } + } + _loop36:; + } // ( ... )* + match("*/"); + _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; + 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 Sqlite3Lexer::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 0xd /* '\r' */ : + { + match('\r' /* charlit */ ); + break; + } + case 0xa /* '\n' */ : + { + match('\n' /* charlit */ ); + newline(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn()); + } + } + } + _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; + 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 Sqlite3Lexer::mSTRING(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STRING; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('\'' /* charlit */ ); + { // ( ... )* + for (;;) { + if ((_tokenSet_5.member(LA(1)))) { + { + match(_tokenSet_5); + } + } + else { + goto _loop42; + } + + } + _loop42:; + } // ( ... )* + match('\'' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mLPAREN(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LPAREN; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('(' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mRPAREN(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = RPAREN; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(')' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mCOMMA(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = COMMA; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(',' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mSEMI(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = SEMI; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(';' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mSTAR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = STAR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('*' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mTILDE(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = TILDE; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('~' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mAMPERSAND(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = AMPERSAND; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('&' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mBITOR(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = BITOR; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('|' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mOROP(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = OROP; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("||"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mEQUAL(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQUAL; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('=' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mEQUAL2(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = EQUAL2; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("=="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mGREATER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('>' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mGREATEREQUAL(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = GREATEREQUAL; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(">="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mLOWER(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LOWER; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match('<' /* charlit */ ); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mLOWEREQUAL(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = LOWEREQUAL; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mUNEQUAL(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = UNEQUAL; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("!="); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mUNEQUAL2(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = UNEQUAL2; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mBITWISELEFT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = BITWISELEFT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match("<<"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + +void Sqlite3Lexer::mBITWISERIGHT(bool _createToken) { + int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length(); + _ttype = BITWISERIGHT; + ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex; + + match(">>"); + if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) { + _token = makeToken(_ttype); + _token->setText(text.substr(_begin, text.length()-_begin)); + } + _returnToken = _token; + _saveIndex=0; +} + + +const unsigned long Sqlite3Lexer::_tokenSet_0_data_[] = { 4294967295UL, 4294967295UL, 4294967295UL, 4294967294UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 +// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e +// 0x1f ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > +// ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ +// a b c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_0(_tokenSet_0_data_,8); +const unsigned long Sqlite3Lexer::_tokenSet_1_data_[] = { 4294967295UL, 4294967295UL, 3758096383UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 +// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e +// 0x1f ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > +// ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ^ _ ` +// a b c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_1(_tokenSet_1_data_,8); +const unsigned long Sqlite3Lexer::_tokenSet_2_data_[] = { 4294967295UL, 4294967291UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 +// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e +// 0x1f ! # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? +// @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` +// a b c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_2(_tokenSet_2_data_,8); +const unsigned long Sqlite3Lexer::_tokenSet_3_data_[] = { 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xd 0xe 0xf 0x10 0x11 +// 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f +// ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ +// A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a +// b c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_3(_tokenSet_3_data_,8); +const unsigned long Sqlite3Lexer::_tokenSet_4_data_[] = { 4294966271UL, 4294966271UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xd 0xe 0xf 0x10 0x11 +// 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f +// ! \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A +// B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b +// c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_4(_tokenSet_4_data_,8); +const unsigned long Sqlite3Lexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL }; +// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 +// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e +// 0x1f ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? +// @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` +// a b c d +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Lexer::_tokenSet_5(_tokenSet_5_data_,8); + diff --git a/src/grammar/Sqlite3Lexer.hpp b/src/grammar/Sqlite3Lexer.hpp new file mode 100644 index 00000000..e8c6d967 --- /dev/null +++ b/src/grammar/Sqlite3Lexer.hpp @@ -0,0 +1,71 @@ +#ifndef INC_Sqlite3Lexer_hpp_ +#define INC_Sqlite3Lexer_hpp_ + +#include +/* $ANTLR 2.7.7 (20121001): "sqlite3.g" -> "Sqlite3Lexer.hpp"$ */ +#include +#include +#include +#include "sqlite3TokenTypes.hpp" +#include +class CUSTOM_API Sqlite3Lexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public sqlite3TokenTypes +{ +private: + void initLiterals(); +public: + bool getCaseSensitiveLiterals() const + { + return true; + } +public: + Sqlite3Lexer(ANTLR_USE_NAMESPACE(std)istream& in); + Sqlite3Lexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib); + Sqlite3Lexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state); + ANTLR_USE_NAMESPACE(antlr)RefToken nextToken(); + protected: void mDIGIT(bool _createToken); + protected: void mDOT(bool _createToken); + public: void mID(bool _createToken); + public: void mQUOTEDID(bool _createToken); + public: void mNUMERIC(bool _createToken); + public: void mPLUS(bool _createToken); + public: void mMINUS(bool _createToken); + public: void mSL_COMMENT(bool _createToken); + public: void mML_COMMENT(bool _createToken); + public: void mWS(bool _createToken); + public: void mSTRING(bool _createToken); + public: void mLPAREN(bool _createToken); + public: void mRPAREN(bool _createToken); + public: void mCOMMA(bool _createToken); + public: void mSEMI(bool _createToken); + public: void mSTAR(bool _createToken); + public: void mTILDE(bool _createToken); + public: void mAMPERSAND(bool _createToken); + public: void mBITOR(bool _createToken); + public: void mOROP(bool _createToken); + public: void mEQUAL(bool _createToken); + public: void mEQUAL2(bool _createToken); + public: void mGREATER(bool _createToken); + public: void mGREATEREQUAL(bool _createToken); + public: void mLOWER(bool _createToken); + public: void mLOWEREQUAL(bool _createToken); + public: void mUNEQUAL(bool _createToken); + public: void mUNEQUAL2(bool _createToken); + public: void mBITWISELEFT(bool _createToken); + public: void mBITWISERIGHT(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; + 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; +}; + +#endif /*INC_Sqlite3Lexer_hpp_*/ diff --git a/src/grammar/Sqlite3Parser.cpp b/src/grammar/Sqlite3Parser.cpp new file mode 100644 index 00000000..b797d6c9 --- /dev/null +++ b/src/grammar/Sqlite3Parser.cpp @@ -0,0 +1,2971 @@ +/* $ANTLR 2.7.7 (20121001): "sqlite3.g" -> "Sqlite3Parser.cpp"$ */ +#include "Sqlite3Parser.hpp" +#include +#include +#include +Sqlite3Parser::Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) +{ +} + +Sqlite3Parser::Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2) +{ +} + +Sqlite3Parser::Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) +{ +} + +Sqlite3Parser::Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2) +{ +} + +Sqlite3Parser::Sqlite3Parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2) +{ +} + +void Sqlite3Parser::id() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST id_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case ID: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp1_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp1_AST); + match(ID); + id_AST = currentAST.root; + break; + } + case QUOTEDID: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp2_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp2_AST); + match(QUOTEDID); + id_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_0); + } + returnAST = id_AST; +} + +void Sqlite3Parser::databasename() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST databasename_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + id(); + astFactory->addASTChild( currentAST, returnAST ); + databasename_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_1); + } + returnAST = databasename_AST; +} + +void Sqlite3Parser::tablename() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tablename_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + id(); + astFactory->addASTChild( currentAST, returnAST ); + tablename_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_2); + } + returnAST = tablename_AST; +} + +void Sqlite3Parser::columnname() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST columnname_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + id(); + astFactory->addASTChild( currentAST, returnAST ); + columnname_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_3); + } + returnAST = columnname_AST; +} + +void Sqlite3Parser::identifier() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST identifier_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + if (((LA(1) >= DOT && LA(1) <= QUOTEDID)) && ((LA(2) >= DOT && LA(2) <= QUOTEDID))) { + { + switch ( LA(1)) { + case ID: + case QUOTEDID: + { + databasename(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case DOT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp3_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp3_AST); + match(DOT); + } + else if ((LA(1) == ID || LA(1) == QUOTEDID) && (LA(2) == ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + tablename(); + astFactory->addASTChild( currentAST, returnAST ); + identifier_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_4); + } + returnAST = identifier_AST; +} + +void Sqlite3Parser::collationname() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST collationname_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp4_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp4_AST); + match(ID); + collationname_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_5); + } + returnAST = collationname_AST; +} + +void Sqlite3Parser::signednumber() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST signednumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case PLUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp5_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp5_AST); + match(PLUS); + break; + } + case MINUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp6_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp6_AST); + match(MINUS); + break; + } + case NUMERIC: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp7_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp7_AST); + match(NUMERIC); + signednumber_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_5); + } + returnAST = signednumber_AST; +} + +void Sqlite3Parser::statementlist() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST statementlist_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case CREATE: + { + statement(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMI)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp8_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp8_AST); + match(SEMI); + statement(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop77; + } + + } + _loop77:; + } // ( ... )* + statementlist_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_4); + } + returnAST = statementlist_AST; +} + +void Sqlite3Parser::statement() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + createtable(); + astFactory->addASTChild( currentAST, returnAST ); + statement_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_6); + } + returnAST = statement_AST; +} + +void Sqlite3Parser::createtable() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST createtable_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp9_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp9_AST); + match(CREATE); + { + switch ( LA(1)) { + case TEMP: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp10_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp10_AST); + match(TEMP); + break; + } + case TEMPORARY: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp11_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp11_AST); + match(TEMPORARY); + break; + } + case TABLE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp12_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp12_AST); + match(TABLE); + { + switch ( LA(1)) { + case IF_T: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp13_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp13_AST); + match(IF_T); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp14_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp14_AST); + match(NOT); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp15_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp15_AST); + match(EXISTS); + break; + } + case ID: + case QUOTEDID: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + tablename(); + astFactory->addASTChild( currentAST, returnAST ); + { + switch ( LA(1)) { + case LPAREN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp16_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp16_AST); + match(LPAREN); + columndef(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA) && (LA(2) == ID || LA(2) == QUOTEDID)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp17_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp17_AST); + match(COMMA); + columndef(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop85; + } + + } + _loop85:; + } // ( ... )* + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp18_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp18_AST); + match(COMMA); + tableconstraint(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop87; + } + + } + _loop87:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp19_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp19_AST); + match(RPAREN); + break; + } + case AS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp20_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp20_AST); + match(AS); + selectstmt(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + createtable_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root); + createtable_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(astFactory->create(CREATETABLE,"CREATETABLE"))->add(createtable_AST))); + currentAST.root = createtable_AST; + if ( createtable_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST && + createtable_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST ) + currentAST.child = createtable_AST->getFirstChild(); + else + currentAST.child = createtable_AST; + currentAST.advanceChildToEnd(); + createtable_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_6); + } + returnAST = createtable_AST; +} + +void Sqlite3Parser::create_statements() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST create_statements_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + createtable(); + astFactory->addASTChild( currentAST, returnAST ); + create_statements_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_4); + } + returnAST = create_statements_AST; +} + +void Sqlite3Parser::columndef() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST columndef_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + { + switch ( LA(1)) { + case ID: + case QUOTEDID: + { + type_name(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { // ( ... )* + for (;;) { + if ((_tokenSet_7.member(LA(1)))) { + columnconstraint(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop91; + } + + } + _loop91:; + } // ( ... )* + columndef_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root); + columndef_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(astFactory->create(COLUMNDEF,"COLUMNDEF"))->add(columndef_AST))); + currentAST.root = columndef_AST; + if ( columndef_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST && + columndef_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST ) + currentAST.child = columndef_AST->getFirstChild(); + else + currentAST.child = columndef_AST; + currentAST.advanceChildToEnd(); + columndef_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_8); + } + returnAST = columndef_AST; +} + +void Sqlite3Parser::tableconstraint() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tableconstraint_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case CONSTRAINT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp21_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp21_AST); + match(CONSTRAINT); + name(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CHECK: + case PRIMARY: + case UNIQUE: + case FOREIGN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case PRIMARY: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp22_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp22_AST); + match(PRIMARY); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp23_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp23_AST); + match(KEY); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp24_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp24_AST); + match(LPAREN); + indexedcolumn(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp25_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp25_AST); + match(COMMA); + indexedcolumn(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop110; + } + + } + _loop110:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp26_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp26_AST); + match(RPAREN); + { + switch ( LA(1)) { + case ON: + { + conflictclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case UNIQUE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp27_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp27_AST); + match(UNIQUE); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp28_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp28_AST); + match(LPAREN); + indexedcolumn(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp29_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp29_AST); + match(COMMA); + indexedcolumn(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop113; + } + + } + _loop113:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp30_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp30_AST); + match(RPAREN); + { + switch ( LA(1)) { + case ON: + { + conflictclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case CHECK: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp31_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp31_AST); + match(CHECK); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp32_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp32_AST); + match(LPAREN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp33_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp33_AST); + match(RPAREN); + break; + } + case FOREIGN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp34_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp34_AST); + match(FOREIGN); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp35_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp35_AST); + match(KEY); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp36_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp36_AST); + match(LPAREN); + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp37_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp37_AST); + match(COMMA); + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop116; + } + + } + _loop116:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp38_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp38_AST); + match(RPAREN); + foreignkeyclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + tableconstraint_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root); + tableconstraint_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(astFactory->create(TABLECONSTRAINT,"TABLECONSTRAINT"))->add(tableconstraint_AST))); + currentAST.root = tableconstraint_AST; + if ( tableconstraint_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST && + tableconstraint_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST ) + currentAST.child = tableconstraint_AST->getFirstChild(); + else + currentAST.child = tableconstraint_AST; + currentAST.advanceChildToEnd(); + tableconstraint_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_8); + } + returnAST = tableconstraint_AST; +} + +void Sqlite3Parser::selectstmt() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST selectstmt_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp39_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp39_AST); + match(SELECT); + selectstmt_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_9); + } + returnAST = selectstmt_AST; +} + +void Sqlite3Parser::type_name() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST type_name_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { // ( ... )+ + int _cnt95=0; + for (;;) { + if ((LA(1) == ID || LA(1) == QUOTEDID)) { + name(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt95++; + } + _loop95:; + } // ( ... )+ + { + switch ( LA(1)) { + case LPAREN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp40_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp40_AST); + match(LPAREN); + signednumber(); + astFactory->addASTChild( currentAST, returnAST ); + { + switch ( LA(1)) { + case COMMA: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp41_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp41_AST); + match(COMMA); + signednumber(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp42_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp42_AST); + match(RPAREN); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + type_name_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root); + type_name_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(astFactory->create(TYPE_NAME,"TYPE_NAME"))->add(type_name_AST))); + currentAST.root = type_name_AST; + if ( type_name_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST && + type_name_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST ) + currentAST.child = type_name_AST->getFirstChild(); + else + currentAST.child = type_name_AST; + currentAST.advanceChildToEnd(); + type_name_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_10); + } + returnAST = type_name_AST; +} + +void Sqlite3Parser::columnconstraint() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST columnconstraint_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case CONSTRAINT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp43_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp43_AST); + match(CONSTRAINT); + name(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CHECK: + case COLLATE: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case PRIMARY: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp44_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp44_AST); + match(PRIMARY); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp45_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp45_AST); + match(KEY); + { + switch ( LA(1)) { + case ASC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp46_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp46_AST); + match(ASC); + break; + } + case DESC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp47_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp47_AST); + match(DESC); + break; + } + case AUTOINCREMENT: + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case AUTOINCREMENT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp48_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp48_AST); + match(AUTOINCREMENT); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case NOT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp49_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp49_AST); + match(NOT); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp50_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp50_AST); + match(NULL_T); + { + switch ( LA(1)) { + case ON: + { + conflictclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case UNIQUE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp51_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp51_AST); + match(UNIQUE); + { + switch ( LA(1)) { + case ON: + { + conflictclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case CHECK: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp52_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp52_AST); + match(CHECK); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp53_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp53_AST); + match(LPAREN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp54_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp54_AST); + match(RPAREN); + break; + } + case DEFAULT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp55_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp55_AST); + match(DEFAULT); + { + switch ( LA(1)) { + case NUMERIC: + case PLUS: + case MINUS: + { + signednumber(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case STRING: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp56_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp56_AST); + match(STRING); + break; + } + case LPAREN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp57_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp57_AST); + match(LPAREN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp58_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp58_AST); + match(RPAREN); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case COLLATE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp59_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp59_AST); + match(COLLATE); + collationname(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case REFERENCES: + { + foreignkeyclause(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + columnconstraint_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(currentAST.root); + columnconstraint_AST = ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(astFactory->create(COLUMNCONSTRAINT,"COLUMNCONSTRAINT"))->add(columnconstraint_AST))); + currentAST.root = columnconstraint_AST; + if ( columnconstraint_AST!=ANTLR_USE_NAMESPACE(antlr)nullAST && + columnconstraint_AST->getFirstChild() != ANTLR_USE_NAMESPACE(antlr)nullAST ) + currentAST.child = columnconstraint_AST->getFirstChild(); + else + currentAST.child = columnconstraint_AST; + currentAST.advanceChildToEnd(); + columnconstraint_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_10); + } + returnAST = columnconstraint_AST; +} + +void Sqlite3Parser::name() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST name_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case ID: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp60_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp60_AST); + match(ID); + name_AST = currentAST.root; + break; + } + case QUOTEDID: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp61_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp61_AST); + match(QUOTEDID); + name_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_11); + } + returnAST = name_AST; +} + +void Sqlite3Parser::conflictclause() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST conflictclause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp62_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp62_AST); + match(ON); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp63_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp63_AST); + match(CONFLICT); + { + switch ( LA(1)) { + case ROLLBACK: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp64_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp64_AST); + match(ROLLBACK); + break; + } + case ABORT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp65_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp65_AST); + match(ABORT); + break; + } + case FAIL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp66_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp66_AST); + match(FAIL); + break; + } + case IGNORE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp67_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp67_AST); + match(IGNORE); + break; + } + case REPLACE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp68_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp68_AST); + match(REPLACE); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + conflictclause_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_10); + } + returnAST = conflictclause_AST; +} + +void Sqlite3Parser::expr() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST expr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + subexpr(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) { + { + switch ( LA(1)) { + case GLOB: + case LIKE: + case IS: + case MATCH: + case REGEXP: + case PLUS: + case MINUS: + case STAR: + case AMPERSAND: + case BITOR: + case OROP: + case EQUAL: + case EQUAL2: + case GREATER: + case GREATEREQUAL: + case LOWER: + case LOWEREQUAL: + case UNEQUAL: + case UNEQUAL2: + case BITWISELEFT: + case BITWISERIGHT: + case IN: + case SLASH: + case PERCENT: + { + binaryoperator(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case AND: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp69_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp69_AST); + match(AND); + break; + } + case OR: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp70_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp70_AST); + match(OR); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subexpr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop138; + } + + } + _loop138:; + } // ( ... )* + expr_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_14); + } + returnAST = expr_AST; +} + +void Sqlite3Parser::foreignkeyclause() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST foreignkeyclause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp71_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp71_AST); + match(REFERENCES); + tablename(); + astFactory->addASTChild( currentAST, returnAST ); + { + switch ( LA(1)) { + case LPAREN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp72_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp72_AST); + match(LPAREN); + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp73_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp73_AST); + match(COMMA); + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop123; + } + + } + _loop123:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp74_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp74_AST); + match(RPAREN); + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case MATCH: + case ON: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + case DEFERRABLE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case ON: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp75_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp75_AST); + match(ON); + { + switch ( LA(1)) { + case DELETE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp76_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp76_AST); + match(DELETE); + break; + } + case UPDATE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp77_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp77_AST); + match(UPDATE); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case SET: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp78_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp78_AST); + match(SET); + { + switch ( LA(1)) { + case NULL_T: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp79_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp79_AST); + match(NULL_T); + break; + } + case DEFAULT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp80_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp80_AST); + match(DEFAULT); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case CASCADE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp81_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp81_AST); + match(CASCADE); + break; + } + case RESTRICT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp82_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp82_AST); + match(RESTRICT); + break; + } + case NO: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp83_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp83_AST); + match(NO); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp84_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp84_AST); + match(ACTION); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case MATCH: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp85_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp85_AST); + match(MATCH); + name(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + goto _loop128; + } + } + } + _loop128:; + } // ( ... )* + { + if ((LA(1) == NOT || LA(1) == DEFERRABLE) && (_tokenSet_15.member(LA(2)))) { + { + switch ( LA(1)) { + case NOT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp86_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp86_AST); + match(NOT); + break; + } + case DEFERRABLE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp87_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp87_AST); + match(DEFERRABLE); + { + switch ( LA(1)) { + case INITIALLY: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp88_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp88_AST); + match(INITIALLY); + { + switch ( LA(1)) { + case DEFERRED: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp89_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp89_AST); + match(DEFERRED); + break; + } + case IMMEDIATE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp90_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp90_AST); + match(IMMEDIATE); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case CHECK: + case COLLATE: + case CONSTRAINT: + case DEFAULT: + case NOT: + case PRIMARY: + case REFERENCES: + case UNIQUE: + case RPAREN: + case COMMA: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_16.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + foreignkeyclause_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_10); + } + returnAST = foreignkeyclause_AST; +} + +void Sqlite3Parser::indexedcolumn() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST indexedcolumn_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + id(); + astFactory->addASTChild( currentAST, returnAST ); + indexedcolumn_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_8); + } + returnAST = indexedcolumn_AST; +} + +void Sqlite3Parser::functionname() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST functionname_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + id(); + astFactory->addASTChild( currentAST, returnAST ); + functionname_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_17); + } + returnAST = functionname_AST; +} + +void Sqlite3Parser::subexpr() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST subexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) { + unaryoperator(); + astFactory->addASTChild( currentAST, returnAST ); + } + else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + { + switch ( LA(1)) { + case CURRENT_TIME: + case CURRENT_DATE: + case CURRENT_TIMESTAMP: + case NULL_T: + case NUMERIC: + case STRING: + case PLUS: + case MINUS: + { + literalvalue(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CAST: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp91_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp91_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp91_AST); + match(CAST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp92_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp92_AST); + match(LPAREN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp93_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp93_AST); + match(AS); + type_name(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp94_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp94_AST); + match(RPAREN); + break; + } + case CASE_T: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp95_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp95_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp95_AST); + match(CASE_T); + { + switch ( LA(1)) { + case CASE_T: + case CURRENT_TIME: + case CURRENT_DATE: + case CURRENT_TIMESTAMP: + case NOT: + case NULL_T: + case EXISTS: + case ID: + case QUOTEDID: + case NUMERIC: + case STRING: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case CAST: + case RAISE: + { + expr(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case WHEN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { // ( ... )+ + int _cnt151=0; + for (;;) { + if ((LA(1) == WHEN)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp96_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp96_AST); + match(WHEN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp97_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp97_AST); + match(THEN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt151++; + } + _loop151:; + } // ( ... )+ + { + switch ( LA(1)) { + case ELSE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp98_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp98_AST); + match(ELSE); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp99_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp99_AST); + match(END); + break; + } + case RAISE: + { + raisefunction(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + if ((LA(1) == ID || LA(1) == QUOTEDID) && (_tokenSet_21.member(LA(2)))) { + { + if ((LA(1) == ID || LA(1) == QUOTEDID) && ((LA(2) >= DOT && LA(2) <= QUOTEDID))) { + { + if ((LA(1) == ID || LA(1) == QUOTEDID) && (LA(2) == DOT)) { + databasename(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp100_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp100_AST); + match(DOT); + } + else if ((LA(1) == ID || LA(1) == QUOTEDID) && (LA(2) == ID || LA(2) == QUOTEDID)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + tablename(); + astFactory->addASTChild( currentAST, returnAST ); + } + else if ((LA(1) == ID || LA(1) == QUOTEDID) && (_tokenSet_22.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + columnname(); + astFactory->addASTChild( currentAST, returnAST ); + } + else if ((LA(1) == ID || LA(1) == QUOTEDID) && (LA(2) == LPAREN)) { + functionname(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp101_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp101_AST); + match(LPAREN); + { + switch ( LA(1)) { + case CASE_T: + case CURRENT_TIME: + case CURRENT_DATE: + case CURRENT_TIMESTAMP: + case NOT: + case NULL_T: + case EXISTS: + case ID: + case QUOTEDID: + case NUMERIC: + case STRING: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case CAST: + case RAISE: + { + expr(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp102_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp102_AST); + match(COMMA); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop146; + } + + } + _loop146:; + } // ( ... )* + break; + } + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp103_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp103_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp103_AST); + match(RPAREN); + } + else if ((LA(1) == LPAREN) && (_tokenSet_13.member(LA(2)))) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp104_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp104_AST); + match(LPAREN); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp105_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp105_AST); + match(RPAREN); + } + else if ((LA(1) == NOT || LA(1) == EXISTS || LA(1) == LPAREN) && (LA(2) == EXISTS || LA(2) == LPAREN || LA(2) == SELECT)) { + { + switch ( LA(1)) { + case NOT: + case EXISTS: + { + { + switch ( LA(1)) { + case NOT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp106_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp106_AST); + match(NOT); + break; + } + case EXISTS: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp107_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp107_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp107_AST); + match(EXISTS); + break; + } + case LPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp108_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp108_AST); + match(LPAREN); + selectstmt(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp109_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp109_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp109_AST); + match(RPAREN); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) { + suffixexpr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + subexpr_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_14); + } + returnAST = subexpr_AST; +} + +void Sqlite3Parser::binaryoperator() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST binaryoperator_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case OROP: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp110_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp110_AST); + match(OROP); + binaryoperator_AST = currentAST.root; + break; + } + case STAR: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp111_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp111_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp111_AST); + match(STAR); + binaryoperator_AST = currentAST.root; + break; + } + case SLASH: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp112_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp112_AST); + match(SLASH); + binaryoperator_AST = currentAST.root; + break; + } + case PERCENT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp113_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp113_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp113_AST); + match(PERCENT); + binaryoperator_AST = currentAST.root; + break; + } + case PLUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp114_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp114_AST); + match(PLUS); + binaryoperator_AST = currentAST.root; + break; + } + case MINUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp115_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp115_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp115_AST); + match(MINUS); + binaryoperator_AST = currentAST.root; + break; + } + case BITWISELEFT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp116_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp116_AST); + match(BITWISELEFT); + binaryoperator_AST = currentAST.root; + break; + } + case BITWISERIGHT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp117_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp117_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp117_AST); + match(BITWISERIGHT); + binaryoperator_AST = currentAST.root; + break; + } + case AMPERSAND: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp118_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp118_AST); + match(AMPERSAND); + binaryoperator_AST = currentAST.root; + break; + } + case BITOR: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp119_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp119_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp119_AST); + match(BITOR); + binaryoperator_AST = currentAST.root; + break; + } + case LOWER: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp120_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp120_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp120_AST); + match(LOWER); + binaryoperator_AST = currentAST.root; + break; + } + case LOWEREQUAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp121_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp121_AST); + match(LOWEREQUAL); + binaryoperator_AST = currentAST.root; + break; + } + case GREATER: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp122_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp122_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp122_AST); + match(GREATER); + binaryoperator_AST = currentAST.root; + break; + } + case GREATEREQUAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp123_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp123_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp123_AST); + match(GREATEREQUAL); + binaryoperator_AST = currentAST.root; + break; + } + case EQUAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp124_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp124_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp124_AST); + match(EQUAL); + binaryoperator_AST = currentAST.root; + break; + } + case EQUAL2: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp125_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp125_AST); + match(EQUAL2); + binaryoperator_AST = currentAST.root; + break; + } + case UNEQUAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp126_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp126_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp126_AST); + match(UNEQUAL); + binaryoperator_AST = currentAST.root; + break; + } + case UNEQUAL2: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp127_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp127_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp127_AST); + match(UNEQUAL2); + binaryoperator_AST = currentAST.root; + break; + } + case IS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp128_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp128_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp128_AST); + match(IS); + { + if ((LA(1) == NOT) && (_tokenSet_13.member(LA(2)))) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp129_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp129_AST); + match(NOT); + } + else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_20.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + binaryoperator_AST = currentAST.root; + break; + } + case IN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp130_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp130_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp130_AST); + match(IN); + binaryoperator_AST = currentAST.root; + break; + } + case LIKE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp131_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp131_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp131_AST); + match(LIKE); + binaryoperator_AST = currentAST.root; + break; + } + case GLOB: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp132_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp132_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp132_AST); + match(GLOB); + binaryoperator_AST = currentAST.root; + break; + } + case MATCH: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp133_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp133_AST); + match(MATCH); + binaryoperator_AST = currentAST.root; + break; + } + case REGEXP: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp134_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp134_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp134_AST); + match(REGEXP); + binaryoperator_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_13); + } + returnAST = binaryoperator_AST; +} + +void Sqlite3Parser::unaryoperator() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST unaryoperator_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case MINUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp135_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp135_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp135_AST); + match(MINUS); + unaryoperator_AST = currentAST.root; + break; + } + case PLUS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp136_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp136_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp136_AST); + match(PLUS); + unaryoperator_AST = currentAST.root; + break; + } + case TILDE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp137_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp137_AST); + match(TILDE); + unaryoperator_AST = currentAST.root; + break; + } + case NOT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp138_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp138_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp138_AST); + match(NOT); + unaryoperator_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_19); + } + returnAST = unaryoperator_AST; +} + +void Sqlite3Parser::literalvalue() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST literalvalue_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case NUMERIC: + case PLUS: + case MINUS: + { + signednumber(); + astFactory->addASTChild( currentAST, returnAST ); + literalvalue_AST = currentAST.root; + break; + } + case STRING: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp139_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp139_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp139_AST); + match(STRING); + literalvalue_AST = currentAST.root; + break; + } + case NULL_T: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp140_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp140_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp140_AST); + match(NULL_T); + literalvalue_AST = currentAST.root; + break; + } + case CURRENT_TIME: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp141_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp141_AST); + match(CURRENT_TIME); + literalvalue_AST = currentAST.root; + break; + } + case CURRENT_DATE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp142_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp142_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp142_AST); + match(CURRENT_DATE); + literalvalue_AST = currentAST.root; + break; + } + case CURRENT_TIMESTAMP: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp143_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp143_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp143_AST); + match(CURRENT_TIMESTAMP); + literalvalue_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_22); + } + returnAST = literalvalue_AST; +} + +void Sqlite3Parser::raisefunction() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST raisefunction_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp144_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp144_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp144_AST); + match(RAISE); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp145_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp145_AST); + match(LPAREN); + { + switch ( LA(1)) { + case IGNORE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp146_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp146_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp146_AST); + match(IGNORE); + break; + } + case ROLLBACK: + case ABORT: + case FAIL: + { + { + switch ( LA(1)) { + case ROLLBACK: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp147_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp147_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp147_AST); + match(ROLLBACK); + break; + } + case ABORT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp148_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp148_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp148_AST); + match(ABORT); + break; + } + case FAIL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp149_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp149_AST); + match(FAIL); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp150_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp150_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp150_AST); + match(COMMA); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp151_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp151_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp151_AST); + match(STRING); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp152_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp152_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp152_AST); + match(RPAREN); + raisefunction_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_22); + } + returnAST = raisefunction_AST; +} + +void Sqlite3Parser::suffixexpr() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST suffixexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case COLLATE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp153_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp153_AST); + match(COLLATE); + collationname(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case GLOB: + case LIKE: + case NOT: + case MATCH: + case REGEXP: + case IN: + { + { + switch ( LA(1)) { + case NOT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp154_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp154_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp154_AST); + match(NOT); + break; + } + case GLOB: + case LIKE: + case MATCH: + case REGEXP: + case IN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case GLOB: + case LIKE: + case MATCH: + case REGEXP: + { + { + switch ( LA(1)) { + case LIKE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp155_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp155_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp155_AST); + match(LIKE); + break; + } + case GLOB: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp156_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp156_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp156_AST); + match(GLOB); + break; + } + case REGEXP: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp157_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp157_AST); + match(REGEXP); + break; + } + case MATCH: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp158_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp158_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp158_AST); + match(MATCH); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + expr(); + astFactory->addASTChild( currentAST, returnAST ); + { + if ((LA(1) == ESCAPE) && (_tokenSet_13.member(LA(2)))) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp159_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp159_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp159_AST); + match(ESCAPE); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + break; + } + case IN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp160_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp160_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp160_AST); + match(IN); + { + switch ( LA(1)) { + case LPAREN: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp161_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp161_AST); + match(LPAREN); + { + switch ( LA(1)) { + case SELECT: + { + selectstmt(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case CASE_T: + case CURRENT_TIME: + case CURRENT_DATE: + case CURRENT_TIMESTAMP: + case NOT: + case NULL_T: + case EXISTS: + case ID: + case QUOTEDID: + case NUMERIC: + case STRING: + case LPAREN: + case PLUS: + case MINUS: + case TILDE: + case CAST: + case RAISE: + { + expr(); + astFactory->addASTChild( currentAST, returnAST ); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp162_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp162_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp162_AST); + match(COMMA); + expr(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop163; + } + + } + _loop163:; + } // ( ... )* + break; + } + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp163_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp163_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp163_AST); + match(RPAREN); + break; + } + case ID: + case QUOTEDID: + { + tablename(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + suffixexpr_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_14); + } + returnAST = suffixexpr_AST; +} + +void Sqlite3Parser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(100); +} +const char* Sqlite3Parser::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"AUTOINCREMENT\"", + "\"AS\"", + "\"ASC\"", + "\"CASE\"", + "\"CHECK\"", + "\"CREATE\"", + "\"COLLATE\"", + "\"CONFLICT\"", + "\"CONSTRAINT\"", + "\"CURRENT_TIME\"", + "\"CURRENT_DATE\"", + "\"CURRENT_TIMESTAMP\"", + "\"DEFAULT\"", + "\"DESC\"", + "\"ELSE\"", + "\"END\"", + "\"ESCAPE\"", + "\"GLOB\"", + "\"KEY\"", + "\"LIKE\"", + "\"TABLE\"", + "\"IF\"", + "\"IS\"", + "\"NOT\"", + "\"NULL\"", + "\"MATCH\"", + "\"EXISTS\"", + "\"ON\"", + "\"PRIMARY\"", + "\"REFERENCES\"", + "\"REGEXP\"", + "\"TEMPORARY\"", + "\"TEMP\"", + "\"THEN\"", + "\"UNIQUE\"", + "\"WHEN\"", + "TYPE_NAME", + "COLUMNDEF", + "COLUMNCONSTRAINT", + "TABLECONSTRAINT", + "CREATETABLE", + "DIGIT", + "DOT", + "ID", + "QUOTEDID", + "NUMERIC", + "SL_COMMENT", + "ML_COMMENT", + "WS", + "STRING", + "LPAREN", + "RPAREN", + "COMMA", + "SEMI", + "PLUS", + "MINUS", + "STAR", + "TILDE", + "AMPERSAND", + "BITOR", + "OROP", + "EQUAL", + "EQUAL2", + "GREATER", + "GREATEREQUAL", + "LOWER", + "LOWEREQUAL", + "UNEQUAL", + "UNEQUAL2", + "BITWISELEFT", + "BITWISERIGHT", + "FOREIGN", + "ROLLBACK", + "ABORT", + "FAIL", + "IGNORE", + "REPLACE", + "DELETE", + "UPDATE", + "SET", + "CASCADE", + "RESTRICT", + "NO", + "ACTION", + "DEFERRABLE", + "INITIALLY", + "DEFERRED", + "IMMEDIATE", + "SELECT", + "AND", + "OR", + "CAST", + "ELSE", + "IN", + "RAISE", + "SLASH", + "PERCENT", + 0 +}; + +const unsigned long Sqlite3Parser::_tokenSet_0_data_[] = { 2897810722UL, 3720462567UL, 1627391999UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "AS" "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "END" "ESCAPE" "GLOB" +// "LIKE" "IS" "NOT" "MATCH" "ON" "PRIMARY" "REFERENCES" "REGEXP" "THEN" +// "UNIQUE" "WHEN" DOT ID QUOTEDID LPAREN RPAREN COMMA PLUS MINUS STAR +// AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL +// UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT DEFERRABLE AND OR ELSE IN +// SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_0(_tokenSet_0_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_1_data_[] = { 0UL, 16384UL, 0UL, 0UL }; +// DOT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_1(_tokenSet_1_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_2_data_[] = { 2897810722UL, 3720446183UL, 1627391999UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "AS" "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "END" "ESCAPE" "GLOB" +// "LIKE" "IS" "NOT" "MATCH" "ON" "PRIMARY" "REFERENCES" "REGEXP" "THEN" +// "UNIQUE" "WHEN" ID QUOTEDID LPAREN RPAREN COMMA PLUS MINUS STAR AMPERSAND +// BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL +// UNEQUAL2 BITWISELEFT BITWISERIGHT DEFERRABLE AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_2(_tokenSet_2_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_3_data_[] = { 750327072UL, 3716251879UL, 1610614783UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "END" "ESCAPE" "GLOB" +// "LIKE" "IS" "NOT" "MATCH" "PRIMARY" "REFERENCES" "REGEXP" "THEN" "UNIQUE" +// "WHEN" ID QUOTEDID RPAREN COMMA PLUS MINUS STAR AMPERSAND BITOR OROP +// EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 +// BITWISELEFT BITWISERIGHT AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_3(_tokenSet_3_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_4_data_[] = { 2UL, 0UL, 0UL, 0UL }; +// EOF +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_4(_tokenSet_4_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_5_data_[] = { 750327072UL, 3716153575UL, 1610614783UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "END" "ESCAPE" "GLOB" +// "LIKE" "IS" "NOT" "MATCH" "PRIMARY" "REFERENCES" "REGEXP" "THEN" "UNIQUE" +// "WHEN" RPAREN COMMA PLUS MINUS STAR AMPERSAND BITOR OROP EQUAL EQUAL2 +// GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT +// AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_5(_tokenSet_5_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_6_data_[] = { 2UL, 33554432UL, 0UL, 0UL }; +// EOF SEMI +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_6(_tokenSet_6_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_7_data_[] = { 134288640UL, 67UL, 0UL, 0UL }; +// "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "NOT" "PRIMARY" "REFERENCES" +// "UNIQUE" +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_7(_tokenSet_7_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_8_data_[] = { 0UL, 25165824UL, 0UL, 0UL }; +// RPAREN COMMA +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_8(_tokenSet_8_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_9_data_[] = { 2UL, 41943040UL, 0UL, 0UL }; +// EOF RPAREN SEMI +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_9(_tokenSet_9_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_10_data_[] = { 134288640UL, 25165891UL, 0UL, 0UL }; +// "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "NOT" "PRIMARY" "REFERENCES" +// "UNIQUE" RPAREN COMMA +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_10(_tokenSet_10_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_11_data_[] = { 2818643200UL, 29458499UL, 16779264UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "NOT" "MATCH" "ON" "PRIMARY" +// "REFERENCES" "UNIQUE" ID QUOTEDID LPAREN RPAREN COMMA FOREIGN DEFERRABLE +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_11(_tokenSet_11_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_12_data_[] = { 614465536UL, 3690987524UL, 1610614783UL, 26UL, 0UL, 0UL, 0UL, 0UL }; +// "GLOB" "LIKE" "IS" "MATCH" "REGEXP" PLUS MINUS STAR AMPERSAND BITOR +// OROP EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 +// BITWISELEFT BITWISERIGHT AND OR IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_12(_tokenSet_12_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_13_data_[] = { 1476452480UL, 744718336UL, 2147483648UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "CASE" "CURRENT_TIME" "CURRENT_DATE" "CURRENT_TIMESTAMP" "NOT" "NULL" +// "EXISTS" ID QUOTEDID NUMERIC STRING LPAREN PLUS MINUS TILDE CAST RAISE +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_13(_tokenSet_13_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_14_data_[] = { 616038432UL, 3716153508UL, 1610614783UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "END" "ESCAPE" "GLOB" "LIKE" "IS" "MATCH" "REGEXP" "THEN" "WHEN" +// RPAREN COMMA PLUS MINUS STAR AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER +// GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT +// AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_14(_tokenSet_14_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_15_data_[] = { 134288640UL, 25165891UL, 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "NOT" "PRIMARY" "REFERENCES" +// "UNIQUE" RPAREN COMMA DEFERRABLE INITIALLY +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_15(_tokenSet_15_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_16_data_[] = { 2554402050UL, 266567747UL, 2048UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" "KEY" "NOT" "NULL" "ON" +// "PRIMARY" "REFERENCES" "UNIQUE" ID QUOTEDID NUMERIC STRING LPAREN RPAREN +// COMMA SEMI PLUS MINUS FOREIGN +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_16(_tokenSet_16_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_17_data_[] = { 0UL, 4194304UL, 0UL, 0UL }; +// LPAREN +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_17(_tokenSet_17_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_18_data_[] = { 134217728UL, 738197504UL, 0UL, 0UL }; +// "NOT" PLUS MINUS TILDE +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_18(_tokenSet_18_data_,4); +const unsigned long Sqlite3Parser::_tokenSet_19_data_[] = { 1476452480UL, 207847424UL, 2147483648UL, 4UL, 0UL, 0UL, 0UL, 0UL }; +// "CASE" "CURRENT_TIME" "CURRENT_DATE" "CURRENT_TIMESTAMP" "NOT" "NULL" +// "EXISTS" ID QUOTEDID NUMERIC STRING LPAREN PLUS MINUS CAST RAISE +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_19(_tokenSet_19_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_20_data_[] = { 2092491936UL, 4259561636UL, 4026533887UL, 31UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "CASE" "COLLATE" "CURRENT_TIME" "CURRENT_DATE" "CURRENT_TIMESTAMP" +// "END" "ESCAPE" "GLOB" "LIKE" "IS" "NOT" "NULL" "MATCH" "EXISTS" "REGEXP" +// "THEN" "WHEN" DOT ID QUOTEDID NUMERIC STRING LPAREN RPAREN COMMA PLUS +// MINUS STAR TILDE AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL +// LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT SELECT AND +// OR CAST ELSE IN RAISE SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_20(_tokenSet_20_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_21_data_[] = { 750257184UL, 3716268196UL, 1610614783UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "COLLATE" "END" "ESCAPE" "GLOB" "LIKE" "IS" "NOT" "MATCH" "REGEXP" +// "THEN" "WHEN" DOT ID QUOTEDID RPAREN COMMA PLUS MINUS STAR AMPERSAND +// BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL +// UNEQUAL2 BITWISELEFT BITWISERIGHT AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_21(_tokenSet_21_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_22_data_[] = { 750257184UL, 3716153508UL, 1610614783UL, 27UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "COLLATE" "END" "ESCAPE" "GLOB" "LIKE" "IS" "NOT" "MATCH" "REGEXP" +// "THEN" "WHEN" RPAREN COMMA PLUS MINUS STAR AMPERSAND BITOR OROP EQUAL +// EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT +// BITWISERIGHT AND OR ELSE IN SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_22(_tokenSet_22_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_23_data_[] = { 681575424UL, 4UL, 0UL, 2UL, 0UL, 0UL, 0UL, 0UL }; +// "COLLATE" "GLOB" "LIKE" "NOT" "MATCH" "REGEXP" IN +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_23(_tokenSet_23_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_24_data_[] = { 2023809152UL, 744718340UL, 2147483648UL, 6UL, 0UL, 0UL, 0UL, 0UL }; +// "CASE" "CURRENT_TIME" "CURRENT_DATE" "CURRENT_TIMESTAMP" "GLOB" "LIKE" +// "NOT" "NULL" "MATCH" "EXISTS" "REGEXP" ID QUOTEDID NUMERIC STRING LPAREN +// PLUS MINUS TILDE CAST IN RAISE +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_24(_tokenSet_24_data_,8); +const unsigned long Sqlite3Parser::_tokenSet_25_data_[] = { 2092561824UL, 4259545319UL, 3758098431UL, 31UL, 0UL, 0UL, 0UL, 0UL }; +// "AS" "CASE" "CHECK" "COLLATE" "CONSTRAINT" "CURRENT_TIME" "CURRENT_DATE" +// "CURRENT_TIMESTAMP" "DEFAULT" "END" "ESCAPE" "GLOB" "LIKE" "IS" "NOT" +// "NULL" "MATCH" "EXISTS" "PRIMARY" "REFERENCES" "REGEXP" "THEN" "UNIQUE" +// "WHEN" ID QUOTEDID NUMERIC STRING LPAREN RPAREN COMMA PLUS MINUS STAR +// TILDE AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL LOWER LOWEREQUAL +// UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT AND OR CAST ELSE IN RAISE +// SLASH PERCENT +const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_25(_tokenSet_25_data_,8); + + diff --git a/src/grammar/Sqlite3Parser.hpp b/src/grammar/Sqlite3Parser.hpp new file mode 100644 index 00000000..92bb7f4e --- /dev/null +++ b/src/grammar/Sqlite3Parser.hpp @@ -0,0 +1,137 @@ +#ifndef INC_Sqlite3Parser_hpp_ +#define INC_Sqlite3Parser_hpp_ + +#include +/* $ANTLR 2.7.7 (20121001): "sqlite3.g" -> "Sqlite3Parser.hpp"$ */ +#include +#include +#include "sqlite3TokenTypes.hpp" +#include + +class CUSTOM_API Sqlite3Parser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public sqlite3TokenTypes +{ +public: + void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ); +protected: + Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k); +public: + Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf); +protected: + Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k); +public: + Sqlite3Parser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer); + Sqlite3Parser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state); + int getNumTokens() const + { + return Sqlite3Parser::NUM_TOKENS; + } + const char* getTokenName( int type ) const + { + if( type > getNumTokens() ) return 0; + return Sqlite3Parser::tokenNames[type]; + } + const char* const* getTokenNames() const + { + return Sqlite3Parser::tokenNames; + } + public: void id(); + public: void databasename(); + public: void tablename(); + public: void columnname(); + public: void identifier(); + public: void collationname(); + public: void signednumber(); + public: void statementlist(); + public: void statement(); + public: void createtable(); + public: void create_statements(); + public: void columndef(); + public: void tableconstraint(); + public: void selectstmt(); + public: void type_name(); + public: void columnconstraint(); + public: void name(); + public: void conflictclause(); + public: void expr(); + public: void foreignkeyclause(); + public: void indexedcolumn(); + public: void functionname(); + public: void subexpr(); + public: void binaryoperator(); + public: void unaryoperator(); + public: void literalvalue(); + public: void raisefunction(); + public: void suffixexpr(); +public: + ANTLR_USE_NAMESPACE(antlr)RefAST getAST() + { + return returnAST; + } + +protected: + ANTLR_USE_NAMESPACE(antlr)RefAST returnAST; +private: + static const char* tokenNames[]; +#ifndef NO_STATIC_CONSTS + static const int NUM_TOKENS = 101; +#else + enum { + NUM_TOKENS = 101 + }; +#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; +}; + +#endif /*INC_Sqlite3Parser_hpp_*/ diff --git a/src/grammar/sqlite3.g b/src/grammar/sqlite3.g new file mode 100644 index 00000000..e6698e7c --- /dev/null +++ b/src/grammar/sqlite3.g @@ -0,0 +1,339 @@ +options { + language="Cpp"; + genHashLines=false; +} + +class Sqlite3Lexer extends Lexer; +options { + k=2; + exportVocab=sqlite3; + caseSensitive=false; +} + +tokens { + AUTOINCREMENT="AUTOINCREMENT"; + AS="AS"; + ASC="ASC"; + CASE_T="CASE"; + CHECK="CHECK"; + CREATE="CREATE"; + COLLATE="COLLATE"; + CONFLICT="CONFLICT"; + CONSTRAINT="CONSTRAINT"; + CURRENT_TIME="CURRENT_TIME"; + CURRENT_DATE="CURRENT_DATE"; + CURRENT_TIMESTAMP="CURRENT_TIMESTAMP"; + DEFAULT="DEFAULT"; + DESC="DESC"; + ELSE_T="ELSE"; + END="END"; + ESCAPE="ESCAPE"; + GLOB="GLOB"; + KEY="KEY"; + LIKE="LIKE"; + TABLE="TABLE"; + IF_T="IF"; + IS="IS"; + NOT="NOT"; + NULL_T="NULL"; + MATCH="MATCH"; + EXISTS="EXISTS"; + ON="ON"; + PRIMARY="PRIMARY"; + REFERENCES="REFERENCES"; + REGEXP="REGEXP"; + TEMPORARY="TEMPORARY"; + TEMP="TEMP"; + THEN="THEN"; + UNIQUE="UNIQUE"; + WHEN="WHEN"; + +//ast + + TYPE_NAME; + COLUMNDEF; + COLUMNCONSTRAINT; + TABLECONSTRAINT; + CREATETABLE; +} + +protected +DIGIT : '0'..'9' ; + +protected DOT:; + +ID + : + ('a'..'z'|'_') ('a'..'z'|'0'..'9'|'_')* + ; + +QUOTEDID + : '`' ( ~('`') )* '`' + | '[' ( ~(']') )* ']' + | '"' ( ~('"') )* '"' + ; + +NUMERIC + : ( (DIGIT)+ ( '.' (DIGIT)* )? + | '.' { _ttype=DOT; } (DIGIT)+) + ( 'e' (PLUS|MINUS)? (DIGIT)+ )? + ; + +SL_COMMENT + : + "//" (~'\n')* '\n' { _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline(); } + ; + +ML_COMMENT + : "/*" + ( { LA(2)!='/' }? '*' + | '\n' { newline(); } + | ~('*'|'\n') + )* + "*/" + {$setType(ANTLR_USE_NAMESPACE(antlr)Token::SKIP);} + ; + +WS + : + ( ' ' + | '\t' + | '\r' + | '\n' {newline();} + ) { _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; } + ; + +STRING + : +// '"' ( ESC_SEQ | ~('\\'|'"') )* '"' + '\'' ( ~('\'') )* '\'' + ; + +//protected +//ESC_SEQ +// : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\') +// ; + +LPAREN : '('; +RPAREN : ')'; +COMMA : ','; +SEMI : ';'; +PLUS : '+'; +MINUS : '-'; +STAR : '*'; +TILDE : '~'; +AMPERSAND: '&'; +BITOR: '|'; +OROP: "||"; +EQUAL: '='; +EQUAL2: "=="; +GREATER: '>'; +GREATEREQUAL: ">="; +LOWER: '<'; +LOWEREQUAL: "<="; +UNEQUAL: "!="; +UNEQUAL2: "<>"; +BITWISELEFT: "<<"; +BITWISERIGHT: ">>"; + +// parser + +class Sqlite3Parser extends Parser; +options { + k=2; + buildAST = true; +} + +id : ID | QUOTEDID ; + +databasename + : + id + ; + +tablename + : + id + ; + +columnname + : + id + ; + +identifier + : + ((databasename)? DOT)? tablename + ; + +collationname + : + ID + ; + +signednumber + : (PLUS | MINUS)? NUMERIC +// {#signednumber = #([SIGNEDNUMBER, "SIGNEDNUMBER"], #signednumber);} + ; + +// parser part +statementlist + : + (statement)? + (SEMI statement)* + ; + +statement + : + createtable + ; + +create_statements + : + createtable + ; + +createtable + : + CREATE (TEMP|TEMPORARY)? TABLE (IF_T NOT EXISTS)? tablename + ( LPAREN columndef (COMMA columndef)* (COMMA tableconstraint)* RPAREN + | AS selectstmt + ) + {#createtable = #([CREATETABLE, "CREATETABLE"], #createtable);} + ; + +columndef + : + columnname (type_name)? (columnconstraint)* + {#columndef = #([COLUMNDEF, "COLUMNDEF"], #columndef);} + ; + +name : ID | QUOTEDID; + +type_name + : + (name)+ + (LPAREN signednumber (COMMA signednumber)? RPAREN)? + {#type_name = #([TYPE_NAME, "TYPE_NAME"], #type_name);} + ; + +columnconstraint + : + (CONSTRAINT name)? + ( PRIMARY KEY (ASC|DESC)? (AUTOINCREMENT)? + | NOT NULL_T (conflictclause)? + | UNIQUE (conflictclause)? + | CHECK LPAREN expr RPAREN + | DEFAULT (signednumber | STRING | LPAREN expr RPAREN) + | COLLATE collationname + | foreignkeyclause) + {#columnconstraint = #([COLUMNCONSTRAINT, "COLUMNCONSTRAINT"], #columnconstraint);} + ; + +tableconstraint + : + (CONSTRAINT name)? + ( PRIMARY KEY LPAREN indexedcolumn (COMMA indexedcolumn)* RPAREN (conflictclause)? + | UNIQUE LPAREN indexedcolumn (COMMA indexedcolumn)* RPAREN (conflictclause)? + | CHECK LPAREN expr RPAREN + | FOREIGN KEY LPAREN columnname (COMMA columnname)* RPAREN foreignkeyclause + ) + {#tableconstraint = #([TABLECONSTRAINT, "TABLECONSTRAINT"], #tableconstraint);} + ; + +indexedcolumn + : id + ; + +conflictclause + : + ON CONFLICT + ( ROLLBACK + | ABORT + | FAIL + | IGNORE + | REPLACE + ) + ; + +foreignkeyclause + : + REFERENCES tablename (LPAREN columnname (COMMA columnname)* RPAREN)? + ( ON (DELETE | UPDATE) + ( SET (NULL_T | DEFAULT) + | CASCADE + | RESTRICT + | NO ACTION + ) + | MATCH name + )* + ( (NOT)? DEFERRABLE (INITIALLY (DEFERRED | IMMEDIATE))? )? + ; + +selectstmt + : SELECT + ; + +functionname + : id ; + +expr + : + subexpr ( ( binaryoperator | AND | OR) subexpr )* +// {#expr = #([EXPR, "EXPR"],#expr);} + ; + +subexpr + : + (unaryoperator)? + ( literalvalue +// | bindparameter TODO + | ((databasename DOT)? tablename)? columnname + | functionname LPAREN (expr (COMMA expr)* )? RPAREN //TODO + | CAST LPAREN expr AS type_name RPAREN + | LPAREN expr RPAREN + | ( (NOT)? EXISTS)? LPAREN selectstmt RPAREN + | CASE_T (expr)? (WHEN expr THEN expr)+ (ELSE expr)? END + | raisefunction + ) + (suffixexpr)? + ; + +suffixexpr + : + ( COLLATE collationname + | (NOT)? + ( (LIKE | GLOB | REGEXP | MATCH) expr (ESCAPE expr)? + | IN ( LPAREN (selectstmt | expr (COMMA expr)* )? RPAREN | tablename) + ) + ) + ; + +literalvalue + : signednumber + | STRING +// | blob-literal + | NULL_T + | CURRENT_TIME + | CURRENT_DATE + | CURRENT_TIMESTAMP + ; + +raisefunction + : RAISE LPAREN ( IGNORE | (ROLLBACK | ABORT | FAIL) COMMA STRING ) RPAREN ; + +// TODO operators missing +binaryoperator + : + OROP + | STAR | SLASH | PERCENT + | PLUS | MINUS + | BITWISELEFT | BITWISERIGHT | AMPERSAND | BITOR + | LOWER | LOWEREQUAL | GREATER | GREATEREQUAL + | EQUAL | EQUAL2 | UNEQUAL | UNEQUAL2 + | IS (NOT)? | IN | LIKE | GLOB | MATCH | REGEXP + ; + +unaryoperator + : MINUS | PLUS | TILDE | NOT ; + diff --git a/src/grammar/sqlite3TokenTypes.hpp b/src/grammar/sqlite3TokenTypes.hpp new file mode 100644 index 00000000..9c32cca3 --- /dev/null +++ b/src/grammar/sqlite3TokenTypes.hpp @@ -0,0 +1,117 @@ +#ifndef INC_sqlite3TokenTypes_hpp_ +#define INC_sqlite3TokenTypes_hpp_ + +/* $ANTLR 2.7.7 (20121001): "sqlite3.g" -> "sqlite3TokenTypes.hpp"$ */ + +#ifndef CUSTOM_API +# define CUSTOM_API +#endif + +#ifdef __cplusplus +struct CUSTOM_API sqlite3TokenTypes { +#endif + enum { + EOF_ = 1, + AUTOINCREMENT = 4, + AS = 5, + ASC = 6, + CASE_T = 7, + CHECK = 8, + CREATE = 9, + COLLATE = 10, + CONFLICT = 11, + CONSTRAINT = 12, + CURRENT_TIME = 13, + CURRENT_DATE = 14, + CURRENT_TIMESTAMP = 15, + DEFAULT = 16, + DESC = 17, + ELSE_T = 18, + END = 19, + ESCAPE = 20, + GLOB = 21, + KEY = 22, + LIKE = 23, + TABLE = 24, + IF_T = 25, + IS = 26, + NOT = 27, + NULL_T = 28, + MATCH = 29, + EXISTS = 30, + ON = 31, + PRIMARY = 32, + REFERENCES = 33, + REGEXP = 34, + TEMPORARY = 35, + TEMP = 36, + THEN = 37, + UNIQUE = 38, + WHEN = 39, + TYPE_NAME = 40, + COLUMNDEF = 41, + COLUMNCONSTRAINT = 42, + TABLECONSTRAINT = 43, + CREATETABLE = 44, + DIGIT = 45, + DOT = 46, + ID = 47, + QUOTEDID = 48, + NUMERIC = 49, + SL_COMMENT = 50, + ML_COMMENT = 51, + WS = 52, + STRING = 53, + LPAREN = 54, + RPAREN = 55, + COMMA = 56, + SEMI = 57, + PLUS = 58, + MINUS = 59, + STAR = 60, + TILDE = 61, + AMPERSAND = 62, + BITOR = 63, + OROP = 64, + EQUAL = 65, + EQUAL2 = 66, + GREATER = 67, + GREATEREQUAL = 68, + LOWER = 69, + LOWEREQUAL = 70, + UNEQUAL = 71, + UNEQUAL2 = 72, + BITWISELEFT = 73, + BITWISERIGHT = 74, + FOREIGN = 75, + ROLLBACK = 76, + ABORT = 77, + FAIL = 78, + IGNORE = 79, + REPLACE = 80, + DELETE = 81, + UPDATE = 82, + SET = 83, + CASCADE = 84, + RESTRICT = 85, + NO = 86, + ACTION = 87, + DEFERRABLE = 88, + INITIALLY = 89, + DEFERRED = 90, + IMMEDIATE = 91, + SELECT = 92, + AND = 93, + OR = 94, + CAST = 95, + ELSE = 96, + IN = 97, + RAISE = 98, + SLASH = 99, + PERCENT = 100, + NULL_TREE_LOOKAHEAD = 3 + }; +#ifdef __cplusplus +}; +#endif +#endif /*INC_sqlite3TokenTypes_hpp_*/ diff --git a/src/sqlitetypes.cpp b/src/sqlitetypes.cpp index 994be911..5d8cfa0a 100644 --- a/src/sqlitetypes.cpp +++ b/src/sqlitetypes.cpp @@ -1,4 +1,9 @@ #include "sqlitetypes.h" +#include "grammar/Sqlite3Lexer.hpp" +#include "grammar/Sqlite3Parser.hpp" + +#include +#include namespace sqlb { @@ -9,6 +14,8 @@ QString Field::toString(const QString& indent, const QString& sep) const QString str = indent + m_name + sep + m_type; if(m_notnull) str += " NOT NULL"; + if(!m_defaultvalue.isEmpty()) + str += " DEFAULT " + m_defaultvalue; if(!m_check.isEmpty()) str += " CHECK(" + m_check + ")"; if(m_autoincrement) @@ -47,9 +54,6 @@ bool Field::isInteger() const void Table::clear() { - foreach(Field* f, m_fields) { - delete f; - } m_fields.clear(); m_primarykey.clear(); } @@ -59,9 +63,9 @@ Table::~Table() clear(); } -void Table::addField(Field *f) +void Table::addField(const FieldPtr& f) { - m_fields.append(f); + m_fields.append(FieldPtr(f)); } void Table::setFields(const FieldList &fields) @@ -71,9 +75,19 @@ void Table::setFields(const FieldList &fields) m_fields = fields; } +int Table::findField(const QString &sname) +{ + for(int i = 0; i < m_fields.count(); ++i) + { + if(sname == m_fields.at(i)->name()) + return i; + } + return -1; +} + bool Table::setPrimaryKey(const FieldList& pk) { - foreach(Field* f, pk) { + foreach(FieldPtr f, pk) { if(!m_fields.contains(f)) return false; } @@ -82,7 +96,7 @@ bool Table::setPrimaryKey(const FieldList& pk) return true; } -bool Table::setPrimaryKey(Field* pk, bool autoincrement) +bool Table::setPrimaryKey(FieldPtr pk, bool autoincrement) { if(m_fields.contains(pk)) { @@ -100,7 +114,7 @@ QStringList Table::fieldList() const { QStringList sl; - foreach(Field* f, m_fields) { + foreach(FieldPtr f, m_fields) { sl << f->toString(); } @@ -109,13 +123,39 @@ QStringList Table::fieldList() const bool Table::hasAutoIncrement() const { - foreach(Field* f, m_fields) { + foreach(FieldPtr f, m_fields) { if(f->autoIncrement()) return true; } return false; } +Table Table::parseSQL(const QString &sSQL) +{ + std::stringstream s; + s << sSQL.toStdString(); + Sqlite3Lexer lex(s); + + Sqlite3Parser parser(lex); + + antlr::ASTFactory ast_factory; + parser.initializeASTFactory(ast_factory); + parser.setASTFactory(&ast_factory); + + try + { + parser.createtable(); + CreateTableWalker ctw(parser.getAST()); + return ctw.table(); + } + catch(...) + { + qCritical() << "Sqlite parse error."; //TODO + } + + return Table(""); +} + QString Table::sql() const { QString sql = QString("CREATE TABLE `%1` (\n").arg(m_name); @@ -126,17 +166,180 @@ QString Table::sql() const if( m_primarykey.size() > 0 && !hasAutoIncrement()) { sql += ",\n\tPRIMARY KEY("; - for(QList::ConstIterator it = m_primarykey.constBegin(); + for(FieldList::ConstIterator it = m_primarykey.constBegin(); it != m_primarykey.constEnd(); ++it) { sql += (*it)->name(); - if(it != --m_primarykey.constEnd()) + if(*it != m_primarykey.last()) sql += ","; } sql += ")"; } - return sql + "\n)"; + return sql + "\n);"; } + +namespace +{ +QString identifier(antlr::RefAST ident) +{ + QString sident = ident->getText().c_str(); + if(ident->getType() == sqlite3TokenTypes::QUOTEDID) + { + sident.remove(0, 1); + sident.remove(sident.length() - 1, 1); + } + return sident; +} + +QString concatTextAST(antlr::RefAST t) +{ + QString stext; + while(t != antlr::nullAST) + { + stext.append(t->getText().c_str()); + t = t->getNextSibling(); + } + return stext; +} +} + +Table CreateTableWalker::table() +{ + Table tab(""); + + if( m_root ) //CREATE TABLE + { + antlr::RefAST s = m_root->getFirstChild(); + //qDebug() << m_root->toStringTree().cd; + //skip to tablename + while(s->getType() != Sqlite3Lexer::ID && s->getType() != Sqlite3Lexer::QUOTEDID) s = s->getNextSibling(); + tab.setName(identifier(s)); + + s = s->getNextSibling(); // LPAREN + s = s->getNextSibling(); // first column name + antlr::RefAST column = s; + // loop columndefs + FieldList pks; + while(column != antlr::nullAST && column->getType() == sqlite3TokenTypes::COLUMNDEF) + { + FieldPtr f; + bool pk = parsecolumn(f, column->getFirstChild()); + tab.addField(f); + if(pk) + pks.append(FieldPtr(f)); + column = column->getNextSibling(); //COMMA or RPAREN + column = column->getNextSibling(); //null or tableconstraint + } + + tab.setPrimaryKey(pks); + + // now we are finished or it is a tableconstraint + while(s != antlr::nullAST) + { + antlr::RefAST tc = s->getFirstChild(); + // skip constraint name, if there is any + if(tc->getType() == sqlite3TokenTypes::CONSTRAINT) + tc = tc->getNextSibling()->getNextSibling(); + + switch(tc->getType()) + { + case sqlite3TokenTypes::PRIMARY: + { + tc = tc->getNextSibling()->getNextSibling(); // skip primary and key + tc = tc->getNextSibling(); // skip LPAREN + pks.clear(); + do + { + QString col = identifier(tc); + int fieldindex = tab.findField(col); + if(fieldindex != -1) + pks.append(tab.fields().at(fieldindex)); + tc = tc->getNextSibling(); // skip ident and comma + tc = tc->getNextSibling(); + } while(tc != antlr::nullAST && tc->getType() != sqlite3TokenTypes::RPAREN); + + tab.setPrimaryKey(pks); + } + break; + default: break; + } + + s = s->getNextSibling(); //COMMA or RPAREN + s = s->getNextSibling(); + } + } + + return tab; +} + +bool CreateTableWalker::parsecolumn(FieldPtr& f, antlr::RefAST c) +{ + QString columnname; + QString type = "TEXT"; + bool autoincrement = false; + bool primarykey = false; + bool notnull = false; + QString defaultvalue; + QString check; + + columnname = identifier(c); + c = c->getNextSibling(); //type? + if(c != antlr::nullAST && c->getType() == sqlite3TokenTypes::TYPE_NAME) + { + type = concatTextAST(c->getFirstChild()); + c = c->getNextSibling(); + } + + // finished with type parsing + // now columnconstraints + while(c != antlr::nullAST) + { + antlr::RefAST con = c->getFirstChild(); + + // skip constraint name, if there is any + if(con->getType() == sqlite3TokenTypes::CONSTRAINT) + con = con->getNextSibling()->getNextSibling(); + + switch(con->getType()) + { + case sqlite3TokenTypes::PRIMARY: + { + primarykey = true; + con = con->getNextSibling()->getNextSibling(); // skip KEY + if(con != antlr::nullAST && (con->getType() == sqlite3TokenTypes::ASC + || con->getType() == sqlite3TokenTypes::DESC)) + con = con->getNextSibling(); //skip + if(con != antlr::nullAST && con->getType() == sqlite3TokenTypes::AUTOINCREMENT) + autoincrement = true; + } + break; + case sqlite3TokenTypes::NOT: + { + notnull = true; + } + break; + case sqlite3TokenTypes::CHECK: + { + con = con->getNextSibling(); //LPAREN + check = concatTextAST(con); + } + break; + case sqlite3TokenTypes::DEFAULT: + { + con = con->getNextSibling(); //SIGNEDNUMBER,STRING,LPAREN + defaultvalue = concatTextAST(con); + } + break; + default: break; + } + c = c->getNextSibling(); + } + + f = FieldPtr( new Field(columnname, type, notnull, defaultvalue, check)); + f->setAutoIncrement(autoincrement); + return primarykey; +} + } //namespace sqlb diff --git a/src/sqlitetypes.h b/src/sqlitetypes.h index 04a95d90..0756f5c6 100644 --- a/src/sqlitetypes.h +++ b/src/sqlitetypes.h @@ -2,8 +2,11 @@ #ifndef SQLITETYPES_H #define SQLITETYPES_H +#include "antlr/ASTRefCount.hpp" + #include -#include +#include +#include #include namespace sqlb { @@ -11,8 +14,17 @@ namespace sqlb { class Field { public: - Field(const QString& name, const QString& type, bool notnull = false, const QString& check = "") - : m_name(name), m_type(type), m_notnull(notnull), m_check(check), m_autoincrement(false) {} + Field(const QString& name, + const QString& type, + bool notnull = false, + const QString& defaultvalue = "", + const QString& check = "") + : m_name(name) + , m_type(type) + , m_notnull(notnull) + , m_check(check) + , m_defaultvalue(defaultvalue) + , m_autoincrement(false) {} QString toString(const QString& indent = "\t", const QString& sep = "\t") const; @@ -20,6 +32,7 @@ public: void setType(const QString& type) { m_type = type; } void setNotNull(bool notnull = true) { m_notnull = notnull; } void setCheck(const QString& check) { m_check = check; } + void setDefaultValue(const QString& defaultvalue) { m_defaultvalue = defaultvalue; } void setAutoIncrement(bool autoinc) { m_autoincrement = autoinc; } bool isText() const; @@ -29,6 +42,7 @@ public: const QString& type() const { return m_type; } bool notnull() const { return m_notnull; } const QString& check() const { return m_check; } + const QString& defaultValue() const { return m_defaultvalue; } bool autoIncrement() const { return m_autoincrement; } static QStringList Datatypes; @@ -37,10 +51,12 @@ private: QString m_type; bool m_notnull; QString m_check; + QString m_defaultvalue; bool m_autoincrement; //! this is stored here for simplification }; -typedef QList FieldList; +typedef QSharedPointer FieldPtr; +typedef QVector< FieldPtr > FieldList; class Table { public: @@ -50,14 +66,25 @@ public: void setName(const QString& name) { m_name = name; } const QString& name() const { return m_name; } + const FieldList& fields() const { return m_fields; } + const FieldList& primarykey() const { return m_primarykey; } QString sql() const; - void addField(Field* f); + void addField(const FieldPtr& f); void setFields(const FieldList& fields); void clear(); + /** + * @brief findField Finds a field and returns the index. + * @param sname + * @return The field index if the field was found. + * -1 if field coulnd't be found. + */ + int findField(const QString& sname); bool setPrimaryKey(const FieldList& pk); - bool setPrimaryKey(Field* pk, bool autoincrement = false); + bool setPrimaryKey(FieldPtr pk, bool autoincrement = false); + + static Table parseSQL(const QString& sSQL); private: QStringList fieldList() const; @@ -68,6 +95,26 @@ private: FieldList m_fields; FieldList m_primarykey; }; + +/** + * @brief The CreateTableWalker class + * Goes trough the createtable AST and returns + * Table object. + */ +class CreateTableWalker +{ +public: + CreateTableWalker(antlr::RefAST r) : m_root(r) {} + + Table table(); + +private: + bool parsecolumn(FieldPtr& f, antlr::RefAST c); + +private: + antlr::RefAST m_root; +}; + } //namespace sqlb #endif // SQLITETYPES_H diff --git a/src/src.pro b/src/src.pro index 8eb6ec88..dbcb002a 100644 --- a/src/src.pro +++ b/src/src.pro @@ -5,7 +5,6 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets TARGET = sqlitebrowser -#INCLUDEPATH += sqlite_source/ CONFIG += qt \ warn_on @@ -25,7 +24,10 @@ HEADERS += \ ImportCsvDialog.h \ sqltextedit.h \ sqlitetypes.h \ - ExtendedTableWidget.h + ExtendedTableWidget.h \ + grammar/Sqlite3Lexer.hpp \ + grammar/Sqlite3Parser.hpp \ + grammar/sqlite3TokenTypes.hpp SOURCES += \ sqlitedb.cpp \ @@ -43,7 +45,9 @@ SOURCES += \ ImportCsvDialog.cpp \ sqltextedit.cpp \ sqlitetypes.cpp \ - ExtendedTableWidget.cpp + ExtendedTableWidget.cpp \ + grammar/Sqlite3Lexer.cpp \ + grammar/Sqlite3Parser.cpp # create a unittest option CONFIG(unittest) { @@ -84,3 +88,7 @@ FORMS += \ EditDialog.ui \ ExportCsvDialog.ui \ ImportCsvDialog.ui + +INCLUDEPATH += $$PWD/../libs/antlr-2.7.7 +LIBS += -L$$OUT_PWD/../libs/antlr-2.7.7/ -lantlr +DEPENDPATH += $$PWD/../libs/antlr-2.7.7 diff --git a/src/tests/testsqlobjects.cpp b/src/tests/testsqlobjects.cpp index 95e2d7b7..90fd7a21 100644 --- a/src/tests/testsqlobjects.cpp +++ b/src/tests/testsqlobjects.cpp @@ -11,17 +11,20 @@ private slots: void sqlOutput(); void autoincrement(); void notnull(); + + void parseSQL(); + void parseSQLMultiPk(); }; void TestTable::sqlOutput() { Table tt("testtable"); - Field* f = new Field("id", "integer"); - Field* fkm = new Field("km", "integer", false, "km > 1000"); + FieldPtr f = FieldPtr(new Field("id", "integer")); + FieldPtr fkm = FieldPtr(new Field("km", "integer", false, "", "km > 1000")); tt.addField(f); - tt.addField(new Field("car", "text")); + tt.addField(FieldPtr(new Field("car", "text"))); tt.addField(fkm); - QList pk; + FieldList pk; pk.append(f); pk.append(fkm); tt.setPrimaryKey(pk); @@ -31,16 +34,16 @@ void TestTable::sqlOutput() "\tcar\ttext,\n" "\tkm\tinteger CHECK(km > 1000),\n" "\tPRIMARY KEY(id,km)\n" - ")")); + ");")); } void TestTable::autoincrement() { Table tt("testtable"); - Field* f = new Field("id", "integer"); - Field* fkm = new Field("km", "integer"); + FieldPtr f = FieldPtr(new Field("id", "integer")); + FieldPtr fkm = FieldPtr(new Field("km", "integer")); tt.addField(f); - tt.addField(new Field("car", "text")); + tt.addField(FieldPtr(new Field("car", "text"))); tt.addField(fkm); tt.setPrimaryKey(f, true); @@ -48,16 +51,16 @@ void TestTable::autoincrement() "\tid\tinteger PRIMARY KEY AUTOINCREMENT,\n" "\tcar\ttext,\n" "\tkm\tinteger\n" - ")")); + ");")); } void TestTable::notnull() { Table tt("testtable"); - Field* f = new Field("id", "integer"); - Field* fkm = new Field("km", "integer"); + FieldPtr f = FieldPtr(new Field("id", "integer")); + FieldPtr fkm = FieldPtr(new Field("km", "integer")); tt.addField(f); - tt.addField(new Field("car", "text", true)); + tt.addField(FieldPtr(new Field("car", "text", true))); tt.addField(fkm); tt.setPrimaryKey(f, true); @@ -65,7 +68,56 @@ void TestTable::notnull() "\tid\tinteger PRIMARY KEY AUTOINCREMENT,\n" "\tcar\ttext NOT NULL,\n" "\tkm\tinteger\n" - ")")); + ");")); +} + +void TestTable::parseSQL() +{ + QString sSQL = "CREATE TABLE hero (\n" + "\tid integer PRIMARY KEY AUTOINCREMENT,\n" + "\tname text NOT NULL DEFAULT 'xxxx',\n" + "\tinfo VARCHAR(255) CHECK (info == x)\n" + ");"; + + Table tab = Table::parseSQL(sSQL); + + QVERIFY(tab.name() == "hero"); + QVERIFY(tab.fields().at(0)->name() == "id"); + QVERIFY(tab.fields().at(1)->name() == "name"); + QVERIFY(tab.fields().at(2)->name() == "info"); + + QVERIFY(tab.fields().at(0)->type() == "integer"); + QVERIFY(tab.fields().at(1)->type() == "text"); + QVERIFY(tab.fields().at(2)->type() == "VARCHAR(255)"); + + QVERIFY(tab.fields().at(0)->autoIncrement()); + QVERIFY(tab.fields().at(1)->notnull()); + QCOMPARE(tab.fields().at(1)->check(), QString("")); + QCOMPARE(tab.fields().at(2)->check(), QString("(info==x)")); + + QVERIFY(tab.primarykey().contains(tab.fields().at(0))); +} + +void TestTable::parseSQLMultiPk() +{ + QString sSQL = "CREATE TABLE hero (\n" + "\tid1 integer,\n" + "\tid2 integer,\n" + "\tnonpkfield blob,\n" + "PRIMARY KEY(id1,id2)\n" + ");"; + + Table tab = Table::parseSQL(sSQL); + + QVERIFY(tab.name() == "hero"); + QVERIFY(tab.fields().at(0)->name() == "id1"); + QVERIFY(tab.fields().at(1)->name() == "id2"); + + QVERIFY(tab.fields().at(0)->type() == "integer"); + QVERIFY(tab.fields().at(1)->type() == "integer"); + + QVERIFY(tab.primarykey().contains(tab.fields().at(0))); + QVERIFY(tab.primarykey().contains(tab.fields().at(1))); } QTEST_MAIN(TestTable)