diff --git a/.github/workflows/clp-s-generated-code-checks.yaml b/.github/workflows/clp-s-generated-code-checks.yaml new file mode 100644 index 0000000000..e605db9005 --- /dev/null +++ b/.github/workflows/clp-s-generated-code-checks.yaml @@ -0,0 +1,42 @@ +name: "clp-s-generated-code-checks" + +on: + pull_request: + push: + workflow_dispatch: + +concurrency: + group: "${{github.workflow}}-${{github.ref}}" + # Cancel in-progress jobs for efficiency + cancel-in-progress: true + +jobs: + antlr-code-committed: + name: "antlr-code-committed" + strategy: + matrix: + os: ["macos-latest", "ubuntu-latest"] + runs-on: "${{matrix.os}}" + steps: + - uses: "actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683" + with: + submodules: "recursive" + + - name: "Install task" + shell: "bash" + run: "npm install -g @go-task/cli" + + - if: "matrix.os == 'macos-latest'" + name: "Install coreutils (for md5sum)" + run: "brew install coreutils" + + - name: "Check if the generated parsers are the latest" + shell: "bash" + run: + | + git status --porcelain \ + components/core/src/clp_s/search/kql/generated \ + components/core/src/clp_s/search/sql/generated \ + | grep . > /dev/null \ + && exit 1 \ + || exit 0 diff --git a/components/core/CMakeLists.txt b/components/core/CMakeLists.txt index a7e80d4d6d..1e4fd4a2e8 100644 --- a/components/core/CMakeLists.txt +++ b/components/core/CMakeLists.txt @@ -119,12 +119,9 @@ if (absl_FOUND) endif() # Find and setup ANTLR Library -# We build and link to the static library -find_package(ANTLR REQUIRED) -if (ANTLR_FOUND) - message(STATUS "Found ANTLR ${ANTLR_VERSION}") -else() - message(FATAL_ERROR "Could not find libraries for ANTLR ${ANTLR4_TAG}") +find_package(antlr4-runtime REQUIRED) +if (antlr4-runtime_FOUND) + message(STATUS "Found antlr4-runtime ${antlr4-runtime_VERSION}") endif() # Find and setup Boost Library diff --git a/components/core/cmake/Modules/ExternalAntlr4Cpp.cmake b/components/core/cmake/Modules/ExternalAntlr4Cpp.cmake deleted file mode 100644 index 9c12ee3f3b..0000000000 --- a/components/core/cmake/Modules/ExternalAntlr4Cpp.cmake +++ /dev/null @@ -1,180 +0,0 @@ -# NOTE: ExternalAntlr4Cpp.cmake taken from -# https://github.com/antlr/antlr4/blob/4.13.1/runtime/Cpp/cmake/ExternalAntlr4Cpp.cmake - -cmake_minimum_required(VERSION 3.7) - -if(POLICY CMP0114) - cmake_policy(SET CMP0114 NEW) -endif() - -include(ExternalProject) - -set(ANTLR4_ROOT ${CMAKE_CURRENT_BINARY_DIR}/antlr4_runtime/src/antlr4_runtime) -set(ANTLR4_INCLUDE_DIRS ${ANTLR4_ROOT}/runtime/Cpp/runtime/src) -set(ANTLR4_GIT_REPOSITORY https://github.com/antlr/antlr4.git) -if(NOT DEFINED ANTLR4_TAG) - # Set to branch name to keep library updated at the cost of needing to rebuild after 'clean' - # Set to commit hash to keep the build stable and does not need to rebuild after 'clean' - set(ANTLR4_TAG master) -endif() - -# Ensure that the include dir already exists at configure time (to avoid cmake erroring -# on non-existent include dirs) -file(MAKE_DIRECTORY "${ANTLR4_INCLUDE_DIRS}") - -if(${CMAKE_GENERATOR} MATCHES "Visual Studio.*") - set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist/$(Configuration)) -elseif(${CMAKE_GENERATOR} MATCHES "Xcode.*") - set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist/$(CONFIGURATION)) -else() - set(ANTLR4_OUTPUT_DIR ${ANTLR4_ROOT}/runtime/Cpp/dist) -endif() - -if(MSVC) - set(ANTLR4_STATIC_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/antlr4-runtime-static.lib) - set(ANTLR4_SHARED_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/antlr4-runtime.lib) - set(ANTLR4_RUNTIME_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/antlr4-runtime.dll) -else() - set(ANTLR4_STATIC_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.a) - if(MINGW) - set(ANTLR4_SHARED_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll.a) - set(ANTLR4_RUNTIME_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll) - elseif(CYGWIN) - set(ANTLR4_SHARED_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dll.a) - set(ANTLR4_RUNTIME_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/cygantlr4-runtime-${ANTLR4_TAG}.dll) - elseif(APPLE) - set(ANTLR4_RUNTIME_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.dylib) - else() - set(ANTLR4_RUNTIME_LIBRARIES - ${ANTLR4_OUTPUT_DIR}/libantlr4-runtime.so) - endif() -endif() - -if(${CMAKE_GENERATOR} MATCHES ".* Makefiles") - # This avoids - # 'warning: jobserver unavailable: using -j1. Add '+' to parent make rule.' - set(ANTLR4_BUILD_COMMAND $(MAKE)) -elseif(${CMAKE_GENERATOR} MATCHES "Visual Studio.*") - set(ANTLR4_BUILD_COMMAND - ${CMAKE_COMMAND} - --build . - --config $(Configuration) - --target) -elseif(${CMAKE_GENERATOR} MATCHES "Xcode.*") - set(ANTLR4_BUILD_COMMAND - ${CMAKE_COMMAND} - --build . - --config $(CONFIGURATION) - --target) -else() - set(ANTLR4_BUILD_COMMAND - ${CMAKE_COMMAND} - --build . - --target) -endif() - -if(NOT DEFINED ANTLR4_WITH_STATIC_CRT) - set(ANTLR4_WITH_STATIC_CRT ON) -endif() - -if(ANTLR4_ZIP_REPOSITORY) - ExternalProject_Add( - antlr4_runtime - PREFIX antlr4_runtime - URL ${ANTLR4_ZIP_REPOSITORY} - DOWNLOAD_DIR ${CMAKE_CURRENT_BINARY_DIR} - BUILD_COMMAND "" - BUILD_IN_SOURCE 1 - SOURCE_DIR ${ANTLR4_ROOT} - SOURCE_SUBDIR runtime/Cpp - CMAKE_CACHE_ARGS - -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} - -DWITH_STATIC_CRT:BOOL=${ANTLR4_WITH_STATIC_CRT} - -DDISABLE_WARNINGS:BOOL=ON - # -DCMAKE_CXX_STANDARD:STRING=17 # if desired, compile the runtime with a different C++ standard - # -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD} # alternatively, compile the runtime with the same C++ standard as the outer project - INSTALL_COMMAND "" - EXCLUDE_FROM_ALL 1) -else() - ExternalProject_Add( - antlr4_runtime - PREFIX antlr4_runtime - GIT_REPOSITORY ${ANTLR4_GIT_REPOSITORY} - GIT_TAG ${ANTLR4_TAG} - DOWNLOAD_DIR ${CMAKE_CURRENT_BINARY_DIR} - BUILD_COMMAND "" - BUILD_IN_SOURCE 1 - SOURCE_DIR ${ANTLR4_ROOT} - SOURCE_SUBDIR runtime/Cpp - CMAKE_CACHE_ARGS - -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} - -DWITH_STATIC_CRT:BOOL=${ANTLR4_WITH_STATIC_CRT} - -DDISABLE_WARNINGS:BOOL=ON - # -DCMAKE_CXX_STANDARD:STRING=17 # if desired, compile the runtime with a different C++ standard - # -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD} # alternatively, compile the runtime with the same C++ standard as the outer project - INSTALL_COMMAND "" - EXCLUDE_FROM_ALL 1) -endif() - -# Separate build step as rarely people want both -set(ANTLR4_BUILD_DIR ${ANTLR4_ROOT}) -if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0") - # CMake 3.14 builds in above's SOURCE_SUBDIR when BUILD_IN_SOURCE is true - set(ANTLR4_BUILD_DIR ${ANTLR4_ROOT}/runtime/Cpp) -endif() - -ExternalProject_Add_Step( - antlr4_runtime - build_static - COMMAND ${ANTLR4_BUILD_COMMAND} antlr4_static - # Depend on target instead of step (a custom command) - # to avoid running dependent steps concurrently - DEPENDS antlr4_runtime - BYPRODUCTS ${ANTLR4_STATIC_LIBRARIES} - EXCLUDE_FROM_MAIN 1 - WORKING_DIRECTORY ${ANTLR4_BUILD_DIR}) -ExternalProject_Add_StepTargets(antlr4_runtime build_static) - -add_library(antlr4_static STATIC IMPORTED) -add_dependencies(antlr4_static antlr4_runtime-build_static) -set_target_properties(antlr4_static PROPERTIES - IMPORTED_LOCATION ${ANTLR4_STATIC_LIBRARIES}) -target_include_directories(antlr4_static - INTERFACE - ${ANTLR4_INCLUDE_DIRS} -) - -ExternalProject_Add_Step( - antlr4_runtime - build_shared - COMMAND ${ANTLR4_BUILD_COMMAND} antlr4_shared - # Depend on target instead of step (a custom command) - # to avoid running dependent steps concurrently - DEPENDS antlr4_runtime - BYPRODUCTS ${ANTLR4_SHARED_LIBRARIES} ${ANTLR4_RUNTIME_LIBRARIES} - EXCLUDE_FROM_MAIN 1 - WORKING_DIRECTORY ${ANTLR4_BUILD_DIR}) -ExternalProject_Add_StepTargets(antlr4_runtime build_shared) - -add_library(antlr4_shared SHARED IMPORTED) -add_dependencies(antlr4_shared antlr4_runtime-build_shared) -set_target_properties(antlr4_shared PROPERTIES - IMPORTED_LOCATION ${ANTLR4_RUNTIME_LIBRARIES}) -target_include_directories(antlr4_shared - INTERFACE - ${ANTLR4_INCLUDE_DIRS} -) - -if(ANTLR4_SHARED_LIBRARIES) - set_target_properties(antlr4_shared PROPERTIES - IMPORTED_IMPLIB ${ANTLR4_SHARED_LIBRARIES}) -endif() diff --git a/components/core/cmake/Modules/FindANTLR.cmake b/components/core/cmake/Modules/FindANTLR.cmake deleted file mode 100644 index 6e2f96d2b5..0000000000 --- a/components/core/cmake/Modules/FindANTLR.cmake +++ /dev/null @@ -1,138 +0,0 @@ -# NOTE: FindANTLR.cmake taken from -# https://github.com/antlr/antlr4/blob/4.13.1/runtime/Cpp/cmake/FindANTLR.cmake - -# TODO: Clean up ANTLR cmake files -# On macOS, the way Java is installed with brew doesn't also make it the default version of Java on -# the system. So we set JAVA_HOME to the install location here. -if (APPLE) - set(ENV{JAVA_HOME} "/usr/local/opt/openjdk@11/") -endif () - -set(ANTLR4_TAG 4.13.1) -add_definitions(-DANTLR4CPP_STATIC) -include(ExternalAntlr4Cpp) - -find_package(Java 11 REQUIRED COMPONENTS Runtime) - -if(NOT ANTLR_EXECUTABLE) - find_program(ANTLR_EXECUTABLE - NAMES antlr.jar antlr4.jar antlr-4.jar antlr-${ANTLR4_TAG}-complete.jar) -endif() - -if(ANTLR_EXECUTABLE AND Java_JAVA_EXECUTABLE) - execute_process( - COMMAND ${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE} - OUTPUT_VARIABLE ANTLR_COMMAND_OUTPUT - ERROR_VARIABLE ANTLR_COMMAND_ERROR - RESULT_VARIABLE ANTLR_COMMAND_RESULT - OUTPUT_STRIP_TRAILING_WHITESPACE) - - if(ANTLR_COMMAND_RESULT EQUAL 0) - string(REGEX MATCH "Version [0-9]+(\\.[0-9]+)*" ANTLR_VERSION ${ANTLR_COMMAND_OUTPUT}) - string(REPLACE "Version " "" ANTLR_VERSION ${ANTLR_VERSION}) - else() - message( - SEND_ERROR - "Command '${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE}' " - "failed with the output '${ANTLR_COMMAND_ERROR}'") - endif() - - macro(ANTLR_TARGET Name InputFile) - set(ANTLR_OPTIONS LEXER PARSER LISTENER VISITOR) - set(ANTLR_ONE_VALUE_ARGS PACKAGE OUTPUT_DIRECTORY DEPENDS_ANTLR) - set(ANTLR_MULTI_VALUE_ARGS COMPILE_FLAGS DEPENDS) - cmake_parse_arguments(ANTLR_TARGET - "${ANTLR_OPTIONS}" - "${ANTLR_ONE_VALUE_ARGS}" - "${ANTLR_MULTI_VALUE_ARGS}" - ${ARGN}) - - set(ANTLR_${Name}_INPUT ${InputFile}) - - get_filename_component(ANTLR_INPUT ${InputFile} NAME_WE) - - if(ANTLR_TARGET_OUTPUT_DIRECTORY) - set(ANTLR_${Name}_OUTPUT_DIR ${ANTLR_TARGET_OUTPUT_DIRECTORY}) - else() - set(ANTLR_${Name}_OUTPUT_DIR - ${CMAKE_CURRENT_BINARY_DIR}/antlr4cpp_generated_src/${ANTLR_INPUT}) - endif() - - unset(ANTLR_${Name}_CXX_OUTPUTS) - - if((ANTLR_TARGET_LEXER AND NOT ANTLR_TARGET_PARSER) OR - (ANTLR_TARGET_PARSER AND NOT ANTLR_TARGET_LEXER)) - list(APPEND ANTLR_${Name}_CXX_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.cpp) - set(ANTLR_${Name}_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.interp - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}.tokens) - else() - list(APPEND ANTLR_${Name}_CXX_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.cpp - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Parser.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Parser.cpp) - list(APPEND ANTLR_${Name}_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.interp - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Lexer.tokens) - endif() - - if(ANTLR_TARGET_LISTENER) - list(APPEND ANTLR_${Name}_CXX_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseListener.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseListener.cpp - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Listener.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Listener.cpp) - list(APPEND ANTLR_TARGET_COMPILE_FLAGS -listener) - endif() - - if(ANTLR_TARGET_VISITOR) - list(APPEND ANTLR_${Name}_CXX_OUTPUTS - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseVisitor.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}BaseVisitor.cpp - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Visitor.h - ${ANTLR_${Name}_OUTPUT_DIR}/${ANTLR_INPUT}Visitor.cpp) - list(APPEND ANTLR_TARGET_COMPILE_FLAGS -visitor) - endif() - - if(ANTLR_TARGET_PACKAGE) - list(APPEND ANTLR_TARGET_COMPILE_FLAGS -package ${ANTLR_TARGET_PACKAGE}) - endif() - - list(APPEND ANTLR_${Name}_OUTPUTS ${ANTLR_${Name}_CXX_OUTPUTS}) - - if(ANTLR_TARGET_DEPENDS_ANTLR) - if(ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_INPUT) - list(APPEND ANTLR_TARGET_DEPENDS - ${ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_INPUT}) - list(APPEND ANTLR_TARGET_DEPENDS - ${ANTLR_${ANTLR_TARGET_DEPENDS_ANTLR}_OUTPUTS}) - else() - message(SEND_ERROR - "ANTLR target '${ANTLR_TARGET_DEPENDS_ANTLR}' not found") - endif() - endif() - - add_custom_command( - OUTPUT ${ANTLR_${Name}_OUTPUTS} - COMMAND ${Java_JAVA_EXECUTABLE} -jar ${ANTLR_EXECUTABLE} - ${InputFile} - -o ${ANTLR_${Name}_OUTPUT_DIR} - -no-listener - -Dlanguage=Cpp - ${ANTLR_TARGET_COMPILE_FLAGS} - DEPENDS ${InputFile} - ${ANTLR_TARGET_DEPENDS} - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} - COMMENT "Building ${Name} with ANTLR ${ANTLR_VERSION}") - endmacro(ANTLR_TARGET) - -endif(ANTLR_EXECUTABLE AND Java_JAVA_EXECUTABLE) - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args( - ANTLR - REQUIRED_VARS ANTLR_EXECUTABLE Java_JAVA_EXECUTABLE - VERSION_VAR ANTLR_VERSION) diff --git a/components/core/src/clp_s/search/kql/CMakeLists.txt b/components/core/src/clp_s/search/kql/CMakeLists.txt index 2a661d7a61..7919201700 100644 --- a/components/core/src/clp_s/search/kql/CMakeLists.txt +++ b/components/core/src/clp_s/search/kql/CMakeLists.txt @@ -1,25 +1,35 @@ -ANTLR_TARGET( - KqlParser - Kql.g4 - LEXER PARSER VISITOR - PACKAGE kql +set(ANTLR_GENERATED_SOURCE_DIR generated) + +set(ANTLR_GENERATED_SOURCES + ${ANTLR_GENERATED_SOURCE_DIR}/KqlBaseVisitor.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/KqlBaseVisitor.h + ${ANTLR_GENERATED_SOURCE_DIR}/KqlLexer.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/KqlLexer.h + ${ANTLR_GENERATED_SOURCE_DIR}/KqlParser.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/KqlParser.h + ${ANTLR_GENERATED_SOURCE_DIR}/KqlVisitor.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/KqlVisitor.h ) add_library( clp_s_search_kql + ${ANTLR_GENERATED_SOURCES} ../antlr_common/ErrorListener.hpp - ${ANTLR_KqlParser_CXX_OUTPUTS} kql.cpp kql.hpp ) add_library(clp_s::search::kql ALIAS clp_s_search_kql) target_compile_features(clp_s_search_kql PRIVATE cxx_std_20) -target_include_directories(clp_s_search_kql PRIVATE ${ANTLR_KqlParser_OUTPUT_DIR}) +target_include_directories(clp_s_search_kql + PRIVATE + ${ANTLR_GENERATED_SOURCE_DIR} +) + target_link_libraries( clp_s_search_kql PRIVATE antlr4_static clp::string_utils - clp_s::search::ast + clp_s::search::ast spdlog::spdlog ) diff --git a/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.cpp b/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.cpp new file mode 100644 index 0000000000..aed0ca6d77 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + + +#include "KqlBaseVisitor.h" + + +using namespace clp_s::search::kql::generated; + diff --git a/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.h b/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.h new file mode 100644 index 0000000000..0df2f721f1 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlBaseVisitor.h @@ -0,0 +1,71 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "KqlVisitor.h" + + +namespace clp_s::search::kql::generated { + +/** + * This class provides an empty implementation of KqlVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class KqlBaseVisitor : public KqlVisitor { +public: + + virtual std::any visitStart(KqlParser::StartContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitExpr(KqlParser::ExprContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNestedQuery(KqlParser::NestedQueryContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitNotQuery(KqlParser::NotQueryContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitSubQuery(KqlParser::SubQueryContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitOrAndQuery(KqlParser::OrAndQueryContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitExpression(KqlParser::ExpressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitColumn_range_expression(KqlParser::Column_range_expressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitColumn_value_expression(KqlParser::Column_value_expressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitColumn(KqlParser::ColumnContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitValue_expression(KqlParser::Value_expressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual std::any visitList_of_values(KqlParser::List_of_valuesContext *ctx) override { + return visitChildren(ctx); + } + + +}; + +} // namespace clp_s::search::kql::generated diff --git a/components/core/src/clp_s/search/kql/generated/KqlLexer.cpp b/components/core/src/clp_s/search/kql/generated/KqlLexer.cpp new file mode 100644 index 0000000000..2615e6f2ff --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlLexer.cpp @@ -0,0 +1,200 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + + +#include "KqlLexer.h" + + +using namespace antlr4; + +using namespace clp_s::search::kql::generated; + + +using namespace antlr4; + +namespace { + +struct KqlLexerStaticData final { + KqlLexerStaticData(std::vector ruleNames, + std::vector channelNames, + std::vector modeNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)), + modeNames(std::move(modeNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + KqlLexerStaticData(const KqlLexerStaticData&) = delete; + KqlLexerStaticData(KqlLexerStaticData&&) = delete; + KqlLexerStaticData& operator=(const KqlLexerStaticData&) = delete; + KqlLexerStaticData& operator=(KqlLexerStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector channelNames; + const std::vector modeNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag kqllexerLexerOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr kqllexerLexerStaticData = nullptr; + +void kqllexerLexerInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (kqllexerLexerStaticData != nullptr) { + return; + } +#else + assert(kqllexerLexerStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "T__0", "T__1", "T__2", "T__3", "T__4", "AND", "OR", "NOT", "DATE_LITERAL", + "LITERAL", "QUOTED_STRING", "UNQUOTED_LITERAL", "QUOTED_CHARACTER", + "UNQUOTED_CHARACTER", "WILDCARD", "KEYWORD", "RANGE_OPERATOR", "ESCAPED_SPECIAL_CHARACTER", + "ESCAPED_SPACE", "SPECIAL_CHARACTER", "UNICODE", "HEXDIGIT", "SPACE" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + "", "':'", "'{'", "'}'", "'('", "')'" + }, + std::vector{ + "", "", "", "", "", "", "AND", "OR", "NOT", "DATE_LITERAL", "LITERAL", + "QUOTED_STRING", "UNQUOTED_LITERAL", "RANGE_OPERATOR", "SPACE" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,14,163,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14, + 7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21, + 7,21,2,22,7,22,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,5,1, + 5,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,4,8,77, + 8,8,11,8,12,8,78,1,8,1,8,1,8,4,8,84,8,8,11,8,12,8,85,3,8,88,8,8,1,8,1, + 8,1,9,1,9,3,9,94,8,9,1,10,1,10,5,10,98,8,10,10,10,12,10,101,9,10,1,10, + 1,10,1,11,4,11,106,8,11,11,11,12,11,107,1,12,1,12,1,12,1,12,3,12,114, + 8,12,1,13,1,13,1,13,1,13,1,13,3,13,121,8,13,1,14,1,14,1,15,1,15,1,15, + 3,15,128,8,15,1,16,1,16,1,16,1,16,1,16,3,16,135,8,16,1,17,1,17,1,17,1, + 18,1,18,1,18,1,18,1,18,1,18,3,18,146,8,18,1,19,1,19,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,1,21,1,21,1,22,1,22,1,22,1,22,0,0,23,1,1,3,2,5, + 3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,0,27,0,29,0,31,0,33, + 13,35,0,37,0,39,0,41,0,43,0,45,14,1,0,13,2,0,65,65,97,97,2,0,78,78,110, + 110,2,0,68,68,100,100,2,0,79,79,111,111,2,0,82,82,114,114,2,0,84,84,116, + 116,1,0,34,34,11,0,9,10,13,13,32,32,34,34,40,41,58,58,60,60,62,62,92, + 92,123,123,125,125,2,0,42,42,63,63,2,0,60,60,62,62,9,0,33,36,40,42,46, + 46,58,58,60,60,62,64,92,92,123,123,125,125,3,0,48,57,65,70,97,102,3,0, + 9,10,13,13,32,32,171,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0, + 0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19, + 1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,33,1,0,0,0,0,45,1,0,0,0,1,47,1,0, + 0,0,3,49,1,0,0,0,5,51,1,0,0,0,7,53,1,0,0,0,9,55,1,0,0,0,11,57,1,0,0,0, + 13,61,1,0,0,0,15,64,1,0,0,0,17,68,1,0,0,0,19,93,1,0,0,0,21,95,1,0,0,0, + 23,105,1,0,0,0,25,113,1,0,0,0,27,120,1,0,0,0,29,122,1,0,0,0,31,127,1, + 0,0,0,33,134,1,0,0,0,35,136,1,0,0,0,37,145,1,0,0,0,39,147,1,0,0,0,41, + 149,1,0,0,0,43,157,1,0,0,0,45,159,1,0,0,0,47,48,5,58,0,0,48,2,1,0,0,0, + 49,50,5,123,0,0,50,4,1,0,0,0,51,52,5,125,0,0,52,6,1,0,0,0,53,54,5,40, + 0,0,54,8,1,0,0,0,55,56,5,41,0,0,56,10,1,0,0,0,57,58,7,0,0,0,58,59,7,1, + 0,0,59,60,7,2,0,0,60,12,1,0,0,0,61,62,7,3,0,0,62,63,7,4,0,0,63,14,1,0, + 0,0,64,65,7,1,0,0,65,66,7,3,0,0,66,67,7,5,0,0,67,16,1,0,0,0,68,69,5,100, + 0,0,69,70,5,97,0,0,70,71,5,116,0,0,71,72,5,101,0,0,72,73,5,40,0,0,73, + 87,1,0,0,0,74,76,5,34,0,0,75,77,3,25,12,0,76,75,1,0,0,0,77,78,1,0,0,0, + 78,76,1,0,0,0,78,79,1,0,0,0,79,80,1,0,0,0,80,81,5,34,0,0,81,88,1,0,0, + 0,82,84,3,25,12,0,83,82,1,0,0,0,84,85,1,0,0,0,85,83,1,0,0,0,85,86,1,0, + 0,0,86,88,1,0,0,0,87,74,1,0,0,0,87,83,1,0,0,0,88,89,1,0,0,0,89,90,5,41, + 0,0,90,18,1,0,0,0,91,94,3,21,10,0,92,94,3,23,11,0,93,91,1,0,0,0,93,92, + 1,0,0,0,94,20,1,0,0,0,95,99,5,34,0,0,96,98,3,25,12,0,97,96,1,0,0,0,98, + 101,1,0,0,0,99,97,1,0,0,0,99,100,1,0,0,0,100,102,1,0,0,0,101,99,1,0,0, + 0,102,103,5,34,0,0,103,22,1,0,0,0,104,106,3,27,13,0,105,104,1,0,0,0,106, + 107,1,0,0,0,107,105,1,0,0,0,107,108,1,0,0,0,108,24,1,0,0,0,109,114,3, + 37,18,0,110,111,5,92,0,0,111,114,5,34,0,0,112,114,8,6,0,0,113,109,1,0, + 0,0,113,110,1,0,0,0,113,112,1,0,0,0,114,26,1,0,0,0,115,121,3,37,18,0, + 116,121,3,35,17,0,117,121,3,29,14,0,118,121,3,41,20,0,119,121,8,7,0,0, + 120,115,1,0,0,0,120,116,1,0,0,0,120,117,1,0,0,0,120,118,1,0,0,0,120,119, + 1,0,0,0,121,28,1,0,0,0,122,123,7,8,0,0,123,30,1,0,0,0,124,128,3,11,5, + 0,125,128,3,13,6,0,126,128,3,15,7,0,127,124,1,0,0,0,127,125,1,0,0,0,127, + 126,1,0,0,0,128,32,1,0,0,0,129,130,5,60,0,0,130,135,5,61,0,0,131,132, + 5,62,0,0,132,135,5,61,0,0,133,135,7,9,0,0,134,129,1,0,0,0,134,131,1,0, + 0,0,134,133,1,0,0,0,135,34,1,0,0,0,136,137,5,92,0,0,137,138,3,39,19,0, + 138,36,1,0,0,0,139,140,5,92,0,0,140,146,5,116,0,0,141,142,5,92,0,0,142, + 146,5,114,0,0,143,144,5,92,0,0,144,146,5,110,0,0,145,139,1,0,0,0,145, + 141,1,0,0,0,145,143,1,0,0,0,146,38,1,0,0,0,147,148,7,10,0,0,148,40,1, + 0,0,0,149,150,5,92,0,0,150,151,5,117,0,0,151,152,1,0,0,0,152,153,3,43, + 21,0,153,154,3,43,21,0,154,155,3,43,21,0,155,156,3,43,21,0,156,42,1,0, + 0,0,157,158,7,11,0,0,158,44,1,0,0,0,159,160,7,12,0,0,160,161,1,0,0,0, + 161,162,6,22,0,0,162,46,1,0,0,0,12,0,78,85,87,93,99,107,113,120,127,134, + 145,1,6,0,0 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + kqllexerLexerStaticData = std::move(staticData); +} + +} + +KqlLexer::KqlLexer(CharStream *input) : Lexer(input) { + KqlLexer::initialize(); + _interpreter = new atn::LexerATNSimulator(this, *kqllexerLexerStaticData->atn, kqllexerLexerStaticData->decisionToDFA, kqllexerLexerStaticData->sharedContextCache); +} + +KqlLexer::~KqlLexer() { + delete _interpreter; +} + +std::string KqlLexer::getGrammarFileName() const { + return "Kql.g4"; +} + +const std::vector& KqlLexer::getRuleNames() const { + return kqllexerLexerStaticData->ruleNames; +} + +const std::vector& KqlLexer::getChannelNames() const { + return kqllexerLexerStaticData->channelNames; +} + +const std::vector& KqlLexer::getModeNames() const { + return kqllexerLexerStaticData->modeNames; +} + +const dfa::Vocabulary& KqlLexer::getVocabulary() const { + return kqllexerLexerStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView KqlLexer::getSerializedATN() const { + return kqllexerLexerStaticData->serializedATN; +} + +const atn::ATN& KqlLexer::getATN() const { + return *kqllexerLexerStaticData->atn; +} + + + + +void KqlLexer::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + kqllexerLexerInitialize(); +#else + ::antlr4::internal::call_once(kqllexerLexerOnceFlag, kqllexerLexerInitialize); +#endif +} diff --git a/components/core/src/clp_s/search/kql/generated/KqlLexer.h b/components/core/src/clp_s/search/kql/generated/KqlLexer.h new file mode 100644 index 0000000000..fa3b15dd20 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlLexer.h @@ -0,0 +1,53 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace clp_s::search::kql::generated { + + +class KqlLexer : public antlr4::Lexer { +public: + enum { + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, AND = 6, OR = 7, NOT = 8, + DATE_LITERAL = 9, LITERAL = 10, QUOTED_STRING = 11, UNQUOTED_LITERAL = 12, + RANGE_OPERATOR = 13, SPACE = 14 + }; + + explicit KqlLexer(antlr4::CharStream *input); + + ~KqlLexer() override; + + + std::string getGrammarFileName() const override; + + const std::vector& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& getModeNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + const antlr4::atn::ATN& getATN() const override; + + // By default the static state used to implement the lexer is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + +}; + +} // namespace clp_s::search::kql::generated diff --git a/components/core/src/clp_s/search/kql/generated/KqlParser.cpp b/components/core/src/clp_s/search/kql/generated/KqlParser.cpp new file mode 100644 index 0000000000..62f7561178 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlParser.cpp @@ -0,0 +1,901 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + + +#include "KqlVisitor.h" + +#include "KqlParser.h" + + +using namespace antlrcpp; +using namespace clp_s::search::kql::generated; + +using namespace antlr4; + +namespace { + +struct KqlParserStaticData final { + KqlParserStaticData(std::vector ruleNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + KqlParserStaticData(const KqlParserStaticData&) = delete; + KqlParserStaticData(KqlParserStaticData&&) = delete; + KqlParserStaticData& operator=(const KqlParserStaticData&) = delete; + KqlParserStaticData& operator=(KqlParserStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag kqlParserOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr kqlParserStaticData = nullptr; + +void kqlParserInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (kqlParserStaticData != nullptr) { + return; + } +#else + assert(kqlParserStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "start", "query", "expression", "column_range_expression", "column_value_expression", + "column", "value_expression", "list_of_values" + }, + std::vector{ + "", "':'", "'{'", "'}'", "'('", "')'" + }, + std::vector{ + "", "", "", "", "", "", "AND", "OR", "NOT", "DATE_LITERAL", "LITERAL", + "QUOTED_STRING", "UNQUOTED_LITERAL", "RANGE_OPERATOR", "SPACE" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,14,78,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7, + 7,7,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,3,1,34,8,1,1,1,1,1,1,1,5,1,39,8,1,10,1,12,1,42,9,1,1,2,1,2,1,2,3,2, + 47,8,2,1,3,1,3,1,3,1,3,3,3,53,8,3,1,4,1,4,1,4,1,4,1,4,3,4,60,8,4,1,5, + 1,5,1,6,1,6,1,7,1,7,3,7,68,8,7,1,7,5,7,71,8,7,10,7,12,7,74,9,7,1,7,1, + 7,1,7,0,1,2,8,0,2,4,6,8,10,12,14,0,2,1,0,6,7,1,0,6,8,80,0,16,1,0,0,0, + 2,33,1,0,0,0,4,46,1,0,0,0,6,48,1,0,0,0,8,54,1,0,0,0,10,61,1,0,0,0,12, + 63,1,0,0,0,14,65,1,0,0,0,16,17,3,2,1,0,17,18,5,0,0,1,18,1,1,0,0,0,19, + 20,6,1,-1,0,20,21,3,10,5,0,21,22,5,1,0,0,22,23,5,2,0,0,23,24,3,2,1,0, + 24,25,5,3,0,0,25,34,1,0,0,0,26,27,5,4,0,0,27,28,3,2,1,0,28,29,5,5,0,0, + 29,34,1,0,0,0,30,31,5,8,0,0,31,34,3,2,1,3,32,34,3,4,2,0,33,19,1,0,0,0, + 33,26,1,0,0,0,33,30,1,0,0,0,33,32,1,0,0,0,34,40,1,0,0,0,35,36,10,2,0, + 0,36,37,7,0,0,0,37,39,3,2,1,3,38,35,1,0,0,0,39,42,1,0,0,0,40,38,1,0,0, + 0,40,41,1,0,0,0,41,3,1,0,0,0,42,40,1,0,0,0,43,47,3,6,3,0,44,47,3,8,4, + 0,45,47,3,12,6,0,46,43,1,0,0,0,46,44,1,0,0,0,46,45,1,0,0,0,47,5,1,0,0, + 0,48,49,3,10,5,0,49,52,5,13,0,0,50,53,5,9,0,0,51,53,5,10,0,0,52,50,1, + 0,0,0,52,51,1,0,0,0,53,7,1,0,0,0,54,55,3,10,5,0,55,59,5,1,0,0,56,60,3, + 14,7,0,57,60,5,9,0,0,58,60,5,10,0,0,59,56,1,0,0,0,59,57,1,0,0,0,59,58, + 1,0,0,0,60,9,1,0,0,0,61,62,5,10,0,0,62,11,1,0,0,0,63,64,5,10,0,0,64,13, + 1,0,0,0,65,67,5,4,0,0,66,68,7,1,0,0,67,66,1,0,0,0,67,68,1,0,0,0,68,72, + 1,0,0,0,69,71,5,10,0,0,70,69,1,0,0,0,71,74,1,0,0,0,72,70,1,0,0,0,72,73, + 1,0,0,0,73,75,1,0,0,0,74,72,1,0,0,0,75,76,5,5,0,0,76,15,1,0,0,0,7,33, + 40,46,52,59,67,72 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + kqlParserStaticData = std::move(staticData); +} + +} + +KqlParser::KqlParser(TokenStream *input) : KqlParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} + +KqlParser::KqlParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { + KqlParser::initialize(); + _interpreter = new atn::ParserATNSimulator(this, *kqlParserStaticData->atn, kqlParserStaticData->decisionToDFA, kqlParserStaticData->sharedContextCache, options); +} + +KqlParser::~KqlParser() { + delete _interpreter; +} + +const atn::ATN& KqlParser::getATN() const { + return *kqlParserStaticData->atn; +} + +std::string KqlParser::getGrammarFileName() const { + return "Kql.g4"; +} + +const std::vector& KqlParser::getRuleNames() const { + return kqlParserStaticData->ruleNames; +} + +const dfa::Vocabulary& KqlParser::getVocabulary() const { + return kqlParserStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView KqlParser::getSerializedATN() const { + return kqlParserStaticData->serializedATN; +} + + +//----------------- StartContext ------------------------------------------------------------------ + +KqlParser::StartContext::StartContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +KqlParser::QueryContext* KqlParser::StartContext::query() { + return getRuleContext(0); +} + +tree::TerminalNode* KqlParser::StartContext::EOF() { + return getToken(KqlParser::EOF, 0); +} + + +size_t KqlParser::StartContext::getRuleIndex() const { + return KqlParser::RuleStart; +} + + +std::any KqlParser::StartContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStart(this); + else + return visitor->visitChildren(this); +} + +KqlParser::StartContext* KqlParser::start() { + StartContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, KqlParser::RuleStart); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(16); + query(0); + setState(17); + match(KqlParser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- QueryContext ------------------------------------------------------------------ + +KqlParser::QueryContext::QueryContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t KqlParser::QueryContext::getRuleIndex() const { + return KqlParser::RuleQuery; +} + +void KqlParser::QueryContext::copyFrom(QueryContext *ctx) { + ParserRuleContext::copyFrom(ctx); +} + +//----------------- ExprContext ------------------------------------------------------------------ + +KqlParser::ExpressionContext* KqlParser::ExprContext::expression() { + return getRuleContext(0); +} + +KqlParser::ExprContext::ExprContext(QueryContext *ctx) { copyFrom(ctx); } + + +std::any KqlParser::ExprContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpr(this); + else + return visitor->visitChildren(this); +} +//----------------- NestedQueryContext ------------------------------------------------------------------ + +KqlParser::ColumnContext* KqlParser::NestedQueryContext::column() { + return getRuleContext(0); +} + +KqlParser::QueryContext* KqlParser::NestedQueryContext::query() { + return getRuleContext(0); +} + +KqlParser::NestedQueryContext::NestedQueryContext(QueryContext *ctx) { copyFrom(ctx); } + + +std::any KqlParser::NestedQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNestedQuery(this); + else + return visitor->visitChildren(this); +} +//----------------- NotQueryContext ------------------------------------------------------------------ + +tree::TerminalNode* KqlParser::NotQueryContext::NOT() { + return getToken(KqlParser::NOT, 0); +} + +KqlParser::QueryContext* KqlParser::NotQueryContext::query() { + return getRuleContext(0); +} + +KqlParser::NotQueryContext::NotQueryContext(QueryContext *ctx) { copyFrom(ctx); } + + +std::any KqlParser::NotQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNotQuery(this); + else + return visitor->visitChildren(this); +} +//----------------- SubQueryContext ------------------------------------------------------------------ + +KqlParser::QueryContext* KqlParser::SubQueryContext::query() { + return getRuleContext(0); +} + +KqlParser::SubQueryContext::SubQueryContext(QueryContext *ctx) { copyFrom(ctx); } + + +std::any KqlParser::SubQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitSubQuery(this); + else + return visitor->visitChildren(this); +} +//----------------- OrAndQueryContext ------------------------------------------------------------------ + +std::vector KqlParser::OrAndQueryContext::query() { + return getRuleContexts(); +} + +KqlParser::QueryContext* KqlParser::OrAndQueryContext::query(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* KqlParser::OrAndQueryContext::OR() { + return getToken(KqlParser::OR, 0); +} + +tree::TerminalNode* KqlParser::OrAndQueryContext::AND() { + return getToken(KqlParser::AND, 0); +} + +KqlParser::OrAndQueryContext::OrAndQueryContext(QueryContext *ctx) { copyFrom(ctx); } + + +std::any KqlParser::OrAndQueryContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitOrAndQuery(this); + else + return visitor->visitChildren(this); +} + +KqlParser::QueryContext* KqlParser::query() { + return query(0); +} + +KqlParser::QueryContext* KqlParser::query(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + KqlParser::QueryContext *_localctx = _tracker.createInstance(_ctx, parentState); + KqlParser::QueryContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 2; + enterRecursionRule(_localctx, 2, KqlParser::RuleQuery, precedence); + + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(33); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { + case 1: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + + setState(20); + antlrcpp::downCast(_localctx)->col = column(); + setState(21); + match(KqlParser::T__0); + setState(22); + match(KqlParser::T__1); + setState(23); + antlrcpp::downCast(_localctx)->q = query(0); + setState(24); + match(KqlParser::T__2); + break; + } + + case 2: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(26); + match(KqlParser::T__3); + setState(27); + antlrcpp::downCast(_localctx)->q = query(0); + setState(28); + match(KqlParser::T__4); + break; + } + + case 3: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(30); + match(KqlParser::NOT); + setState(31); + antlrcpp::downCast(_localctx)->q = query(3); + break; + } + + case 4: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(32); + expression(); + break; + } + + default: + break; + } + _ctx->stop = _input->LT(-1); + setState(40); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 1, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + newContext->lhs = previousContext; + pushNewRecursionContext(newContext, startState, RuleQuery); + setState(35); + + if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(36); + antlrcpp::downCast(_localctx)->op = _input->LT(1); + _la = _input->LA(1); + if (!(_la == KqlParser::AND + + || _la == KqlParser::OR)) { + antlrcpp::downCast(_localctx)->op = _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(37); + antlrcpp::downCast(_localctx)->rhs = query(3); + } + setState(42); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 1, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ExpressionContext ------------------------------------------------------------------ + +KqlParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +KqlParser::Column_range_expressionContext* KqlParser::ExpressionContext::column_range_expression() { + return getRuleContext(0); +} + +KqlParser::Column_value_expressionContext* KqlParser::ExpressionContext::column_value_expression() { + return getRuleContext(0); +} + +KqlParser::Value_expressionContext* KqlParser::ExpressionContext::value_expression() { + return getRuleContext(0); +} + + +size_t KqlParser::ExpressionContext::getRuleIndex() const { + return KqlParser::RuleExpression; +} + + +std::any KqlParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpression(this); + else + return visitor->visitChildren(this); +} + +KqlParser::ExpressionContext* KqlParser::expression() { + ExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, KqlParser::RuleExpression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(46); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 2, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(43); + column_range_expression(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(44); + column_value_expression(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(45); + value_expression(); + break; + } + + default: + break; + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Column_range_expressionContext ------------------------------------------------------------------ + +KqlParser::Column_range_expressionContext::Column_range_expressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* KqlParser::Column_range_expressionContext::RANGE_OPERATOR() { + return getToken(KqlParser::RANGE_OPERATOR, 0); +} + +KqlParser::ColumnContext* KqlParser::Column_range_expressionContext::column() { + return getRuleContext(0); +} + +tree::TerminalNode* KqlParser::Column_range_expressionContext::DATE_LITERAL() { + return getToken(KqlParser::DATE_LITERAL, 0); +} + +tree::TerminalNode* KqlParser::Column_range_expressionContext::LITERAL() { + return getToken(KqlParser::LITERAL, 0); +} + + +size_t KqlParser::Column_range_expressionContext::getRuleIndex() const { + return KqlParser::RuleColumn_range_expression; +} + + +std::any KqlParser::Column_range_expressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitColumn_range_expression(this); + else + return visitor->visitChildren(this); +} + +KqlParser::Column_range_expressionContext* KqlParser::column_range_expression() { + Column_range_expressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, KqlParser::RuleColumn_range_expression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(48); + antlrcpp::downCast(_localctx)->col = column(); + setState(49); + match(KqlParser::RANGE_OPERATOR); + setState(52); + _errHandler->sync(this); + switch (_input->LA(1)) { + case KqlParser::DATE_LITERAL: { + setState(50); + antlrcpp::downCast(_localctx)->date_lit = match(KqlParser::DATE_LITERAL); + break; + } + + case KqlParser::LITERAL: { + setState(51); + antlrcpp::downCast(_localctx)->lit = match(KqlParser::LITERAL); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Column_value_expressionContext ------------------------------------------------------------------ + +KqlParser::Column_value_expressionContext::Column_value_expressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +KqlParser::ColumnContext* KqlParser::Column_value_expressionContext::column() { + return getRuleContext(0); +} + +KqlParser::List_of_valuesContext* KqlParser::Column_value_expressionContext::list_of_values() { + return getRuleContext(0); +} + +tree::TerminalNode* KqlParser::Column_value_expressionContext::DATE_LITERAL() { + return getToken(KqlParser::DATE_LITERAL, 0); +} + +tree::TerminalNode* KqlParser::Column_value_expressionContext::LITERAL() { + return getToken(KqlParser::LITERAL, 0); +} + + +size_t KqlParser::Column_value_expressionContext::getRuleIndex() const { + return KqlParser::RuleColumn_value_expression; +} + + +std::any KqlParser::Column_value_expressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitColumn_value_expression(this); + else + return visitor->visitChildren(this); +} + +KqlParser::Column_value_expressionContext* KqlParser::column_value_expression() { + Column_value_expressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, KqlParser::RuleColumn_value_expression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(54); + antlrcpp::downCast(_localctx)->col = column(); + setState(55); + match(KqlParser::T__0); + setState(59); + _errHandler->sync(this); + switch (_input->LA(1)) { + case KqlParser::T__3: { + setState(56); + antlrcpp::downCast(_localctx)->list = list_of_values(); + break; + } + + case KqlParser::DATE_LITERAL: { + setState(57); + antlrcpp::downCast(_localctx)->date_lit = match(KqlParser::DATE_LITERAL); + break; + } + + case KqlParser::LITERAL: { + setState(58); + antlrcpp::downCast(_localctx)->lit = match(KqlParser::LITERAL); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ColumnContext ------------------------------------------------------------------ + +KqlParser::ColumnContext::ColumnContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* KqlParser::ColumnContext::LITERAL() { + return getToken(KqlParser::LITERAL, 0); +} + + +size_t KqlParser::ColumnContext::getRuleIndex() const { + return KqlParser::RuleColumn; +} + + +std::any KqlParser::ColumnContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitColumn(this); + else + return visitor->visitChildren(this); +} + +KqlParser::ColumnContext* KqlParser::column() { + ColumnContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, KqlParser::RuleColumn); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(61); + match(KqlParser::LITERAL); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Value_expressionContext ------------------------------------------------------------------ + +KqlParser::Value_expressionContext::Value_expressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* KqlParser::Value_expressionContext::LITERAL() { + return getToken(KqlParser::LITERAL, 0); +} + + +size_t KqlParser::Value_expressionContext::getRuleIndex() const { + return KqlParser::RuleValue_expression; +} + + +std::any KqlParser::Value_expressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitValue_expression(this); + else + return visitor->visitChildren(this); +} + +KqlParser::Value_expressionContext* KqlParser::value_expression() { + Value_expressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, KqlParser::RuleValue_expression); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(63); + match(KqlParser::LITERAL); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- List_of_valuesContext ------------------------------------------------------------------ + +KqlParser::List_of_valuesContext::List_of_valuesContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector KqlParser::List_of_valuesContext::LITERAL() { + return getTokens(KqlParser::LITERAL); +} + +tree::TerminalNode* KqlParser::List_of_valuesContext::LITERAL(size_t i) { + return getToken(KqlParser::LITERAL, i); +} + +tree::TerminalNode* KqlParser::List_of_valuesContext::AND() { + return getToken(KqlParser::AND, 0); +} + +tree::TerminalNode* KqlParser::List_of_valuesContext::OR() { + return getToken(KqlParser::OR, 0); +} + +tree::TerminalNode* KqlParser::List_of_valuesContext::NOT() { + return getToken(KqlParser::NOT, 0); +} + + +size_t KqlParser::List_of_valuesContext::getRuleIndex() const { + return KqlParser::RuleList_of_values; +} + + +std::any KqlParser::List_of_valuesContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitList_of_values(this); + else + return visitor->visitChildren(this); +} + +KqlParser::List_of_valuesContext* KqlParser::list_of_values() { + List_of_valuesContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, KqlParser::RuleList_of_values); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(65); + match(KqlParser::T__3); + setState(67); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 448) != 0)) { + setState(66); + antlrcpp::downCast(_localctx)->condition = _input->LT(1); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & 448) != 0))) { + antlrcpp::downCast(_localctx)->condition = _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + } + setState(72); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == KqlParser::LITERAL) { + setState(69); + antlrcpp::downCast(_localctx)->literalToken = match(KqlParser::LITERAL); + antlrcpp::downCast(_localctx)->literals.push_back(antlrcpp::downCast(_localctx)->literalToken); + setState(74); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(75); + match(KqlParser::T__4); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool KqlParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 1: return querySempred(antlrcpp::downCast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool KqlParser::querySempred(QueryContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return precpred(_ctx, 2); + + default: + break; + } + return true; +} + +void KqlParser::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + kqlParserInitialize(); +#else + ::antlr4::internal::call_once(kqlParserOnceFlag, kqlParserInitialize); +#endif +} diff --git a/components/core/src/clp_s/search/kql/generated/KqlParser.h b/components/core/src/clp_s/search/kql/generated/KqlParser.h new file mode 100644 index 0000000000..1ca5172b70 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlParser.h @@ -0,0 +1,252 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace clp_s::search::kql::generated { + + +class KqlParser : public antlr4::Parser { +public: + enum { + T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, AND = 6, OR = 7, NOT = 8, + DATE_LITERAL = 9, LITERAL = 10, QUOTED_STRING = 11, UNQUOTED_LITERAL = 12, + RANGE_OPERATOR = 13, SPACE = 14 + }; + + enum { + RuleStart = 0, RuleQuery = 1, RuleExpression = 2, RuleColumn_range_expression = 3, + RuleColumn_value_expression = 4, RuleColumn = 5, RuleValue_expression = 6, + RuleList_of_values = 7 + }; + + explicit KqlParser(antlr4::TokenStream *input); + + KqlParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + + ~KqlParser() override; + + std::string getGrammarFileName() const override; + + const antlr4::atn::ATN& getATN() const override; + + const std::vector& getRuleNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + + class StartContext; + class QueryContext; + class ExpressionContext; + class Column_range_expressionContext; + class Column_value_expressionContext; + class ColumnContext; + class Value_expressionContext; + class List_of_valuesContext; + + class StartContext : public antlr4::ParserRuleContext { + public: + StartContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + QueryContext *query(); + antlr4::tree::TerminalNode *EOF(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StartContext* start(); + + class QueryContext : public antlr4::ParserRuleContext { + public: + QueryContext(antlr4::ParserRuleContext *parent, size_t invokingState); + + QueryContext() = default; + void copyFrom(QueryContext *context); + using antlr4::ParserRuleContext::copyFrom; + + virtual size_t getRuleIndex() const override; + + + }; + + class ExprContext : public QueryContext { + public: + ExprContext(QueryContext *ctx); + + ExpressionContext *expression(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class NestedQueryContext : public QueryContext { + public: + NestedQueryContext(QueryContext *ctx); + + KqlParser::ColumnContext *col = nullptr; + KqlParser::QueryContext *q = nullptr; + ColumnContext *column(); + QueryContext *query(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class NotQueryContext : public QueryContext { + public: + NotQueryContext(QueryContext *ctx); + + KqlParser::QueryContext *q = nullptr; + antlr4::tree::TerminalNode *NOT(); + QueryContext *query(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class SubQueryContext : public QueryContext { + public: + SubQueryContext(QueryContext *ctx); + + KqlParser::QueryContext *q = nullptr; + QueryContext *query(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class OrAndQueryContext : public QueryContext { + public: + OrAndQueryContext(QueryContext *ctx); + + KqlParser::QueryContext *lhs = nullptr; + antlr4::Token *op = nullptr; + KqlParser::QueryContext *rhs = nullptr; + std::vector query(); + QueryContext* query(size_t i); + antlr4::tree::TerminalNode *OR(); + antlr4::tree::TerminalNode *AND(); + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + QueryContext* query(); + QueryContext* query(int precedence); + class ExpressionContext : public antlr4::ParserRuleContext { + public: + ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + Column_range_expressionContext *column_range_expression(); + Column_value_expressionContext *column_value_expression(); + Value_expressionContext *value_expression(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpressionContext* expression(); + + class Column_range_expressionContext : public antlr4::ParserRuleContext { + public: + KqlParser::ColumnContext *col = nullptr; + antlr4::Token *date_lit = nullptr; + antlr4::Token *lit = nullptr; + Column_range_expressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *RANGE_OPERATOR(); + ColumnContext *column(); + antlr4::tree::TerminalNode *DATE_LITERAL(); + antlr4::tree::TerminalNode *LITERAL(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + Column_range_expressionContext* column_range_expression(); + + class Column_value_expressionContext : public antlr4::ParserRuleContext { + public: + KqlParser::ColumnContext *col = nullptr; + KqlParser::List_of_valuesContext *list = nullptr; + antlr4::Token *date_lit = nullptr; + antlr4::Token *lit = nullptr; + Column_value_expressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ColumnContext *column(); + List_of_valuesContext *list_of_values(); + antlr4::tree::TerminalNode *DATE_LITERAL(); + antlr4::tree::TerminalNode *LITERAL(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + Column_value_expressionContext* column_value_expression(); + + class ColumnContext : public antlr4::ParserRuleContext { + public: + ColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LITERAL(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ColumnContext* column(); + + class Value_expressionContext : public antlr4::ParserRuleContext { + public: + Value_expressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LITERAL(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + Value_expressionContext* value_expression(); + + class List_of_valuesContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *condition = nullptr; + antlr4::Token *literalToken = nullptr; + std::vector literals; + List_of_valuesContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector LITERAL(); + antlr4::tree::TerminalNode* LITERAL(size_t i); + antlr4::tree::TerminalNode *AND(); + antlr4::tree::TerminalNode *OR(); + antlr4::tree::TerminalNode *NOT(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + List_of_valuesContext* list_of_values(); + + + bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + + bool querySempred(QueryContext *_localctx, size_t predicateIndex); + + // By default the static state used to implement the parser is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: +}; + +} // namespace clp_s::search::kql::generated diff --git a/components/core/src/clp_s/search/kql/generated/KqlVisitor.cpp b/components/core/src/clp_s/search/kql/generated/KqlVisitor.cpp new file mode 100644 index 0000000000..44df6d3974 --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + + +#include "KqlVisitor.h" + + +using namespace clp_s::search::kql::generated; + diff --git a/components/core/src/clp_s/search/kql/generated/KqlVisitor.h b/components/core/src/clp_s/search/kql/generated/KqlVisitor.h new file mode 100644 index 0000000000..85947f48fc --- /dev/null +++ b/components/core/src/clp_s/search/kql/generated/KqlVisitor.h @@ -0,0 +1,50 @@ + +// Generated from clp_s/search/kql/Kql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "KqlParser.h" + + +namespace clp_s::search::kql::generated { + +/** + * This class defines an abstract visitor for a parse tree + * produced by KqlParser. + */ +class KqlVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by KqlParser. + */ + virtual std::any visitStart(KqlParser::StartContext *context) = 0; + + virtual std::any visitExpr(KqlParser::ExprContext *context) = 0; + + virtual std::any visitNestedQuery(KqlParser::NestedQueryContext *context) = 0; + + virtual std::any visitNotQuery(KqlParser::NotQueryContext *context) = 0; + + virtual std::any visitSubQuery(KqlParser::SubQueryContext *context) = 0; + + virtual std::any visitOrAndQuery(KqlParser::OrAndQueryContext *context) = 0; + + virtual std::any visitExpression(KqlParser::ExpressionContext *context) = 0; + + virtual std::any visitColumn_range_expression(KqlParser::Column_range_expressionContext *context) = 0; + + virtual std::any visitColumn_value_expression(KqlParser::Column_value_expressionContext *context) = 0; + + virtual std::any visitColumn(KqlParser::ColumnContext *context) = 0; + + virtual std::any visitValue_expression(KqlParser::Value_expressionContext *context) = 0; + + virtual std::any visitList_of_values(KqlParser::List_of_valuesContext *context) = 0; + + +}; + +} // namespace clp_s::search::kql::generated diff --git a/components/core/src/clp_s/search/kql/kql.cpp b/components/core/src/clp_s/search/kql/kql.cpp index a67f5422b2..0d72ca082e 100644 --- a/components/core/src/clp_s/search/kql/kql.cpp +++ b/components/core/src/clp_s/search/kql/kql.cpp @@ -26,7 +26,6 @@ #include "KqlParser.h" using namespace antlr4; -using namespace kql; using clp_s::search::antlr_common::ErrorListener; using clp_s::search::ast::AndExpr; @@ -45,6 +44,10 @@ using clp_s::search::ast::OrExpr; using clp_s::search::ast::StringLiteral; namespace clp_s::search::kql { +using generated::KqlBaseVisitor; +using generated::KqlLexer; +using generated::KqlParser; + namespace { class ParseTreeVisitor : public KqlBaseVisitor { private: diff --git a/components/core/src/clp_s/search/sql/CMakeLists.txt b/components/core/src/clp_s/search/sql/CMakeLists.txt index 672a221b9e..9e4ce19d5f 100644 --- a/components/core/src/clp_s/search/sql/CMakeLists.txt +++ b/components/core/src/clp_s/search/sql/CMakeLists.txt @@ -1,24 +1,34 @@ -ANTLR_TARGET( - SqlParser - Sql.g4 - LEXER PARSER VISITOR - PACKAGE sql +set(ANTLR_GENERATED_SOURCE_DIR generated) + +set(ANTLR_GENERATED_SOURCES + ${ANTLR_GENERATED_SOURCE_DIR}/SqlBaseVisitor.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/SqlBaseVisitor.h + ${ANTLR_GENERATED_SOURCE_DIR}/SqlLexer.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/SqlLexer.h + ${ANTLR_GENERATED_SOURCE_DIR}/SqlParser.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/SqlParser.h + ${ANTLR_GENERATED_SOURCE_DIR}/SqlVisitor.cpp + ${ANTLR_GENERATED_SOURCE_DIR}/SqlVisitor.h ) add_library( clp_s_search_sql + ${ANTLR_GENERATED_SOURCES} ../antlr_common/ErrorListener.hpp - ${ANTLR_SqlParser_CXX_OUTPUTS} sql.cpp sql.hpp ) add_library(clp_s::search::sql ALIAS clp_s_search_sql) target_compile_features(clp_s_search_sql PRIVATE cxx_std_20) -target_include_directories(clp_s_search_sql PRIVATE ${ANTLR_SqlParser_OUTPUT_DIR}) +target_include_directories(clp_s_search_sql + PRIVATE + ${ANTLR_GENERATED_SOURCE_DIR} +) + target_link_libraries( clp_s_search_sql PRIVATE antlr4_static - clp_s::search::ast + clp_s::search::ast spdlog::spdlog ) diff --git a/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.cpp b/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.cpp new file mode 100644 index 0000000000..a508ee1afb --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + + +#include "SqlBaseVisitor.h" + + +using namespace clp_s::search::sql::generated; + diff --git a/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.h b/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.h new file mode 100644 index 0000000000..94ae148452 --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlBaseVisitor.h @@ -0,0 +1,27 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SqlVisitor.h" + + +namespace clp_s::search::sql::generated { + +/** + * This class provides an empty implementation of SqlVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class SqlBaseVisitor : public SqlVisitor { +public: + + virtual std::any visitStart(SqlParser::StartContext *ctx) override { + return visitChildren(ctx); + } + + +}; + +} // namespace clp_s::search::sql::generated diff --git a/components/core/src/clp_s/search/sql/generated/SqlLexer.cpp b/components/core/src/clp_s/search/sql/generated/SqlLexer.cpp new file mode 100644 index 0000000000..abb185f5d4 --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlLexer.cpp @@ -0,0 +1,141 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + + +#include "SqlLexer.h" + + +using namespace antlr4; + +using namespace clp_s::search::sql::generated; + + +using namespace antlr4; + +namespace { + +struct SqlLexerStaticData final { + SqlLexerStaticData(std::vector ruleNames, + std::vector channelNames, + std::vector modeNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)), + modeNames(std::move(modeNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + SqlLexerStaticData(const SqlLexerStaticData&) = delete; + SqlLexerStaticData(SqlLexerStaticData&&) = delete; + SqlLexerStaticData& operator=(const SqlLexerStaticData&) = delete; + SqlLexerStaticData& operator=(SqlLexerStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector channelNames; + const std::vector modeNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sqllexerLexerOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sqllexerLexerStaticData = nullptr; + +void sqllexerLexerInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sqllexerLexerStaticData != nullptr) { + return; + } +#else + assert(sqllexerLexerStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "SPACE" + }, + std::vector{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }, + std::vector{ + "DEFAULT_MODE" + }, + std::vector{ + }, + std::vector{ + "", "SPACE" + } + ); + static const int32_t serializedATNSegment[] = { + 4,0,1,7,6,-1,2,0,7,0,1,0,1,0,1,0,1,0,0,0,1,1,1,1,0,1,3,0,9,10,13,13,32, + 32,6,0,1,1,0,0,0,1,3,1,0,0,0,3,4,7,0,0,0,4,5,1,0,0,0,5,6,6,0,0,0,6,2, + 1,0,0,0,1,0,1,6,0,0 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + sqllexerLexerStaticData = std::move(staticData); +} + +} + +SqlLexer::SqlLexer(CharStream *input) : Lexer(input) { + SqlLexer::initialize(); + _interpreter = new atn::LexerATNSimulator(this, *sqllexerLexerStaticData->atn, sqllexerLexerStaticData->decisionToDFA, sqllexerLexerStaticData->sharedContextCache); +} + +SqlLexer::~SqlLexer() { + delete _interpreter; +} + +std::string SqlLexer::getGrammarFileName() const { + return "Sql.g4"; +} + +const std::vector& SqlLexer::getRuleNames() const { + return sqllexerLexerStaticData->ruleNames; +} + +const std::vector& SqlLexer::getChannelNames() const { + return sqllexerLexerStaticData->channelNames; +} + +const std::vector& SqlLexer::getModeNames() const { + return sqllexerLexerStaticData->modeNames; +} + +const dfa::Vocabulary& SqlLexer::getVocabulary() const { + return sqllexerLexerStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView SqlLexer::getSerializedATN() const { + return sqllexerLexerStaticData->serializedATN; +} + +const atn::ATN& SqlLexer::getATN() const { + return *sqllexerLexerStaticData->atn; +} + + + + +void SqlLexer::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + sqllexerLexerInitialize(); +#else + ::antlr4::internal::call_once(sqllexerLexerOnceFlag, sqllexerLexerInitialize); +#endif +} diff --git a/components/core/src/clp_s/search/sql/generated/SqlLexer.h b/components/core/src/clp_s/search/sql/generated/SqlLexer.h new file mode 100644 index 0000000000..906c468e4a --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlLexer.h @@ -0,0 +1,51 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace clp_s::search::sql::generated { + + +class SqlLexer : public antlr4::Lexer { +public: + enum { + SPACE = 1 + }; + + explicit SqlLexer(antlr4::CharStream *input); + + ~SqlLexer() override; + + + std::string getGrammarFileName() const override; + + const std::vector& getRuleNames() const override; + + const std::vector& getChannelNames() const override; + + const std::vector& getModeNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + const antlr4::atn::ATN& getATN() const override; + + // By default the static state used to implement the lexer is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + +}; + +} // namespace clp_s::search::sql::generated diff --git a/components/core/src/clp_s/search/sql/generated/SqlParser.cpp b/components/core/src/clp_s/search/sql/generated/SqlParser.cpp new file mode 100644 index 0000000000..20f7f2391d --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlParser.cpp @@ -0,0 +1,170 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + + +#include "SqlVisitor.h" + +#include "SqlParser.h" + + +using namespace antlrcpp; +using namespace clp_s::search::sql::generated; + +using namespace antlr4; + +namespace { + +struct SqlParserStaticData final { + SqlParserStaticData(std::vector ruleNames, + std::vector literalNames, + std::vector symbolicNames) + : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), + symbolicNames(std::move(symbolicNames)), + vocabulary(this->literalNames, this->symbolicNames) {} + + SqlParserStaticData(const SqlParserStaticData&) = delete; + SqlParserStaticData(SqlParserStaticData&&) = delete; + SqlParserStaticData& operator=(const SqlParserStaticData&) = delete; + SqlParserStaticData& operator=(SqlParserStaticData&&) = delete; + + std::vector decisionToDFA; + antlr4::atn::PredictionContextCache sharedContextCache; + const std::vector ruleNames; + const std::vector literalNames; + const std::vector symbolicNames; + const antlr4::dfa::Vocabulary vocabulary; + antlr4::atn::SerializedATNView serializedATN; + std::unique_ptr atn; +}; + +::antlr4::internal::OnceFlag sqlParserOnceFlag; +#if ANTLR4_USE_THREAD_LOCAL_CACHE +static thread_local +#endif +std::unique_ptr sqlParserStaticData = nullptr; + +void sqlParserInitialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + if (sqlParserStaticData != nullptr) { + return; + } +#else + assert(sqlParserStaticData == nullptr); +#endif + auto staticData = std::make_unique( + std::vector{ + "start" + }, + std::vector{ + }, + std::vector{ + "", "SPACE" + } + ); + static const int32_t serializedATNSegment[] = { + 4,1,1,5,2,0,7,0,1,0,1,0,1,0,0,0,1,0,0,0,3,0,2,1,0,0,0,2,3,5,0,0,1,3,1, + 1,0,0,0,0 + }; + staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); + + antlr4::atn::ATNDeserializer deserializer; + staticData->atn = deserializer.deserialize(staticData->serializedATN); + + const size_t count = staticData->atn->getNumberOfDecisions(); + staticData->decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); + } + sqlParserStaticData = std::move(staticData); +} + +} + +SqlParser::SqlParser(TokenStream *input) : SqlParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} + +SqlParser::SqlParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { + SqlParser::initialize(); + _interpreter = new atn::ParserATNSimulator(this, *sqlParserStaticData->atn, sqlParserStaticData->decisionToDFA, sqlParserStaticData->sharedContextCache, options); +} + +SqlParser::~SqlParser() { + delete _interpreter; +} + +const atn::ATN& SqlParser::getATN() const { + return *sqlParserStaticData->atn; +} + +std::string SqlParser::getGrammarFileName() const { + return "Sql.g4"; +} + +const std::vector& SqlParser::getRuleNames() const { + return sqlParserStaticData->ruleNames; +} + +const dfa::Vocabulary& SqlParser::getVocabulary() const { + return sqlParserStaticData->vocabulary; +} + +antlr4::atn::SerializedATNView SqlParser::getSerializedATN() const { + return sqlParserStaticData->serializedATN; +} + + +//----------------- StartContext ------------------------------------------------------------------ + +SqlParser::StartContext::StartContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SqlParser::StartContext::EOF() { + return getToken(SqlParser::EOF, 0); +} + + +size_t SqlParser::StartContext::getRuleIndex() const { + return SqlParser::RuleStart; +} + + +std::any SqlParser::StartContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStart(this); + else + return visitor->visitChildren(this); +} + +SqlParser::StartContext* SqlParser::start() { + StartContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, SqlParser::RuleStart); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2); + match(SqlParser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +void SqlParser::initialize() { +#if ANTLR4_USE_THREAD_LOCAL_CACHE + sqlParserInitialize(); +#else + ::antlr4::internal::call_once(sqlParserOnceFlag, sqlParserInitialize); +#endif +} diff --git a/components/core/src/clp_s/search/sql/generated/SqlParser.h b/components/core/src/clp_s/search/sql/generated/SqlParser.h new file mode 100644 index 0000000000..6f5558d72b --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlParser.h @@ -0,0 +1,64 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" + + +namespace clp_s::search::sql::generated { + + +class SqlParser : public antlr4::Parser { +public: + enum { + SPACE = 1 + }; + + enum { + RuleStart = 0 + }; + + explicit SqlParser(antlr4::TokenStream *input); + + SqlParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options); + + ~SqlParser() override; + + std::string getGrammarFileName() const override; + + const antlr4::atn::ATN& getATN() const override; + + const std::vector& getRuleNames() const override; + + const antlr4::dfa::Vocabulary& getVocabulary() const override; + + antlr4::atn::SerializedATNView getSerializedATN() const override; + + + class StartContext; + + class StartContext : public antlr4::ParserRuleContext { + public: + StartContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *EOF(); + + + virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StartContext* start(); + + + // By default the static state used to implement the parser is lazily initialized during the first + // call to the constructor. You can call this function if you wish to initialize the static state + // ahead of time. + static void initialize(); + +private: +}; + +} // namespace clp_s::search::sql::generated diff --git a/components/core/src/clp_s/search/sql/generated/SqlVisitor.cpp b/components/core/src/clp_s/search/sql/generated/SqlVisitor.cpp new file mode 100644 index 0000000000..755454fc3e --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlVisitor.cpp @@ -0,0 +1,9 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + + +#include "SqlVisitor.h" + + +using namespace clp_s::search::sql::generated; + diff --git a/components/core/src/clp_s/search/sql/generated/SqlVisitor.h b/components/core/src/clp_s/search/sql/generated/SqlVisitor.h new file mode 100644 index 0000000000..bec8f3b3c7 --- /dev/null +++ b/components/core/src/clp_s/search/sql/generated/SqlVisitor.h @@ -0,0 +1,28 @@ + +// Generated from clp_s/search/sql/Sql.g4 by ANTLR 4.13.2 + +#pragma once + + +#include "antlr4-runtime.h" +#include "SqlParser.h" + + +namespace clp_s::search::sql::generated { + +/** + * This class defines an abstract visitor for a parse tree + * produced by SqlParser. + */ +class SqlVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by SqlParser. + */ + virtual std::any visitStart(SqlParser::StartContext *context) = 0; + + +}; + +} // namespace clp_s::search::sql::generated diff --git a/components/core/src/clp_s/search/sql/sql.cpp b/components/core/src/clp_s/search/sql/sql.cpp index a1f75391fd..accf020844 100644 --- a/components/core/src/clp_s/search/sql/sql.cpp +++ b/components/core/src/clp_s/search/sql/sql.cpp @@ -15,14 +15,15 @@ using antlr4::ANTLRInputStream; using antlr4::CommonTokenStream; using clp_s::search::antlr_common::ErrorListener; -using sql::SqlBaseVisitor; -using sql::SqlLexer; -using sql::SqlParser; using clp_s::search::ast::EmptyExpr; using clp_s::search::ast::Expression; namespace clp_s::search::sql { +using generated::SqlBaseVisitor; +using generated::SqlLexer; +using generated::SqlParser; + namespace { class ParseTreeVisitor : public SqlBaseVisitor { public: diff --git a/taskfile.yaml b/taskfile.yaml index ace78f22dc..b7012bfdb9 100644 --- a/taskfile.yaml +++ b/taskfile.yaml @@ -182,6 +182,47 @@ tasks: CHECKSUM_FILE: "{{.CHECKSUM_FILE}}" INCLUDE_PATTERNS: ["{{.OUTPUT_DIR}}"] + clp-s-generate-parsers: + vars: + CHECKSUM_FILE: "{{.G_BUILD_DIR}}/{{.TASK}}.md5" + OUTPUT_DIRS: + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/generated" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/generated" + deps: + - "deps:antlr-jar" + - task: "utils:checksum:validate" + vars: + CHECKSUM_FILE: "{{.CHECKSUM_FILE}}" + INCLUDE_PATTERNS: + ref: ".OUTPUT_DIRS" + generates: ["{{.CHECKSUM_FILE}}"] + sources: + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/Kql.g4" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/Sql.g4" + dir: "{{.G_CORE_COMPONENT_DIR}}/src/" + cmds: + - for: ["kql", "sql"] + cmd: |- + rm -rf "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/{{.ITEM}}/generated/"* \ + && java -jar {{.G_ANTLR_JAR_FILE}} \ + -Dlanguage=Cpp \ + -no-listener \ + -visitor \ + -package clp_s::search::{{.ITEM}}::generated \ + -o clp_s/search/{{.ITEM}}/generated \ + -Xexact-output-dir \ + clp_s/search/{{.ITEM}}/*.g4 \ + && find "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/{{.ITEM}}/generated" \ + -type f -and -not \( -name "*.cpp" -o -name "*.h" \) \ + -exec rm {} \; + + # This command must be last + - task: "utils:checksum:compute" + vars: + CHECKSUM_FILE: "{{.CHECKSUM_FILE}}" + INCLUDE_PATTERNS: + ref: ".OUTPUT_DIRS" + core: cmds: - task: "core-generate" @@ -196,7 +237,9 @@ tasks: - "{{.G_CORE_COMPONENT_DIR}}/src/**/*" - "{{.TASKFILE}}" - "/etc/os-release" - deps: ["deps:core"] + deps: + - "clp-s-generate-parsers" + - "deps:core" cmds: - task: "utils:cmake:generate" vars: diff --git a/taskfiles/deps/main.yaml b/taskfiles/deps/main.yaml index 82e8dd2c26..f3516458f8 100644 --- a/taskfiles/deps/main.yaml +++ b/taskfiles/deps/main.yaml @@ -20,6 +20,10 @@ vars: # Library names G_FMT_LIB_NAME: "fmt" + # Antlr + G_ANTLR_VERSION: "4.13.2" + G_ANTLR_JAR_FILE: "{{.G_DEPS_CORE_DIR}}/antlr-{{.G_ANTLR_VERSION}}-complete.jar" + tasks: default: deps: @@ -56,7 +60,8 @@ tasks: run: "once" deps: - task: "absl" - - task: "antlr" + - task: "antlr-jar" + - task: "antlr-runtime" - task: "catch2" - task: "date" - task: "fmt" @@ -84,14 +89,11 @@ tasks: TARBALL_SHA256: "987ce98f02eefbaf930d6e38ab16aa05737234d7afbab2d5c4ea7adbe50c28ed" TARBALL_URL: "https://github.com/abseil/abseil-cpp/archive/refs/tags/20230802.1.tar.gz" - antlr: + antlr-jar: internal: true vars: - DEP_NAME: "antlr" - - # Paths - CHECKSUM_FILE: "{{.G_DEPS_CORE_CHECKSUMS_DIR}}/{{.DEP_NAME}}.md5" - OUTPUT_FILE: "{{.G_DEPS_CORE_DIR}}/antlr-4.13.1-complete.jar" + CHECKSUM_FILE: "{{.G_DEPS_CORE_CHECKSUMS_DIR}}/antlr-jar.md5" + OUTPUT_FILE: "{{.G_ANTLR_JAR_FILE}}" run: "once" deps: - task: "yscope-dev-utils:checksum:validate" @@ -103,13 +105,9 @@ tasks: cmds: - task: "yscope-dev-utils:remote:curl" vars: - FILE_SHA256: "bc13a9c57a8dd7d5196888211e5ede657cb64a3ce968608697e4f668251a8487" + FILE_SHA256: "eae2dfa119a64327444672aff63e9ec35a20180dc5b8090b7a6ab85125df4d76" OUTPUT_FILE: "{{.OUTPUT_FILE}}" - URL: "https://www.antlr.org/download/antlr-4.13.1-complete.jar" - - >- - echo "set( - ANTLR_EXECUTABLE \"{{.OUTPUT_FILE}}\" - )" > "{{.G_DEPS_CORE_CMAKE_SETTINGS_DIR}}/{{.DEP_NAME}}.cmake" + URL: "https://www.antlr.org/download/antlr-{{.G_ANTLR_VERSION}}-complete.jar" # This command must be last - task: "yscope-dev-utils:checksum:compute" @@ -118,6 +116,64 @@ tasks: INCLUDE_PATTERNS: - "{{.OUTPUT_FILE}}" + antlr-runtime: + internal: true + run: "once" + vars: + LIB_NAME: "antlr4-runtime" + + # Paths + BUILD_DIR: "{{.G_DEPS_CORE_DIR}}/{{.LIB_NAME}}-build" + CHECKSUM_FILE: "{{.G_DEPS_CORE_CHECKSUMS_DIR}}/{{.LIB_NAME}}.md5" + INSTALL_PREFIX: "{{.G_DEPS_CORE_DIR}}/{{.LIB_NAME}}-install" + SOURCE_DIR: "{{.G_DEPS_CORE_DIR}}/{{.LIB_NAME}}-src" + deps: + - task: "utils:init" + - task: "yscope-dev-utils:checksum:validate" + vars: + CHECKSUM_FILE: "{{.CHECKSUM_FILE}}" + INCLUDE_PATTERNS: ["{{.INSTALL_PREFIX}}"] + + # NOTE: We can't use `yscope-dev-utils:cmake:install-remote-tar` (and by extension + # `utils:install-remote-cmake-lib`) since it doesn't yet support the `INCLUDE_PATTERNS` and + # `NUM_COMPONENTS_TO_STRIP` parameters. + cmds: + - task: "yscope-dev-utils:remote:download-and-extract-tar" + vars: + FILE_SHA256: "9f18272a9b32b622835a3365f850dd1063d60f5045fb1e12ce475ae6e18a35bb" + INCLUDE_PATTERNS: ["*/runtime/Cpp"] + NUM_COMPONENTS_TO_STRIP: 3 + OUTPUT_DIR: "{{.SOURCE_DIR}}" + URL: "https://github.com/antlr/antlr4/archive/refs/tags/{{.G_ANTLR_VERSION}}.tar.gz" + - task: "yscope-dev-utils:cmake:generate" + vars: + BUILD_DIR: "{{.BUILD_DIR}}" + EXTRA_ARGS: + - "-DANTLR4_INSTALL=ON" + - "-DCMAKE_BUILD_TYPE=Release" + - "-DCMAKE_INSTALL_MESSAGE=LAZY" + + # Set CMP0135 so that extracted files use the current timestamp as their modification + # timestamp, which ensures the library gets rebuilt if the extracted files change. + - "-DCMAKE_POLICY_DEFAULT_CMP0135=NEW" + SOURCE_DIR: "{{.SOURCE_DIR}}" + - task: "yscope-dev-utils:cmake:build" + vars: + BUILD_DIR: "{{.BUILD_DIR}}" + JOBS: "{{.G_CORE_MAX_PARALLELISM_PER_BUILD_TASK}}" + - task: "yscope-dev-utils:cmake:install" + vars: + BUILD_DIR: "{{.BUILD_DIR}}" + CMAKE_SETTINGS_DIR: "{{.G_DEPS_CORE_CMAKE_SETTINGS_DIR}}" + INSTALL_PREFIX: "{{.INSTALL_PREFIX}}" + NAME: "{{.LIB_NAME}}" + + # This command must be last + - task: "yscope-dev-utils:checksum:compute" + vars: + CHECKSUM_FILE: "{{.CHECKSUM_FILE}}" + INCLUDE_PATTERNS: ["{{.INSTALL_PREFIX}}"] + catch2: internal: true run: "once" diff --git a/taskfiles/lint.yaml b/taskfiles/lint.yaml index b6dd7ccc9c..b07c4cad31 100644 --- a/taskfiles/lint.yaml +++ b/taskfiles/lint.yaml @@ -135,6 +135,9 @@ tasks: cmds: - task: ":utils:cpp-lint:clang-format" vars: + EXCLUDE_PATTERNS: + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/generated/*" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/generated/*" FLAGS: ["--dry-run"] INCLUDE_FILENAME_PATTERNS: ["*.cpp", "*.h", "*.hpp", "*.inc"] ROOT_PATHS: *cpp_source_files @@ -146,6 +149,9 @@ tasks: cmds: - task: ":utils:cpp-lint:clang-format" vars: + EXCLUDE_PATTERNS: + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/generated/*" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/generated/*" FLAGS: ["-i"] INCLUDE_FILENAME_PATTERNS: ["*.cpp", "*.h", "*.hpp", "*.inc"] ROOT_PATHS: *cpp_source_files @@ -490,6 +496,7 @@ tasks: - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/clp_search/Query.hpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/EvaluateTimestampIndex.cpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/EvaluateTimestampIndex.hpp" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/generated/*" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/kql.cpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/kql/kql.hpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/Output.cpp" @@ -500,6 +507,7 @@ tasks: - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/QueryRunner.hpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/SchemaMatch.cpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/SchemaMatch.hpp" + - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/generated/*" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/search/sql/sql.cpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/SingleFileArchiveDefs.hpp" - "{{.G_CORE_COMPONENT_DIR}}/src/clp_s/TimestampDictionaryReader.cpp"