From 5737925079904df9d6c4bae132cc503a1ff91179 Mon Sep 17 00:00:00 2001 From: Peinthor Rene Date: Sat, 16 Mar 2013 20:18:57 +0100 Subject: [PATCH] Add a sqlite3 antlr2 "create table" grammar + generated parser files There is also a "create table" ast walker which fills info for the new sqlitetype objects. A dependency to the antlr2 runtime was added. The grammar most probably still contain bugs. Why all this? First writing grammars is fun and this is the only way we can get all information for proper table editing + some time in the future when the grammar is finished we can provide real auto completion. --- sqlitedbbrowser.pro | 3 +- src/grammar/README | 6 + src/grammar/Sqlite3Lexer.cpp | 1260 ++++++++++++ src/grammar/Sqlite3Lexer.hpp | 71 + src/grammar/Sqlite3Parser.cpp | 2971 +++++++++++++++++++++++++++++ src/grammar/Sqlite3Parser.hpp | 137 ++ src/grammar/sqlite3.g | 339 ++++ src/grammar/sqlite3TokenTypes.hpp | 117 ++ src/sqlitetypes.cpp | 227 ++- src/sqlitetypes.h | 59 +- src/src.pro | 14 +- src/tests/testsqlobjects.cpp | 78 +- 12 files changed, 5247 insertions(+), 35 deletions(-) create mode 100644 src/grammar/README create mode 100644 src/grammar/Sqlite3Lexer.cpp create mode 100644 src/grammar/Sqlite3Lexer.hpp create mode 100644 src/grammar/Sqlite3Parser.cpp create mode 100644 src/grammar/Sqlite3Parser.hpp create mode 100644 src/grammar/sqlite3.g create mode 100644 src/grammar/sqlite3TokenTypes.hpp 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)