Add support for tracking matched and unmatched capture groups in RegexAST nodes using integer-based tags; Add support for serializing RegexAST nodes.

CMakeLists.txt

@@ -7,6 +7,10 @@ project(log_surgeon
     LANGUAGES CXX
     )
 
+if (POLICY CMP0077)
+    cmake_policy(SET CMP0077 NEW)
+endif()
+
 if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)
     find_package(Catch2 3 REQUIRED)
     include(Catch)
@@ -24,9 +28,27 @@ if (NOT Microsoft.GSL_FOUND)
                          GIT_TAG "v4.0.0"
                          GIT_SHALLOW ON
     )
+endif()
+
+find_package(fmt 8.0.1 QUIET)
+if (NOT fmt_FOUND)
+    FetchContent_Declare(fmt
+                         GIT_REPOSITORY https://github.com/fmtlib/fmt
+                         GIT_TAG "8.0.1"
+    )
+endif()
+
+# Declare the details of all fetched content before making them available.
+if (NOT Microsoft.GSL_FOUND)
     FetchContent_MakeAvailable(GSL)
 endif()
 
+if (NOT fmt_FOUND)
+    # Force fmt to generate install rules
+    set(FMT_INSTALL ON CACHE BOOL "Enable installation for fmt." FORCE)
+    FetchContent_MakeAvailable(fmt)
+endif()
+
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
@@ -83,20 +105,13 @@ set(LCHIP_THIRD_PARTY_INCLUDE_DIR "${LCHIP_INSTALL_INCLUDE_DIR}/log_surgeon/thir
 
 add_library(log_surgeon ${SOURCE_FILES})
 add_library(log_surgeon::log_surgeon ALIAS log_surgeon)
+
 if (Microsoft.GSL_FOUND)
     target_link_libraries(log_surgeon
-                          PUBLIC
-                          Microsoft.GSL::GSL
-    )
-endif()
-target_include_directories(log_surgeon
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    PRIVATE
-    ${CMAKE_CURRENT_SOURCE_DIR}/src
-    )
-if (NOT Microsoft.GSL_FOUND)
+            PUBLIC
+            Microsoft.GSL::GSL
+            )
+else()
     # Since the user doesn't have GSL installed, use the GSL headers directly.
     # NOTE:
     # - We can't link against the `Microsoft.GSL::GSL` target since that would require adding `GSL`
@@ -106,9 +121,19 @@ if (NOT Microsoft.GSL_FOUND)
             PUBLIC
             $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/include>
             $<INSTALL_INTERFACE:${LCHIP_THIRD_PARTY_INCLUDE_DIR}>
-    )
+            )
 endif()
 
+target_link_libraries(log_surgeon PUBLIC fmt::fmt)
+
+target_include_directories(log_surgeon
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+        PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+        )
+
 target_compile_features(log_surgeon
     PRIVATE cxx_std_20
     )

src/log_surgeon/SchemaParser.cpp

@@ -12,6 +12,8 @@
 #include <log_surgeon/Lexer.hpp>
 #include <log_surgeon/utils.hpp>
 
+using ParserValueRegex = log_surgeon::ParserValue<std::unique_ptr<
+        log_surgeon::finite_automata::RegexAST<log_surgeon::finite_automata::RegexNFAByteState>>>;
 using RegexASTByte
         = log_surgeon::finite_automata::RegexAST<log_surgeon::finite_automata::RegexNFAByteState>;
 using RegexASTGroupByte = log_surgeon::finite_automata::RegexASTGroup<
@@ -154,14 +156,22 @@ auto SchemaParser::existing_schema_rule(NonTerminal* m) -> unique_ptr<SchemaAST>
     return schema_ast;
 }
 
+auto SchemaParser::regex_capture_rule(NonTerminal* m) -> std::unique_ptr<ParserAST> {
+    auto* r4 = dynamic_cast<IdentifierAST*>(m->non_terminal_cast(3)->get_parser_ast().get());
+    auto& r6 = m->non_terminal_cast(5)->get_parser_ast()->get<unique_ptr<RegexASTByte>>();
+    return std::make_unique<ParserValueRegex>(make_unique<RegexASTCaptureByte>(
+            r4->m_name,
+            std::move(r6),
+            m_capture_group_id_generator.assign_next_id()
+    ));
+}
+
 static auto identity_rule_ParserASTSchema(NonTerminal* m) -> unique_ptr<SchemaAST> {
     unique_ptr<ParserAST>& r1 = m->non_terminal_cast(0)->get_parser_ast();
     std::unique_ptr<SchemaAST> schema_ast(dynamic_cast<SchemaAST*>(r1.release()));
     return schema_ast;
 }
 
-using ParserValueRegex = ParserValue<unique_ptr<RegexASTByte>>;
-
 static auto regex_identity_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
     return unique_ptr<ParserAST>(new ParserValueRegex(
             std::move(m->non_terminal_cast(0)->get_parser_ast()->get<unique_ptr<RegexASTByte>>())
@@ -283,14 +293,6 @@ static auto regex_range_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
     );
 }
 
-static auto regex_capture_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
-    auto* r4 = dynamic_cast<IdentifierAST*>(m->non_terminal_cast(3)->get_parser_ast().get());
-    auto& r6 = m->non_terminal_cast(5)->get_parser_ast()->get<unique_ptr<RegexASTByte>>();
-    return std::make_unique<ParserValueRegex>(
-            make_unique<RegexASTCaptureByte>(r4->m_name, std::move(r6))
-    );
-}
-
 static auto regex_middle_identity_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
     return unique_ptr<ParserAST>(new ParserValueRegex(
             std::move(m->non_terminal_cast(1)->get_parser_ast()->get<unique_ptr<RegexASTByte>>())
@@ -603,7 +605,7 @@ void SchemaParser::add_productions() {
     add_production(
             "Literal",
             {"Lparen", "QuestionMark", "Langle", "Identifier", "Rangle", "Regex", "Rparen"},
-            regex_capture_rule
+            std::bind(&SchemaParser::regex_capture_rule, this, std::placeholders::_1)
     );
     add_production("Literal", {"Lparen", "Regex", "Rparen"}, regex_middle_identity_rule);
     for (auto const& [special_regex_char, special_regex_name] : m_special_regex_characters) {

src/log_surgeon/SchemaParser.hpp

@@ -6,6 +6,17 @@
 #include <log_surgeon/LALR1Parser.hpp>
 
 namespace log_surgeon {
+/**
+ * Class for generating monotonically increasing integer IDs.
+ */
+class UniqueIdGenerator {
+public:
+    [[nodiscard]] auto assign_next_id() -> uint32_t { return m_next_id++; }
+
+private:
+    uint32_t m_next_id{0};
+};
+
 // ASTs used in SchemaParser AST
 class SchemaAST : public ParserAST {
 public:
@@ -100,6 +111,13 @@ class SchemaParser : public LALR1Parser<
      */
     auto existing_schema_rule(NonTerminal* m) -> std::unique_ptr<SchemaAST>;
 
+    /**
+     * A semantic rule for regex capture groups that needs access to `m_capture_group_id_generator`.
+     * @param m
+     * @return A unique pointer to the parsed regex capture group.
+     */
+    auto regex_capture_rule(NonTerminal* m) -> std::unique_ptr<ParserAST>;
+
     /**
      * After lexing half of the buffer, reads into that half of the buffer and
      * changes variables accordingly
@@ -126,6 +144,8 @@ class SchemaParser : public LALR1Parser<
     auto generate_schema_ast(Reader& reader) -> std::unique_ptr<SchemaAST>;
 
     static inline std::unordered_map<char, std::string> m_special_regex_characters;
+
+    UniqueIdGenerator m_capture_group_id_generator;
 };
 }  // namespace log_surgeon