From 788134eee6cac642e7fad95456ea0da4e0c3b90f Mon Sep 17 00:00:00 2001 From: Martin Kleusberg Date: Tue, 10 Jul 2018 23:07:38 +0200 Subject: [PATCH] grammar: Fix parsing of complex expression This fixes parsing of expressions of the form '(x) AND/OR y' and similar types. It also fixes expression of the '(x)' type and of the '(x op y AND z op w)' type. See issue #1454. --- src/grammar/Sqlite3Lexer.cpp | 2 +- src/grammar/Sqlite3Lexer.hpp | 2 +- src/grammar/Sqlite3Parser.cpp | 1258 +++++++++++++++-------------- src/grammar/Sqlite3Parser.hpp | 2 +- src/grammar/sqlite3.g | 3 +- src/grammar/sqlite3TokenTypes.hpp | 2 +- src/sqlitetypes.cpp | 5 +- 7 files changed, 671 insertions(+), 603 deletions(-) diff --git a/src/grammar/Sqlite3Lexer.cpp b/src/grammar/Sqlite3Lexer.cpp index 54f4af51..ac8c71e1 100644 --- a/src/grammar/Sqlite3Lexer.cpp +++ b/src/grammar/Sqlite3Lexer.cpp @@ -1,4 +1,4 @@ -/* $ANTLR 2.7.7 (20160127): "sqlite3.g" -> "Sqlite3Lexer.cpp"$ */ +/* $ANTLR 2.7.7 (20171109): "sqlite3.g" -> "Sqlite3Lexer.cpp"$ */ #include "Sqlite3Lexer.hpp" #include #include diff --git a/src/grammar/Sqlite3Lexer.hpp b/src/grammar/Sqlite3Lexer.hpp index 0c11880c..ce259078 100644 --- a/src/grammar/Sqlite3Lexer.hpp +++ b/src/grammar/Sqlite3Lexer.hpp @@ -2,7 +2,7 @@ #define INC_Sqlite3Lexer_hpp_ #include -/* $ANTLR 2.7.7 (20160127): "sqlite3.g" -> "Sqlite3Lexer.hpp"$ */ +/* $ANTLR 2.7.7 (20171109): "sqlite3.g" -> "Sqlite3Lexer.hpp"$ */ #include #include #include diff --git a/src/grammar/Sqlite3Parser.cpp b/src/grammar/Sqlite3Parser.cpp index 3a130d4d..6bf53374 100644 --- a/src/grammar/Sqlite3Parser.cpp +++ b/src/grammar/Sqlite3Parser.cpp @@ -1,4 +1,4 @@ -/* $ANTLR 2.7.7 (20160127): "sqlite3.g" -> "Sqlite3Parser.cpp"$ */ +/* $ANTLR 2.7.7 (20171109): "sqlite3.g" -> "Sqlite3Parser.cpp"$ */ #include "Sqlite3Parser.hpp" #include #include @@ -2035,47 +2035,68 @@ void Sqlite3Parser::expr() { astFactory->addASTChild(currentAST, tmp97_AST); } match(LPAREN); - subexpr(); + expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - { // ( ... )+ - int _cnt177=0; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp98_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp98_AST); + } + match(RPAREN); + { // ( ... )* for (;;) { - if ((LA(1) == COMMA)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - if ( inputState->guessing == 0 ) { - tmp98_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp98_AST); + if ((LA(1) == AND || LA(1) == OR) && (_tokenSet_7.member(LA(2)))) { + { + switch ( LA(1)) { + case AND: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp99_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp99_AST); + } + match(AND); + break; } - match(COMMA); - subexpr(); + case OR: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp100_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp100_AST); + } + match(OR); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } } else { - if ( _cnt177>=1 ) { goto _loop177; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + goto _loop178; } - _cnt177++; } - _loop177:; - } // ( ... )+ - ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + _loop178:; + } // ( ... )* + } + expr_AST = currentAST.root; + } + else if ((LA(1) == LPAREN) && (_tokenSet_7.member(LA(2)))) { + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp99_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp99_AST); - } - match(RPAREN); - binaryoperator(); - if (inputState->guessing==0) { - astFactory->addASTChild( currentAST, returnAST ); - } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - if ( inputState->guessing == 0 ) { - tmp100_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp100_AST); + tmp101_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp101_AST); } match(LPAREN); subexpr(); @@ -2083,13 +2104,13 @@ void Sqlite3Parser::expr() { astFactory->addASTChild( currentAST, returnAST ); } { // ( ... )+ - int _cnt179=0; + int _cnt181=0; for (;;) { if ((LA(1) == COMMA)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp101_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp101_AST); + tmp102_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp102_AST); } match(COMMA); subexpr(); @@ -2098,17 +2119,60 @@ void Sqlite3Parser::expr() { } } else { - if ( _cnt179>=1 ) { goto _loop179; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + if ( _cnt181>=1 ) { goto _loop181; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} } - _cnt179++; + _cnt181++; } - _loop179:; + _loop181:; } // ( ... )+ - ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp103_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp102_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp102_AST); + tmp103_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp103_AST); + } + match(RPAREN); + binaryoperator(); + if (inputState->guessing==0) { + astFactory->addASTChild( currentAST, returnAST ); + } + ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp104_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp104_AST); + } + match(LPAREN); + subexpr(); + if (inputState->guessing==0) { + astFactory->addASTChild( currentAST, returnAST ); + } + { // ( ... )+ + int _cnt183=0; + for (;;) { + if ((LA(1) == COMMA)) { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp105_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp105_AST); + } + match(COMMA); + subexpr(); + if (inputState->guessing==0) { + astFactory->addASTChild( currentAST, returnAST ); + } + } + else { + if ( _cnt183>=1 ) { goto _loop183; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt183++; + } + _loop183:; + } // ( ... )+ + ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + if ( inputState->guessing == 0 ) { + tmp106_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp106_AST); } match(RPAREN); } @@ -2157,20 +2221,20 @@ void Sqlite3Parser::expr() { } case AND: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp103_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp107_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp103_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp103_AST); + tmp107_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp107_AST); } match(AND); break; } case OR: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp104_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp104_AST); + tmp108_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp108_AST); } match(OR); break; @@ -2187,11 +2251,11 @@ void Sqlite3Parser::expr() { } } else { - goto _loop183; + goto _loop187; } } - _loop183:; + _loop187:; } // ( ... )* } expr_AST = currentAST.root; @@ -2216,10 +2280,10 @@ void Sqlite3Parser::indexedcolumn() { switch ( LA(1)) { case COLLATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp109_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp105_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp105_AST); + tmp109_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp109_AST); } match(COLLATE); collationname(); @@ -2246,20 +2310,20 @@ void Sqlite3Parser::indexedcolumn() { switch ( LA(1)) { case ASC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp106_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp106_AST); + tmp110_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp110_AST); } match(ASC); break; } case DESC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp107_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp111_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp107_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp107_AST); + tmp111_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp111_AST); } match(DESC); break; @@ -2280,10 +2344,10 @@ void Sqlite3Parser::indexedcolumn() { switch ( LA(1)) { case AUTOINCREMENT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp108_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp108_AST); + tmp112_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp112_AST); } match(AUTOINCREMENT); break; @@ -2323,520 +2387,520 @@ void Sqlite3Parser::keywordascolumnname() { switch ( LA(1)) { case ABORT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp109_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp113_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp109_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp109_AST); + tmp113_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp113_AST); } match(ABORT); break; } case ACTION: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp110_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp110_AST); + tmp114_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp114_AST); } match(ACTION); break; } case AUTOINCREMENT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp111_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp115_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp111_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp111_AST); + tmp115_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp115_AST); } match(AUTOINCREMENT); break; } case AS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp112_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp112_AST); + tmp116_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp116_AST); } match(AS); break; } case ASC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp113_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp117_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp113_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp113_AST); + tmp117_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp117_AST); } match(ASC); break; } case AND: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp114_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp114_AST); + tmp118_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp118_AST); } match(AND); break; } case OR: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp115_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp119_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp115_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp115_AST); + tmp119_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp119_AST); } match(OR); break; } case CASCADE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp120_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp116_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp116_AST); + tmp120_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp120_AST); } match(CASCADE); break; } case CASE_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp117_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp117_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp117_AST); + tmp121_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp121_AST); } match(CASE_T); break; } case CAST: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp122_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp118_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp118_AST); + tmp122_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp122_AST); } match(CAST); break; } case CREATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp119_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp123_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp119_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp119_AST); + tmp123_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp123_AST); } match(CREATE); break; } case COLLATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp120_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp124_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp120_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp120_AST); + tmp124_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp124_AST); } match(COLLATE); break; } case CONFLICT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp121_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp121_AST); + tmp125_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp125_AST); } match(CONFLICT); break; } case CURRENT_TIME: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp122_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp126_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp122_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp122_AST); + tmp126_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp126_AST); } match(CURRENT_TIME); break; } case CURRENT_DATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp123_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp127_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp123_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp123_AST); + tmp127_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp127_AST); } match(CURRENT_DATE); break; } case CURRENT_TIMESTAMP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp124_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp128_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp124_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp124_AST); + tmp128_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp128_AST); } match(CURRENT_TIMESTAMP); break; } case DEFAULT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp125_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp125_AST); + tmp129_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp129_AST); } match(DEFAULT); break; } case DEFERRABLE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp126_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp130_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp126_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp126_AST); + tmp130_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp130_AST); } match(DEFERRABLE); break; } case DEFERRED: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp127_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp131_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp127_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp127_AST); + tmp131_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp131_AST); } match(DEFERRED); break; } case DELETE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp128_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp132_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp128_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp128_AST); + tmp132_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp132_AST); } match(DELETE); break; } case DESC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp129_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp129_AST); + tmp133_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp133_AST); } match(DESC); break; } case ELSE_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp130_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp134_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp130_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp130_AST); + tmp134_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp134_AST); } match(ELSE_T); break; } case END: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp131_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp135_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp131_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp131_AST); + tmp135_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp135_AST); } match(END); break; } case ESCAPE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp132_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp136_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp132_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp132_AST); + tmp136_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp136_AST); } match(ESCAPE); break; } case FAIL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp133_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp133_AST); + tmp137_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp137_AST); } match(FAIL); break; } case GLOB: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp134_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp138_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp134_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp134_AST); + tmp138_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp138_AST); } match(GLOB); break; } case KEY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp135_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp139_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp135_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp135_AST); + tmp139_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp139_AST); } match(KEY); break; } case LIKE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp136_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp140_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp136_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp136_AST); + tmp140_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp140_AST); } match(LIKE); break; } case TABLE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp137_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp137_AST); + tmp141_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp141_AST); } match(TABLE); break; } case IF_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp138_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp142_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp138_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp138_AST); + tmp142_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp142_AST); } match(IF_T); break; } case IGNORE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp139_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp143_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp139_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp139_AST); + tmp143_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp143_AST); } match(IGNORE); break; } case INITIALLY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp140_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp144_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp140_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp140_AST); + tmp144_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp144_AST); } match(INITIALLY); break; } case IMMEDIATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp141_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp141_AST); + tmp145_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp145_AST); } match(IMMEDIATE); break; } case IS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp142_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp146_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp142_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp142_AST); + tmp146_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp146_AST); } match(IS); break; } case NULL_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp143_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp147_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp143_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp143_AST); + tmp147_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp147_AST); } match(NULL_T); break; } case MATCH: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp144_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp148_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp144_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp144_AST); + tmp148_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp148_AST); } match(MATCH); break; } case EXISTS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp145_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp145_AST); + tmp149_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp149_AST); } match(EXISTS); break; } case NO: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp146_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp150_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp146_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp146_AST); + tmp150_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp150_AST); } match(NO); break; } case ON: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp147_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp151_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp147_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp147_AST); + tmp151_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp151_AST); } match(ON); break; } case RAISE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp148_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp152_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp148_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp148_AST); + tmp152_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp152_AST); } match(RAISE); break; } case REFERENCES: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp149_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp149_AST); + tmp153_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp153_AST); } match(REFERENCES); break; } case REGEXP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp150_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp154_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp150_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp150_AST); + tmp154_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp154_AST); } match(REGEXP); break; } case REPLACE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp151_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp155_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp151_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp151_AST); + tmp155_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp155_AST); } match(REPLACE); break; } case RESTRICT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp152_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp156_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp152_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp152_AST); + tmp156_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp156_AST); } match(RESTRICT); break; } case ROLLBACK: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp153_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp153_AST); + tmp157_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp157_AST); } match(ROLLBACK); break; } case ROWID: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp154_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp158_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp154_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp154_AST); + tmp158_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp158_AST); } match(ROWID); break; } case SET: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp155_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp159_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp155_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp155_AST); + tmp159_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp159_AST); } match(SET); break; } case TEMPORARY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp156_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp160_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp156_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp156_AST); + tmp160_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp160_AST); } match(TEMPORARY); break; } case TEMP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp157_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp157_AST); + tmp161_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp161_AST); } match(TEMP); break; } case THEN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp158_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp162_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp158_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp158_AST); + tmp162_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp162_AST); } match(THEN); break; } case UPDATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp159_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp163_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp159_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp159_AST); + tmp163_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp163_AST); } match(UPDATE); break; } case WHEN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp160_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp164_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp160_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp160_AST); + tmp164_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp164_AST); } match(WHEN); break; @@ -3019,10 +3083,10 @@ void Sqlite3Parser::type_name() { switch ( LA(1)) { case LPAREN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp165_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp161_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp161_AST); + tmp165_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp165_AST); } match(LPAREN); signednumber(); @@ -3033,10 +3097,10 @@ void Sqlite3Parser::type_name() { switch ( LA(1)) { case COMMA: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp162_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp166_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp162_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp162_AST); + tmp166_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp166_AST); } match(COMMA); signednumber(); @@ -3055,10 +3119,10 @@ void Sqlite3Parser::type_name() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp163_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp167_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp163_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp163_AST); + tmp167_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp167_AST); } match(RPAREN); break; @@ -3108,10 +3172,10 @@ void Sqlite3Parser::columnconstraint() { switch ( LA(1)) { case CONSTRAINT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp164_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp168_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp164_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp164_AST); + tmp168_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp168_AST); } match(CONSTRAINT); name(); @@ -3141,36 +3205,36 @@ void Sqlite3Parser::columnconstraint() { switch ( LA(1)) { case PRIMARY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp165_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp169_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp165_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp165_AST); + tmp169_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp169_AST); } match(PRIMARY); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp166_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp170_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp166_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp166_AST); + tmp170_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp170_AST); } match(KEY); { switch ( LA(1)) { case ASC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp167_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp171_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp167_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp167_AST); + tmp171_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp171_AST); } match(ASC); break; } case DESC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp168_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp172_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp168_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp168_AST); + tmp172_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp172_AST); } match(DESC); break; @@ -3234,10 +3298,10 @@ void Sqlite3Parser::columnconstraint() { switch ( LA(1)) { case AUTOINCREMENT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp169_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp173_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp169_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp169_AST); + tmp173_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp173_AST); } match(AUTOINCREMENT); break; @@ -3272,10 +3336,10 @@ void Sqlite3Parser::columnconstraint() { switch ( LA(1)) { case NOT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp170_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp174_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp170_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp170_AST); + tmp174_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp174_AST); } match(NOT); break; @@ -3290,10 +3354,10 @@ void Sqlite3Parser::columnconstraint() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp171_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp175_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp171_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp171_AST); + tmp175_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp175_AST); } match(NULL_T); { @@ -3331,10 +3395,10 @@ void Sqlite3Parser::columnconstraint() { } case UNIQUE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp172_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp176_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp172_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp172_AST); + tmp176_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp176_AST); } match(UNIQUE); { @@ -3372,76 +3436,76 @@ void Sqlite3Parser::columnconstraint() { } case CHECK: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp173_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp173_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp173_AST); + tmp177_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp177_AST); } match(CHECK); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp174_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp178_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp174_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp174_AST); + tmp178_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp178_AST); } match(LPAREN); expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp175_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp179_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp175_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp175_AST); + tmp179_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp179_AST); } match(RPAREN); break; } case DEFAULT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp176_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp180_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp176_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp176_AST); + tmp180_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp180_AST); } match(DEFAULT); { switch ( LA(1)) { case QUOTEDLITERAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp181_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp177_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp177_AST); + tmp181_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp181_AST); } match(QUOTEDLITERAL); break; } case LPAREN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp178_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp182_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp178_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp178_AST); + tmp182_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp182_AST); } match(LPAREN); expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp179_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp183_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp179_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp179_AST); + tmp183_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp183_AST); } match(RPAREN); break; } case ID: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp180_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp184_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp180_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp180_AST); + tmp184_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp184_AST); } match(ID); break; @@ -3474,10 +3538,10 @@ void Sqlite3Parser::columnconstraint() { } case COLLATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp181_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp185_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp181_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp181_AST); + tmp185_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp185_AST); } match(COLLATE); collationname(); @@ -3520,66 +3584,66 @@ void Sqlite3Parser::conflictclause() { ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST conflictclause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - ANTLR_USE_NAMESPACE(antlr)RefAST tmp182_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp186_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp182_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp182_AST); + tmp186_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp186_AST); } match(ON); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp183_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp187_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp183_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp183_AST); + tmp187_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp187_AST); } match(CONFLICT); { switch ( LA(1)) { case ROLLBACK: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp184_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp184_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp184_AST); + tmp188_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp188_AST); } match(ROLLBACK); break; } case ABORT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp185_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp185_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp185_AST); + tmp189_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp189_AST); } match(ABORT); break; } case FAIL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp186_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp190_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp186_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp186_AST); + tmp190_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp190_AST); } match(FAIL); break; } case IGNORE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp187_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp191_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp187_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp187_AST); + tmp191_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp191_AST); } match(IGNORE); break; } case REPLACE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp188_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp188_AST); + tmp192_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp192_AST); } match(REPLACE); break; @@ -3602,10 +3666,10 @@ void Sqlite3Parser::literalvalue() { switch ( LA(1)) { case NUMERIC: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp189_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp189_AST); + tmp193_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp193_AST); } match(NUMERIC); literalvalue_AST = currentAST.root; @@ -3613,10 +3677,10 @@ void Sqlite3Parser::literalvalue() { } case STRINGLITERAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp190_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp194_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp190_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp190_AST); + tmp194_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp194_AST); } match(STRINGLITERAL); literalvalue_AST = currentAST.root; @@ -3624,10 +3688,10 @@ void Sqlite3Parser::literalvalue() { } case NULL_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp191_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp195_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp191_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp191_AST); + tmp195_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp195_AST); } match(NULL_T); literalvalue_AST = currentAST.root; @@ -3635,10 +3699,10 @@ void Sqlite3Parser::literalvalue() { } case CURRENT_TIME: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp192_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp192_AST); + tmp196_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp196_AST); } match(CURRENT_TIME); literalvalue_AST = currentAST.root; @@ -3646,10 +3710,10 @@ void Sqlite3Parser::literalvalue() { } case CURRENT_DATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp193_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp193_AST); + tmp197_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp197_AST); } match(CURRENT_DATE); literalvalue_AST = currentAST.root; @@ -3657,10 +3721,10 @@ void Sqlite3Parser::literalvalue() { } case CURRENT_TIMESTAMP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp194_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp198_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp194_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp194_AST); + tmp198_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp198_AST); } match(CURRENT_TIMESTAMP); literalvalue_AST = currentAST.root; @@ -3679,10 +3743,10 @@ void Sqlite3Parser::foreignkeyclause() { ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST foreignkeyclause_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - ANTLR_USE_NAMESPACE(antlr)RefAST tmp195_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp199_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp195_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp195_AST); + tmp199_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp199_AST); } match(REFERENCES); tablename(); @@ -3693,10 +3757,10 @@ void Sqlite3Parser::foreignkeyclause() { switch ( LA(1)) { case LPAREN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp196_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp196_AST); + tmp200_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp200_AST); } match(LPAREN); columnname(); @@ -3706,10 +3770,10 @@ void Sqlite3Parser::foreignkeyclause() { { // ( ... )* for (;;) { if ((LA(1) == COMMA)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp197_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp197_AST); + tmp201_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp201_AST); } match(COMMA); columnname(); @@ -3724,10 +3788,10 @@ void Sqlite3Parser::foreignkeyclause() { } _loop159:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp198_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp202_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp198_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp198_AST); + tmp202_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp202_AST); } match(RPAREN); break; @@ -3761,40 +3825,40 @@ void Sqlite3Parser::foreignkeyclause() { switch ( LA(1)) { case ON: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp199_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp203_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp199_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp199_AST); + tmp203_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp203_AST); } match(ON); { switch ( LA(1)) { case DELETE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp200_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp200_AST); + tmp204_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp204_AST); } match(DELETE); break; } case UPDATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp201_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp201_AST); + tmp205_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp205_AST); } match(UPDATE); break; } case INSERT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp202_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp206_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp202_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp202_AST); + tmp206_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp206_AST); } match(INSERT); break; @@ -3809,30 +3873,30 @@ void Sqlite3Parser::foreignkeyclause() { switch ( LA(1)) { case SET: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp203_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp207_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp203_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp203_AST); + tmp207_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp207_AST); } match(SET); { switch ( LA(1)) { case NULL_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp204_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp204_AST); + tmp208_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp208_AST); } match(NULL_T); break; } case DEFAULT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp205_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp205_AST); + tmp209_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp209_AST); } match(DEFAULT); break; @@ -3847,36 +3911,36 @@ void Sqlite3Parser::foreignkeyclause() { } case CASCADE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp206_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp210_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp206_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp206_AST); + tmp210_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp210_AST); } match(CASCADE); break; } case RESTRICT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp207_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp211_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp207_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp207_AST); + tmp211_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp211_AST); } match(RESTRICT); break; } case NO: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp208_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp208_AST); + tmp212_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp212_AST); } match(NO); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp209_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp209_AST); + tmp213_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp213_AST); } match(ACTION); break; @@ -3891,10 +3955,10 @@ void Sqlite3Parser::foreignkeyclause() { } case MATCH: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp210_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp214_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp210_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp210_AST); + tmp214_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp214_AST); } match(MATCH); name(); @@ -3930,46 +3994,46 @@ void Sqlite3Parser::foreignkeyclause() { inputState->guessing--; } if ( synPredMatched167 ) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp211_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp215_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp211_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp211_AST); + tmp215_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp215_AST); } match(NOT); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp212_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp212_AST); + tmp216_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp216_AST); } match(DEFERRABLE); { switch ( LA(1)) { case INITIALLY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp213_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp213_AST); + tmp217_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp217_AST); } match(INITIALLY); { switch ( LA(1)) { case DEFERRED: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp214_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp218_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp214_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp214_AST); + tmp218_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp218_AST); } match(DEFERRED); break; } case IMMEDIATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp215_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp219_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp215_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp215_AST); + tmp219_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp219_AST); } match(IMMEDIATE); break; @@ -4005,37 +4069,37 @@ void Sqlite3Parser::foreignkeyclause() { } } else if ((LA(1) == DEFERRABLE)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp216_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp216_AST); + tmp220_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp220_AST); } match(DEFERRABLE); { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp217_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp217_AST); + tmp221_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp221_AST); } match(INITIALLY); { switch ( LA(1)) { case DEFERRED: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp218_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp222_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp218_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp218_AST); + tmp222_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp222_AST); } match(DEFERRED); break; } case IMMEDIATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp219_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp223_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp219_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp219_AST); + tmp223_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp223_AST); } match(IMMEDIATE); break; @@ -4081,40 +4145,40 @@ void Sqlite3Parser::subexpr() { switch ( LA(1)) { case MINUS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp220_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp220_AST); + tmp224_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp224_AST); } match(MINUS); break; } case PLUS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp221_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp221_AST); + tmp225_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp225_AST); } match(PLUS); break; } case TILDE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp222_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp226_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp222_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp222_AST); + tmp226_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp226_AST); } match(TILDE); break; } case NOT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp223_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp227_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp223_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp223_AST); + tmp227_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp227_AST); } match(NOT); break; @@ -4202,10 +4266,10 @@ void Sqlite3Parser::subexpr() { if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp228_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp224_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp224_AST); + tmp228_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp228_AST); } match(DOT); } @@ -4220,10 +4284,10 @@ void Sqlite3Parser::subexpr() { if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp225_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp225_AST); + tmp229_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp229_AST); } match(DOT); } @@ -4244,10 +4308,10 @@ void Sqlite3Parser::subexpr() { if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp226_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp226_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp226_AST); + tmp230_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp230_AST); } match(LPAREN); { @@ -4322,10 +4386,10 @@ void Sqlite3Parser::subexpr() { { // ( ... )* for (;;) { if ((LA(1) == COMMA)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp227_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp231_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp227_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp227_AST); + tmp231_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp231_AST); } match(COMMA); expr(); @@ -4334,11 +4398,11 @@ void Sqlite3Parser::subexpr() { } } else { - goto _loop191; + goto _loop195; } } - _loop191:; + _loop195:; } // ( ... )* break; } @@ -4352,10 +4416,10 @@ void Sqlite3Parser::subexpr() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp228_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp232_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp228_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp228_AST); + tmp232_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp232_AST); } match(RPAREN); } @@ -4370,10 +4434,10 @@ void Sqlite3Parser::subexpr() { switch ( LA(1)) { case EXISTS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp233_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp229_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp229_AST); + tmp233_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp233_AST); } match(EXISTS); break; @@ -4388,10 +4452,10 @@ void Sqlite3Parser::subexpr() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp230_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp230_AST); + tmp234_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp234_AST); } match(LPAREN); { @@ -4479,10 +4543,10 @@ void Sqlite3Parser::subexpr() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp231_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp235_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp231_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp231_AST); + tmp235_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp235_AST); } match(RPAREN); } @@ -4529,10 +4593,10 @@ void Sqlite3Parser::binaryoperator() { switch ( LA(1)) { case OROP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp232_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp236_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp232_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp232_AST); + tmp236_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp236_AST); } match(OROP); binaryoperator_AST = currentAST.root; @@ -4540,10 +4604,10 @@ void Sqlite3Parser::binaryoperator() { } case STAR: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp233_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp237_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp233_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp233_AST); + tmp237_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp237_AST); } match(STAR); binaryoperator_AST = currentAST.root; @@ -4551,10 +4615,10 @@ void Sqlite3Parser::binaryoperator() { } case SLASH: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp238_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp234_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp234_AST); + tmp238_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp238_AST); } match(SLASH); binaryoperator_AST = currentAST.root; @@ -4562,10 +4626,10 @@ void Sqlite3Parser::binaryoperator() { } case PERCENT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp235_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp239_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp235_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp235_AST); + tmp239_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp239_AST); } match(PERCENT); binaryoperator_AST = currentAST.root; @@ -4573,10 +4637,10 @@ void Sqlite3Parser::binaryoperator() { } case PLUS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp236_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp240_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp236_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp236_AST); + tmp240_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp240_AST); } match(PLUS); binaryoperator_AST = currentAST.root; @@ -4584,10 +4648,10 @@ void Sqlite3Parser::binaryoperator() { } case MINUS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp237_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp241_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp237_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp237_AST); + tmp241_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp241_AST); } match(MINUS); binaryoperator_AST = currentAST.root; @@ -4595,10 +4659,10 @@ void Sqlite3Parser::binaryoperator() { } case BITWISELEFT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp238_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp242_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp238_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp238_AST); + tmp242_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp242_AST); } match(BITWISELEFT); binaryoperator_AST = currentAST.root; @@ -4606,10 +4670,10 @@ void Sqlite3Parser::binaryoperator() { } case BITWISERIGHT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp239_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp243_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp239_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp239_AST); + tmp243_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp243_AST); } match(BITWISERIGHT); binaryoperator_AST = currentAST.root; @@ -4617,10 +4681,10 @@ void Sqlite3Parser::binaryoperator() { } case AMPERSAND: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp240_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp244_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp240_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp240_AST); + tmp244_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp244_AST); } match(AMPERSAND); binaryoperator_AST = currentAST.root; @@ -4628,10 +4692,10 @@ void Sqlite3Parser::binaryoperator() { } case BITOR: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp241_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp245_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp241_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp241_AST); + tmp245_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp245_AST); } match(BITOR); binaryoperator_AST = currentAST.root; @@ -4639,10 +4703,10 @@ void Sqlite3Parser::binaryoperator() { } case LOWER: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp242_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp246_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp242_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp242_AST); + tmp246_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp246_AST); } match(LOWER); binaryoperator_AST = currentAST.root; @@ -4650,10 +4714,10 @@ void Sqlite3Parser::binaryoperator() { } case LOWEREQUAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp243_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp247_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp243_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp243_AST); + tmp247_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp247_AST); } match(LOWEREQUAL); binaryoperator_AST = currentAST.root; @@ -4661,10 +4725,10 @@ void Sqlite3Parser::binaryoperator() { } case GREATER: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp244_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp248_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp244_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp244_AST); + tmp248_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp248_AST); } match(GREATER); binaryoperator_AST = currentAST.root; @@ -4672,10 +4736,10 @@ void Sqlite3Parser::binaryoperator() { } case GREATEREQUAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp245_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp249_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp245_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp245_AST); + tmp249_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp249_AST); } match(GREATEREQUAL); binaryoperator_AST = currentAST.root; @@ -4683,10 +4747,10 @@ void Sqlite3Parser::binaryoperator() { } case EQUAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp246_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp250_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp246_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp246_AST); + tmp250_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp250_AST); } match(EQUAL); binaryoperator_AST = currentAST.root; @@ -4694,10 +4758,10 @@ void Sqlite3Parser::binaryoperator() { } case EQUAL2: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp247_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp251_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp247_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp247_AST); + tmp251_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp251_AST); } match(EQUAL2); binaryoperator_AST = currentAST.root; @@ -4705,10 +4769,10 @@ void Sqlite3Parser::binaryoperator() { } case UNEQUAL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp248_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp252_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp248_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp248_AST); + tmp252_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp252_AST); } match(UNEQUAL); binaryoperator_AST = currentAST.root; @@ -4716,10 +4780,10 @@ void Sqlite3Parser::binaryoperator() { } case UNEQUAL2: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp249_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp253_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp249_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp249_AST); + tmp253_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp253_AST); } match(UNEQUAL2); binaryoperator_AST = currentAST.root; @@ -4727,10 +4791,10 @@ void Sqlite3Parser::binaryoperator() { } case IS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp250_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp254_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp250_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp250_AST); + tmp254_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp254_AST); } match(IS); binaryoperator_AST = currentAST.root; @@ -4761,36 +4825,36 @@ void Sqlite3Parser::castexpr() { ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST castexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - ANTLR_USE_NAMESPACE(antlr)RefAST tmp251_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp255_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp251_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp251_AST); + tmp255_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp255_AST); } match(CAST); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp252_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp256_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp252_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp252_AST); + tmp256_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp256_AST); } match(LPAREN); expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp253_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp257_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp253_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp253_AST); + tmp257_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp257_AST); } match(AS); type_name(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp254_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp258_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp254_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp254_AST); + tmp258_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp258_AST); } match(RPAREN); castexpr_AST = currentAST.root; @@ -4802,10 +4866,10 @@ void Sqlite3Parser::caseexpr() { ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST caseexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - ANTLR_USE_NAMESPACE(antlr)RefAST tmp255_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp259_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp255_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp255_AST); + tmp259_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp259_AST); } match(CASE_T); { @@ -4823,23 +4887,23 @@ void Sqlite3Parser::caseexpr() { } { // ( ... )+ - int _cnt199=0; + int _cnt203=0; for (;;) { if ((LA(1) == WHEN)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp256_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp260_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp256_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp256_AST); + tmp260_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp260_AST); } match(WHEN); expr(); if (inputState->guessing==0) { astFactory->addASTChild( currentAST, returnAST ); } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp257_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp261_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp257_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp257_AST); + tmp261_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp261_AST); } match(THEN); expr(); @@ -4848,21 +4912,21 @@ void Sqlite3Parser::caseexpr() { } } else { - if ( _cnt199>=1 ) { goto _loop199; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + if ( _cnt203>=1 ) { goto _loop203; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} } - _cnt199++; + _cnt203++; } - _loop199:; + _loop203:; } // ( ... )+ { switch ( LA(1)) { case ELSE_T: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp258_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp262_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp258_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp258_AST); + tmp262_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp262_AST); } match(ELSE_T); expr(); @@ -4881,10 +4945,10 @@ void Sqlite3Parser::caseexpr() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp259_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp263_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp259_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp259_AST); + tmp263_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp263_AST); } match(END); caseexpr_AST = currentAST.root; @@ -4896,26 +4960,26 @@ void Sqlite3Parser::raisefunction() { ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; ANTLR_USE_NAMESPACE(antlr)RefAST raisefunction_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - ANTLR_USE_NAMESPACE(antlr)RefAST tmp260_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp264_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp260_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp260_AST); + tmp264_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp264_AST); } match(RAISE); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp261_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp265_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp261_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp261_AST); + tmp265_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp265_AST); } match(LPAREN); { switch ( LA(1)) { case IGNORE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp262_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp266_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp262_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp262_AST); + tmp266_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp266_AST); } match(IGNORE); break; @@ -4928,30 +4992,30 @@ void Sqlite3Parser::raisefunction() { switch ( LA(1)) { case ROLLBACK: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp263_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp267_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp263_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp263_AST); + tmp267_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp267_AST); } match(ROLLBACK); break; } case ABORT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp264_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp268_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp264_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp264_AST); + tmp268_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp268_AST); } match(ABORT); break; } case FAIL: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp265_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp269_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp265_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp265_AST); + tmp269_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp269_AST); } match(FAIL); break; @@ -4962,16 +5026,16 @@ void Sqlite3Parser::raisefunction() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp266_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp270_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp266_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp266_AST); + tmp270_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp270_AST); } match(COMMA); - ANTLR_USE_NAMESPACE(antlr)RefAST tmp267_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp271_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp267_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp267_AST); + tmp271_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp271_AST); } match(STRINGLITERAL); break; @@ -4982,10 +5046,10 @@ void Sqlite3Parser::raisefunction() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp268_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp272_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp268_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp268_AST); + tmp272_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp272_AST); } match(RPAREN); raisefunction_AST = currentAST.root; @@ -5000,10 +5064,10 @@ void Sqlite3Parser::suffixexpr() { switch ( LA(1)) { case COLLATE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp269_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp273_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp269_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp269_AST); + tmp273_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp273_AST); } match(COLLATE); collationname(); @@ -5025,10 +5089,10 @@ void Sqlite3Parser::suffixexpr() { switch ( LA(1)) { case NOT: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp270_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp274_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp270_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp270_AST); + tmp274_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp274_AST); } match(NOT); break; @@ -5052,10 +5116,10 @@ void Sqlite3Parser::suffixexpr() { switch ( LA(1)) { case BETWEEN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp271_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp275_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp271_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp271_AST); + tmp275_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp275_AST); } match(BETWEEN); subexpr(); @@ -5099,10 +5163,10 @@ void Sqlite3Parser::suffixexpr() { } case OR: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp272_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp276_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp272_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp272_AST); + tmp276_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp276_AST); } match(OR); break; @@ -5119,16 +5183,16 @@ void Sqlite3Parser::suffixexpr() { } } else { - goto _loop210; + goto _loop214; } } - _loop210:; + _loop214:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp273_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp277_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp273_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp273_AST); + tmp277_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp277_AST); } match(AND); expr(); @@ -5139,20 +5203,20 @@ void Sqlite3Parser::suffixexpr() { } case IN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp274_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp278_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp274_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp274_AST); + tmp278_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp278_AST); } match(IN); { switch ( LA(1)) { case LPAREN: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp275_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp279_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp275_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp275_AST); + tmp279_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp279_AST); } match(LPAREN); { @@ -5235,10 +5299,10 @@ void Sqlite3Parser::suffixexpr() { { // ( ... )* for (;;) { if ((LA(1) == COMMA)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp276_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp280_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp276_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp276_AST); + tmp280_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp280_AST); } match(COMMA); expr(); @@ -5247,11 +5311,11 @@ void Sqlite3Parser::suffixexpr() { } } else { - goto _loop214; + goto _loop218; } } - _loop214:; + _loop218:; } // ( ... )* break; } @@ -5265,10 +5329,10 @@ void Sqlite3Parser::suffixexpr() { } } } - ANTLR_USE_NAMESPACE(antlr)RefAST tmp277_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp281_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp277_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp277_AST); + tmp281_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp281_AST); } match(RPAREN); break; @@ -5307,10 +5371,10 @@ void Sqlite3Parser::suffixexpr() { } { if ((LA(1) == ESCAPE) && (_tokenSet_7.member(LA(2)))) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp278_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp282_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp278_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp278_AST); + tmp282_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp282_AST); } match(ESCAPE); subexpr(); @@ -5352,10 +5416,10 @@ void Sqlite3Parser::like_operator() { switch ( LA(1)) { case LIKE: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp279_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp283_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp279_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp279_AST); + tmp283_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp283_AST); } match(LIKE); like_operator_AST = currentAST.root; @@ -5363,10 +5427,10 @@ void Sqlite3Parser::like_operator() { } case GLOB: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp280_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp284_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp280_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp280_AST); + tmp284_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp284_AST); } match(GLOB); like_operator_AST = currentAST.root; @@ -5374,10 +5438,10 @@ void Sqlite3Parser::like_operator() { } case REGEXP: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp281_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp285_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp281_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp281_AST); + tmp285_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp285_AST); } match(REGEXP); like_operator_AST = currentAST.root; @@ -5385,10 +5449,10 @@ void Sqlite3Parser::like_operator() { } case MATCH: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp282_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp286_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp282_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp282_AST); + tmp286_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp286_AST); } match(MATCH); like_operator_AST = currentAST.root; @@ -5412,13 +5476,13 @@ void Sqlite3Parser::between_subexpr() { astFactory->addASTChild( currentAST, returnAST ); } { // ( ... )+ - int _cnt204=0; + int _cnt208=0; for (;;) { if ((LA(1) == AND)) { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp283_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp287_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; if ( inputState->guessing == 0 ) { - tmp283_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp283_AST); + tmp287_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp287_AST); } match(AND); subexpr(); @@ -5427,12 +5491,12 @@ void Sqlite3Parser::between_subexpr() { } } else { - if ( _cnt204>=1 ) { goto _loop204; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + if ( _cnt208>=1 ) { goto _loop208; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} } - _cnt204++; + _cnt208++; } - _loop204:; + _loop208:; } // ( ... )+ between_subexpr_AST = currentAST.root; returnAST = between_subexpr_AST; diff --git a/src/grammar/Sqlite3Parser.hpp b/src/grammar/Sqlite3Parser.hpp index c32183fb..0cc18c08 100644 --- a/src/grammar/Sqlite3Parser.hpp +++ b/src/grammar/Sqlite3Parser.hpp @@ -2,7 +2,7 @@ #define INC_Sqlite3Parser_hpp_ #include -/* $ANTLR 2.7.7 (20160127): "sqlite3.g" -> "Sqlite3Parser.hpp"$ */ +/* $ANTLR 2.7.7 (20171109): "sqlite3.g" -> "Sqlite3Parser.hpp"$ */ #include #include #include "sqlite3TokenTypes.hpp" diff --git a/src/grammar/sqlite3.g b/src/grammar/sqlite3.g index f1e96c8c..fabee224 100644 --- a/src/grammar/sqlite3.g +++ b/src/grammar/sqlite3.g @@ -431,7 +431,8 @@ functionname expr : - ( LPAREN subexpr (COMMA subexpr)+ RPAREN binaryoperator LPAREN subexpr (COMMA subexpr)+ RPAREN ) + ( LPAREN expr RPAREN ((AND | OR) expr)* ) + | ( LPAREN subexpr (COMMA subexpr)+ RPAREN binaryoperator LPAREN subexpr (COMMA subexpr)+ RPAREN ) | ( subexpr ((binaryoperator | AND | OR) subexpr )* ) ; diff --git a/src/grammar/sqlite3TokenTypes.hpp b/src/grammar/sqlite3TokenTypes.hpp index 4b4b7529..4eee5115 100644 --- a/src/grammar/sqlite3TokenTypes.hpp +++ b/src/grammar/sqlite3TokenTypes.hpp @@ -1,7 +1,7 @@ #ifndef INC_sqlite3TokenTypes_hpp_ #define INC_sqlite3TokenTypes_hpp_ -/* $ANTLR 2.7.7 (20160127): "sqlite3.g" -> "sqlite3TokenTypes.hpp"$ */ +/* $ANTLR 2.7.7 (20171109): "sqlite3.g" -> "sqlite3TokenTypes.hpp"$ */ #ifndef CUSTOM_API # define CUSTOM_API diff --git a/src/sqlitetypes.cpp b/src/sqlitetypes.cpp index 0f2836f3..c76dc4fd 100644 --- a/src/sqlitetypes.cpp +++ b/src/sqlitetypes.cpp @@ -945,7 +945,10 @@ TablePtr CreateTableWalker::table() if(num_paren == 0) break; - expr.append(textAST(tc)); + if(tc->getType() == sqlite3TokenTypes::AND || tc->getType() == sqlite3TokenTypes::OR) + expr.append(" " + textAST(tc) + " "); + else + expr.append(textAST(tc)); tc = tc->getNextSibling(); }