Merge branch 'fixed-tagged-dfa' into add-register-to-dfa

Author: SharafMohamed

src/log_surgeon/Lalr1Parser.hpp

@@ -77,7 +77,7 @@ class NonTerminal {
      */
     [[nodiscard]] auto token_cast(uint32_t i) const -> Token* {
         assert(i < cSizeOfAllChildren);
-        return &std::get<Token>(NonTerminal::m_all_children[m_children_start + i]);
+        return &std::get<Token>(m_all_children[m_children_start + i]);
     }
 
     /**
@@ -89,7 +89,7 @@ class NonTerminal {
      */
     [[nodiscard]] auto non_terminal_cast(uint32_t i) const -> NonTerminal* {
         assert(i < cSizeOfAllChildren);
-        return &std::get<NonTerminal>(NonTerminal::m_all_children[m_children_start + i]);
+        return &std::get<NonTerminal>(m_all_children[m_children_start + i]);
     }
 
     /**

src/log_surgeon/Lexer.tpp

@@ -378,7 +378,6 @@ auto Lexer<TypedNfaState, TypedDfaState>::get_rule(uint32_t const variable_id
 template <typename TypedNfaState, typename TypedDfaState>
 void Lexer<TypedNfaState, TypedDfaState>::generate() {
     finite_automata::Nfa<TypedNfaState> nfa{std::move(m_rules)};
-    // TODO: DFA ignores tags. E.g., treats "capture:user=(?<user_id>\d+)" as "capture:user=\d+"
     m_dfa = std::make_unique<finite_automata::Dfa<TypedDfaState>>(std::move(nfa));
     auto const* state = m_dfa->get_root();
     for (uint32_t i = 0; i < cSizeOfByte; i++) {

src/log_surgeon/finite_automata/Dfa.hpp

@@ -11,22 +11,25 @@
 #include <log_surgeon/Constants.hpp>
 #include <log_surgeon/finite_automata/DfaStatePair.hpp>
 #include <log_surgeon/finite_automata/Nfa.hpp>
-#include <log_surgeon/finite_automata/RegisterHandler.hpp>
+#include <log_surgeon/finite_automata/Register.hpp>
 
 namespace log_surgeon::finite_automata {
+template <typename TypedNfaState>
+using NfaStateSet = std::set<RegOpNfaStatePair<TypedNfaState>>;
+
 template <typename TypedDfaState>
 class Dfa {
 public:
-    template <typename NfaStateType>
-    explicit Dfa(Nfa<NfaStateType> nfa);
+    template <typename TypedNfaState>
+    explicit Dfa(Nfa<TypedNfaState> nfa);
 
     /**
      * Creates a new DFA state based on a set of NFA states and adds it to `m_states`.
      * @param nfa_state_set The set of NFA states represented by this DFA state.
      * @return A pointer to the new DFA state.
      */
     template <typename TypedNfaState>
-    auto new_state(std::set<TypedNfaState*> const& nfa_state_set) -> TypedDfaState*;
+    auto new_state(NfaStateSet<TypedNfaState> const& nfa_state_set) -> TypedDfaState*;
 
     auto get_root() const -> TypedDfaState const* { return m_states.at(0).get(); }
 
@@ -42,81 +45,76 @@ class Dfa {
 
 private:
     std::vector<std::unique_ptr<TypedDfaState>> m_states;
+<<<<<<< HEAD
     RegisterHandler m_register_handler;
+=======
+    std::vector<std::unique_ptr<Register>> m_registers;
+>>>>>>> fixed-tagged-dfa
 };
 
+// TODO: Add utf8 case
 template <typename TypedDfaState>
 template <typename TypedNfaState>
 Dfa<TypedDfaState>::Dfa(Nfa<TypedNfaState> nfa) {
-    typedef std::set<TypedNfaState const*> StateSet;
-
-    std::map<StateSet, TypedDfaState*> dfa_states;
-    std::stack<StateSet> unmarked_sets;
-    auto create_dfa_state
-            = [this, &dfa_states, &unmarked_sets](StateSet const& set) -> TypedDfaState* {
-        auto* state = new_state(set);
-        dfa_states[set] = state;
-        unmarked_sets.push(set);
-        return state;
+    std::map<NfaStateSet<TypedNfaState>, TypedDfaState*> dfa_states;
+    std::stack<NfaStateSet<TypedNfaState>> unvisited_nfa_sets;
+    auto create_dfa_state = [this, &dfa_states, &unvisited_nfa_sets](
+                                    NfaStateSet<TypedNfaState> const& nfa_state_set
+                            ) -> TypedDfaState* {
+        TypedDfaState* dfa_state = new_state(nfa_state_set);
+        dfa_states[nfa_state_set] = dfa_state;
+        unvisited_nfa_sets.push(nfa_state_set);
+        return dfa_state;
     };
 
-    auto start_set = nfa.get_root()->epsilon_closure();
-    create_dfa_state(start_set);
-    while (false == unmarked_sets.empty()) {
-        auto set = unmarked_sets.top();
-        unmarked_sets.pop();
-        auto* dfa_state = dfa_states.at(set);
-        std::map<uint32_t, StateSet> ascii_transitions_map;
-        // map<Interval, StateSet> transitions_map;
-        for (auto const* s0 : set) {
+    NfaStateSet<TypedNfaState> const initial_nfa_set = nfa.get_root()->epsilon_closure(m_registers);
+    create_dfa_state(initial_nfa_set);
+    while (!unvisited_nfa_sets.empty()) {
+        NfaStateSet<TypedNfaState> current_nfa_set = unvisited_nfa_sets.top();
+        unvisited_nfa_sets.pop();
+        TypedDfaState* dfa_state = dfa_states.at(current_nfa_set);
+
+        std::map<uint32_t, NfaStateSet<TypedNfaState>> ascii_transitions_map;
+        for (auto const& register_nfa_state_pair : current_nfa_set) {
             for (uint32_t i = 0; i < cSizeOfByte; i++) {
-                for (auto* const s1 : s0->get_byte_transitions(i)) {
-                    StateSet closure = s1->epsilon_closure();
+                for (auto const* s1 : register_nfa_state_pair.get_state()->get_byte_transitions(i))
+                {
+                    NfaStateSet<TypedNfaState> closure = s1->epsilon_closure(m_registers);
                     ascii_transitions_map[i].insert(closure.begin(), closure.end());
                 }
             }
-            // TODO: add this for the utf8 case
-            /*
-            for (auto const& data : s0->get_tree_transitions().all()) {
-                for (auto* const s1 : data.m_value) {
-                    StateSet closure = s1->epsilon_closure();
-                    transitions_map[data.m_interval].insert(closure.begin(), closure.end());
-                }
-            }
-            */
         }
+<<<<<<< HEAD
         auto next_dfa_state
                 = [&dfa_states, &create_dfa_state](StateSet const& set) -> TypedDfaState* {
             TypedDfaState* state{nullptr};
             auto it = dfa_states.find(set);
+=======
+
+        for (typename std::map<uint32_t, NfaStateSet<TypedNfaState>>::value_type const& kv :
+             ascii_transitions_map)
+        {
+            auto const& dest_nfa_state_set = kv.second;
+            TypedDfaState* dest_state;
+            auto it = dfa_states.find(dest_nfa_state_set);
+>>>>>>> fixed-tagged-dfa
             if (it == dfa_states.end()) {
-                state = create_dfa_state(set);
+                dest_state = create_dfa_state(dest_nfa_state_set);
             } else {
-                state = it->second;
+                dest_state = it->second;
             }
-            return state;
-        };
-        for (auto const& kv : ascii_transitions_map) {
-            auto* dest_state = next_dfa_state(kv.second);
             dfa_state->add_byte_transition(kv.first, dest_state);
         }
-        // TODO: add this for the utf8 case
-        /*
-        for (auto& kv : transitions_map) {
-            TypedDfaState* dest_state = next_dfa_state(kv.second);
-            dfa_state->add_tree_transition(kv.first, dest_state);
-        }
-        */
     }
 }
 
 template <typename TypedDfaState>
 template <typename TypedNfaState>
-auto Dfa<TypedDfaState>::new_state(std::set<TypedNfaState*> const& nfa_state_set
-) -> TypedDfaState* {
+auto Dfa<TypedDfaState>::new_state(NfaStateSet<TypedNfaState> const& nfa_state_set) -> TypedDfaState* {
     m_states.emplace_back(std::make_unique<TypedDfaState>());
     auto* dfa_state = m_states.back().get();
-    for (auto const* nfa_state : nfa_state_set) {
+    for (auto const& register_nfa_state_pair : nfa_state_set) {
+        auto const* nfa_state = register_nfa_state_pair.get_state();
         if (nfa_state->is_accepting()) {
             dfa_state->add_matching_variable_id(nfa_state->get_matching_variable_id());
         }

src/log_surgeon/finite_automata/DfaState.hpp

@@ -8,18 +8,18 @@
 #include <type_traits>
 #include <vector>
 
+#include <log_surgeon/finite_automata/StateType.hpp>
 #include <log_surgeon/Constants.hpp>
-#include <log_surgeon/finite_automata/DfaStateType.hpp>
 #include <log_surgeon/finite_automata/UnicodeIntervalTree.hpp>
 
 namespace log_surgeon::finite_automata {
-template <DfaStateType state_type>
+template <StateType state_type>
 class DfaState;
 
-using ByteDfaState = DfaState<DfaStateType::Byte>;
-using Utf8DfaState = DfaState<DfaStateType::Utf8>;
+using DfaByteState = DfaState<StateType::Byte>;
+using DfaUtf8State = DfaState<StateType::Utf8>;
 
-template <DfaStateType state_type>
+template <StateType state_type>
 class DfaState {
 public:
     using Tree = UnicodeIntervalTree<DfaState*>;
@@ -51,14 +51,14 @@ class DfaState {
 private:
     std::vector<uint32_t> m_matching_variable_ids;
     DfaState* m_bytes_transition[cSizeOfByte];
-    // NOTE: We don't need m_tree_transitions for the `state_type == DfaStateType::Byte` case, so we
-    // use an empty class (`std::tuple<>`) in that case.
-    std::conditional_t<state_type == DfaStateType::Utf8, Tree, std::tuple<>> m_tree_transitions;
+    // NOTE: We don't need m_tree_transitions for the `stateType == StateType::Byte` case, so we use
+    // an empty class (`std::tuple<>`) in that case.
+    std::conditional_t<state_type == StateType::Utf8, Tree, std::tuple<>> m_tree_transitions;
 };
 
-template <DfaStateType state_type>
+template <StateType state_type>
 auto DfaState<state_type>::next(uint32_t character) const -> DfaState* {
-    if constexpr (DfaStateType::Byte == state_type) {
+    if constexpr (StateType::Byte == state_type) {
         return m_bytes_transition[character];
     } else {
         if (character < cSizeOfByte) {

src/log_surgeon/finite_automata/DfaStatePair.hpp

@@ -27,7 +27,6 @@ class DfaStatePair {
               m_state2(state2) {};
 
     /**
-     * Used for ordering in a set by considering the states' addresses.
      * @param rhs
      * @return Whether `m_state1` in lhs has a lower address than in rhs, or if they're equal,
      * whether `m_state2` in lhs has a lower address than in rhs.
@@ -73,7 +72,7 @@ auto DfaStatePair<TypedDfaState>::get_reachable_pairs(
         auto next_state1 = m_state1->next(i);
         auto next_state2 = m_state2->next(i);
         if (next_state1 != nullptr && next_state2 != nullptr) {
-            DfaStatePair reachable_pair{next_state1, next_state2};
+            DfaStatePair const reachable_pair{next_state1, next_state2};
             if (visited_pairs.count(reachable_pair) == 0) {
                 unvisited_pairs.insert(reachable_pair);
             }