refactor: Move epsilon_closure and nfa_to_dfa from Lexer class to Dfa class.

CMakeLists.txt

@@ -68,9 +68,9 @@ set(SOURCE_FILES
     src/log_surgeon/Constants.hpp
     src/log_surgeon/FileReader.cpp
     src/log_surgeon/FileReader.hpp
-    src/log_surgeon/LALR1Parser.cpp
-    src/log_surgeon/LALR1Parser.hpp
-    src/log_surgeon/LALR1Parser.tpp
+    src/log_surgeon/Lalr1Parser.cpp
+    src/log_surgeon/Lalr1Parser.hpp
+    src/log_surgeon/Lalr1Parser.tpp
     src/log_surgeon/Lexer.hpp
     src/log_surgeon/Lexer.tpp
     src/log_surgeon/LexicalRule.hpp
@@ -96,11 +96,13 @@ set(SOURCE_FILES
     src/log_surgeon/finite_automata/PrefixTree.cpp
     src/log_surgeon/finite_automata/PrefixTree.hpp
     src/log_surgeon/finite_automata/RegexAST.hpp
-    src/log_surgeon/finite_automata/RegexDFA.hpp
-    src/log_surgeon/finite_automata/RegexDFA.tpp
-    src/log_surgeon/finite_automata/RegexNFA.hpp
-    src/log_surgeon/finite_automata/RegexNFAState.hpp
-    src/log_surgeon/finite_automata/RegexNFAStateType.hpp
+    src/log_surgeon/finite_automata/Dfa.hpp
+    src/log_surgeon/finite_automata/DfaState.hpp
+    src/log_surgeon/finite_automata/DfaStatePair.hpp
+    src/log_surgeon/finite_automata/DfaStateType.hpp
+    src/log_surgeon/finite_automata/Nfa.hpp
+    src/log_surgeon/finite_automata/NfaState.hpp
+    src/log_surgeon/finite_automata/NfaStateType.hpp
     src/log_surgeon/finite_automata/RegisterHandler.hpp
     src/log_surgeon/finite_automata/Tag.hpp
     src/log_surgeon/finite_automata/TaggedTransition.hpp

examples/intersect-test.cpp

@@ -5,10 +5,10 @@
 #include <log_surgeon/Lexer.hpp>
 #include <log_surgeon/Schema.hpp>
 
-using log_surgeon::finite_automata::RegexDFA;
-using log_surgeon::finite_automata::RegexDFAByteState;
-using log_surgeon::finite_automata::RegexNFA;
-using log_surgeon::finite_automata::RegexNFAByteState;
+using log_surgeon::finite_automata::ByteDfaState;
+using log_surgeon::finite_automata::ByteNfaState;
+using log_surgeon::finite_automata::Dfa;
+using log_surgeon::finite_automata::Nfa;
 using log_surgeon::lexers::ByteLexer;
 using log_surgeon::LexicalRule;
 using log_surgeon::ParserAST;
@@ -17,11 +17,11 @@ using std::string;
 using std::unique_ptr;
 using std::vector;
 
-using ByteLexicalRule = log_surgeon::LexicalRule<RegexNFAByteState>;
+using ByteLexicalRule = log_surgeon::LexicalRule<ByteNfaState>;
 
 auto get_intersect_for_query(
         std::map<uint32_t, std::string>& m_id_symbol,
-        std::unique_ptr<RegexDFA<RegexDFAByteState>>& dfa1,
+        std::unique_ptr<Dfa<ByteDfaState>>& dfa1,
         std::string const& search_string
 ) -> void {
     std::string processed_search_string;
@@ -40,9 +40,9 @@ auto get_intersect_for_query(
         auto* schema_var_ast = dynamic_cast<SchemaVarAST*>(parser_ast.get());
         rules.emplace_back(0, std::move(schema_var_ast->m_regex_ptr));
     }
-    RegexNFA<RegexNFAByteState> nfa(std::move(rules));
-    auto dfa2 = ByteLexer::nfa_to_dfa(nfa);
-    auto schema_types = dfa1->get_intersect(dfa2);
+    Nfa<ByteNfaState> nfa(std::move(rules));
+    Dfa dfa2(nfa);
+    auto schema_types = dfa1->get_intersect(dfa2.get());
     std::cout << search_string << ":";
     for (auto const& schema_type : schema_types) {
         std::cout << m_id_symbol[schema_type] << ",";
@@ -78,8 +78,8 @@ auto main() -> int {
             rules.emplace_back(m_id_symbol.size(), std::move(var_ast->m_regex_ptr));
             m_id_symbol[m_id_symbol.size()] = var_ast->m_name;
         }
-        RegexNFA<RegexNFAByteState> nfa(std::move(rules));
-        auto dfa = ByteLexer::nfa_to_dfa(nfa);
+        Nfa<ByteNfaState> nfa(std::move(rules));
+        Dfa dfa(nfa);
         get_intersect_for_query(m_id_symbol, dfa, "*1*");
         get_intersect_for_query(m_id_symbol, dfa, "*a*");
         get_intersect_for_query(m_id_symbol, dfa, "*a1*");

src/log_surgeon/Buffer.hpp

@@ -72,8 +72,8 @@ class Buffer {
     // Currently needed for compression
     [[nodiscard]] auto get_mutable_active_buffer() -> Item* { return m_active_storage; }
 
-    void
-    copy(Item const* storage_to_copy_first, Item const* storage_to_copy_last, uint32_t offset) {
+    auto copy(Item const* storage_to_copy_first, Item const* storage_to_copy_last, uint32_t offset)
+            -> void {
         std::copy(storage_to_copy_first, storage_to_copy_last, m_active_storage + offset);
     }
 

src/log_surgeon/BufferParser.hpp

@@ -20,7 +20,7 @@ class BufferParser {
     /**
      * Constructs the parser using the given schema file.
      * @param schema_file_path
-     * @throw std::runtime_error from LALR1Parser, RegexAST, or Lexer
+     * @throw std::runtime_error from Lalr1Parser, RegexAST, or Lexer
      * describing the failure parsing the schema file or processing the schema
      * AST.
      */
@@ -29,7 +29,7 @@ class BufferParser {
     /**
      * Constructs the parser using the given schema AST.
      * @param schema_ast
-     * @throw std::runtime_error from LALR1Parser, RegexAST, or Lexer
+     * @throw std::runtime_error from Lalr1Parser, RegexAST, or Lexer
      * describing the failure processing the schema AST.
      */
     explicit BufferParser(std::unique_ptr<log_surgeon::SchemaAST> schema_ast);

src/log_surgeon/LALR1Parser.cpp → src/log_surgeon/Lalr1Parser.cpp

@@ -1,4 +1,4 @@
-#include "LALR1Parser.hpp"
+#include "Lalr1Parser.hpp"
 
 namespace log_surgeon {
 MatchedSymbol NonTerminal::m_all_children[cSizeOfAllChildren];
@@ -8,9 +8,9 @@ ParserAST::~ParserAST() = default;
 uint32_t NonTerminal::m_next_children_start = 0;
 
 NonTerminal::NonTerminal(Production* p)
-        : m_children_start(NonTerminal::m_next_children_start),
+        : m_children_start(m_next_children_start),
           m_production(p),
           m_ast(nullptr) {
-    NonTerminal::m_next_children_start += p->m_body.size();
+    m_next_children_start += p->m_body.size();
 }
 }  // namespace log_surgeon

src/log_surgeon/LALR1Parser.hpp → src/log_surgeon/Lalr1Parser.hpp

@@ -120,7 +120,7 @@ struct Production {
      * has nothing on its LHS (i.e., HEAD -> {})
      * @return bool
      */
-    [[nodiscard]] auto is_epsilon() const -> bool { return this->m_body.empty(); }
+    [[nodiscard]] auto is_epsilon() const -> bool { return m_body.empty(); }
 
     uint32_t m_index;
     uint32_t m_head;
@@ -158,16 +158,14 @@ struct Item {
      * @return bool
      */
     [[nodiscard]] auto has_dot_at_end() const -> bool {
-        return this->m_dot == this->m_production->m_body.size();
+        return m_dot == m_production->m_body.size();
     }
 
     /**
      * Returns the next unmatched symbol in the production based on the dot.
      * @return uint32_t
      */
-    [[nodiscard]] auto next_symbol() const -> uint32_t {
-        return this->m_production->m_body.at(this->m_dot);
-    }
+    [[nodiscard]] auto next_symbol() const -> uint32_t { return m_production->m_body.at(m_dot); }
 
     Production* m_production;
     uint32_t m_dot;
@@ -202,10 +200,10 @@ struct ItemSet {
     std::vector<Action> m_actions;
 };
 
-template <typename NFAStateType, typename DFAStateType>
-class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
+template <typename TypedNfaState, typename TypedDfaState>
+class Lalr1Parser : public Parser<TypedNfaState, TypedDfaState> {
 public:
-    LALR1Parser();
+    Lalr1Parser();
 
     /**
      * Add a lexical rule to m_lexer
@@ -214,7 +212,7 @@ class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
      */
     auto add_rule(
             std::string const& name,
-            std::unique_ptr<finite_automata::RegexAST<NFAStateType>> rule
+            std::unique_ptr<finite_automata::RegexAST<TypedNfaState>> rule
     ) -> void override;
 
     /**
@@ -224,7 +222,7 @@ class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
      */
     auto add_token_group(
             std::string const& name,
-            std::unique_ptr<finite_automata::RegexASTGroup<NFAStateType>> rule_group
+            std::unique_ptr<finite_automata::RegexASTGroup<TypedNfaState>> rule_group
     ) -> void;
 
     /**
@@ -276,7 +274,7 @@ class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
      */
     auto report_error() -> std::string;
 
-    /* Lexer<NFAStateType, DFAStateType> m_lexer; */
+    /* Lexer<TypedNfaState, TypedDfaState> m_lexer; */
     std::stack<MatchedSymbol> m_parse_stack_matches;
     std::stack<ItemSet*> m_parse_stack_states;
     ItemSet* m_root_item_set_ptr{nullptr};
@@ -396,6 +394,8 @@ class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
 
     auto symbol_is_token(uint32_t s) -> bool { return m_terminals.find(s) != m_terminals.end(); }
 
+    using Parser<TypedNfaState, TypedDfaState>::m_lexer;
+
     std::set<uint32_t> m_terminals;
     std::set<uint32_t> m_nullable;
     std::map<std::set<Item>, std::unique_ptr<ItemSet>> m_lr0_item_sets;
@@ -407,6 +407,6 @@ class LALR1Parser : public Parser<NFAStateType, DFAStateType> {
 };
 }  // namespace log_surgeon
 
-#include "LALR1Parser.tpp"
+#include "Lalr1Parser.tpp"
 
 #endif  // LOG_SURGEON_LALR1_PARSER_HPP