Bug-Fix: Add negative tags for RegexMultiplicationAST with min=0.

src/log_surgeon/SchemaParser.cpp

@@ -30,6 +30,8 @@ using RegexASTCatByte = log_surgeon::finite_automata::RegexASTCat<
         log_surgeon::finite_automata::RegexNFAByteState>;
 using RegexASTCaptureByte = log_surgeon::finite_automata::RegexASTCapture<
         log_surgeon::finite_automata::RegexNFAByteState>;
+using RegexASTEmptyByte = log_surgeon::finite_automata::RegexASTEmpty<
+        log_surgeon::finite_automata::RegexNFAByteState>;
 
 using std::make_unique;
 using std::string;
@@ -196,8 +198,11 @@ static auto regex_or_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
 
 static auto regex_match_zero_or_more_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
     auto& r1 = m->non_terminal_cast(0)->get_parser_ast()->get<unique_ptr<RegexASTByte>>();
-    return unique_ptr<ParserAST>(new ParserValueRegex(
-            unique_ptr<RegexASTByte>(new RegexASTMultiplicationByte(std::move(r1), 0, 0))
+
+    // To handle negative tags we treat `R{0,N}` as `R{1,N} | ∅`.
+    return make_unique<ParserValueRegex>(make_unique<RegexASTOrByte>(
+            make_unique<RegexASTEmptyByte>(),
+            make_unique<RegexASTMultiplicationByte>(std::move(r1), 1, 0)
     ));
 }
 
@@ -238,6 +243,14 @@ static auto regex_match_range_rule(NonTerminal* m) -> unique_ptr<ParserAST> {
         max += r5_ptr->get_digit(i) * (uint32_t)pow(10, r5_size - i - 1);
     }
     auto& r1 = m->non_terminal_cast(0)->get_parser_ast()->get<unique_ptr<RegexASTByte>>();
+
+    if (min == 0) {
+        // To handle negative tags we treat `R{0,N}` as `R{1,N} | ∅`.
+        return make_unique<ParserValueRegex>(make_unique<RegexASTOrByte>(
+                make_unique<RegexASTEmptyByte>(),
+                make_unique<RegexASTMultiplicationByte>(std::move(r1), 1, max)
+        ));
+    }
     return unique_ptr<ParserAST>(new ParserValueRegex(
             unique_ptr<RegexASTByte>(new RegexASTMultiplicationByte(std::move(r1), min, max))
     ));

src/log_surgeon/finite_automata/RegexAST.hpp

@@ -124,6 +124,49 @@ class RegexAST {
     std::set<uint32_t> m_negative_tags;
 };
 
+template <typename NFAStateType>
+class RegexASTEmpty : public RegexAST<NFAStateType> {
+public:
+    RegexASTEmpty();
+
+    /**
+     * Used for cloning a unique_pointer of type RegexASTEmpty
+     * @return RegexASTEmpty*
+     */
+    [[nodiscard]] auto clone() const -> gsl::owner<RegexASTEmpty*> override {
+        return new RegexASTEmpty(*this);
+    }
+
+    /**
+     * Sets is_possible_input to specify which utf8 characters are allowed in a
+     * lexer rule containing RegexASTEmpty at a leaf node in its AST, which is nothing
+     * @param is_possible_input
+     */
+    auto set_possible_inputs_to_true(
+            [[maybe_unused]] std::array<bool, cSizeOfUnicode>& is_possible_input
+    ) const -> void override {}
+
+    /**
+     * Transforms '.' to to be any non-delimiter in a lexer rule, which does
+     * nothing as RegexASTEmpty is a leaf node that is not a RegexASTGroup
+     * @param delimiters
+     */
+    auto remove_delimiters_from_wildcard([[maybe_unused]] std::vector<uint32_t>& delimiters
+    ) -> void override {
+        // Do nothing
+    }
+
+    /**
+     * Add the needed RegexNFA::states to the passed in nfa to handle a
+     * RegexASTEmpty before transitioning to an accepting end_state
+     * @param nfa
+     * @param end_state
+     */
+    auto add_to_nfa(RegexNFA<NFAStateType>* nfa, NFAStateType* end_state) const -> void override;
+
+    [[nodiscard]] auto serialize() const -> std::u32string override;
+};
+
 template <typename NFAStateType>
 class RegexASTLiteral : public RegexAST<NFAStateType> {
 public:
@@ -655,6 +698,22 @@ class RegexASTCapture : public RegexAST<NFAStateType> {
     uint32_t m_tag;
 };
 
+template <typename NFAStateType>
+RegexASTEmpty<NFAStateType>::RegexASTEmpty() = default;
+
+template <typename NFAStateType>
+void RegexASTEmpty<NFAStateType>::add_to_nfa(
+        [[maybe_unused]] RegexNFA<NFAStateType>* nfa,
+        [[maybe_unused]] NFAStateType* end_state
+) const {
+    // DO NOTHING
+}
+
+template <typename NFAStateType>
+[[nodiscard]] auto RegexASTEmpty<NFAStateType>::serialize() const -> std::u32string {
+    return fmt::format(U"{}", RegexAST<NFAStateType>::serialize_negative_tags());
+}
+
 template <typename NFAStateType>
 RegexASTLiteral<NFAStateType>::RegexASTLiteral(uint32_t character) : m_character(character) {}
 

tests/test-lexer.cpp

@@ -1,4 +1,6 @@
 #include <cstdint>
+#include <numeric>
+#include <ranges>
 #include <string>
 #include <vector>
 
@@ -10,6 +12,7 @@
 #include <log_surgeon/SchemaParser.hpp>
 
 using std::string;
+using std::u32string;
 using std::vector;
 
 using RegexASTCatByte = log_surgeon::finite_automata::RegexASTCat<
@@ -26,6 +29,46 @@ using RegexASTOrByte
         = log_surgeon::finite_automata::RegexASTOr<log_surgeon::finite_automata::RegexNFAByteState>;
 using log_surgeon::SchemaVarAST;
 
+auto test_regex_ast(string const& regex, u32string const& expected_serialized_ast) -> void {
+    log_surgeon::Schema schema;
+    schema.add_variable("capture", regex, -1);
+    auto const schema_ast = schema.release_schema_ast_ptr();
+    auto const& capture_rule_ast = dynamic_cast<SchemaVarAST&>(*schema_ast->m_schema_vars[0]);
+
+    auto u32_to_u8 = [](char32_t c) -> std::string {
+        std::string u8;
+        if (c <= 0x7F) {
+            u8 += static_cast<char>(c);
+        } else if (c <= 0x7FF) {
+            u8 += static_cast<char>((c >> 6) | 0xC0);
+            u8 += static_cast<char>((c & 0x3F) | 0x80);
+        } else if (c <= 0xFFFF) {
+            u8 += static_cast<char>((c >> 12) | 0xE0);
+            u8 += static_cast<char>(((c >> 6) & 0x3F) | 0x80);
+            u8 += static_cast<char>((c & 0x3F) | 0x80);
+        } else {
+            u8 += static_cast<char>((c >> 18) | 0xF0);
+            u8 += static_cast<char>(((c >> 12) & 0x3F) | 0x80);
+            u8 += static_cast<char>(((c >> 6) & 0x3F) | 0x80);
+            u8 += static_cast<char>((c & 0x3F) | 0x80);
+        }
+        return u8;
+    };
+
+    auto const actual_u32string = capture_rule_ast.m_regex_ptr->serialize();
+    auto const actual_string = fmt::format(
+            "{}",
+            fmt::join(actual_u32string | std::ranges::views::transform(u32_to_u8), "")
+    );
+
+    auto const expected_string = fmt::format(
+            "{}",
+            fmt::join(expected_serialized_ast | std::ranges::views::transform(u32_to_u8), "")
+    );
+
+    REQUIRE(actual_string == expected_string);
+}
+
 TEST_CASE("Test the Schema class", "[Schema]") {
     SECTION("Add a number variable to schema") {
         log_surgeon::Schema schema;
@@ -92,7 +135,11 @@ TEST_CASE("Test the Schema class", "[Schema]") {
         // This test validates the serialization of a regex AST with named capture groups. The
         // serialized output includes tags (<n> for positive matches, <~n> for negative matches) to
         // indicate which capture groups are matched or unmatched at each node.
-
+        test_regex_ast(
+                "Z|(A(?<letter>((?<letter1>(a)|(b))|(?<letter2>(c)|(d))))B(?<containerID>\\d+)C)",
+                U"(Z<~0><~1><~2><~3>)|(A((((a)|(b))<0><~1>)|(((c)|(d))<1><~0>))<2>B([0-9]{1,inf})<"
+                "3>C)"
+        );
         log_surgeon::Schema schema;
         schema.add_variable(
                 // clang-format off
@@ -126,4 +173,21 @@ TEST_CASE("Test the Schema class", "[Schema]") {
         REQUIRE(capture_rule_ast.m_regex_ptr->serialize()
                 == std::u32string(cExpectedSerializedU32StringWithTags));
     }
+
+    SECTION("Test reptition regex") {
+        // Repetition without capture groups untagged and tagged AST are the same
+        test_regex_ast("a{0,10}", U"()|(a{1,10})");
+        test_regex_ast("a{5,10}", U"a{5,10}");
+        test_regex_ast("a*", U"()|(a{1,inf})");
+        test_regex_ast("a+", U"a{1,inf}");
+
+        // Repetition with capture groups untagged and tagged AST are different
+        test_regex_ast("(?<letter>a){0,10}", U"(<~0>)|((a)<0>{1,10})");
+        test_regex_ast("(?<letter>a){5,10}", U"(a)<0>{5,10}");
+        test_regex_ast("(?<letter>a)*", U"(<~0>)|((a)<0>{1,inf})");
+        test_regex_ast("(?<letter>a)+", U"(a)<0>{1,inf}");
+
+        // Capture group with repetition
+        test_regex_ast("(?<letter>a{0,10})", U"(()|(a{1,10}))<0>");
+    }
 }