From 534097b520e3fd608be08b55c72db87d68e3b317 Mon Sep 17 00:00:00 2001
From: davidlion <david.lion@yscope.com>
Date: Thu, 28 Aug 2025 11:55:20 -0400
Subject: [PATCH 1/6] fix(clang-format): Re-order header include priorities
 such that external headers appear before the project's headers.

---
 .gitignore        | 2 ++
 src/.clang-format | 8 ++------
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 09944214..2ad978ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
+.clang-format
+.clang-tidy
 .task/
 build/
diff --git a/src/.clang-format b/src/.clang-format
index 09c44902..d371375d 100644
--- a/src/.clang-format
+++ b/src/.clang-format
@@ -6,11 +6,11 @@ IncludeCategories:
 
   # Project library headers
   - Regex: "^<log_surgeon"
-    Priority: 3
+    Priority: 4
 
   # External library headers. Update when adding new libraries.
   - Regex: "^<(fmt|gsl)"
-    Priority: 4
+    Priority: 3
 
   # C system headers
   - Regex: "^<.+\\.h>"
@@ -19,7 +19,3 @@ IncludeCategories:
   # C++ standard libraries
   - Regex: "^<.+>"
     Priority: 2
-
-  # Project relative headers
-  - Regex: "^\".+\""
-    Priority: 5

From f607b1caca7cf101818845af2e54e6c3da8b4d3f Mon Sep 17 00:00:00 2001
From: davidlion <david.lion@yscope.com>
Date: Thu, 28 Aug 2025 11:59:09 -0400
Subject: [PATCH 2/6] Apply clang-format.

---
 examples/buffer-parser.cpp                    | 32 ++-----
 examples/common.cpp                           |  4 +-
 examples/intersect-test.cpp                   |  8 +-
 examples/reader-parser.cpp                    | 20 +---
 src/log_surgeon/BufferParser.cpp              |  4 +-
 src/log_surgeon/FileReader.cpp                | 32 ++-----
 src/log_surgeon/Lalr1Parser.tpp               | 92 +++++--------------
 src/log_surgeon/Lexer.hpp                     | 16 +---
 src/log_surgeon/Lexer.tpp                     | 20 +---
 src/log_surgeon/LogEvent.cpp                  | 20 +---
 src/log_surgeon/LogParser.cpp                 | 32 ++-----
 src/log_surgeon/ParserInputBuffer.cpp         | 24 ++---
 src/log_surgeon/ParserInputBuffer.hpp         |  4 +-
 src/log_surgeon/ReaderParser.cpp              |  4 +-
 src/log_surgeon/SchemaParser.cpp              | 12 +--
 src/log_surgeon/Token.cpp                     | 20 +---
 .../DeterminizationConfiguration.hpp          | 12 +--
 src/log_surgeon/finite_automata/Dfa.hpp       | 38 +++-----
 src/log_surgeon/finite_automata/DfaState.hpp  | 14 +--
 .../finite_automata/DfaStatePair.hpp          |  4 +-
 .../finite_automata/DfaTransition.hpp         | 14 +--
 src/log_surgeon/finite_automata/Nfa.hpp       | 22 ++---
 .../NfaSpontaneousTransition.hpp              |  8 +-
 src/log_surgeon/finite_automata/NfaState.hpp  | 22 ++---
 .../finite_automata/PrefixTree.cpp            |  4 +-
 src/log_surgeon/finite_automata/RegexAST.hpp  | 62 ++++---------
 .../finite_automata/RegisterOperation.hpp     |  8 +-
 .../finite_automata/TagOperation.hpp          |  4 +-
 .../finite_automata/UnicodeIntervalTree.tpp   | 68 ++++----------
 src/log_surgeon/utils.hpp                     |  8 +-
 .../wildcard_query_parser/ExpressionView.cpp  | 16 +---
 .../QueryInterpretation.cpp                   | 22 ++---
 .../VariableQueryToken.cpp                    |  8 +-
 tests/test-buffer-parser.cpp                  | 16 +---
 tests/test-dfa.cpp                            |  4 +-
 35 files changed, 189 insertions(+), 509 deletions(-)

diff --git a/examples/buffer-parser.cpp b/examples/buffer-parser.cpp
index d6e7fe12..bd141b9f 100644
--- a/examples/buffer-parser.cpp
+++ b/examples/buffer-parser.cpp
@@ -17,9 +17,7 @@ using namespace log_surgeon;
 auto process_logs(string const& schema_path, string const& input_path) -> void {
     BufferParser parser{schema_path};
     optional<uint32_t> loglevel_id{parser.get_variable_id("loglevel")};
-    if (false == loglevel_id.has_value()) {
-        throw runtime_error("No 'loglevel' in schema.");
-    }
+    if (false == loglevel_id.has_value()) { throw runtime_error("No 'loglevel' in schema."); }
 
     ifstream infs{input_path, ios::binary | ios::in};
     if (!infs.is_open()) {
@@ -32,9 +30,7 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
     infs.read(buf.data(), cSize);
     ssize_t valid_size{infs.gcount()};
     bool input_done{false};
-    if (infs.eof()) {
-        input_done = true;
-    }
+    if (infs.eof()) { input_done = true; }
     parser.reset();
 
     cout << "# Parsing timestamp and loglevel for each log event in " << input_path << ":" << endl;
@@ -47,12 +43,8 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         {
             // The only expected error is the parser has read to the bound
             // of the buffer.
-            if (ErrorCode::BufferOutOfBounds != err) {
-                throw runtime_error("Parsing Failed.");
-            }
-            if (input_done) {
-                break;
-            }
+            if (ErrorCode::BufferOutOfBounds != err) { throw runtime_error("Parsing Failed."); }
+            if (input_done) { break; }
 
             // If the offset is 0 the parser has not found the end of the
             // log event in the entire buffer, so we make it larger.
@@ -68,9 +60,7 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
 
             infs.read(&*(buf.begin() + valid_size), buf.size() - valid_size);
             ssize_t read{infs.gcount()};
-            if (infs.eof()) {
-                input_done = true;
-            }
+            if (infs.eof()) { input_done = true; }
             valid_size += read;
             continue;
         }
@@ -79,22 +69,16 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         cout << "log: " << event.to_string() << endl;
         print_timestamp_loglevel(event, *loglevel_id);
         cout << "logtype: " << event.get_logtype() << endl;
-        if (event.is_multiline()) {
-            multiline_logs.emplace_back(event);
-        }
+        if (event.is_multiline()) { multiline_logs.emplace_back(event); }
     }
 
     cout << endl << "# Printing multiline logs:" << endl;
-    for (auto const& log : multiline_logs) {
-        cout << log.to_string() << endl;
-    }
+    for (auto const& log : multiline_logs) { cout << log.to_string() << endl; }
 }
 
 auto main(int argc, char* argv[]) -> int {
     std::vector<std::string> const args(argv + 1, argv + argc);
-    if (int const err{check_input(args)}; 0 != err) {
-        return err;
-    }
+    if (int const err{check_input(args)}; 0 != err) { return err; }
     process_logs(args[0], args[1]);
     return 0;
 }
diff --git a/examples/common.cpp b/examples/common.cpp
index 094762b5..884ab301 100644
--- a/examples/common.cpp
+++ b/examples/common.cpp
@@ -24,9 +24,7 @@ auto check_input(std::vector<std::string> const& args) -> int {
         ret = 3;
         cout << "Input file does not exist.\n";
     }
-    if (0 != ret) {
-        cout << "usage: <path to schema file> <path to input log file>\n";
-    }
+    if (0 != ret) { cout << "usage: <path to schema file> <path to input log file>\n"; }
     return ret;
 }
 
diff --git a/examples/intersect-test.cpp b/examples/intersect-test.cpp
index 20d8bb68..007b74b1 100644
--- a/examples/intersect-test.cpp
+++ b/examples/intersect-test.cpp
@@ -27,9 +27,7 @@ auto get_intersect_for_query(
     std::string processed_search_string;
     // Replace all * with .*
     for (char const& c : search_string) {
-        if (c == '*') {
-            processed_search_string.push_back('.');
-        }
+        if (c == '*') { processed_search_string.push_back('.'); }
         processed_search_string.push_back(c);
     }
     log_surgeon::Schema schema;
@@ -44,9 +42,7 @@ auto get_intersect_for_query(
     Dfa<ByteDfaState, ByteNfaState> dfa2(nfa);
     auto schema_types = dfa1.get_intersect(&dfa2);
     std::cout << search_string << ":";
-    for (auto const& schema_type : schema_types) {
-        std::cout << m_id_symbol[schema_type] << ",";
-    }
+    for (auto const& schema_type : schema_types) { std::cout << m_id_symbol[schema_type] << ","; }
     std::cout << std::endl;
 }
 
diff --git a/examples/reader-parser.cpp b/examples/reader-parser.cpp
index 5f896e9a..648cc72f 100644
--- a/examples/reader-parser.cpp
+++ b/examples/reader-parser.cpp
@@ -16,9 +16,7 @@ using namespace log_surgeon;
 auto process_logs(string const& schema_path, string const& input_path) -> void {
     ReaderParser parser{schema_path};
     optional<uint32_t> loglevel_id{parser.get_variable_id("loglevel")};
-    if (false == loglevel_id.has_value()) {
-        throw runtime_error("No 'loglevel' in schema.");
-    }
+    if (false == loglevel_id.has_value()) { throw runtime_error("No 'loglevel' in schema."); }
 
     ifstream infs{input_path, ios::binary | ios::in};
     if (!infs.is_open()) {
@@ -29,9 +27,7 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
     Reader reader{[&](char* buf, size_t count, size_t& read_to) -> ErrorCode {
         infs.read(buf, count);
         read_to = infs.gcount();
-        if (0 == read_to && infs.eof()) {
-            return ErrorCode::EndOfFile;
-        }
+        if (0 == read_to && infs.eof()) { return ErrorCode::EndOfFile; }
         return ErrorCode::Success;
     }};
     parser.reset_and_set_reader(reader);
@@ -48,22 +44,16 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         cout << "log: " << event.to_string() << endl;
         print_timestamp_loglevel(event, *loglevel_id);
         cout << "logtype: " << event.get_logtype() << endl;
-        if (event.is_multiline()) {
-            multiline_logs.emplace_back(event);
-        }
+        if (event.is_multiline()) { multiline_logs.emplace_back(event); }
     }
 
     cout << endl << "# Printing multiline logs:" << endl;
-    for (auto const& log : multiline_logs) {
-        cout << log.to_string() << endl;
-    }
+    for (auto const& log : multiline_logs) { cout << log.to_string() << endl; }
 }
 
 auto main(int argc, char* argv[]) -> int {
     std::vector<std::string> const args(argv + 1, argv + argc);
-    if (int const err{check_input(args)}; 0 != err) {
-        return err;
-    }
+    if (int const err{check_input(args)}; 0 != err) { return err; }
     process_logs(args[0], args[1]);
     return 0;
 }
diff --git a/src/log_surgeon/BufferParser.cpp b/src/log_surgeon/BufferParser.cpp
index d69a04b8..28ef8c6e 100644
--- a/src/log_surgeon/BufferParser.cpp
+++ b/src/log_surgeon/BufferParser.cpp
@@ -37,9 +37,7 @@ BufferParser::parse_next_event(char* buf, size_t size, size_t& offset, bool fini
         reset();
         return error_code;
     }
-    if (LogParser::ParsingAction::CompressAndFinish == parsing_action) {
-        m_done = true;
-    }
+    if (LogParser::ParsingAction::CompressAndFinish == parsing_action) { m_done = true; }
     offset = m_log_parser.get_input_pos();
     return ErrorCode::Success;
 }
diff --git a/src/log_surgeon/FileReader.cpp b/src/log_surgeon/FileReader.cpp
index edaa2b30..01c7f7f9 100644
--- a/src/log_surgeon/FileReader.cpp
+++ b/src/log_surgeon/FileReader.cpp
@@ -16,21 +16,13 @@ FileReader::~FileReader() {
 }
 
 auto FileReader::read(char* buf, size_t num_bytes_to_read, size_t& num_bytes_read) -> ErrorCode {
-    if (nullptr == m_file) {
-        return ErrorCode::NotInit;
-    }
-    if (nullptr == buf) {
-        return ErrorCode::BadParam;
-    }
+    if (nullptr == m_file) { return ErrorCode::NotInit; }
+    if (nullptr == buf) { return ErrorCode::BadParam; }
     num_bytes_read = fread(buf, sizeof(*buf), num_bytes_to_read, m_file);
     if (num_bytes_read < num_bytes_to_read) {
-        if (0 != ferror(m_file)) {
-            return ErrorCode::Errno;
-        }
+        if (0 != ferror(m_file)) { return ErrorCode::Errno; }
         if (0 != feof(m_file)) {
-            if (0 == num_bytes_read) {
-                return ErrorCode::EndOfFile;
-            }
+            if (0 == num_bytes_read) { return ErrorCode::EndOfFile; }
         }
     }
     return ErrorCode::Success;
@@ -41,9 +33,7 @@ auto FileReader::try_open(string const& path) -> ErrorCode {
     close();
     m_file = fopen(path.c_str(), "rb");
     if (nullptr == m_file) {
-        if (ENOENT == errno) {
-            return ErrorCode::FileNotFound;
-        }
+        if (ENOENT == errno) { return ErrorCode::FileNotFound; }
         return ErrorCode::Errno;
     }
     return ErrorCode::Success;
@@ -61,17 +51,11 @@ auto FileReader::close() -> void {
 auto FileReader::try_read_to_delimiter(char delim, bool keep_delimiter, bool append, string& str)
         -> ErrorCode {
     assert(nullptr != m_file);
-    if (false == append) {
-        str.clear();
-    }
+    if (false == append) { str.clear(); }
     ssize_t num_bytes_read = getdelim(&m_get_delim_buf, &m_get_delim_buf_len, delim, m_file);
     if (num_bytes_read < 1) {
-        if (0 != ferror(m_file)) {
-            return ErrorCode::Errno;
-        }
-        if (0 != feof(m_file)) {
-            return ErrorCode::EndOfFile;
-        }
+        if (0 != ferror(m_file)) { return ErrorCode::Errno; }
+        if (0 != feof(m_file)) { return ErrorCode::EndOfFile; }
     }
     if (false == keep_delimiter && delim == m_get_delim_buf[num_bytes_read - 1]) {
         --num_bytes_read;
diff --git a/src/log_surgeon/Lalr1Parser.tpp b/src/log_surgeon/Lalr1Parser.tpp
index 842ad207..5da9512a 100644
--- a/src/log_surgeon/Lalr1Parser.tpp
+++ b/src/log_surgeon/Lalr1Parser.tpp
@@ -178,16 +178,12 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr0_kernels() -> void {
         generate_lr0_closure(item_set_ptr);
         for (auto const& next_symbol : m_terminals) {
             auto* new_item_set_ptr = go_to(item_set_ptr, next_symbol);
-            if (new_item_set_ptr != nullptr) {
-                unused_item_sets.push_back(new_item_set_ptr);
-            }
+            if (new_item_set_ptr != nullptr) { unused_item_sets.push_back(new_item_set_ptr); }
         }
         for (auto const& kv : m_non_terminals) {
             auto next_symbol = kv.first;
             auto* new_item_set_ptr = go_to(item_set_ptr, next_symbol);
-            if (new_item_set_ptr != nullptr) {
-                unused_item_sets.push_back(new_item_set_ptr);
-            }
+            if (new_item_set_ptr != nullptr) { unused_item_sets.push_back(new_item_set_ptr); }
         }
     }
 }
@@ -199,16 +195,10 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::lr_closure_helper(
         uint32_t* next_symbol
 ) -> bool {
     // add {S'->(dot)S, ""}
-    if (!item_set_ptr->m_closure.insert(*item).second) {
-        return true;
-    }
-    if (item->has_dot_at_end()) {
-        return true;
-    }
+    if (!item_set_ptr->m_closure.insert(*item).second) { return true; }
+    if (item->has_dot_at_end()) { return true; }
     *next_symbol = item->next_symbol();
-    if (symbol_is_token(*next_symbol)) {
-        return true;
-    }
+    if (symbol_is_token(*next_symbol)) { return true; }
     return false;
 }
 
@@ -223,12 +213,8 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr0_closure(ItemSet* it
         auto item = q.back();  // {S'->(dot)S, ""}
         q.pop_back();
         uint32_t next_symbol = 0;
-        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) {
-            continue;
-        }
-        if (m_non_terminals.find(next_symbol) == m_non_terminals.end()) {
-            assert(false);
-        }
+        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) { continue; }
+        if (m_non_terminals.find(next_symbol) == m_non_terminals.end()) { assert(false); }
         for (Production* const p : m_non_terminals.at(next_symbol)) {
             // S -> a
             q.emplace_back(p, 0, cNullSymbol);  // {S -> (dot) a, ""}
@@ -244,17 +230,13 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::go_to(
     auto next_item_set_ptr = std::make_unique<ItemSet>();
     assert(from_item_set != nullptr);
     for (auto const& item : from_item_set->m_closure) {
-        if (item.has_dot_at_end()) {
-            continue;
-        }
+        if (item.has_dot_at_end()) { continue; }
         if (item.next_symbol() == next_symbol) {
             next_item_set_ptr->m_kernel
                     .emplace(item.m_production, item.m_dot + 1, item.m_lookahead);
         }
     }
-    if (next_item_set_ptr->m_kernel.empty()) {
-        return nullptr;
-    }
+    if (next_item_set_ptr->m_kernel.empty()) { return nullptr; }
     if (m_lr0_item_sets.find(next_item_set_ptr->m_kernel) != m_lr0_item_sets.end()) {
         auto* existing_item_set_ptr = m_lr0_item_sets[next_item_set_ptr->m_kernel].get();
         m_go_to_table[from_item_set->m_index][next_symbol] = existing_item_set_ptr->m_index;
@@ -288,14 +270,10 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_first_sets() -> void {
             for (auto const& s : p->m_body) {
                 auto& f2 = m_firsts[s];
                 f.insert(f2.begin(), f2.end());
-                if (m_nullable.find(s) == m_nullable.end()) {
-                    break;
-                }
+                if (m_nullable.find(s) == m_nullable.end()) { break; }
                 i++;
             }
-            if (i == p->m_body.size()) {
-                changed = changed || m_nullable.insert(p->m_head).second;
-            }
+            if (i == p->m_body.size()) { changed = changed || m_nullable.insert(p->m_head).second; }
             changed = changed || (f.size() != old);
         }
     }
@@ -386,9 +364,7 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr1_closure(ItemSet* it
         auto item = queue.back();
         queue.pop_back();
         uint32_t next_symbol = 0;
-        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) {
-            continue;
-        }
+        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) { continue; }
         std::vector<uint32_t> lookaheads;
         auto pos = item.m_dot + 1;
         while (pos < item.m_production->m_body.size()) {
@@ -399,18 +375,12 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr1_closure(ItemSet* it
                     std::make_move_iterator(symbol_firsts.begin()),
                     std::make_move_iterator(symbol_firsts.end())
             );
-            if (m_nullable.find(symbol) == m_nullable.end()) {
-                break;
-            }
+            if (m_nullable.find(symbol) == m_nullable.end()) { break; }
             pos++;
         }
-        if (pos == item.m_production->m_body.size()) {
-            lookaheads.push_back(item.m_lookahead);
-        }
+        if (pos == item.m_production->m_body.size()) { lookaheads.push_back(item.m_lookahead); }
         for (auto* const p : m_non_terminals.at(next_symbol)) {
-            for (auto const l : lookaheads) {
-                queue.emplace_back(p, 0, l);
-            }
+            for (auto const l : lookaheads) { queue.emplace_back(p, 0, l); }
         }
     }
 }
@@ -586,9 +556,7 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::report_error() -> std::string {
     std::string error_indicator;
     auto error_token = token;
     auto rest_of_line = get_input_until_next_newline(&error_token);
-    for (uint32_t i = 0; i < consumed_input.size() + 10; i++) {
-        error_indicator += " ";
-    }
+    for (uint32_t i = 0; i < consumed_input.size() + 10; i++) { error_indicator += " "; }
     error_indicator += "^\n";
     if (token.m_type_ids_ptr->at(0) == (uint32_t)SymbolId::TokenEnd && consumed_input.empty()) {
         error_type = "empty file";
@@ -617,9 +585,7 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::report_error() -> std::string {
     auto error_string = "Schema:" + std::to_string(line_num + 1) + ":"
                         + std::to_string(consumed_input.size() + 1) + ": error: " + error_type
                         + "\n";
-    for (int i = 0; i < 10; i++) {
-        error_string += " ";
-    }
+    for (int i = 0; i < 10; i++) { error_string += " "; }
     error_string += consumed_input + error_token.to_string() + rest_of_line + error_indicator;
     return error_string;
 }
@@ -632,13 +598,9 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse(Reader& reader) -> NonTerm
     while (true) {
         m_input_buffer.read_if_safe(reader);
         auto next_terminal = get_next_symbol();
-        if (parse_advance(next_terminal, &accept)) {
-            break;
-        }
-    }
-    if (!accept) {
-        throw std::runtime_error(report_error());
+        if (parse_advance(next_terminal, &accept)) { break; }
     }
+    if (!accept) { throw std::runtime_error(report_error()); }
     assert(!m_parse_stack_matches.empty());
     MatchedSymbol m{std::move(m_parse_stack_matches.top())};
     m_parse_stack_matches.pop();
@@ -649,12 +611,8 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse(Reader& reader) -> NonTerm
 template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::reset() -> void {
     m_next_token = std::nullopt;
-    while (!m_parse_stack_states.empty()) {
-        m_parse_stack_states.pop();
-    }
-    while (!m_parse_stack_matches.empty()) {
-        m_parse_stack_matches.pop();
-    }
+    while (!m_parse_stack_states.empty()) { m_parse_stack_states.pop(); }
+    while (!m_parse_stack_matches.empty()) { m_parse_stack_matches.pop(); }
     m_input_buffer.reset();
     m_lexer.reset();
 }
@@ -663,9 +621,7 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::get_next_symbol() -> Token {
     if (m_next_token == std::nullopt) {
         auto [err, optional_token] = m_lexer.scan(m_input_buffer);
-        if (ErrorCode::Success != err) {
-            throw std::runtime_error("Error scanning in lexer.");
-        }
+        if (ErrorCode::Success != err) { throw std::runtime_error("Error scanning in lexer."); }
         return optional_token.value();
     }
     auto s = m_next_token.value();
@@ -677,9 +633,7 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse_advance(Token& next_token, bool* accept)
         -> bool {
     for (auto const type : *next_token.m_type_ids_ptr) {
-        if (parse_symbol(type, next_token, accept)) {
-            return *accept;
-        }
+        if (parse_symbol(type, next_token, accept)) { return *accept; }
     }
     assert(*accept == false);
     // For error handling
diff --git a/src/log_surgeon/Lexer.hpp b/src/log_surgeon/Lexer.hpp
index 78ed68d8..d77b26e9 100644
--- a/src/log_surgeon/Lexer.hpp
+++ b/src/log_surgeon/Lexer.hpp
@@ -198,9 +198,7 @@ class Lexer {
     [[nodiscard]] auto get_reg_id_from_tag_id(tag_id_t const tag_id) const
             -> std::optional<reg_id_t> {
         auto const& tag_id_to_final_reg_id{m_dfa->get_tag_id_to_final_reg_id()};
-        if (tag_id_to_final_reg_id.contains(tag_id)) {
-            return tag_id_to_final_reg_id.at(tag_id);
-        }
+        if (tag_id_to_final_reg_id.contains(tag_id)) { return tag_id_to_final_reg_id.at(tag_id); }
         return std::nullopt;
     }
 
@@ -213,20 +211,14 @@ class Lexer {
     [[nodiscard]] auto get_reg_ids_from_capture_id(capture_id_t const capture_id) const
             -> std::optional<std::pair<reg_id_t, reg_id_t>> {
         auto const optional_tag_id_pair{get_tag_id_pair_from_capture_id(capture_id)};
-        if (false == optional_tag_id_pair.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_tag_id_pair.has_value()) { return std::nullopt; }
         auto const [start_tag_id, end_tag_id]{optional_tag_id_pair.value()};
 
         auto const optional_start_reg_id{get_reg_id_from_tag_id(start_tag_id)};
-        if (false == optional_start_reg_id.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_start_reg_id.has_value()) { return std::nullopt; }
 
         auto const optional_end_reg_id{get_reg_id_from_tag_id(end_tag_id)};
-        if (false == optional_end_reg_id.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_end_reg_id.has_value()) { return std::nullopt; }
 
         return std::make_pair(optional_start_reg_id.value(), optional_end_reg_id.value());
     }
diff --git a/src/log_surgeon/Lexer.tpp b/src/log_surgeon/Lexer.tpp
index d05f7aa7..1966fd8c 100644
--- a/src/log_surgeon/Lexer.tpp
+++ b/src/log_surgeon/Lexer.tpp
@@ -323,9 +323,7 @@ auto Lexer<TypedNfaState, TypedDfaState>::scan_with_wildcard(
                         unvisited_states.pop();
                         visited_states.insert(current_state);
                         for (uint32_t byte = 0; byte < cSizeOfByte; byte++) {
-                            if (m_is_delimiter[byte]) {
-                                continue;
-                            }
+                            if (m_is_delimiter[byte]) { continue; }
                             auto const& optional_wildcard_transition{
                                     current_state->get_transition(byte)
                             };
@@ -366,9 +364,7 @@ auto Lexer<TypedNfaState, TypedDfaState>::increase_buffer_capacity(ParserInputBu
     bool flipped_static_buffer{false};
     input_buffer.increase_capacity(old_storage_size, flipped_static_buffer);
     if (old_storage_size < input_buffer.storage().size()) {
-        if (flipped_static_buffer) {
-            flip_states(old_storage_size);
-        }
+        if (flipped_static_buffer) { flip_states(old_storage_size); }
         if (0 == m_last_match_pos) {
             m_last_match_pos = old_storage_size;
             m_start_pos = old_storage_size;
@@ -407,12 +403,8 @@ template <typename TypedNfaState, typename TypedDfaState>
 void Lexer<TypedNfaState, TypedDfaState>::set_delimiters(std::vector<uint32_t> const& delimiters) {
     assert(!delimiters.empty());
     m_has_delimiters = true;
-    for (auto& i : m_is_delimiter) {
-        i = false;
-    }
-    for (auto delimiter : delimiters) {
-        m_is_delimiter[delimiter] = true;
-    }
+    for (auto& i : m_is_delimiter) { i = false; }
+    for (auto delimiter : delimiters) { m_is_delimiter[delimiter] = true; }
     m_is_delimiter[utf8::cCharStartOfFile] = true;
 }
 
@@ -428,9 +420,7 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lexer<TypedNfaState, TypedDfaState>::get_highest_priority_rule(rule_id_t const rule_id)
         -> finite_automata::RegexAST<TypedNfaState>* {
     for (auto const& rule : m_rules) {
-        if (rule.get_variable_id() == rule_id) {
-            return rule.get_regex();
-        }
+        if (rule.get_variable_id() == rule_id) { return rule.get_regex(); }
     }
     return nullptr;
 }
diff --git a/src/log_surgeon/LogEvent.cpp b/src/log_surgeon/LogEvent.cpp
index fff930f1..0039dd22 100644
--- a/src/log_surgeon/LogEvent.cpp
+++ b/src/log_surgeon/LogEvent.cpp
@@ -21,26 +21,20 @@ auto LogEventView::deep_copy() const -> LogEvent {
 }
 
 auto LogEventView::reset() -> void {
-    for (std::vector<Token*>& log_var_occ : m_log_var_occurrences) {
-        log_var_occ.clear();
-    }
+    for (std::vector<Token*>& log_var_occ : m_log_var_occurrences) { log_var_occ.clear(); }
     m_log_output_buffer->reset();
     m_multiline = false;
 }
 
 [[nodiscard]] auto LogEventView::get_timestamp() const -> Token* {
-    if (m_log_output_buffer->has_timestamp()) {
-        return &m_log_output_buffer->get_mutable_token(0);
-    }
+    if (m_log_output_buffer->has_timestamp()) { return &m_log_output_buffer->get_mutable_token(0); }
     return nullptr;
 }
 
 [[nodiscard]] auto LogEventView::to_string() const -> std::string {
     std::string raw_log;
     uint32_t start = 0;
-    if (false == m_log_output_buffer->has_timestamp()) {
-        start = 1;
-    }
+    if (false == m_log_output_buffer->has_timestamp()) { start = 1; }
     for (uint32_t i = start; i < m_log_output_buffer->pos(); i++) {
         auto& token = m_log_output_buffer->get_mutable_token(i);
         raw_log += token.to_string_view();
@@ -98,17 +92,13 @@ LogEvent::LogEvent(LogEventView const& src) : LogEventView{src.get_log_parser()}
     m_log_output_buffer->set_has_timestamp(src.m_log_output_buffer->has_timestamp());
     m_log_output_buffer->set_has_delimiters(src.m_log_output_buffer->has_delimiters());
     uint32_t start = 0;
-    if (nullptr == src.get_timestamp()) {
-        start = 1;
-    }
+    if (nullptr == src.get_timestamp()) { start = 1; }
     uint32_t buffer_size{0};
     for (uint32_t i = start; i < src.get_log_output_buffer()->pos(); i++) {
         Token const& token = src.get_log_output_buffer()->get_token(i);
         buffer_size += token.get_length();
     }
-    if (0 >= buffer_size) {
-        throw std::runtime_error("token buffer_size <= 0");
-    }
+    if (0 >= buffer_size) { throw std::runtime_error("token buffer_size <= 0"); }
     m_buffer.resize(buffer_size);
     uint32_t curr_pos = 0;
     for (uint32_t i = start; i < src.get_log_output_buffer()->pos(); i++) {
diff --git a/src/log_surgeon/LogParser.cpp b/src/log_surgeon/LogParser.cpp
index 2fee7726..f01a0e2c 100644
--- a/src/log_surgeon/LogParser.cpp
+++ b/src/log_surgeon/LogParser.cpp
@@ -39,20 +39,14 @@ LogParser::LogParser(std::unique_ptr<SchemaAST> schema_ast) {
 
 auto LogParser::set_delimiters(unique_ptr<ParserAST> const& delimiters) -> void {
     auto* delimiters_ptr = dynamic_cast<DelimiterStringAST*>(delimiters.get());
-    if (delimiters_ptr != nullptr) {
-        m_lexer.set_delimiters(delimiters_ptr->m_delimiters);
-    }
+    if (delimiters_ptr != nullptr) { m_lexer.set_delimiters(delimiters_ptr->m_delimiters); }
 }
 
 auto LogParser::add_rules(std::unique_ptr<SchemaAST> schema_ast) -> void {
-    for (auto const& delimiters : schema_ast->m_delimiters) {
-        set_delimiters(delimiters);
-    }
+    for (auto const& delimiters : schema_ast->m_delimiters) { set_delimiters(delimiters); }
     vector<uint32_t> delimiters;
     for (uint32_t i = 0; i < cSizeOfByte; i++) {
-        if (m_lexer.is_delimiter(i)) {
-            delimiters.push_back(i);
-        }
+        if (m_lexer.is_delimiter(i)) { delimiters.push_back(i); }
     }
 
     // Required to have delimiters
@@ -117,9 +111,7 @@ auto LogParser::reset() -> void {
 
 auto LogParser::parse_and_generate_metadata(LogParser::ParsingAction& parsing_action) -> ErrorCode {
     ErrorCode error_code = parse(parsing_action);
-    if (ErrorCode::Success == error_code) {
-        generate_log_event_view_metadata();
-    }
+    if (ErrorCode::Success == error_code) { generate_log_event_view_metadata(); }
     return error_code;
 }
 
@@ -132,9 +124,7 @@ auto LogParser::parse(LogParser::ParsingAction& parsing_action) -> ErrorCode {
             next_token = m_start_of_log_message;
         } else {
             auto [err, optional_next_token] = get_next_symbol();
-            if (ErrorCode::Success != err) {
-                return err;
-            }
+            if (ErrorCode::Success != err) { return err; }
             next_token = optional_next_token.value();
             if (false == output_buffer->has_timestamp()
                 && next_token.m_type_ids_ptr->at(0) == (uint32_t)SymbolId::TokenNewlineTimestamp)
@@ -184,9 +174,7 @@ auto LogParser::parse(LogParser::ParsingAction& parsing_action) -> ErrorCode {
 
     while (true) {
         auto [err, optional_next_token] = get_next_symbol();
-        if (ErrorCode::Success != err) {
-            return err;
-        }
+        if (ErrorCode::Success != err) { return err; }
         Token next_token{optional_next_token.value()};
         output_buffer->set_curr_token(next_token);
         auto token_type = next_token.m_type_ids_ptr->at(0);
@@ -249,16 +237,12 @@ auto LogParser::get_next_symbol() -> std::pair<ErrorCode, std::optional<Token>>
 
 auto LogParser::generate_log_event_view_metadata() -> void {
     uint32_t start = 0;
-    if (false == m_log_event_view->m_log_output_buffer->has_timestamp()) {
-        start = 1;
-    }
+    if (false == m_log_event_view->m_log_output_buffer->has_timestamp()) { start = 1; }
     uint32_t first_newline_pos{0};
     for (uint32_t i = start; i < m_log_event_view->m_log_output_buffer->pos(); i++) {
         Token* token = &m_log_event_view->m_log_output_buffer->get_mutable_token(i);
         m_log_event_view->add_token(token->m_type_ids_ptr->at(0), token);
-        if (token->get_delimiter() == "\n" && first_newline_pos == 0) {
-            first_newline_pos = i;
-        }
+        if (token->get_delimiter() == "\n" && first_newline_pos == 0) { first_newline_pos = i; }
     }
     // To be a multiline log there must be at least one token between the
     // newline token and the last token in the output buffer.
diff --git a/src/log_surgeon/ParserInputBuffer.cpp b/src/log_surgeon/ParserInputBuffer.cpp
index 8fdb70b2..89208ec0 100644
--- a/src/log_surgeon/ParserInputBuffer.cpp
+++ b/src/log_surgeon/ParserInputBuffer.cpp
@@ -19,9 +19,7 @@ auto ParserInputBuffer::reset() -> void {
 }
 
 auto ParserInputBuffer::read_is_safe() -> bool {
-    if (m_finished_reading_input) {
-        return false;
-    }
+    if (m_finished_reading_input) { return false; }
     // Check if the last log message ends in the buffer half last read.
     // This means the other half of the buffer has already been fully used.
     if ((!m_last_read_first_half && m_consumed_pos > m_storage.size() / 2)
@@ -36,28 +34,20 @@ auto ParserInputBuffer::read(Reader& reader) -> ErrorCode {
     size_t bytes_read{0};
     // read into the correct half of the buffer
     uint32_t read_offset{0};
-    if (m_last_read_first_half) {
-        read_offset = m_storage.size() / 2;
-    }
+    if (m_last_read_first_half) { read_offset = m_storage.size() / 2; }
     if (ErrorCode err = m_storage.read(reader, read_offset, m_storage.size() / 2, bytes_read);
         ErrorCode::Success != err)
     {
-        if (ErrorCode::EndOfFile == err) {
-            m_finished_reading_input = true;
-        }
+        if (ErrorCode::EndOfFile == err) { m_finished_reading_input = true; }
         return err;
     }
     m_last_read_first_half = !m_last_read_first_half;
     // TODO: This is not a portable check for certain forms of IO
     // A method from Reader should be used to check if the input source is
     // finished
-    if (bytes_read < m_storage.size() / 2) {
-        m_finished_reading_input = true;
-    }
+    if (bytes_read < m_storage.size() / 2) { m_finished_reading_input = true; }
     m_pos_last_read_char += bytes_read;
-    if (m_pos_last_read_char > m_storage.size()) {
-        m_pos_last_read_char -= m_storage.size();
-    }
+    if (m_pos_last_read_char > m_storage.size()) { m_pos_last_read_char -= m_storage.size(); }
     return ErrorCode::Success;
 }
 
@@ -96,9 +86,7 @@ auto ParserInputBuffer::get_next_character(unsigned char& next_char) -> ErrorCod
     }
     char character = m_storage.get_curr_value();
     m_storage.increment_pos();
-    if (m_storage.pos() == m_storage.size()) {
-        m_storage.set_pos(0);
-    }
+    if (m_storage.pos() == m_storage.size()) { m_storage.set_pos(0); }
     next_char = character;
     return ErrorCode::Success;
 }
diff --git a/src/log_surgeon/ParserInputBuffer.hpp b/src/log_surgeon/ParserInputBuffer.hpp
index 5e50ce0a..df67ff39 100644
--- a/src/log_surgeon/ParserInputBuffer.hpp
+++ b/src/log_surgeon/ParserInputBuffer.hpp
@@ -39,9 +39,7 @@ class ParserInputBuffer {
      * @return ErrorCode forwarded from read.
      */
     auto read_if_safe(Reader& reader) -> ErrorCode {
-        if (read_is_safe()) {
-            return read(reader);
-        }
+        if (read_is_safe()) { return read(reader); }
         return ErrorCode::Success;
     }
 
diff --git a/src/log_surgeon/ReaderParser.cpp b/src/log_surgeon/ReaderParser.cpp
index bcb5c7d0..44e1a41b 100644
--- a/src/log_surgeon/ReaderParser.cpp
+++ b/src/log_surgeon/ReaderParser.cpp
@@ -29,9 +29,7 @@ auto ReaderParser::parse_next_event() -> ErrorCode {
         LogParser::ParsingAction parsing_action{LogParser::ParsingAction::None};
         ErrorCode parse_error = m_log_parser.parse_and_generate_metadata(parsing_action);
         if (ErrorCode::Success == parse_error) {
-            if (LogParser::ParsingAction::CompressAndFinish == parsing_action) {
-                m_done = true;
-            }
+            if (LogParser::ParsingAction::CompressAndFinish == parsing_action) { m_done = true; }
             break;
         }
         if (ErrorCode::BufferOutOfBounds == parse_error) {
diff --git a/src/log_surgeon/SchemaParser.cpp b/src/log_surgeon/SchemaParser.cpp
index ef6cd42f..7e1af6b7 100644
--- a/src/log_surgeon/SchemaParser.cpp
+++ b/src/log_surgeon/SchemaParser.cpp
@@ -80,9 +80,7 @@ auto SchemaParser::try_schema_file(string const& schema_file_path) -> unique_ptr
     SchemaParser sp;
     Reader reader{[&](char* buf, size_t count, size_t& read_to) -> ErrorCode {
         schema_reader.read(buf, count, read_to);
-        if (read_to == 0) {
-            return ErrorCode::EndOfFile;
-        }
+        if (read_to == 0) { return ErrorCode::EndOfFile; }
         return ErrorCode::Success;
     }};
     unique_ptr<SchemaAST> schema_ast = sp.generate_schema_ast(reader);
@@ -98,12 +96,8 @@ auto SchemaParser::try_schema_string(string_view const schema_string) -> unique_
             count = schema_string.length() - unparsed_string_pos;
         }
         read_to = count;
-        if (read_to == 0) {
-            return ErrorCode::EndOfFile;
-        }
-        for (uint32_t i = 0; i < count; i++) {
-            buf[i] = schema_string[unparsed_string_pos + i];
-        }
+        if (read_to == 0) { return ErrorCode::EndOfFile; }
+        for (uint32_t i = 0; i < count; i++) { buf[i] = schema_string[unparsed_string_pos + i]; }
         unparsed_string_pos += count;
         return ErrorCode::Success;
     }};
diff --git a/src/log_surgeon/Token.cpp b/src/log_surgeon/Token.cpp
index e8966412..52cbc6af 100644
--- a/src/log_surgeon/Token.cpp
+++ b/src/log_surgeon/Token.cpp
@@ -6,9 +6,7 @@
 
 namespace log_surgeon {
 auto Token::to_string() -> std::string {
-    if (m_start_pos <= m_end_pos) {
-        return {m_buffer + m_start_pos, m_buffer + m_end_pos};
-    }
+    if (m_start_pos <= m_end_pos) { return {m_buffer + m_start_pos, m_buffer + m_end_pos}; }
     if (m_wrap_around_string.empty()) {
         m_wrap_around_string = std::string{m_buffer + m_start_pos, m_buffer + m_buffer_size}
                                + std::string{m_buffer, m_buffer + m_end_pos};
@@ -17,9 +15,7 @@ auto Token::to_string() -> std::string {
 }
 
 auto Token::to_string_view() -> std::string_view {
-    if (m_start_pos <= m_end_pos) {
-        return {m_buffer + m_start_pos, m_end_pos - m_start_pos};
-    }
+    if (m_start_pos <= m_end_pos) { return {m_buffer + m_start_pos, m_end_pos - m_start_pos}; }
     if (m_wrap_around_string.empty()) {
         m_wrap_around_string = std::string{m_buffer + m_start_pos, m_buffer + m_buffer_size}
                                + std::string{m_buffer, m_buffer + m_end_pos};
@@ -49,9 +45,7 @@ void Token::append_context_to_logtype(
         auto const reg_end_positions{m_reg_handler.get_reversed_positions(end_reg_id)};
 
         for (size_t j{0}; j < reg_start_positions.size(); ++j) {
-            if (reg_start_positions[j] < 0) {
-                continue;
-            }
+            if (reg_start_positions[j] < 0) { continue; }
             variable_positions.push_back(
                     {static_cast<uint32_t>(reg_start_positions[j]),
                      static_cast<uint32_t>(reg_end_positions[j]),
@@ -84,9 +78,7 @@ void Token::append_context_to_logtype(
 }
 
 auto Token::get_char(uint8_t i) const -> char {
-    if (m_start_pos + i < m_buffer_size) {
-        return m_buffer[m_start_pos + i];
-    }
+    if (m_start_pos + i < m_buffer_size) { return m_buffer[m_start_pos + i]; }
     return m_buffer[i - (m_buffer_size - m_start_pos)];
 }
 
@@ -95,9 +87,7 @@ auto Token::get_delimiter() const -> std::string {
 }
 
 auto Token::get_length() const -> uint32_t {
-    if (m_start_pos <= m_end_pos) {
-        return m_end_pos - m_start_pos;
-    }
+    if (m_start_pos <= m_end_pos) { return m_end_pos - m_start_pos; }
     return m_buffer_size - m_start_pos + m_end_pos;
 }
 }  // namespace log_surgeon
diff --git a/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp b/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
index af679957..4f52a534 100644
--- a/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
+++ b/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
@@ -75,9 +75,7 @@ class DeterminizationConfiguration {
         if (m_tag_id_to_reg_ids != rhs.m_tag_id_to_reg_ids) {
             return m_tag_id_to_reg_ids < rhs.m_tag_id_to_reg_ids;
         }
-        if (m_history != rhs.m_history) {
-            return m_history < rhs.m_history;
-        }
+        if (m_history != rhs.m_history) { return m_history < rhs.m_history; }
         return m_lookahead < rhs.m_lookahead;
     }
 
@@ -133,9 +131,7 @@ class DeterminizationConfiguration {
 
     [[nodiscard]] auto get_tag_history(tag_id_t const tag_id) const -> std::optional<TagOperation> {
         for (auto const tag_op : m_history) {
-            if (tag_op.get_tag_id() == tag_id) {
-                return std::make_optional<TagOperation>(tag_op);
-            }
+            if (tag_op.get_tag_id() == tag_id) { return std::make_optional<TagOperation>(tag_op); }
         }
         return std::nullopt;
     }
@@ -145,9 +141,7 @@ class DeterminizationConfiguration {
     [[nodiscard]] auto get_tag_lookahead(tag_id_t const tag_id) const
             -> std::optional<TagOperation> {
         for (auto const tag_op : m_lookahead) {
-            if (tag_op.get_tag_id() == tag_id) {
-                return std::make_optional<TagOperation>(tag_op);
-            }
+            if (tag_op.get_tag_id() == tag_id) { return std::make_optional<TagOperation>(tag_op); }
         }
         return std::nullopt;
     }
diff --git a/src/log_surgeon/finite_automata/Dfa.hpp b/src/log_surgeon/finite_automata/Dfa.hpp
index 70118236..186de5a2 100644
--- a/src/log_surgeon/finite_automata/Dfa.hpp
+++ b/src/log_surgeon/finite_automata/Dfa.hpp
@@ -16,6 +16,9 @@
 #include <utility>
 #include <vector>
 
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
 #include <log_surgeon/Constants.hpp>
 #include <log_surgeon/finite_automata/DeterminizationConfiguration.hpp>
 #include <log_surgeon/finite_automata/DfaStatePair.hpp>
@@ -25,9 +28,6 @@
 #include <log_surgeon/finite_automata/TagOperation.hpp>
 #include <log_surgeon/Token.hpp>
 
-#include <fmt/format.h>
-#include <fmt/ranges.h>
-
 namespace log_surgeon::finite_automata {
 /**
  * Represents a Deterministic Finite Automaton (DFA).
@@ -341,9 +341,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
         ConfigurationSet const& lhs,
         ConfigurationSet const& rhs
 ) -> std::optional<std::unordered_map<reg_id_t, reg_id_t>> {
-    if (lhs.size() != rhs.size()) {
-        return std::nullopt;
-    }
+    if (lhs.size() != rhs.size()) { return std::nullopt; }
     std::unordered_map<reg_id_t, reg_id_t> reg_map_lhs_to_rhs;
     std::unordered_map<reg_id_t, reg_id_t> reg_map_rhs_to_lhs;
     for (auto const& config_lhs : lhs) {
@@ -356,9 +354,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
             }
             for (auto const [tag_id, lhs_reg_id] : config_lhs.get_tag_id_to_reg_ids()) {
                 // If the NFA state sets the tag then the current register is irrelevent
-                if (config_lhs.get_tag_lookahead(tag_id).has_value()) {
-                    continue;
-                }
+                if (config_lhs.get_tag_lookahead(tag_id).has_value()) { continue; }
                 auto const rhs_reg_id{config_rhs.get_tag_id_to_reg_ids().at(tag_id)};
                 if (false == reg_map_lhs_to_rhs.contains(lhs_reg_id)
                     && false == reg_map_rhs_to_lhs.contains(rhs_reg_id))
@@ -376,9 +372,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
             found = true;
             break;
         }
-        if (false == found) {
-            return std::nullopt;
-        }
+        if (false == found) { return std::nullopt; }
     }
     return reg_map_lhs_to_rhs;
 }
@@ -392,9 +386,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::create_or_get_dfa_state(
     if (false == dfa_states.contains(config_set)) {
         for (auto const& [config_set_in_map, dfa_state] : dfa_states) {
             auto const optional_reg_map{try_get_mapping(config_set, config_set_in_map)};
-            if (optional_reg_map.has_value()) {
-                return {dfa_state, optional_reg_map};
-            }
+            if (optional_reg_map.has_value()) { return {dfa_state, optional_reg_map}; }
         }
         dfa_states.insert({config_set, new_state(config_set, m_tag_id_to_final_reg_id)});
         unexplored_sets.push(config_set);
@@ -489,9 +481,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::reassign_transition_reg_ops(
         std::vector<RegisterOperation>& reg_ops
 ) -> void {
     for (auto const [old_reg_id, new_reg_id] : reg_map) {
-        if (old_reg_id == new_reg_id) {
-            continue;
-        }
+        if (old_reg_id == new_reg_id) { continue; }
         bool is_existing_reg_op_mapping{false};
         for (auto& reg_op : reg_ops) {
             if (reg_op.get_reg_id() == old_reg_id) {
@@ -574,9 +564,7 @@ auto Dfa<TypedDfaState, TypedNfaState>::get_bfs_traversal_order() const
 
     auto try_add_to_queue_and_visited
             = [&state_queue, &visited_states](TypedDfaState const* dest_state) {
-                  if (visited_states.insert(dest_state).second) {
-                      state_queue.push(dest_state);
-                  }
+                  if (visited_states.insert(dest_state).second) { state_queue.push(dest_state); }
               };
 
     try_add_to_queue_and_visited(get_root());
@@ -602,16 +590,12 @@ auto Dfa<TypedDfaState, TypedNfaState>::serialize() const -> std::optional<std::
 
     std::unordered_map<TypedDfaState const*, uint32_t> state_ids;
     state_ids.reserve(traversal_order.size());
-    for (auto const* state : traversal_order) {
-        state_ids.emplace(state, state_ids.size());
-    }
+    for (auto const* state : traversal_order) { state_ids.emplace(state, state_ids.size()); }
 
     std::vector<std::string> serialized_states;
     for (auto const* state : traversal_order) {
         auto const optional_serialized_state{state->serialize(state_ids)};
-        if (false == optional_serialized_state.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_serialized_state.has_value()) { return std::nullopt; }
         serialized_states.emplace_back(optional_serialized_state.value());
     }
     return fmt::format("{}\n", fmt::join(serialized_states, "\n"));
diff --git a/src/log_surgeon/finite_automata/DfaState.hpp b/src/log_surgeon/finite_automata/DfaState.hpp
index b974d459..5ec3375c 100644
--- a/src/log_surgeon/finite_automata/DfaState.hpp
+++ b/src/log_surgeon/finite_automata/DfaState.hpp
@@ -12,15 +12,15 @@
 #include <unordered_map>
 #include <vector>
 
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
 #include <log_surgeon/Constants.hpp>
 #include <log_surgeon/finite_automata/DfaTransition.hpp>
 #include <log_surgeon/finite_automata/RegisterOperation.hpp>
 #include <log_surgeon/finite_automata/StateType.hpp>
 #include <log_surgeon/finite_automata/UnicodeIntervalTree.hpp>
 
-#include <fmt/format.h>
-#include <fmt/ranges.h>
-
 namespace log_surgeon::finite_automata {
 template <StateType state_type>
 class DfaState;
@@ -118,13 +118,9 @@ auto DfaState<state_type>::serialize(
 
     std::vector<std::string> transition_strings;
     for (uint32_t idx{0}; idx < cSizeOfByte; ++idx) {
-        if (false == m_bytes_transition[idx].has_value()) {
-            continue;
-        }
+        if (false == m_bytes_transition[idx].has_value()) { continue; }
         auto const optional_byte_transition_string{m_bytes_transition[idx]->serialize(state_ids)};
-        if (false == optional_byte_transition_string.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_byte_transition_string.has_value()) { return std::nullopt; }
         transition_strings.emplace_back(
                 fmt::format("{}{}", static_cast<char>(idx), optional_byte_transition_string.value())
         );
diff --git a/src/log_surgeon/finite_automata/DfaStatePair.hpp b/src/log_surgeon/finite_automata/DfaStatePair.hpp
index ce103f5d..2a5796e9 100644
--- a/src/log_surgeon/finite_automata/DfaStatePair.hpp
+++ b/src/log_surgeon/finite_automata/DfaStatePair.hpp
@@ -32,9 +32,7 @@ class DfaStatePair {
      * whether `m_state2` in lhs has a lower address than in rhs.
      */
     auto operator<(DfaStatePair const& rhs) const -> bool {
-        if (m_state1 == rhs.m_state1) {
-            return m_state2 < rhs.m_state2;
-        }
+        if (m_state1 == rhs.m_state1) { return m_state2 < rhs.m_state2; }
         return m_state1 < rhs.m_state1;
     }
 
diff --git a/src/log_surgeon/finite_automata/DfaTransition.hpp b/src/log_surgeon/finite_automata/DfaTransition.hpp
index e1c13b13..e08688e5 100644
--- a/src/log_surgeon/finite_automata/DfaTransition.hpp
+++ b/src/log_surgeon/finite_automata/DfaTransition.hpp
@@ -8,12 +8,12 @@
 #include <utility>
 #include <vector>
 
-#include <log_surgeon/finite_automata/RegisterOperation.hpp>
-#include <log_surgeon/finite_automata/StateType.hpp>
-
 #include <fmt/format.h>
 #include <fmt/ranges.h>
 
+#include <log_surgeon/finite_automata/RegisterOperation.hpp>
+#include <log_surgeon/finite_automata/StateType.hpp>
+
 namespace log_surgeon::finite_automata {
 template <StateType state_type>
 class DfaState;
@@ -59,16 +59,12 @@ template <StateType state_type>
 auto DfaTransition<state_type>::serialize(
         std::unordered_map<DfaState<state_type> const*, uint32_t> const& state_ids
 ) const -> std::optional<std::string> {
-    if (false == state_ids.contains(m_dest_state)) {
-        return std::nullopt;
-    }
+    if (false == state_ids.contains(m_dest_state)) { return std::nullopt; }
 
     std::vector<std::string> transformed_ops;
     for (auto const& reg_op : m_reg_ops) {
         auto const optional_serialized_op{reg_op.serialize()};
-        if (false == optional_serialized_op.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_serialized_op.has_value()) { return std::nullopt; }
         transformed_ops.emplace_back(optional_serialized_op.value());
     }
 
diff --git a/src/log_surgeon/finite_automata/Nfa.hpp b/src/log_surgeon/finite_automata/Nfa.hpp
index ae6d0fc6..8a6ade73 100644
--- a/src/log_surgeon/finite_automata/Nfa.hpp
+++ b/src/log_surgeon/finite_automata/Nfa.hpp
@@ -12,6 +12,9 @@
 #include <utility>
 #include <vector>
 
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
 #include <log_surgeon/Constants.hpp>
 #include <log_surgeon/finite_automata/Capture.hpp>
 #include <log_surgeon/finite_automata/TagOperation.hpp>
@@ -20,9 +23,6 @@
 #include <log_surgeon/types.hpp>
 #include <log_surgeon/UniqueIdGenerator.hpp>
 
-#include <fmt/format.h>
-#include <fmt/ranges.h>
-
 namespace log_surgeon::finite_automata {
 /**
  * Represents a Non-Deterministic Finite Automaton (NFA) designed to recognize a language based on
@@ -129,9 +129,7 @@ class Nfa {
 template <typename TypedNfaState>
 Nfa<TypedNfaState>::Nfa(std::vector<LexicalRule<TypedNfaState>> const& rules) {
     m_root = new_state();
-    for (auto const& rule : rules) {
-        rule.add_to_nfa(this);
-    }
+    for (auto const& rule : rules) { rule.add_to_nfa(this); }
 }
 
 template <typename TypedNfaState>
@@ -225,9 +223,7 @@ auto Nfa<TypedNfaState>::get_bfs_traversal_order() const -> std::vector<TypedNfa
 
     auto add_to_queue_and_visited
             = [&state_queue, &visited_states](TypedNfaState const* dest_state) {
-                  if (visited_states.insert(dest_state).second) {
-                      state_queue.push(dest_state);
-                  }
+                  if (visited_states.insert(dest_state).second) { state_queue.push(dest_state); }
               };
 
     add_to_queue_and_visited(m_root);
@@ -253,16 +249,12 @@ auto Nfa<TypedNfaState>::serialize() const -> std::optional<std::string> {
     auto const traversal_order = get_bfs_traversal_order();
 
     std::unordered_map<TypedNfaState const*, uint32_t> state_ids;
-    for (auto const* state : traversal_order) {
-        state_ids.emplace(state, state_ids.size());
-    }
+    for (auto const* state : traversal_order) { state_ids.emplace(state, state_ids.size()); }
 
     std::vector<std::string> serialized_states;
     for (auto const* state : traversal_order) {
         auto const optional_serialized_state{state->serialize(state_ids)};
-        if (false == optional_serialized_state.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_serialized_state.has_value()) { return std::nullopt; }
         serialized_states.emplace_back(optional_serialized_state.value());
     }
     return fmt::format("{}\n", fmt::join(serialized_states, "\n"));
diff --git a/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp b/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
index de72715a..b2176442 100644
--- a/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
+++ b/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
@@ -9,11 +9,11 @@
 #include <utility>
 #include <vector>
 
-#include <log_surgeon/finite_automata/TagOperation.hpp>
-
 #include <fmt/format.h>
 #include <fmt/ranges.h>
 
+#include <log_surgeon/finite_automata/TagOperation.hpp>
+
 namespace log_surgeon::finite_automata {
 /**
  * Represents an NFA transition with a collection of tag operations to be performed during the
@@ -50,9 +50,7 @@ template <typename TypedNfaState>
 auto NfaSpontaneousTransition<TypedNfaState>::serialize(
         std::unordered_map<TypedNfaState const*, uint32_t> const& state_ids
 ) const -> std::optional<std::string> {
-    if (false == state_ids.contains(m_dest_state)) {
-        return std::nullopt;
-    }
+    if (false == state_ids.contains(m_dest_state)) { return std::nullopt; }
     auto transformed_operations
             = m_tag_ops | std::ranges::views::transform(&TagOperation::serialize);
 
diff --git a/src/log_surgeon/finite_automata/NfaState.hpp b/src/log_surgeon/finite_automata/NfaState.hpp
index ee80e900..dac6345e 100644
--- a/src/log_surgeon/finite_automata/NfaState.hpp
+++ b/src/log_surgeon/finite_automata/NfaState.hpp
@@ -13,6 +13,9 @@
 #include <utility>
 #include <vector>
 
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
 #include <log_surgeon/Constants.hpp>
 #include <log_surgeon/finite_automata/NfaSpontaneousTransition.hpp>
 #include <log_surgeon/finite_automata/StateType.hpp>
@@ -20,9 +23,6 @@
 #include <log_surgeon/finite_automata/UnicodeIntervalTree.hpp>
 #include <log_surgeon/types.hpp>
 
-#include <fmt/format.h>
-#include <fmt/ranges.h>
-
 namespace log_surgeon::finite_automata {
 template <StateType state_type>
 class NfaState;
@@ -78,9 +78,7 @@ class NfaState {
     ) -> void {
         std::vector<TagOperation> tag_ops;
         tag_ops.reserve(tag_ids.size());
-        for (auto const tag_id : tag_ids) {
-            tag_ops.emplace_back(tag_id, op_type, multi_valued);
-        }
+        for (auto const tag_id : tag_ids) { tag_ops.emplace_back(tag_id, op_type, multi_valued); }
         m_spontaneous_transitions.emplace_back(std::move(tag_ops), dest_state);
     }
 
@@ -139,15 +137,11 @@ template <StateType state_type>
 auto NfaState<state_type>::add_interval(Interval interval, NfaState* dest_state) -> void {
     if (interval.first < cSizeOfByte) {
         uint32_t const bound = std::min(interval.second, cSizeOfByte - 1);
-        for (uint32_t i = interval.first; i <= bound; i++) {
-            add_byte_transition(i, dest_state);
-        }
+        for (uint32_t i = interval.first; i <= bound; i++) { add_byte_transition(i, dest_state); }
         interval.first = bound + 1;
     }
     if constexpr (StateType::Utf8 == state_type) {
-        if (interval.second < cSizeOfByte) {
-            return;
-        }
+        if (interval.second < cSizeOfByte) { return; }
         std::unique_ptr<std::vector<typename Tree::Data>> overlaps
                 = m_tree_transitions.pop(interval);
         for (typename Tree::Data const& data : *overlaps) {
@@ -202,9 +196,7 @@ auto NfaState<state_type>::serialize(
     std::vector<std::string> serialized_spontaneous_transitions;
     for (auto const& spontaneous_transition : m_spontaneous_transitions) {
         auto const optional_serialized_transition{spontaneous_transition.serialize(state_ids)};
-        if (false == optional_serialized_transition.has_value()) {
-            return std::nullopt;
-        }
+        if (false == optional_serialized_transition.has_value()) { return std::nullopt; }
         serialized_spontaneous_transitions.emplace_back(optional_serialized_transition.value());
     }
 
diff --git a/src/log_surgeon/finite_automata/PrefixTree.cpp b/src/log_surgeon/finite_automata/PrefixTree.cpp
index 4a652346..92e72dac 100644
--- a/src/log_surgeon/finite_automata/PrefixTree.cpp
+++ b/src/log_surgeon/finite_automata/PrefixTree.cpp
@@ -5,9 +5,7 @@
 
 namespace log_surgeon::finite_automata {
 auto PrefixTree::get_reversed_positions(id_t const node_id) const -> std::vector<position_t> {
-    if (m_nodes.size() <= node_id) {
-        throw std::out_of_range("Prefix tree index out of range.");
-    }
+    if (m_nodes.size() <= node_id) { throw std::out_of_range("Prefix tree index out of range."); }
 
     std::vector<position_t> reversed_positions;
     auto current_node{m_nodes[node_id]};
diff --git a/src/log_surgeon/finite_automata/RegexAST.hpp b/src/log_surgeon/finite_automata/RegexAST.hpp
index 36b9301c..8aaa632d 100644
--- a/src/log_surgeon/finite_automata/RegexAST.hpp
+++ b/src/log_surgeon/finite_automata/RegexAST.hpp
@@ -14,16 +14,16 @@
 #include <utility>
 #include <vector>
 
-#include <log_surgeon/Constants.hpp>
-#include <log_surgeon/finite_automata/Capture.hpp>
-#include <log_surgeon/finite_automata/TagOperation.hpp>
-#include <log_surgeon/finite_automata/UnicodeIntervalTree.hpp>
-
 #include <fmt/format.h>
 #include <fmt/ranges.h>
 #include <fmt/xchar.h>
 #include <gsl/pointers>
 
+#include <log_surgeon/Constants.hpp>
+#include <log_surgeon/finite_automata/Capture.hpp>
+#include <log_surgeon/finite_automata/TagOperation.hpp>
+#include <log_surgeon/finite_automata/UnicodeIntervalTree.hpp>
+
 namespace log_surgeon::finite_automata {
 template <typename TypedNfaState>
 class Nfa;
@@ -158,9 +158,7 @@ class RegexAST {
     auto operator=(RegexAST&& rhs) noexcept -> RegexAST& = delete;
 
     [[nodiscard]] auto serialize_negative_captures() const -> std::u32string {
-        if (m_negative_captures.empty()) {
-            return U"";
-        }
+        if (m_negative_captures.empty()) { return U""; }
 
         auto const transformed_negative_captures{
                 m_negative_captures | std::ranges::views::transform([](Capture const* capture) {
@@ -289,9 +287,7 @@ class RegexASTInteger : public RegexAST<TypedNfaState> {
      */
     auto set_possible_inputs_to_true(std::array<bool, cSizeOfUnicode>& is_possible_input) const
             -> void override {
-        for (uint32_t const i : m_digits) {
-            is_possible_input.at('0' + i) = true;
-        }
+        for (uint32_t const i : m_digits) { is_possible_input.at('0' + i) = true; }
     }
 
     /**
@@ -361,21 +357,15 @@ class RegexASTGroup : public RegexAST<TypedNfaState> {
             -> void override {
         if (!m_negate) {
             for (auto const& [begin, end] : m_ranges) {
-                for (uint32_t i = begin; i <= end; i++) {
-                    is_possible_input.at(i) = true;
-                }
+                for (uint32_t i = begin; i <= end; i++) { is_possible_input.at(i) = true; }
             }
         } else {
             std::vector<char> inputs(cSizeOfUnicode, 1);
             for (auto const& [begin, end] : m_ranges) {
-                for (uint32_t i = begin; i <= end; i++) {
-                    inputs[i] = 0;
-                }
+                for (uint32_t i = begin; i <= end; i++) { inputs[i] = 0; }
             }
             for (uint32_t i = 0; i < inputs.size(); i++) {
-                if (inputs[i] != 0) {
-                    is_possible_input.at(i) = true;
-                }
+                if (inputs[i] != 0) { is_possible_input.at(i) = true; }
             }
         }
     }
@@ -386,12 +376,8 @@ class RegexASTGroup : public RegexAST<TypedNfaState> {
      * @param delimiters
      */
     auto remove_delimiters_from_wildcard(std::vector<uint32_t>& delimiters) -> void override {
-        if (!m_is_wildcard) {
-            return;
-        }
-        if (delimiters.empty()) {
-            return;
-        }
+        if (!m_is_wildcard) { return; }
+        if (delimiters.empty()) { return; }
         m_ranges.clear();
         std::ranges::sort(delimiters);
         if (delimiters[0] != 0) {
@@ -668,9 +654,7 @@ class RegexASTCapture : public RegexAST<TypedNfaState> {
         if (nullptr == m_capture_regex_ast) {
             throw std::invalid_argument("Group regex AST cannot be null");
         }
-        if (nullptr == m_capture) {
-            throw std::invalid_argument("Capture cannot be null");
-        }
+        if (nullptr == m_capture) { throw std::invalid_argument("Capture cannot be null"); }
 
         RegexAST<TypedNfaState>::set_subtree_positive_captures(
                 m_capture_regex_ast->get_subtree_positive_captures()
@@ -1059,9 +1043,7 @@ RegexASTGroup<TypedNfaState>::RegexASTGroup(
 template <typename TypedNfaState>
 RegexASTGroup<TypedNfaState>::RegexASTGroup(std::vector<uint32_t> const& literals)
         : m_negate(false) {
-    for (uint32_t literal : literals) {
-        m_ranges.emplace_back(literal, literal);
-    }
+    for (uint32_t literal : literals) { m_ranges.emplace_back(literal, literal); }
 }
 
 template <typename TypedNfaState>
@@ -1073,9 +1055,7 @@ RegexASTGroup<TypedNfaState>::RegexASTGroup(uint32_t min, uint32_t max) : m_nega
 template <typename TypedNfaState>
 auto RegexASTGroup<TypedNfaState>::merge(std::vector<Range> const& ranges) -> std::vector<Range> {
     std::vector<Range> merged_ranges;
-    if (ranges.empty()) {
-        return merged_ranges;
-    }
+    if (ranges.empty()) { return merged_ranges; }
     Range cur = ranges[0];
     for (size_t i = 1; i < ranges.size(); i++) {
         auto const& range = ranges[i];
@@ -1097,14 +1077,10 @@ auto RegexASTGroup<TypedNfaState>::complement(std::vector<Range> const& ranges)
     std::vector<Range> complemented;
     uint32_t low = 0;
     for (auto const& [begin, end] : ranges) {
-        if (begin > 0) {
-            complemented.emplace_back(low, begin - 1);
-        }
+        if (begin > 0) { complemented.emplace_back(low, begin - 1); }
         low = end + 1;
     }
-    if (low > 0) {
-        complemented.emplace_back(low, cUnicodeMax);
-    }
+    if (low > 0) { complemented.emplace_back(low, cUnicodeMax); }
     return complemented;
 }
 
@@ -1119,9 +1095,7 @@ void RegexASTGroup<TypedNfaState>::add_to_nfa(
     auto merged_ranges = m_ranges;
     std::sort(merged_ranges.begin(), merged_ranges.end());
     merged_ranges = merge(merged_ranges);
-    if (m_negate) {
-        merged_ranges = complement(merged_ranges);
-    }
+    if (m_negate) { merged_ranges = complement(merged_ranges); }
     for (auto const& [begin, end] : merged_ranges) {
         nfa->get_root()->add_interval(Interval(begin, end), end_state);
     }
diff --git a/src/log_surgeon/finite_automata/RegisterOperation.hpp b/src/log_surgeon/finite_automata/RegisterOperation.hpp
index 4dfb1e7d..d3176a9d 100644
--- a/src/log_surgeon/finite_automata/RegisterOperation.hpp
+++ b/src/log_surgeon/finite_automata/RegisterOperation.hpp
@@ -5,10 +5,10 @@
 #include <optional>
 #include <string>
 
-#include <log_surgeon/types.hpp>
-
 #include <fmt/format.h>
 
+#include <log_surgeon/types.hpp>
+
 namespace log_surgeon::finite_automata {
 /**
  * Represents a register operation:
@@ -61,9 +61,7 @@ class RegisterOperation {
     [[nodiscard]] auto serialize() const -> std::optional<std::string> {
         switch (m_type) {
             case Type::Copy:
-                if (false == m_copy_reg_id.has_value()) {
-                    return std::nullopt;
-                }
+                if (false == m_copy_reg_id.has_value()) { return std::nullopt; }
                 return fmt::format("{}{}{}", m_reg_id, "c", m_copy_reg_id.value());
             case Type::Set:
                 return fmt::format("{}{}", m_reg_id, "p");
diff --git a/src/log_surgeon/finite_automata/TagOperation.hpp b/src/log_surgeon/finite_automata/TagOperation.hpp
index 52ac4993..f3c03c62 100644
--- a/src/log_surgeon/finite_automata/TagOperation.hpp
+++ b/src/log_surgeon/finite_automata/TagOperation.hpp
@@ -5,10 +5,10 @@
 #include <string>
 #include <tuple>
 
-#include <log_surgeon/types.hpp>
-
 #include <fmt/format.h>
 
+#include <log_surgeon/types.hpp>
+
 namespace log_surgeon::finite_automata {
 enum class TagOperationType : uint8_t {
     Set,
diff --git a/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp b/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
index 44fe2b0a..4ba5831e 100644
--- a/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
+++ b/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
@@ -32,21 +32,15 @@ auto UnicodeIntervalTree<T>::Node::insert(std::unique_ptr<Node> node, Interval i
 template <typename T>
 auto UnicodeIntervalTree<T>::all() const -> std::vector<Data> {
     std::vector<Data> results;
-    if (m_root != nullptr) {
-        m_root->all(&results);
-    }
+    if (m_root != nullptr) { m_root->all(&results); }
     return results;
 }
 
 template <typename T>
 auto UnicodeIntervalTree<T>::Node::all(std::vector<Data>* results) -> void {
-    if (m_left != nullptr) {
-        m_left->all(results);
-    }
+    if (m_left != nullptr) { m_left->all(results); }
     results->push_back(Data(m_interval, m_value));
-    if (m_right != nullptr) {
-        m_right->all(results);
-    }
+    if (m_right != nullptr) { m_right->all(results); }
 }
 
 template <typename T>
@@ -58,18 +52,10 @@ auto UnicodeIntervalTree<T>::find(Interval interval) -> std::unique_ptr<std::vec
 
 template <class T>
 auto UnicodeIntervalTree<T>::Node::find(Interval interval, std::vector<Data>* results) -> void {
-    if (!overlaps_recursive(interval)) {
-        return;
-    }
-    if (m_left != nullptr) {
-        m_left->find(interval, results);
-    }
-    if (overlaps(interval)) {
-        results->push_back(Data(m_interval, m_value));
-    }
-    if (m_right != nullptr) {
-        m_right->find(interval, results);
-    }
+    if (!overlaps_recursive(interval)) { return; }
+    if (m_left != nullptr) { m_left->find(interval, results); }
+    if (overlaps(interval)) { results->push_back(Data(m_interval, m_value)); }
+    if (m_right != nullptr) { m_right->find(interval, results); }
 }
 
 template <class T>
@@ -78,9 +64,7 @@ auto UnicodeIntervalTree<T>::pop(Interval interval) -> std::unique_ptr<std::vect
     while (true) {
         std::unique_ptr<Node> n;
         m_root = Node::pop(std::move(m_root), interval, &n);
-        if (n == nullptr) {
-            break;
-        }
+        if (n == nullptr) { break; }
         results->push_back(Data(n->get_interval(), n->get_value()));
     }
     return results;
@@ -92,12 +76,8 @@ auto UnicodeIntervalTree<T>::Node::pop(
         Interval interval,
         std::unique_ptr<Node>* ret
 ) -> std::unique_ptr<Node> {
-    if (node == nullptr) {
-        return nullptr;
-    }
-    if (!node->overlaps_recursive(interval)) {
-        return node;
-    }
+    if (node == nullptr) { return nullptr; }
+    if (!node->overlaps_recursive(interval)) { return node; }
     node->m_left = Node::pop(std::move(node->m_left), interval, ret);
     if (ret->get() != nullptr) {
         node->update();
@@ -105,15 +85,9 @@ auto UnicodeIntervalTree<T>::Node::pop(
     }
     assert(node->overlaps(interval));
     ret->reset(node.release());
-    if (((*ret)->m_left == nullptr) && ((*ret)->m_right == nullptr)) {
-        return nullptr;
-    }
-    if ((*ret)->m_left == nullptr) {
-        return std::move((*ret)->m_right);
-    }
-    if ((*ret)->m_right == nullptr) {
-        return std::move((*ret)->m_left);
-    }
+    if (((*ret)->m_left == nullptr) && ((*ret)->m_right == nullptr)) { return nullptr; }
+    if ((*ret)->m_left == nullptr) { return std::move((*ret)->m_right); }
+    if ((*ret)->m_right == nullptr) { return std::move((*ret)->m_left); }
     std::unique_ptr<Node> replacement;
     std::unique_ptr<Node> sub_tree = Node::pop_min(std::move((*ret)->m_right), &replacement);
     replacement->m_left = std::move((*ret)->m_left);
@@ -166,14 +140,10 @@ auto UnicodeIntervalTree<T>::Node::balance_factor() -> int {
 template <class T>
 auto UnicodeIntervalTree<T>::Node::balance(std::unique_ptr<Node> node) -> std::unique_ptr<Node> {
     auto const factor = node->balance_factor();
-    if (factor * factor <= 1) {
-        return node;
-    }
+    if (factor * factor <= 1) { return node; }
     auto const sub_factor
             = (factor < 0) ? node->m_left->balance_factor() : node->m_right->balance_factor();
-    if (factor * sub_factor > 0) {
-        return Node::rotate(std::move(node), factor);
-    }
+    if (factor * sub_factor > 0) { return Node::rotate(std::move(node), factor); }
     if (factor == 2) {
         node->m_right = Node::rotate(std::move(node->m_right), sub_factor);
     } else {
@@ -185,12 +155,8 @@ auto UnicodeIntervalTree<T>::Node::balance(std::unique_ptr<Node> node) -> std::u
 template <class T>
 auto UnicodeIntervalTree<T>::Node::rotate(std::unique_ptr<Node> node, int factor)
         -> std::unique_ptr<Node> {
-    if (factor < 0) {
-        return Node::rotate_cw(std::move(node));
-    }
-    if (factor > 0) {
-        return Node::rotate_ccw(std::move(node));
-    }
+    if (factor < 0) { return Node::rotate_cw(std::move(node)); }
+    if (factor > 0) { return Node::rotate_ccw(std::move(node)); }
     return node;
 }
 
diff --git a/src/log_surgeon/utils.hpp b/src/log_surgeon/utils.hpp
index 976eb207..e4c259e6 100644
--- a/src/log_surgeon/utils.hpp
+++ b/src/log_surgeon/utils.hpp
@@ -9,15 +9,11 @@
 template <typename... Args>
 auto strfmt(std::string const& fmt, Args... args) -> std::string {
     auto size = std::snprintf(nullptr, 0, fmt.c_str(), args...);
-    if (size <= 0) {
-        throw std::runtime_error("Error during formatting.");
-    }
+    if (size <= 0) { throw std::runtime_error("Error during formatting."); }
     // Add 1 for null character to terminate the C string
     std::vector<char> buf(size + 1);
     size = std::snprintf(buf.data(), buf.size(), fmt.c_str(), args...);
-    if (size <= 0) {
-        throw std::runtime_error("Error during formatting.");
-    }
+    if (size <= 0) { throw std::runtime_error("Error during formatting."); }
     return {buf.data(), buf.data() + size};
 }
 
diff --git a/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp b/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
index 15e5339d..45e2891e 100644
--- a/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
+++ b/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
@@ -43,16 +43,10 @@ auto ExpressionView::extend_to_adjacent_greedy_wildcards() const
 }
 
 auto ExpressionView::is_well_formed() const -> bool {
-    if (m_chars.empty()) {
-        return true;
-    }
+    if (m_chars.empty()) { return true; }
     auto const [begin_idx, end_idx]{get_indices()};
-    if (begin_idx > 0 && m_expression->get_chars()[begin_idx - 1].is_escape()) {
-        return false;
-    }
-    if (m_chars.back().is_escape()) {
-        return false;
-    }
+    if (begin_idx > 0 && m_expression->get_chars()[begin_idx - 1].is_escape()) { return false; }
+    if (m_chars.back().is_escape()) { return false; }
     return true;
 }
 
@@ -62,9 +56,7 @@ auto ExpressionView::generate_regex_string() const -> std::pair<string, bool> {
     bool regex_contains_wildcard{false};
 
     for (auto const& expression_char : m_chars) {
-        if (expression_char.is_escape()) {
-            continue;
-        }
+        if (expression_char.is_escape()) { continue; }
         auto const& value{expression_char.value()};
         if (expression_char.is_greedy_wildcard()) {
             regex_string += ".*";
diff --git a/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp b/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
index 674035ad..9fcf70d1 100644
--- a/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
+++ b/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
@@ -6,12 +6,12 @@
 #include <variant>
 #include <vector>
 
-#include <log_surgeon/wildcard_query_parser/StaticQueryToken.hpp>
-#include <log_surgeon/wildcard_query_parser/VariableQueryToken.hpp>
-
 #include <fmt/format.h>
 #include <fmt/ranges.h>
 
+#include <log_surgeon/wildcard_query_parser/StaticQueryToken.hpp>
+#include <log_surgeon/wildcard_query_parser/VariableQueryToken.hpp>
+
 using std::string;
 using std::strong_ordering;
 using std::vector;
@@ -23,19 +23,13 @@ auto QueryInterpretation::operator<=>(QueryInterpretation const& rhs) const -> s
     // in `m_tokens` have `<=>` which returns `strong_ordering`. Therefore, we can convert the
     // result of `<=>` between two `m_tokens` from `weak_ordering` to `strong_ordering`.
     auto const tokens_weak_cmp{m_tokens <=> rhs.m_tokens};
-    if (weak_ordering::less == tokens_weak_cmp) {
-        return strong_ordering::less;
-    }
-    if (weak_ordering::greater == tokens_weak_cmp) {
-        return strong_ordering::greater;
-    }
+    if (weak_ordering::less == tokens_weak_cmp) { return strong_ordering::less; }
+    if (weak_ordering::greater == tokens_weak_cmp) { return strong_ordering::greater; }
     return strong_ordering::equal;
 }
 
 void QueryInterpretation::append_query_interpretation(QueryInterpretation const& suffix) {
-    if (suffix.m_tokens.empty()) {
-        return;
-    }
+    if (suffix.m_tokens.empty()) { return; }
     if (m_tokens.empty()) {
         m_tokens = suffix.m_tokens;
         return;
@@ -55,9 +49,7 @@ void QueryInterpretation::append_query_interpretation(QueryInterpretation const&
 }
 
 auto QueryInterpretation::append_static_token(std::string const& query_substring) -> void {
-    if (query_substring.empty()) {
-        return;
-    }
+    if (query_substring.empty()) { return; }
 
     StaticQueryToken static_query_token(query_substring);
     if (m_tokens.empty()) {
diff --git a/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp b/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
index 5717d5f2..7f06583a 100644
--- a/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
+++ b/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
@@ -7,14 +7,10 @@ using std::strong_ordering;
 namespace log_surgeon::wildcard_query_parser {
 auto VariableQueryToken::operator<=>(VariableQueryToken const& rhs) const -> strong_ordering {
     auto const variable_type_cmp{m_variable_type <=> rhs.m_variable_type};
-    if (std::strong_ordering::equal != variable_type_cmp) {
-        return variable_type_cmp;
-    }
+    if (std::strong_ordering::equal != variable_type_cmp) { return variable_type_cmp; }
 
     auto const query_substring_cmp{m_query_substring <=> rhs.m_query_substring};
-    if (std::strong_ordering::equal != query_substring_cmp) {
-        return query_substring_cmp;
-    }
+    if (std::strong_ordering::equal != query_substring_cmp) { return query_substring_cmp; }
 
     // bool does not have a <=> operator, so we have to manual order it:
     return static_cast<int>(m_contains_wildcard) <=> static_cast<int>(rhs.m_contains_wildcard);
diff --git a/tests/test-buffer-parser.cpp b/tests/test-buffer-parser.cpp
index ceb1ab8c..29f59141 100644
--- a/tests/test-buffer-parser.cpp
+++ b/tests/test-buffer-parser.cpp
@@ -96,9 +96,7 @@ auto parse_and_validate(
         }
 
         uint32_t event_offset{0};
-        if (nullptr == event.get_timestamp()) {
-            event_offset = 1;
-        }
+        if (nullptr == event.get_timestamp()) { event_offset = 1; }
 
         REQUIRE(expected_tokens.size() == event.get_log_output_buffer()->pos() - event_offset);
         for (size_t i{0}; i < expected_tokens.size(); ++i) {
@@ -124,18 +122,14 @@ auto parse_and_validate(
                 auto optional_capture_ids{lexer.get_capture_ids_from_rule_id(token_type)};
                 REQUIRE(optional_capture_ids.has_value());
 
-                if (false == optional_capture_ids.has_value()) {
-                    return;
-                }
+                if (false == optional_capture_ids.has_value()) { return; }
 
                 for (auto const capture_id : optional_capture_ids.value()) {
                     auto const capture_name{lexer.m_id_symbol.at(capture_id)};
                     REQUIRE(expected_captures.contains(capture_name));
                     auto optional_reg_ids{lexer.get_reg_ids_from_capture_id(capture_id)};
                     REQUIRE(optional_reg_ids.has_value());
-                    if (false == optional_reg_ids.has_value()) {
-                        return;
-                    }
+                    if (false == optional_reg_ids.has_value()) { return; }
                     auto const [start_reg_id, end_reg_id]{optional_reg_ids.value()};
                     auto const actual_start_positions{
                             token.get_reversed_reg_positions(start_reg_id)
@@ -155,9 +149,7 @@ auto parse_and_validate(
 
 auto serialize_id_symbol_map(unordered_map<rule_id_t, string> const& map) -> string {
     string serialized_map;
-    for (auto const& [id, symbol] : map) {
-        serialized_map += fmt::format("{}->{},", id, symbol);
-    }
+    for (auto const& [id, symbol] : map) { serialized_map += fmt::format("{}->{},", id, symbol); }
     return serialized_map;
 }
 }  // namespace
diff --git a/tests/test-dfa.cpp b/tests/test-dfa.cpp
index d2cdfbfc..2edb1bc4 100644
--- a/tests/test-dfa.cpp
+++ b/tests/test-dfa.cpp
@@ -46,9 +46,7 @@ auto test_dfa(std::vector<string> const& var_schemas, string const& expected_ser
 auto test_dfa(std::vector<string> const& var_schemas, string const& expected_serialized_dfa)
         -> void {
     Schema schema;
-    for (auto const& var_schema : var_schemas) {
-        schema.add_variable(var_schema, -1);
-    }
+    for (auto const& var_schema : var_schemas) { schema.add_variable(var_schema, -1); }
     auto const schema_ast = schema.release_schema_ast_ptr();
     vector<ByteLexicalRule> rules;
     for (size_t i{0}; i < var_schemas.size(); i++) {

From c0dde5bd6da229c56c051f8151b2d041aa15e56e Mon Sep 17 00:00:00 2001
From: davidlion <david.lion@yscope.com>
Date: Mon, 1 Sep 2025 15:09:50 -0400
Subject: [PATCH 3/6] Bump dev-utils to get latest clang-format config; Apply
 format changes.

---
 examples/buffer-parser.cpp                    | 32 +++++--
 examples/common.cpp                           |  4 +-
 examples/intersect-test.cpp                   |  8 +-
 examples/reader-parser.cpp                    | 20 +++-
 src/log_surgeon/BufferParser.cpp              |  4 +-
 src/log_surgeon/FileReader.cpp                | 32 +++++--
 src/log_surgeon/Lalr1Parser.tpp               | 92 ++++++++++++++-----
 src/log_surgeon/Lexer.hpp                     | 16 +++-
 src/log_surgeon/Lexer.tpp                     | 20 +++-
 src/log_surgeon/LogEvent.cpp                  | 20 +++-
 src/log_surgeon/LogParser.cpp                 | 32 +++++--
 src/log_surgeon/ParserInputBuffer.cpp         | 24 +++--
 src/log_surgeon/ParserInputBuffer.hpp         |  4 +-
 src/log_surgeon/ReaderParser.cpp              |  4 +-
 src/log_surgeon/SchemaParser.cpp              | 19 ++--
 src/log_surgeon/Token.cpp                     | 20 +++-
 .../DeterminizationConfiguration.hpp          | 12 ++-
 src/log_surgeon/finite_automata/Dfa.hpp       | 32 +++++--
 src/log_surgeon/finite_automata/DfaState.hpp  |  8 +-
 .../finite_automata/DfaStatePair.hpp          |  4 +-
 .../finite_automata/DfaTransition.hpp         |  8 +-
 src/log_surgeon/finite_automata/Nfa.hpp       | 16 +++-
 .../NfaSpontaneousTransition.hpp              |  4 +-
 src/log_surgeon/finite_automata/NfaState.hpp  | 16 +++-
 .../finite_automata/PrefixTree.cpp            |  4 +-
 src/log_surgeon/finite_automata/RegexAST.hpp  | 52 ++++++++---
 .../finite_automata/RegisterOperation.hpp     |  4 +-
 .../finite_automata/UnicodeIntervalTree.tpp   | 68 ++++++++++----
 src/log_surgeon/utils.hpp                     |  8 +-
 .../wildcard_query_parser/ExpressionView.cpp  | 16 +++-
 .../QueryInterpretation.cpp                   | 16 +++-
 .../VariableQueryToken.cpp                    |  8 +-
 tests/test-buffer-parser.cpp                  | 16 +++-
 tests/test-dfa.cpp                            |  4 +-
 tests/test-schema.cpp                         |  4 +-
 tools/yscope-dev-utils                        |  2 +-
 36 files changed, 487 insertions(+), 166 deletions(-)

diff --git a/examples/buffer-parser.cpp b/examples/buffer-parser.cpp
index bd141b9f..d6e7fe12 100644
--- a/examples/buffer-parser.cpp
+++ b/examples/buffer-parser.cpp
@@ -17,7 +17,9 @@ using namespace log_surgeon;
 auto process_logs(string const& schema_path, string const& input_path) -> void {
     BufferParser parser{schema_path};
     optional<uint32_t> loglevel_id{parser.get_variable_id("loglevel")};
-    if (false == loglevel_id.has_value()) { throw runtime_error("No 'loglevel' in schema."); }
+    if (false == loglevel_id.has_value()) {
+        throw runtime_error("No 'loglevel' in schema.");
+    }
 
     ifstream infs{input_path, ios::binary | ios::in};
     if (!infs.is_open()) {
@@ -30,7 +32,9 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
     infs.read(buf.data(), cSize);
     ssize_t valid_size{infs.gcount()};
     bool input_done{false};
-    if (infs.eof()) { input_done = true; }
+    if (infs.eof()) {
+        input_done = true;
+    }
     parser.reset();
 
     cout << "# Parsing timestamp and loglevel for each log event in " << input_path << ":" << endl;
@@ -43,8 +47,12 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         {
             // The only expected error is the parser has read to the bound
             // of the buffer.
-            if (ErrorCode::BufferOutOfBounds != err) { throw runtime_error("Parsing Failed."); }
-            if (input_done) { break; }
+            if (ErrorCode::BufferOutOfBounds != err) {
+                throw runtime_error("Parsing Failed.");
+            }
+            if (input_done) {
+                break;
+            }
 
             // If the offset is 0 the parser has not found the end of the
             // log event in the entire buffer, so we make it larger.
@@ -60,7 +68,9 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
 
             infs.read(&*(buf.begin() + valid_size), buf.size() - valid_size);
             ssize_t read{infs.gcount()};
-            if (infs.eof()) { input_done = true; }
+            if (infs.eof()) {
+                input_done = true;
+            }
             valid_size += read;
             continue;
         }
@@ -69,16 +79,22 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         cout << "log: " << event.to_string() << endl;
         print_timestamp_loglevel(event, *loglevel_id);
         cout << "logtype: " << event.get_logtype() << endl;
-        if (event.is_multiline()) { multiline_logs.emplace_back(event); }
+        if (event.is_multiline()) {
+            multiline_logs.emplace_back(event);
+        }
     }
 
     cout << endl << "# Printing multiline logs:" << endl;
-    for (auto const& log : multiline_logs) { cout << log.to_string() << endl; }
+    for (auto const& log : multiline_logs) {
+        cout << log.to_string() << endl;
+    }
 }
 
 auto main(int argc, char* argv[]) -> int {
     std::vector<std::string> const args(argv + 1, argv + argc);
-    if (int const err{check_input(args)}; 0 != err) { return err; }
+    if (int const err{check_input(args)}; 0 != err) {
+        return err;
+    }
     process_logs(args[0], args[1]);
     return 0;
 }
diff --git a/examples/common.cpp b/examples/common.cpp
index 884ab301..094762b5 100644
--- a/examples/common.cpp
+++ b/examples/common.cpp
@@ -24,7 +24,9 @@ auto check_input(std::vector<std::string> const& args) -> int {
         ret = 3;
         cout << "Input file does not exist.\n";
     }
-    if (0 != ret) { cout << "usage: <path to schema file> <path to input log file>\n"; }
+    if (0 != ret) {
+        cout << "usage: <path to schema file> <path to input log file>\n";
+    }
     return ret;
 }
 
diff --git a/examples/intersect-test.cpp b/examples/intersect-test.cpp
index 007b74b1..20d8bb68 100644
--- a/examples/intersect-test.cpp
+++ b/examples/intersect-test.cpp
@@ -27,7 +27,9 @@ auto get_intersect_for_query(
     std::string processed_search_string;
     // Replace all * with .*
     for (char const& c : search_string) {
-        if (c == '*') { processed_search_string.push_back('.'); }
+        if (c == '*') {
+            processed_search_string.push_back('.');
+        }
         processed_search_string.push_back(c);
     }
     log_surgeon::Schema schema;
@@ -42,7 +44,9 @@ auto get_intersect_for_query(
     Dfa<ByteDfaState, ByteNfaState> dfa2(nfa);
     auto schema_types = dfa1.get_intersect(&dfa2);
     std::cout << search_string << ":";
-    for (auto const& schema_type : schema_types) { std::cout << m_id_symbol[schema_type] << ","; }
+    for (auto const& schema_type : schema_types) {
+        std::cout << m_id_symbol[schema_type] << ",";
+    }
     std::cout << std::endl;
 }
 
diff --git a/examples/reader-parser.cpp b/examples/reader-parser.cpp
index 648cc72f..5f896e9a 100644
--- a/examples/reader-parser.cpp
+++ b/examples/reader-parser.cpp
@@ -16,7 +16,9 @@ using namespace log_surgeon;
 auto process_logs(string const& schema_path, string const& input_path) -> void {
     ReaderParser parser{schema_path};
     optional<uint32_t> loglevel_id{parser.get_variable_id("loglevel")};
-    if (false == loglevel_id.has_value()) { throw runtime_error("No 'loglevel' in schema."); }
+    if (false == loglevel_id.has_value()) {
+        throw runtime_error("No 'loglevel' in schema.");
+    }
 
     ifstream infs{input_path, ios::binary | ios::in};
     if (!infs.is_open()) {
@@ -27,7 +29,9 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
     Reader reader{[&](char* buf, size_t count, size_t& read_to) -> ErrorCode {
         infs.read(buf, count);
         read_to = infs.gcount();
-        if (0 == read_to && infs.eof()) { return ErrorCode::EndOfFile; }
+        if (0 == read_to && infs.eof()) {
+            return ErrorCode::EndOfFile;
+        }
         return ErrorCode::Success;
     }};
     parser.reset_and_set_reader(reader);
@@ -44,16 +48,22 @@ auto process_logs(string const& schema_path, string const& input_path) -> void {
         cout << "log: " << event.to_string() << endl;
         print_timestamp_loglevel(event, *loglevel_id);
         cout << "logtype: " << event.get_logtype() << endl;
-        if (event.is_multiline()) { multiline_logs.emplace_back(event); }
+        if (event.is_multiline()) {
+            multiline_logs.emplace_back(event);
+        }
     }
 
     cout << endl << "# Printing multiline logs:" << endl;
-    for (auto const& log : multiline_logs) { cout << log.to_string() << endl; }
+    for (auto const& log : multiline_logs) {
+        cout << log.to_string() << endl;
+    }
 }
 
 auto main(int argc, char* argv[]) -> int {
     std::vector<std::string> const args(argv + 1, argv + argc);
-    if (int const err{check_input(args)}; 0 != err) { return err; }
+    if (int const err{check_input(args)}; 0 != err) {
+        return err;
+    }
     process_logs(args[0], args[1]);
     return 0;
 }
diff --git a/src/log_surgeon/BufferParser.cpp b/src/log_surgeon/BufferParser.cpp
index 28ef8c6e..d69a04b8 100644
--- a/src/log_surgeon/BufferParser.cpp
+++ b/src/log_surgeon/BufferParser.cpp
@@ -37,7 +37,9 @@ BufferParser::parse_next_event(char* buf, size_t size, size_t& offset, bool fini
         reset();
         return error_code;
     }
-    if (LogParser::ParsingAction::CompressAndFinish == parsing_action) { m_done = true; }
+    if (LogParser::ParsingAction::CompressAndFinish == parsing_action) {
+        m_done = true;
+    }
     offset = m_log_parser.get_input_pos();
     return ErrorCode::Success;
 }
diff --git a/src/log_surgeon/FileReader.cpp b/src/log_surgeon/FileReader.cpp
index 01c7f7f9..edaa2b30 100644
--- a/src/log_surgeon/FileReader.cpp
+++ b/src/log_surgeon/FileReader.cpp
@@ -16,13 +16,21 @@ FileReader::~FileReader() {
 }
 
 auto FileReader::read(char* buf, size_t num_bytes_to_read, size_t& num_bytes_read) -> ErrorCode {
-    if (nullptr == m_file) { return ErrorCode::NotInit; }
-    if (nullptr == buf) { return ErrorCode::BadParam; }
+    if (nullptr == m_file) {
+        return ErrorCode::NotInit;
+    }
+    if (nullptr == buf) {
+        return ErrorCode::BadParam;
+    }
     num_bytes_read = fread(buf, sizeof(*buf), num_bytes_to_read, m_file);
     if (num_bytes_read < num_bytes_to_read) {
-        if (0 != ferror(m_file)) { return ErrorCode::Errno; }
+        if (0 != ferror(m_file)) {
+            return ErrorCode::Errno;
+        }
         if (0 != feof(m_file)) {
-            if (0 == num_bytes_read) { return ErrorCode::EndOfFile; }
+            if (0 == num_bytes_read) {
+                return ErrorCode::EndOfFile;
+            }
         }
     }
     return ErrorCode::Success;
@@ -33,7 +41,9 @@ auto FileReader::try_open(string const& path) -> ErrorCode {
     close();
     m_file = fopen(path.c_str(), "rb");
     if (nullptr == m_file) {
-        if (ENOENT == errno) { return ErrorCode::FileNotFound; }
+        if (ENOENT == errno) {
+            return ErrorCode::FileNotFound;
+        }
         return ErrorCode::Errno;
     }
     return ErrorCode::Success;
@@ -51,11 +61,17 @@ auto FileReader::close() -> void {
 auto FileReader::try_read_to_delimiter(char delim, bool keep_delimiter, bool append, string& str)
         -> ErrorCode {
     assert(nullptr != m_file);
-    if (false == append) { str.clear(); }
+    if (false == append) {
+        str.clear();
+    }
     ssize_t num_bytes_read = getdelim(&m_get_delim_buf, &m_get_delim_buf_len, delim, m_file);
     if (num_bytes_read < 1) {
-        if (0 != ferror(m_file)) { return ErrorCode::Errno; }
-        if (0 != feof(m_file)) { return ErrorCode::EndOfFile; }
+        if (0 != ferror(m_file)) {
+            return ErrorCode::Errno;
+        }
+        if (0 != feof(m_file)) {
+            return ErrorCode::EndOfFile;
+        }
     }
     if (false == keep_delimiter && delim == m_get_delim_buf[num_bytes_read - 1]) {
         --num_bytes_read;
diff --git a/src/log_surgeon/Lalr1Parser.tpp b/src/log_surgeon/Lalr1Parser.tpp
index 5da9512a..842ad207 100644
--- a/src/log_surgeon/Lalr1Parser.tpp
+++ b/src/log_surgeon/Lalr1Parser.tpp
@@ -178,12 +178,16 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr0_kernels() -> void {
         generate_lr0_closure(item_set_ptr);
         for (auto const& next_symbol : m_terminals) {
             auto* new_item_set_ptr = go_to(item_set_ptr, next_symbol);
-            if (new_item_set_ptr != nullptr) { unused_item_sets.push_back(new_item_set_ptr); }
+            if (new_item_set_ptr != nullptr) {
+                unused_item_sets.push_back(new_item_set_ptr);
+            }
         }
         for (auto const& kv : m_non_terminals) {
             auto next_symbol = kv.first;
             auto* new_item_set_ptr = go_to(item_set_ptr, next_symbol);
-            if (new_item_set_ptr != nullptr) { unused_item_sets.push_back(new_item_set_ptr); }
+            if (new_item_set_ptr != nullptr) {
+                unused_item_sets.push_back(new_item_set_ptr);
+            }
         }
     }
 }
@@ -195,10 +199,16 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::lr_closure_helper(
         uint32_t* next_symbol
 ) -> bool {
     // add {S'->(dot)S, ""}
-    if (!item_set_ptr->m_closure.insert(*item).second) { return true; }
-    if (item->has_dot_at_end()) { return true; }
+    if (!item_set_ptr->m_closure.insert(*item).second) {
+        return true;
+    }
+    if (item->has_dot_at_end()) {
+        return true;
+    }
     *next_symbol = item->next_symbol();
-    if (symbol_is_token(*next_symbol)) { return true; }
+    if (symbol_is_token(*next_symbol)) {
+        return true;
+    }
     return false;
 }
 
@@ -213,8 +223,12 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr0_closure(ItemSet* it
         auto item = q.back();  // {S'->(dot)S, ""}
         q.pop_back();
         uint32_t next_symbol = 0;
-        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) { continue; }
-        if (m_non_terminals.find(next_symbol) == m_non_terminals.end()) { assert(false); }
+        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) {
+            continue;
+        }
+        if (m_non_terminals.find(next_symbol) == m_non_terminals.end()) {
+            assert(false);
+        }
         for (Production* const p : m_non_terminals.at(next_symbol)) {
             // S -> a
             q.emplace_back(p, 0, cNullSymbol);  // {S -> (dot) a, ""}
@@ -230,13 +244,17 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::go_to(
     auto next_item_set_ptr = std::make_unique<ItemSet>();
     assert(from_item_set != nullptr);
     for (auto const& item : from_item_set->m_closure) {
-        if (item.has_dot_at_end()) { continue; }
+        if (item.has_dot_at_end()) {
+            continue;
+        }
         if (item.next_symbol() == next_symbol) {
             next_item_set_ptr->m_kernel
                     .emplace(item.m_production, item.m_dot + 1, item.m_lookahead);
         }
     }
-    if (next_item_set_ptr->m_kernel.empty()) { return nullptr; }
+    if (next_item_set_ptr->m_kernel.empty()) {
+        return nullptr;
+    }
     if (m_lr0_item_sets.find(next_item_set_ptr->m_kernel) != m_lr0_item_sets.end()) {
         auto* existing_item_set_ptr = m_lr0_item_sets[next_item_set_ptr->m_kernel].get();
         m_go_to_table[from_item_set->m_index][next_symbol] = existing_item_set_ptr->m_index;
@@ -270,10 +288,14 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_first_sets() -> void {
             for (auto const& s : p->m_body) {
                 auto& f2 = m_firsts[s];
                 f.insert(f2.begin(), f2.end());
-                if (m_nullable.find(s) == m_nullable.end()) { break; }
+                if (m_nullable.find(s) == m_nullable.end()) {
+                    break;
+                }
                 i++;
             }
-            if (i == p->m_body.size()) { changed = changed || m_nullable.insert(p->m_head).second; }
+            if (i == p->m_body.size()) {
+                changed = changed || m_nullable.insert(p->m_head).second;
+            }
             changed = changed || (f.size() != old);
         }
     }
@@ -364,7 +386,9 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr1_closure(ItemSet* it
         auto item = queue.back();
         queue.pop_back();
         uint32_t next_symbol = 0;
-        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) { continue; }
+        if (lr_closure_helper(item_set_ptr, &item, &next_symbol)) {
+            continue;
+        }
         std::vector<uint32_t> lookaheads;
         auto pos = item.m_dot + 1;
         while (pos < item.m_production->m_body.size()) {
@@ -375,12 +399,18 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::generate_lr1_closure(ItemSet* it
                     std::make_move_iterator(symbol_firsts.begin()),
                     std::make_move_iterator(symbol_firsts.end())
             );
-            if (m_nullable.find(symbol) == m_nullable.end()) { break; }
+            if (m_nullable.find(symbol) == m_nullable.end()) {
+                break;
+            }
             pos++;
         }
-        if (pos == item.m_production->m_body.size()) { lookaheads.push_back(item.m_lookahead); }
+        if (pos == item.m_production->m_body.size()) {
+            lookaheads.push_back(item.m_lookahead);
+        }
         for (auto* const p : m_non_terminals.at(next_symbol)) {
-            for (auto const l : lookaheads) { queue.emplace_back(p, 0, l); }
+            for (auto const l : lookaheads) {
+                queue.emplace_back(p, 0, l);
+            }
         }
     }
 }
@@ -556,7 +586,9 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::report_error() -> std::string {
     std::string error_indicator;
     auto error_token = token;
     auto rest_of_line = get_input_until_next_newline(&error_token);
-    for (uint32_t i = 0; i < consumed_input.size() + 10; i++) { error_indicator += " "; }
+    for (uint32_t i = 0; i < consumed_input.size() + 10; i++) {
+        error_indicator += " ";
+    }
     error_indicator += "^\n";
     if (token.m_type_ids_ptr->at(0) == (uint32_t)SymbolId::TokenEnd && consumed_input.empty()) {
         error_type = "empty file";
@@ -585,7 +617,9 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::report_error() -> std::string {
     auto error_string = "Schema:" + std::to_string(line_num + 1) + ":"
                         + std::to_string(consumed_input.size() + 1) + ": error: " + error_type
                         + "\n";
-    for (int i = 0; i < 10; i++) { error_string += " "; }
+    for (int i = 0; i < 10; i++) {
+        error_string += " ";
+    }
     error_string += consumed_input + error_token.to_string() + rest_of_line + error_indicator;
     return error_string;
 }
@@ -598,9 +632,13 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse(Reader& reader) -> NonTerm
     while (true) {
         m_input_buffer.read_if_safe(reader);
         auto next_terminal = get_next_symbol();
-        if (parse_advance(next_terminal, &accept)) { break; }
+        if (parse_advance(next_terminal, &accept)) {
+            break;
+        }
+    }
+    if (!accept) {
+        throw std::runtime_error(report_error());
     }
-    if (!accept) { throw std::runtime_error(report_error()); }
     assert(!m_parse_stack_matches.empty());
     MatchedSymbol m{std::move(m_parse_stack_matches.top())};
     m_parse_stack_matches.pop();
@@ -611,8 +649,12 @@ auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse(Reader& reader) -> NonTerm
 template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::reset() -> void {
     m_next_token = std::nullopt;
-    while (!m_parse_stack_states.empty()) { m_parse_stack_states.pop(); }
-    while (!m_parse_stack_matches.empty()) { m_parse_stack_matches.pop(); }
+    while (!m_parse_stack_states.empty()) {
+        m_parse_stack_states.pop();
+    }
+    while (!m_parse_stack_matches.empty()) {
+        m_parse_stack_matches.pop();
+    }
     m_input_buffer.reset();
     m_lexer.reset();
 }
@@ -621,7 +663,9 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::get_next_symbol() -> Token {
     if (m_next_token == std::nullopt) {
         auto [err, optional_token] = m_lexer.scan(m_input_buffer);
-        if (ErrorCode::Success != err) { throw std::runtime_error("Error scanning in lexer."); }
+        if (ErrorCode::Success != err) {
+            throw std::runtime_error("Error scanning in lexer.");
+        }
         return optional_token.value();
     }
     auto s = m_next_token.value();
@@ -633,7 +677,9 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lalr1Parser<TypedNfaState, TypedDfaState>::parse_advance(Token& next_token, bool* accept)
         -> bool {
     for (auto const type : *next_token.m_type_ids_ptr) {
-        if (parse_symbol(type, next_token, accept)) { return *accept; }
+        if (parse_symbol(type, next_token, accept)) {
+            return *accept;
+        }
     }
     assert(*accept == false);
     // For error handling
diff --git a/src/log_surgeon/Lexer.hpp b/src/log_surgeon/Lexer.hpp
index d77b26e9..78ed68d8 100644
--- a/src/log_surgeon/Lexer.hpp
+++ b/src/log_surgeon/Lexer.hpp
@@ -198,7 +198,9 @@ class Lexer {
     [[nodiscard]] auto get_reg_id_from_tag_id(tag_id_t const tag_id) const
             -> std::optional<reg_id_t> {
         auto const& tag_id_to_final_reg_id{m_dfa->get_tag_id_to_final_reg_id()};
-        if (tag_id_to_final_reg_id.contains(tag_id)) { return tag_id_to_final_reg_id.at(tag_id); }
+        if (tag_id_to_final_reg_id.contains(tag_id)) {
+            return tag_id_to_final_reg_id.at(tag_id);
+        }
         return std::nullopt;
     }
 
@@ -211,14 +213,20 @@ class Lexer {
     [[nodiscard]] auto get_reg_ids_from_capture_id(capture_id_t const capture_id) const
             -> std::optional<std::pair<reg_id_t, reg_id_t>> {
         auto const optional_tag_id_pair{get_tag_id_pair_from_capture_id(capture_id)};
-        if (false == optional_tag_id_pair.has_value()) { return std::nullopt; }
+        if (false == optional_tag_id_pair.has_value()) {
+            return std::nullopt;
+        }
         auto const [start_tag_id, end_tag_id]{optional_tag_id_pair.value()};
 
         auto const optional_start_reg_id{get_reg_id_from_tag_id(start_tag_id)};
-        if (false == optional_start_reg_id.has_value()) { return std::nullopt; }
+        if (false == optional_start_reg_id.has_value()) {
+            return std::nullopt;
+        }
 
         auto const optional_end_reg_id{get_reg_id_from_tag_id(end_tag_id)};
-        if (false == optional_end_reg_id.has_value()) { return std::nullopt; }
+        if (false == optional_end_reg_id.has_value()) {
+            return std::nullopt;
+        }
 
         return std::make_pair(optional_start_reg_id.value(), optional_end_reg_id.value());
     }
diff --git a/src/log_surgeon/Lexer.tpp b/src/log_surgeon/Lexer.tpp
index 1966fd8c..d05f7aa7 100644
--- a/src/log_surgeon/Lexer.tpp
+++ b/src/log_surgeon/Lexer.tpp
@@ -323,7 +323,9 @@ auto Lexer<TypedNfaState, TypedDfaState>::scan_with_wildcard(
                         unvisited_states.pop();
                         visited_states.insert(current_state);
                         for (uint32_t byte = 0; byte < cSizeOfByte; byte++) {
-                            if (m_is_delimiter[byte]) { continue; }
+                            if (m_is_delimiter[byte]) {
+                                continue;
+                            }
                             auto const& optional_wildcard_transition{
                                     current_state->get_transition(byte)
                             };
@@ -364,7 +366,9 @@ auto Lexer<TypedNfaState, TypedDfaState>::increase_buffer_capacity(ParserInputBu
     bool flipped_static_buffer{false};
     input_buffer.increase_capacity(old_storage_size, flipped_static_buffer);
     if (old_storage_size < input_buffer.storage().size()) {
-        if (flipped_static_buffer) { flip_states(old_storage_size); }
+        if (flipped_static_buffer) {
+            flip_states(old_storage_size);
+        }
         if (0 == m_last_match_pos) {
             m_last_match_pos = old_storage_size;
             m_start_pos = old_storage_size;
@@ -403,8 +407,12 @@ template <typename TypedNfaState, typename TypedDfaState>
 void Lexer<TypedNfaState, TypedDfaState>::set_delimiters(std::vector<uint32_t> const& delimiters) {
     assert(!delimiters.empty());
     m_has_delimiters = true;
-    for (auto& i : m_is_delimiter) { i = false; }
-    for (auto delimiter : delimiters) { m_is_delimiter[delimiter] = true; }
+    for (auto& i : m_is_delimiter) {
+        i = false;
+    }
+    for (auto delimiter : delimiters) {
+        m_is_delimiter[delimiter] = true;
+    }
     m_is_delimiter[utf8::cCharStartOfFile] = true;
 }
 
@@ -420,7 +428,9 @@ template <typename TypedNfaState, typename TypedDfaState>
 auto Lexer<TypedNfaState, TypedDfaState>::get_highest_priority_rule(rule_id_t const rule_id)
         -> finite_automata::RegexAST<TypedNfaState>* {
     for (auto const& rule : m_rules) {
-        if (rule.get_variable_id() == rule_id) { return rule.get_regex(); }
+        if (rule.get_variable_id() == rule_id) {
+            return rule.get_regex();
+        }
     }
     return nullptr;
 }
diff --git a/src/log_surgeon/LogEvent.cpp b/src/log_surgeon/LogEvent.cpp
index 0039dd22..fff930f1 100644
--- a/src/log_surgeon/LogEvent.cpp
+++ b/src/log_surgeon/LogEvent.cpp
@@ -21,20 +21,26 @@ auto LogEventView::deep_copy() const -> LogEvent {
 }
 
 auto LogEventView::reset() -> void {
-    for (std::vector<Token*>& log_var_occ : m_log_var_occurrences) { log_var_occ.clear(); }
+    for (std::vector<Token*>& log_var_occ : m_log_var_occurrences) {
+        log_var_occ.clear();
+    }
     m_log_output_buffer->reset();
     m_multiline = false;
 }
 
 [[nodiscard]] auto LogEventView::get_timestamp() const -> Token* {
-    if (m_log_output_buffer->has_timestamp()) { return &m_log_output_buffer->get_mutable_token(0); }
+    if (m_log_output_buffer->has_timestamp()) {
+        return &m_log_output_buffer->get_mutable_token(0);
+    }
     return nullptr;
 }
 
 [[nodiscard]] auto LogEventView::to_string() const -> std::string {
     std::string raw_log;
     uint32_t start = 0;
-    if (false == m_log_output_buffer->has_timestamp()) { start = 1; }
+    if (false == m_log_output_buffer->has_timestamp()) {
+        start = 1;
+    }
     for (uint32_t i = start; i < m_log_output_buffer->pos(); i++) {
         auto& token = m_log_output_buffer->get_mutable_token(i);
         raw_log += token.to_string_view();
@@ -92,13 +98,17 @@ LogEvent::LogEvent(LogEventView const& src) : LogEventView{src.get_log_parser()}
     m_log_output_buffer->set_has_timestamp(src.m_log_output_buffer->has_timestamp());
     m_log_output_buffer->set_has_delimiters(src.m_log_output_buffer->has_delimiters());
     uint32_t start = 0;
-    if (nullptr == src.get_timestamp()) { start = 1; }
+    if (nullptr == src.get_timestamp()) {
+        start = 1;
+    }
     uint32_t buffer_size{0};
     for (uint32_t i = start; i < src.get_log_output_buffer()->pos(); i++) {
         Token const& token = src.get_log_output_buffer()->get_token(i);
         buffer_size += token.get_length();
     }
-    if (0 >= buffer_size) { throw std::runtime_error("token buffer_size <= 0"); }
+    if (0 >= buffer_size) {
+        throw std::runtime_error("token buffer_size <= 0");
+    }
     m_buffer.resize(buffer_size);
     uint32_t curr_pos = 0;
     for (uint32_t i = start; i < src.get_log_output_buffer()->pos(); i++) {
diff --git a/src/log_surgeon/LogParser.cpp b/src/log_surgeon/LogParser.cpp
index f01a0e2c..2fee7726 100644
--- a/src/log_surgeon/LogParser.cpp
+++ b/src/log_surgeon/LogParser.cpp
@@ -39,14 +39,20 @@ LogParser::LogParser(std::unique_ptr<SchemaAST> schema_ast) {
 
 auto LogParser::set_delimiters(unique_ptr<ParserAST> const& delimiters) -> void {
     auto* delimiters_ptr = dynamic_cast<DelimiterStringAST*>(delimiters.get());
-    if (delimiters_ptr != nullptr) { m_lexer.set_delimiters(delimiters_ptr->m_delimiters); }
+    if (delimiters_ptr != nullptr) {
+        m_lexer.set_delimiters(delimiters_ptr->m_delimiters);
+    }
 }
 
 auto LogParser::add_rules(std::unique_ptr<SchemaAST> schema_ast) -> void {
-    for (auto const& delimiters : schema_ast->m_delimiters) { set_delimiters(delimiters); }
+    for (auto const& delimiters : schema_ast->m_delimiters) {
+        set_delimiters(delimiters);
+    }
     vector<uint32_t> delimiters;
     for (uint32_t i = 0; i < cSizeOfByte; i++) {
-        if (m_lexer.is_delimiter(i)) { delimiters.push_back(i); }
+        if (m_lexer.is_delimiter(i)) {
+            delimiters.push_back(i);
+        }
     }
 
     // Required to have delimiters
@@ -111,7 +117,9 @@ auto LogParser::reset() -> void {
 
 auto LogParser::parse_and_generate_metadata(LogParser::ParsingAction& parsing_action) -> ErrorCode {
     ErrorCode error_code = parse(parsing_action);
-    if (ErrorCode::Success == error_code) { generate_log_event_view_metadata(); }
+    if (ErrorCode::Success == error_code) {
+        generate_log_event_view_metadata();
+    }
     return error_code;
 }
 
@@ -124,7 +132,9 @@ auto LogParser::parse(LogParser::ParsingAction& parsing_action) -> ErrorCode {
             next_token = m_start_of_log_message;
         } else {
             auto [err, optional_next_token] = get_next_symbol();
-            if (ErrorCode::Success != err) { return err; }
+            if (ErrorCode::Success != err) {
+                return err;
+            }
             next_token = optional_next_token.value();
             if (false == output_buffer->has_timestamp()
                 && next_token.m_type_ids_ptr->at(0) == (uint32_t)SymbolId::TokenNewlineTimestamp)
@@ -174,7 +184,9 @@ auto LogParser::parse(LogParser::ParsingAction& parsing_action) -> ErrorCode {
 
     while (true) {
         auto [err, optional_next_token] = get_next_symbol();
-        if (ErrorCode::Success != err) { return err; }
+        if (ErrorCode::Success != err) {
+            return err;
+        }
         Token next_token{optional_next_token.value()};
         output_buffer->set_curr_token(next_token);
         auto token_type = next_token.m_type_ids_ptr->at(0);
@@ -237,12 +249,16 @@ auto LogParser::get_next_symbol() -> std::pair<ErrorCode, std::optional<Token>>
 
 auto LogParser::generate_log_event_view_metadata() -> void {
     uint32_t start = 0;
-    if (false == m_log_event_view->m_log_output_buffer->has_timestamp()) { start = 1; }
+    if (false == m_log_event_view->m_log_output_buffer->has_timestamp()) {
+        start = 1;
+    }
     uint32_t first_newline_pos{0};
     for (uint32_t i = start; i < m_log_event_view->m_log_output_buffer->pos(); i++) {
         Token* token = &m_log_event_view->m_log_output_buffer->get_mutable_token(i);
         m_log_event_view->add_token(token->m_type_ids_ptr->at(0), token);
-        if (token->get_delimiter() == "\n" && first_newline_pos == 0) { first_newline_pos = i; }
+        if (token->get_delimiter() == "\n" && first_newline_pos == 0) {
+            first_newline_pos = i;
+        }
     }
     // To be a multiline log there must be at least one token between the
     // newline token and the last token in the output buffer.
diff --git a/src/log_surgeon/ParserInputBuffer.cpp b/src/log_surgeon/ParserInputBuffer.cpp
index 89208ec0..8fdb70b2 100644
--- a/src/log_surgeon/ParserInputBuffer.cpp
+++ b/src/log_surgeon/ParserInputBuffer.cpp
@@ -19,7 +19,9 @@ auto ParserInputBuffer::reset() -> void {
 }
 
 auto ParserInputBuffer::read_is_safe() -> bool {
-    if (m_finished_reading_input) { return false; }
+    if (m_finished_reading_input) {
+        return false;
+    }
     // Check if the last log message ends in the buffer half last read.
     // This means the other half of the buffer has already been fully used.
     if ((!m_last_read_first_half && m_consumed_pos > m_storage.size() / 2)
@@ -34,20 +36,28 @@ auto ParserInputBuffer::read(Reader& reader) -> ErrorCode {
     size_t bytes_read{0};
     // read into the correct half of the buffer
     uint32_t read_offset{0};
-    if (m_last_read_first_half) { read_offset = m_storage.size() / 2; }
+    if (m_last_read_first_half) {
+        read_offset = m_storage.size() / 2;
+    }
     if (ErrorCode err = m_storage.read(reader, read_offset, m_storage.size() / 2, bytes_read);
         ErrorCode::Success != err)
     {
-        if (ErrorCode::EndOfFile == err) { m_finished_reading_input = true; }
+        if (ErrorCode::EndOfFile == err) {
+            m_finished_reading_input = true;
+        }
         return err;
     }
     m_last_read_first_half = !m_last_read_first_half;
     // TODO: This is not a portable check for certain forms of IO
     // A method from Reader should be used to check if the input source is
     // finished
-    if (bytes_read < m_storage.size() / 2) { m_finished_reading_input = true; }
+    if (bytes_read < m_storage.size() / 2) {
+        m_finished_reading_input = true;
+    }
     m_pos_last_read_char += bytes_read;
-    if (m_pos_last_read_char > m_storage.size()) { m_pos_last_read_char -= m_storage.size(); }
+    if (m_pos_last_read_char > m_storage.size()) {
+        m_pos_last_read_char -= m_storage.size();
+    }
     return ErrorCode::Success;
 }
 
@@ -86,7 +96,9 @@ auto ParserInputBuffer::get_next_character(unsigned char& next_char) -> ErrorCod
     }
     char character = m_storage.get_curr_value();
     m_storage.increment_pos();
-    if (m_storage.pos() == m_storage.size()) { m_storage.set_pos(0); }
+    if (m_storage.pos() == m_storage.size()) {
+        m_storage.set_pos(0);
+    }
     next_char = character;
     return ErrorCode::Success;
 }
diff --git a/src/log_surgeon/ParserInputBuffer.hpp b/src/log_surgeon/ParserInputBuffer.hpp
index df67ff39..5e50ce0a 100644
--- a/src/log_surgeon/ParserInputBuffer.hpp
+++ b/src/log_surgeon/ParserInputBuffer.hpp
@@ -39,7 +39,9 @@ class ParserInputBuffer {
      * @return ErrorCode forwarded from read.
      */
     auto read_if_safe(Reader& reader) -> ErrorCode {
-        if (read_is_safe()) { return read(reader); }
+        if (read_is_safe()) {
+            return read(reader);
+        }
         return ErrorCode::Success;
     }
 
diff --git a/src/log_surgeon/ReaderParser.cpp b/src/log_surgeon/ReaderParser.cpp
index 44e1a41b..bcb5c7d0 100644
--- a/src/log_surgeon/ReaderParser.cpp
+++ b/src/log_surgeon/ReaderParser.cpp
@@ -29,7 +29,9 @@ auto ReaderParser::parse_next_event() -> ErrorCode {
         LogParser::ParsingAction parsing_action{LogParser::ParsingAction::None};
         ErrorCode parse_error = m_log_parser.parse_and_generate_metadata(parsing_action);
         if (ErrorCode::Success == parse_error) {
-            if (LogParser::ParsingAction::CompressAndFinish == parsing_action) { m_done = true; }
+            if (LogParser::ParsingAction::CompressAndFinish == parsing_action) {
+                m_done = true;
+            }
             break;
         }
         if (ErrorCode::BufferOutOfBounds == parse_error) {
diff --git a/src/log_surgeon/SchemaParser.cpp b/src/log_surgeon/SchemaParser.cpp
index 7e1af6b7..76f4b64b 100644
--- a/src/log_surgeon/SchemaParser.cpp
+++ b/src/log_surgeon/SchemaParser.cpp
@@ -23,7 +23,8 @@
 #include <log_surgeon/utils.hpp>
 
 using ParserValueRegex = log_surgeon::ParserValue<std::unique_ptr<
-        log_surgeon::finite_automata::RegexAST<log_surgeon::finite_automata::ByteNfaState>>>;
+        log_surgeon::finite_automata::RegexAST<log_surgeon::finite_automata::ByteNfaState>
+>>;
 using RegexASTByte
         = log_surgeon::finite_automata::RegexAST<log_surgeon::finite_automata::ByteNfaState>;
 using RegexASTGroupByte
@@ -32,8 +33,8 @@ using RegexASTIntegerByte
         = log_surgeon::finite_automata::RegexASTInteger<log_surgeon::finite_automata::ByteNfaState>;
 using RegexASTLiteralByte
         = log_surgeon::finite_automata::RegexASTLiteral<log_surgeon::finite_automata::ByteNfaState>;
-using RegexASTMultiplicationByte = log_surgeon::finite_automata::RegexASTMultiplication<
-        log_surgeon::finite_automata::ByteNfaState>;
+using RegexASTMultiplicationByte = log_surgeon::finite_automata::
+        RegexASTMultiplication<log_surgeon::finite_automata::ByteNfaState>;
 using RegexASTOrByte
         = log_surgeon::finite_automata::RegexASTOr<log_surgeon::finite_automata::ByteNfaState>;
 using RegexASTCatByte
@@ -80,7 +81,9 @@ auto SchemaParser::try_schema_file(string const& schema_file_path) -> unique_ptr
     SchemaParser sp;
     Reader reader{[&](char* buf, size_t count, size_t& read_to) -> ErrorCode {
         schema_reader.read(buf, count, read_to);
-        if (read_to == 0) { return ErrorCode::EndOfFile; }
+        if (read_to == 0) {
+            return ErrorCode::EndOfFile;
+        }
         return ErrorCode::Success;
     }};
     unique_ptr<SchemaAST> schema_ast = sp.generate_schema_ast(reader);
@@ -96,8 +99,12 @@ auto SchemaParser::try_schema_string(string_view const schema_string) -> unique_
             count = schema_string.length() - unparsed_string_pos;
         }
         read_to = count;
-        if (read_to == 0) { return ErrorCode::EndOfFile; }
-        for (uint32_t i = 0; i < count; i++) { buf[i] = schema_string[unparsed_string_pos + i]; }
+        if (read_to == 0) {
+            return ErrorCode::EndOfFile;
+        }
+        for (uint32_t i = 0; i < count; i++) {
+            buf[i] = schema_string[unparsed_string_pos + i];
+        }
         unparsed_string_pos += count;
         return ErrorCode::Success;
     }};
diff --git a/src/log_surgeon/Token.cpp b/src/log_surgeon/Token.cpp
index 52cbc6af..e8966412 100644
--- a/src/log_surgeon/Token.cpp
+++ b/src/log_surgeon/Token.cpp
@@ -6,7 +6,9 @@
 
 namespace log_surgeon {
 auto Token::to_string() -> std::string {
-    if (m_start_pos <= m_end_pos) { return {m_buffer + m_start_pos, m_buffer + m_end_pos}; }
+    if (m_start_pos <= m_end_pos) {
+        return {m_buffer + m_start_pos, m_buffer + m_end_pos};
+    }
     if (m_wrap_around_string.empty()) {
         m_wrap_around_string = std::string{m_buffer + m_start_pos, m_buffer + m_buffer_size}
                                + std::string{m_buffer, m_buffer + m_end_pos};
@@ -15,7 +17,9 @@ auto Token::to_string() -> std::string {
 }
 
 auto Token::to_string_view() -> std::string_view {
-    if (m_start_pos <= m_end_pos) { return {m_buffer + m_start_pos, m_end_pos - m_start_pos}; }
+    if (m_start_pos <= m_end_pos) {
+        return {m_buffer + m_start_pos, m_end_pos - m_start_pos};
+    }
     if (m_wrap_around_string.empty()) {
         m_wrap_around_string = std::string{m_buffer + m_start_pos, m_buffer + m_buffer_size}
                                + std::string{m_buffer, m_buffer + m_end_pos};
@@ -45,7 +49,9 @@ void Token::append_context_to_logtype(
         auto const reg_end_positions{m_reg_handler.get_reversed_positions(end_reg_id)};
 
         for (size_t j{0}; j < reg_start_positions.size(); ++j) {
-            if (reg_start_positions[j] < 0) { continue; }
+            if (reg_start_positions[j] < 0) {
+                continue;
+            }
             variable_positions.push_back(
                     {static_cast<uint32_t>(reg_start_positions[j]),
                      static_cast<uint32_t>(reg_end_positions[j]),
@@ -78,7 +84,9 @@ void Token::append_context_to_logtype(
 }
 
 auto Token::get_char(uint8_t i) const -> char {
-    if (m_start_pos + i < m_buffer_size) { return m_buffer[m_start_pos + i]; }
+    if (m_start_pos + i < m_buffer_size) {
+        return m_buffer[m_start_pos + i];
+    }
     return m_buffer[i - (m_buffer_size - m_start_pos)];
 }
 
@@ -87,7 +95,9 @@ auto Token::get_delimiter() const -> std::string {
 }
 
 auto Token::get_length() const -> uint32_t {
-    if (m_start_pos <= m_end_pos) { return m_end_pos - m_start_pos; }
+    if (m_start_pos <= m_end_pos) {
+        return m_end_pos - m_start_pos;
+    }
     return m_buffer_size - m_start_pos + m_end_pos;
 }
 }  // namespace log_surgeon
diff --git a/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp b/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
index 4f52a534..af679957 100644
--- a/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
+++ b/src/log_surgeon/finite_automata/DeterminizationConfiguration.hpp
@@ -75,7 +75,9 @@ class DeterminizationConfiguration {
         if (m_tag_id_to_reg_ids != rhs.m_tag_id_to_reg_ids) {
             return m_tag_id_to_reg_ids < rhs.m_tag_id_to_reg_ids;
         }
-        if (m_history != rhs.m_history) { return m_history < rhs.m_history; }
+        if (m_history != rhs.m_history) {
+            return m_history < rhs.m_history;
+        }
         return m_lookahead < rhs.m_lookahead;
     }
 
@@ -131,7 +133,9 @@ class DeterminizationConfiguration {
 
     [[nodiscard]] auto get_tag_history(tag_id_t const tag_id) const -> std::optional<TagOperation> {
         for (auto const tag_op : m_history) {
-            if (tag_op.get_tag_id() == tag_id) { return std::make_optional<TagOperation>(tag_op); }
+            if (tag_op.get_tag_id() == tag_id) {
+                return std::make_optional<TagOperation>(tag_op);
+            }
         }
         return std::nullopt;
     }
@@ -141,7 +145,9 @@ class DeterminizationConfiguration {
     [[nodiscard]] auto get_tag_lookahead(tag_id_t const tag_id) const
             -> std::optional<TagOperation> {
         for (auto const tag_op : m_lookahead) {
-            if (tag_op.get_tag_id() == tag_id) { return std::make_optional<TagOperation>(tag_op); }
+            if (tag_op.get_tag_id() == tag_id) {
+                return std::make_optional<TagOperation>(tag_op);
+            }
         }
         return std::nullopt;
     }
diff --git a/src/log_surgeon/finite_automata/Dfa.hpp b/src/log_surgeon/finite_automata/Dfa.hpp
index 186de5a2..7475e9c8 100644
--- a/src/log_surgeon/finite_automata/Dfa.hpp
+++ b/src/log_surgeon/finite_automata/Dfa.hpp
@@ -341,7 +341,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
         ConfigurationSet const& lhs,
         ConfigurationSet const& rhs
 ) -> std::optional<std::unordered_map<reg_id_t, reg_id_t>> {
-    if (lhs.size() != rhs.size()) { return std::nullopt; }
+    if (lhs.size() != rhs.size()) {
+        return std::nullopt;
+    }
     std::unordered_map<reg_id_t, reg_id_t> reg_map_lhs_to_rhs;
     std::unordered_map<reg_id_t, reg_id_t> reg_map_rhs_to_lhs;
     for (auto const& config_lhs : lhs) {
@@ -354,7 +356,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
             }
             for (auto const [tag_id, lhs_reg_id] : config_lhs.get_tag_id_to_reg_ids()) {
                 // If the NFA state sets the tag then the current register is irrelevent
-                if (config_lhs.get_tag_lookahead(tag_id).has_value()) { continue; }
+                if (config_lhs.get_tag_lookahead(tag_id).has_value()) {
+                    continue;
+                }
                 auto const rhs_reg_id{config_rhs.get_tag_id_to_reg_ids().at(tag_id)};
                 if (false == reg_map_lhs_to_rhs.contains(lhs_reg_id)
                     && false == reg_map_rhs_to_lhs.contains(rhs_reg_id))
@@ -372,7 +376,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::try_get_mapping(
             found = true;
             break;
         }
-        if (false == found) { return std::nullopt; }
+        if (false == found) {
+            return std::nullopt;
+        }
     }
     return reg_map_lhs_to_rhs;
 }
@@ -386,7 +392,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::create_or_get_dfa_state(
     if (false == dfa_states.contains(config_set)) {
         for (auto const& [config_set_in_map, dfa_state] : dfa_states) {
             auto const optional_reg_map{try_get_mapping(config_set, config_set_in_map)};
-            if (optional_reg_map.has_value()) { return {dfa_state, optional_reg_map}; }
+            if (optional_reg_map.has_value()) {
+                return {dfa_state, optional_reg_map};
+            }
         }
         dfa_states.insert({config_set, new_state(config_set, m_tag_id_to_final_reg_id)});
         unexplored_sets.push(config_set);
@@ -481,7 +489,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::reassign_transition_reg_ops(
         std::vector<RegisterOperation>& reg_ops
 ) -> void {
     for (auto const [old_reg_id, new_reg_id] : reg_map) {
-        if (old_reg_id == new_reg_id) { continue; }
+        if (old_reg_id == new_reg_id) {
+            continue;
+        }
         bool is_existing_reg_op_mapping{false};
         for (auto& reg_op : reg_ops) {
             if (reg_op.get_reg_id() == old_reg_id) {
@@ -564,7 +574,9 @@ auto Dfa<TypedDfaState, TypedNfaState>::get_bfs_traversal_order() const
 
     auto try_add_to_queue_and_visited
             = [&state_queue, &visited_states](TypedDfaState const* dest_state) {
-                  if (visited_states.insert(dest_state).second) { state_queue.push(dest_state); }
+                  if (visited_states.insert(dest_state).second) {
+                      state_queue.push(dest_state);
+                  }
               };
 
     try_add_to_queue_and_visited(get_root());
@@ -590,12 +602,16 @@ auto Dfa<TypedDfaState, TypedNfaState>::serialize() const -> std::optional<std::
 
     std::unordered_map<TypedDfaState const*, uint32_t> state_ids;
     state_ids.reserve(traversal_order.size());
-    for (auto const* state : traversal_order) { state_ids.emplace(state, state_ids.size()); }
+    for (auto const* state : traversal_order) {
+        state_ids.emplace(state, state_ids.size());
+    }
 
     std::vector<std::string> serialized_states;
     for (auto const* state : traversal_order) {
         auto const optional_serialized_state{state->serialize(state_ids)};
-        if (false == optional_serialized_state.has_value()) { return std::nullopt; }
+        if (false == optional_serialized_state.has_value()) {
+            return std::nullopt;
+        }
         serialized_states.emplace_back(optional_serialized_state.value());
     }
     return fmt::format("{}\n", fmt::join(serialized_states, "\n"));
diff --git a/src/log_surgeon/finite_automata/DfaState.hpp b/src/log_surgeon/finite_automata/DfaState.hpp
index 5ec3375c..0cec7c77 100644
--- a/src/log_surgeon/finite_automata/DfaState.hpp
+++ b/src/log_surgeon/finite_automata/DfaState.hpp
@@ -118,9 +118,13 @@ auto DfaState<state_type>::serialize(
 
     std::vector<std::string> transition_strings;
     for (uint32_t idx{0}; idx < cSizeOfByte; ++idx) {
-        if (false == m_bytes_transition[idx].has_value()) { continue; }
+        if (false == m_bytes_transition[idx].has_value()) {
+            continue;
+        }
         auto const optional_byte_transition_string{m_bytes_transition[idx]->serialize(state_ids)};
-        if (false == optional_byte_transition_string.has_value()) { return std::nullopt; }
+        if (false == optional_byte_transition_string.has_value()) {
+            return std::nullopt;
+        }
         transition_strings.emplace_back(
                 fmt::format("{}{}", static_cast<char>(idx), optional_byte_transition_string.value())
         );
diff --git a/src/log_surgeon/finite_automata/DfaStatePair.hpp b/src/log_surgeon/finite_automata/DfaStatePair.hpp
index 2a5796e9..ce103f5d 100644
--- a/src/log_surgeon/finite_automata/DfaStatePair.hpp
+++ b/src/log_surgeon/finite_automata/DfaStatePair.hpp
@@ -32,7 +32,9 @@ class DfaStatePair {
      * whether `m_state2` in lhs has a lower address than in rhs.
      */
     auto operator<(DfaStatePair const& rhs) const -> bool {
-        if (m_state1 == rhs.m_state1) { return m_state2 < rhs.m_state2; }
+        if (m_state1 == rhs.m_state1) {
+            return m_state2 < rhs.m_state2;
+        }
         return m_state1 < rhs.m_state1;
     }
 
diff --git a/src/log_surgeon/finite_automata/DfaTransition.hpp b/src/log_surgeon/finite_automata/DfaTransition.hpp
index e08688e5..327116a4 100644
--- a/src/log_surgeon/finite_automata/DfaTransition.hpp
+++ b/src/log_surgeon/finite_automata/DfaTransition.hpp
@@ -59,12 +59,16 @@ template <StateType state_type>
 auto DfaTransition<state_type>::serialize(
         std::unordered_map<DfaState<state_type> const*, uint32_t> const& state_ids
 ) const -> std::optional<std::string> {
-    if (false == state_ids.contains(m_dest_state)) { return std::nullopt; }
+    if (false == state_ids.contains(m_dest_state)) {
+        return std::nullopt;
+    }
 
     std::vector<std::string> transformed_ops;
     for (auto const& reg_op : m_reg_ops) {
         auto const optional_serialized_op{reg_op.serialize()};
-        if (false == optional_serialized_op.has_value()) { return std::nullopt; }
+        if (false == optional_serialized_op.has_value()) {
+            return std::nullopt;
+        }
         transformed_ops.emplace_back(optional_serialized_op.value());
     }
 
diff --git a/src/log_surgeon/finite_automata/Nfa.hpp b/src/log_surgeon/finite_automata/Nfa.hpp
index 8a6ade73..6ce71320 100644
--- a/src/log_surgeon/finite_automata/Nfa.hpp
+++ b/src/log_surgeon/finite_automata/Nfa.hpp
@@ -129,7 +129,9 @@ class Nfa {
 template <typename TypedNfaState>
 Nfa<TypedNfaState>::Nfa(std::vector<LexicalRule<TypedNfaState>> const& rules) {
     m_root = new_state();
-    for (auto const& rule : rules) { rule.add_to_nfa(this); }
+    for (auto const& rule : rules) {
+        rule.add_to_nfa(this);
+    }
 }
 
 template <typename TypedNfaState>
@@ -223,7 +225,9 @@ auto Nfa<TypedNfaState>::get_bfs_traversal_order() const -> std::vector<TypedNfa
 
     auto add_to_queue_and_visited
             = [&state_queue, &visited_states](TypedNfaState const* dest_state) {
-                  if (visited_states.insert(dest_state).second) { state_queue.push(dest_state); }
+                  if (visited_states.insert(dest_state).second) {
+                      state_queue.push(dest_state);
+                  }
               };
 
     add_to_queue_and_visited(m_root);
@@ -249,12 +253,16 @@ auto Nfa<TypedNfaState>::serialize() const -> std::optional<std::string> {
     auto const traversal_order = get_bfs_traversal_order();
 
     std::unordered_map<TypedNfaState const*, uint32_t> state_ids;
-    for (auto const* state : traversal_order) { state_ids.emplace(state, state_ids.size()); }
+    for (auto const* state : traversal_order) {
+        state_ids.emplace(state, state_ids.size());
+    }
 
     std::vector<std::string> serialized_states;
     for (auto const* state : traversal_order) {
         auto const optional_serialized_state{state->serialize(state_ids)};
-        if (false == optional_serialized_state.has_value()) { return std::nullopt; }
+        if (false == optional_serialized_state.has_value()) {
+            return std::nullopt;
+        }
         serialized_states.emplace_back(optional_serialized_state.value());
     }
     return fmt::format("{}\n", fmt::join(serialized_states, "\n"));
diff --git a/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp b/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
index b2176442..2f990bb9 100644
--- a/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
+++ b/src/log_surgeon/finite_automata/NfaSpontaneousTransition.hpp
@@ -50,7 +50,9 @@ template <typename TypedNfaState>
 auto NfaSpontaneousTransition<TypedNfaState>::serialize(
         std::unordered_map<TypedNfaState const*, uint32_t> const& state_ids
 ) const -> std::optional<std::string> {
-    if (false == state_ids.contains(m_dest_state)) { return std::nullopt; }
+    if (false == state_ids.contains(m_dest_state)) {
+        return std::nullopt;
+    }
     auto transformed_operations
             = m_tag_ops | std::ranges::views::transform(&TagOperation::serialize);
 
diff --git a/src/log_surgeon/finite_automata/NfaState.hpp b/src/log_surgeon/finite_automata/NfaState.hpp
index dac6345e..e5f973bd 100644
--- a/src/log_surgeon/finite_automata/NfaState.hpp
+++ b/src/log_surgeon/finite_automata/NfaState.hpp
@@ -78,7 +78,9 @@ class NfaState {
     ) -> void {
         std::vector<TagOperation> tag_ops;
         tag_ops.reserve(tag_ids.size());
-        for (auto const tag_id : tag_ids) { tag_ops.emplace_back(tag_id, op_type, multi_valued); }
+        for (auto const tag_id : tag_ids) {
+            tag_ops.emplace_back(tag_id, op_type, multi_valued);
+        }
         m_spontaneous_transitions.emplace_back(std::move(tag_ops), dest_state);
     }
 
@@ -137,11 +139,15 @@ template <StateType state_type>
 auto NfaState<state_type>::add_interval(Interval interval, NfaState* dest_state) -> void {
     if (interval.first < cSizeOfByte) {
         uint32_t const bound = std::min(interval.second, cSizeOfByte - 1);
-        for (uint32_t i = interval.first; i <= bound; i++) { add_byte_transition(i, dest_state); }
+        for (uint32_t i = interval.first; i <= bound; i++) {
+            add_byte_transition(i, dest_state);
+        }
         interval.first = bound + 1;
     }
     if constexpr (StateType::Utf8 == state_type) {
-        if (interval.second < cSizeOfByte) { return; }
+        if (interval.second < cSizeOfByte) {
+            return;
+        }
         std::unique_ptr<std::vector<typename Tree::Data>> overlaps
                 = m_tree_transitions.pop(interval);
         for (typename Tree::Data const& data : *overlaps) {
@@ -196,7 +202,9 @@ auto NfaState<state_type>::serialize(
     std::vector<std::string> serialized_spontaneous_transitions;
     for (auto const& spontaneous_transition : m_spontaneous_transitions) {
         auto const optional_serialized_transition{spontaneous_transition.serialize(state_ids)};
-        if (false == optional_serialized_transition.has_value()) { return std::nullopt; }
+        if (false == optional_serialized_transition.has_value()) {
+            return std::nullopt;
+        }
         serialized_spontaneous_transitions.emplace_back(optional_serialized_transition.value());
     }
 
diff --git a/src/log_surgeon/finite_automata/PrefixTree.cpp b/src/log_surgeon/finite_automata/PrefixTree.cpp
index 92e72dac..4a652346 100644
--- a/src/log_surgeon/finite_automata/PrefixTree.cpp
+++ b/src/log_surgeon/finite_automata/PrefixTree.cpp
@@ -5,7 +5,9 @@
 
 namespace log_surgeon::finite_automata {
 auto PrefixTree::get_reversed_positions(id_t const node_id) const -> std::vector<position_t> {
-    if (m_nodes.size() <= node_id) { throw std::out_of_range("Prefix tree index out of range."); }
+    if (m_nodes.size() <= node_id) {
+        throw std::out_of_range("Prefix tree index out of range.");
+    }
 
     std::vector<position_t> reversed_positions;
     auto current_node{m_nodes[node_id]};
diff --git a/src/log_surgeon/finite_automata/RegexAST.hpp b/src/log_surgeon/finite_automata/RegexAST.hpp
index 8aaa632d..3d5bbe04 100644
--- a/src/log_surgeon/finite_automata/RegexAST.hpp
+++ b/src/log_surgeon/finite_automata/RegexAST.hpp
@@ -158,7 +158,9 @@ class RegexAST {
     auto operator=(RegexAST&& rhs) noexcept -> RegexAST& = delete;
 
     [[nodiscard]] auto serialize_negative_captures() const -> std::u32string {
-        if (m_negative_captures.empty()) { return U""; }
+        if (m_negative_captures.empty()) {
+            return U"";
+        }
 
         auto const transformed_negative_captures{
                 m_negative_captures | std::ranges::views::transform([](Capture const* capture) {
@@ -287,7 +289,9 @@ class RegexASTInteger : public RegexAST<TypedNfaState> {
      */
     auto set_possible_inputs_to_true(std::array<bool, cSizeOfUnicode>& is_possible_input) const
             -> void override {
-        for (uint32_t const i : m_digits) { is_possible_input.at('0' + i) = true; }
+        for (uint32_t const i : m_digits) {
+            is_possible_input.at('0' + i) = true;
+        }
     }
 
     /**
@@ -357,15 +361,21 @@ class RegexASTGroup : public RegexAST<TypedNfaState> {
             -> void override {
         if (!m_negate) {
             for (auto const& [begin, end] : m_ranges) {
-                for (uint32_t i = begin; i <= end; i++) { is_possible_input.at(i) = true; }
+                for (uint32_t i = begin; i <= end; i++) {
+                    is_possible_input.at(i) = true;
+                }
             }
         } else {
             std::vector<char> inputs(cSizeOfUnicode, 1);
             for (auto const& [begin, end] : m_ranges) {
-                for (uint32_t i = begin; i <= end; i++) { inputs[i] = 0; }
+                for (uint32_t i = begin; i <= end; i++) {
+                    inputs[i] = 0;
+                }
             }
             for (uint32_t i = 0; i < inputs.size(); i++) {
-                if (inputs[i] != 0) { is_possible_input.at(i) = true; }
+                if (inputs[i] != 0) {
+                    is_possible_input.at(i) = true;
+                }
             }
         }
     }
@@ -376,8 +386,12 @@ class RegexASTGroup : public RegexAST<TypedNfaState> {
      * @param delimiters
      */
     auto remove_delimiters_from_wildcard(std::vector<uint32_t>& delimiters) -> void override {
-        if (!m_is_wildcard) { return; }
-        if (delimiters.empty()) { return; }
+        if (!m_is_wildcard) {
+            return;
+        }
+        if (delimiters.empty()) {
+            return;
+        }
         m_ranges.clear();
         std::ranges::sort(delimiters);
         if (delimiters[0] != 0) {
@@ -654,7 +668,9 @@ class RegexASTCapture : public RegexAST<TypedNfaState> {
         if (nullptr == m_capture_regex_ast) {
             throw std::invalid_argument("Group regex AST cannot be null");
         }
-        if (nullptr == m_capture) { throw std::invalid_argument("Capture cannot be null"); }
+        if (nullptr == m_capture) {
+            throw std::invalid_argument("Capture cannot be null");
+        }
 
         RegexAST<TypedNfaState>::set_subtree_positive_captures(
                 m_capture_regex_ast->get_subtree_positive_captures()
@@ -1043,7 +1059,9 @@ RegexASTGroup<TypedNfaState>::RegexASTGroup(
 template <typename TypedNfaState>
 RegexASTGroup<TypedNfaState>::RegexASTGroup(std::vector<uint32_t> const& literals)
         : m_negate(false) {
-    for (uint32_t literal : literals) { m_ranges.emplace_back(literal, literal); }
+    for (uint32_t literal : literals) {
+        m_ranges.emplace_back(literal, literal);
+    }
 }
 
 template <typename TypedNfaState>
@@ -1055,7 +1073,9 @@ RegexASTGroup<TypedNfaState>::RegexASTGroup(uint32_t min, uint32_t max) : m_nega
 template <typename TypedNfaState>
 auto RegexASTGroup<TypedNfaState>::merge(std::vector<Range> const& ranges) -> std::vector<Range> {
     std::vector<Range> merged_ranges;
-    if (ranges.empty()) { return merged_ranges; }
+    if (ranges.empty()) {
+        return merged_ranges;
+    }
     Range cur = ranges[0];
     for (size_t i = 1; i < ranges.size(); i++) {
         auto const& range = ranges[i];
@@ -1077,10 +1097,14 @@ auto RegexASTGroup<TypedNfaState>::complement(std::vector<Range> const& ranges)
     std::vector<Range> complemented;
     uint32_t low = 0;
     for (auto const& [begin, end] : ranges) {
-        if (begin > 0) { complemented.emplace_back(low, begin - 1); }
+        if (begin > 0) {
+            complemented.emplace_back(low, begin - 1);
+        }
         low = end + 1;
     }
-    if (low > 0) { complemented.emplace_back(low, cUnicodeMax); }
+    if (low > 0) {
+        complemented.emplace_back(low, cUnicodeMax);
+    }
     return complemented;
 }
 
@@ -1095,7 +1119,9 @@ void RegexASTGroup<TypedNfaState>::add_to_nfa(
     auto merged_ranges = m_ranges;
     std::sort(merged_ranges.begin(), merged_ranges.end());
     merged_ranges = merge(merged_ranges);
-    if (m_negate) { merged_ranges = complement(merged_ranges); }
+    if (m_negate) {
+        merged_ranges = complement(merged_ranges);
+    }
     for (auto const& [begin, end] : merged_ranges) {
         nfa->get_root()->add_interval(Interval(begin, end), end_state);
     }
diff --git a/src/log_surgeon/finite_automata/RegisterOperation.hpp b/src/log_surgeon/finite_automata/RegisterOperation.hpp
index d3176a9d..9de94871 100644
--- a/src/log_surgeon/finite_automata/RegisterOperation.hpp
+++ b/src/log_surgeon/finite_automata/RegisterOperation.hpp
@@ -61,7 +61,9 @@ class RegisterOperation {
     [[nodiscard]] auto serialize() const -> std::optional<std::string> {
         switch (m_type) {
             case Type::Copy:
-                if (false == m_copy_reg_id.has_value()) { return std::nullopt; }
+                if (false == m_copy_reg_id.has_value()) {
+                    return std::nullopt;
+                }
                 return fmt::format("{}{}{}", m_reg_id, "c", m_copy_reg_id.value());
             case Type::Set:
                 return fmt::format("{}{}", m_reg_id, "p");
diff --git a/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp b/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
index 4ba5831e..44fe2b0a 100644
--- a/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
+++ b/src/log_surgeon/finite_automata/UnicodeIntervalTree.tpp
@@ -32,15 +32,21 @@ auto UnicodeIntervalTree<T>::Node::insert(std::unique_ptr<Node> node, Interval i
 template <typename T>
 auto UnicodeIntervalTree<T>::all() const -> std::vector<Data> {
     std::vector<Data> results;
-    if (m_root != nullptr) { m_root->all(&results); }
+    if (m_root != nullptr) {
+        m_root->all(&results);
+    }
     return results;
 }
 
 template <typename T>
 auto UnicodeIntervalTree<T>::Node::all(std::vector<Data>* results) -> void {
-    if (m_left != nullptr) { m_left->all(results); }
+    if (m_left != nullptr) {
+        m_left->all(results);
+    }
     results->push_back(Data(m_interval, m_value));
-    if (m_right != nullptr) { m_right->all(results); }
+    if (m_right != nullptr) {
+        m_right->all(results);
+    }
 }
 
 template <typename T>
@@ -52,10 +58,18 @@ auto UnicodeIntervalTree<T>::find(Interval interval) -> std::unique_ptr<std::vec
 
 template <class T>
 auto UnicodeIntervalTree<T>::Node::find(Interval interval, std::vector<Data>* results) -> void {
-    if (!overlaps_recursive(interval)) { return; }
-    if (m_left != nullptr) { m_left->find(interval, results); }
-    if (overlaps(interval)) { results->push_back(Data(m_interval, m_value)); }
-    if (m_right != nullptr) { m_right->find(interval, results); }
+    if (!overlaps_recursive(interval)) {
+        return;
+    }
+    if (m_left != nullptr) {
+        m_left->find(interval, results);
+    }
+    if (overlaps(interval)) {
+        results->push_back(Data(m_interval, m_value));
+    }
+    if (m_right != nullptr) {
+        m_right->find(interval, results);
+    }
 }
 
 template <class T>
@@ -64,7 +78,9 @@ auto UnicodeIntervalTree<T>::pop(Interval interval) -> std::unique_ptr<std::vect
     while (true) {
         std::unique_ptr<Node> n;
         m_root = Node::pop(std::move(m_root), interval, &n);
-        if (n == nullptr) { break; }
+        if (n == nullptr) {
+            break;
+        }
         results->push_back(Data(n->get_interval(), n->get_value()));
     }
     return results;
@@ -76,8 +92,12 @@ auto UnicodeIntervalTree<T>::Node::pop(
         Interval interval,
         std::unique_ptr<Node>* ret
 ) -> std::unique_ptr<Node> {
-    if (node == nullptr) { return nullptr; }
-    if (!node->overlaps_recursive(interval)) { return node; }
+    if (node == nullptr) {
+        return nullptr;
+    }
+    if (!node->overlaps_recursive(interval)) {
+        return node;
+    }
     node->m_left = Node::pop(std::move(node->m_left), interval, ret);
     if (ret->get() != nullptr) {
         node->update();
@@ -85,9 +105,15 @@ auto UnicodeIntervalTree<T>::Node::pop(
     }
     assert(node->overlaps(interval));
     ret->reset(node.release());
-    if (((*ret)->m_left == nullptr) && ((*ret)->m_right == nullptr)) { return nullptr; }
-    if ((*ret)->m_left == nullptr) { return std::move((*ret)->m_right); }
-    if ((*ret)->m_right == nullptr) { return std::move((*ret)->m_left); }
+    if (((*ret)->m_left == nullptr) && ((*ret)->m_right == nullptr)) {
+        return nullptr;
+    }
+    if ((*ret)->m_left == nullptr) {
+        return std::move((*ret)->m_right);
+    }
+    if ((*ret)->m_right == nullptr) {
+        return std::move((*ret)->m_left);
+    }
     std::unique_ptr<Node> replacement;
     std::unique_ptr<Node> sub_tree = Node::pop_min(std::move((*ret)->m_right), &replacement);
     replacement->m_left = std::move((*ret)->m_left);
@@ -140,10 +166,14 @@ auto UnicodeIntervalTree<T>::Node::balance_factor() -> int {
 template <class T>
 auto UnicodeIntervalTree<T>::Node::balance(std::unique_ptr<Node> node) -> std::unique_ptr<Node> {
     auto const factor = node->balance_factor();
-    if (factor * factor <= 1) { return node; }
+    if (factor * factor <= 1) {
+        return node;
+    }
     auto const sub_factor
             = (factor < 0) ? node->m_left->balance_factor() : node->m_right->balance_factor();
-    if (factor * sub_factor > 0) { return Node::rotate(std::move(node), factor); }
+    if (factor * sub_factor > 0) {
+        return Node::rotate(std::move(node), factor);
+    }
     if (factor == 2) {
         node->m_right = Node::rotate(std::move(node->m_right), sub_factor);
     } else {
@@ -155,8 +185,12 @@ auto UnicodeIntervalTree<T>::Node::balance(std::unique_ptr<Node> node) -> std::u
 template <class T>
 auto UnicodeIntervalTree<T>::Node::rotate(std::unique_ptr<Node> node, int factor)
         -> std::unique_ptr<Node> {
-    if (factor < 0) { return Node::rotate_cw(std::move(node)); }
-    if (factor > 0) { return Node::rotate_ccw(std::move(node)); }
+    if (factor < 0) {
+        return Node::rotate_cw(std::move(node));
+    }
+    if (factor > 0) {
+        return Node::rotate_ccw(std::move(node));
+    }
     return node;
 }
 
diff --git a/src/log_surgeon/utils.hpp b/src/log_surgeon/utils.hpp
index e4c259e6..976eb207 100644
--- a/src/log_surgeon/utils.hpp
+++ b/src/log_surgeon/utils.hpp
@@ -9,11 +9,15 @@
 template <typename... Args>
 auto strfmt(std::string const& fmt, Args... args) -> std::string {
     auto size = std::snprintf(nullptr, 0, fmt.c_str(), args...);
-    if (size <= 0) { throw std::runtime_error("Error during formatting."); }
+    if (size <= 0) {
+        throw std::runtime_error("Error during formatting.");
+    }
     // Add 1 for null character to terminate the C string
     std::vector<char> buf(size + 1);
     size = std::snprintf(buf.data(), buf.size(), fmt.c_str(), args...);
-    if (size <= 0) { throw std::runtime_error("Error during formatting."); }
+    if (size <= 0) {
+        throw std::runtime_error("Error during formatting.");
+    }
     return {buf.data(), buf.data() + size};
 }
 
diff --git a/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp b/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
index 45e2891e..15e5339d 100644
--- a/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
+++ b/src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
@@ -43,10 +43,16 @@ auto ExpressionView::extend_to_adjacent_greedy_wildcards() const
 }
 
 auto ExpressionView::is_well_formed() const -> bool {
-    if (m_chars.empty()) { return true; }
+    if (m_chars.empty()) {
+        return true;
+    }
     auto const [begin_idx, end_idx]{get_indices()};
-    if (begin_idx > 0 && m_expression->get_chars()[begin_idx - 1].is_escape()) { return false; }
-    if (m_chars.back().is_escape()) { return false; }
+    if (begin_idx > 0 && m_expression->get_chars()[begin_idx - 1].is_escape()) {
+        return false;
+    }
+    if (m_chars.back().is_escape()) {
+        return false;
+    }
     return true;
 }
 
@@ -56,7 +62,9 @@ auto ExpressionView::generate_regex_string() const -> std::pair<string, bool> {
     bool regex_contains_wildcard{false};
 
     for (auto const& expression_char : m_chars) {
-        if (expression_char.is_escape()) { continue; }
+        if (expression_char.is_escape()) {
+            continue;
+        }
         auto const& value{expression_char.value()};
         if (expression_char.is_greedy_wildcard()) {
             regex_string += ".*";
diff --git a/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp b/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
index 9fcf70d1..c1adb151 100644
--- a/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
+++ b/src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
@@ -23,13 +23,19 @@ auto QueryInterpretation::operator<=>(QueryInterpretation const& rhs) const -> s
     // in `m_tokens` have `<=>` which returns `strong_ordering`. Therefore, we can convert the
     // result of `<=>` between two `m_tokens` from `weak_ordering` to `strong_ordering`.
     auto const tokens_weak_cmp{m_tokens <=> rhs.m_tokens};
-    if (weak_ordering::less == tokens_weak_cmp) { return strong_ordering::less; }
-    if (weak_ordering::greater == tokens_weak_cmp) { return strong_ordering::greater; }
+    if (weak_ordering::less == tokens_weak_cmp) {
+        return strong_ordering::less;
+    }
+    if (weak_ordering::greater == tokens_weak_cmp) {
+        return strong_ordering::greater;
+    }
     return strong_ordering::equal;
 }
 
 void QueryInterpretation::append_query_interpretation(QueryInterpretation const& suffix) {
-    if (suffix.m_tokens.empty()) { return; }
+    if (suffix.m_tokens.empty()) {
+        return;
+    }
     if (m_tokens.empty()) {
         m_tokens = suffix.m_tokens;
         return;
@@ -49,7 +55,9 @@ void QueryInterpretation::append_query_interpretation(QueryInterpretation const&
 }
 
 auto QueryInterpretation::append_static_token(std::string const& query_substring) -> void {
-    if (query_substring.empty()) { return; }
+    if (query_substring.empty()) {
+        return;
+    }
 
     StaticQueryToken static_query_token(query_substring);
     if (m_tokens.empty()) {
diff --git a/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp b/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
index 7f06583a..5717d5f2 100644
--- a/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
+++ b/src/log_surgeon/wildcard_query_parser/VariableQueryToken.cpp
@@ -7,10 +7,14 @@ using std::strong_ordering;
 namespace log_surgeon::wildcard_query_parser {
 auto VariableQueryToken::operator<=>(VariableQueryToken const& rhs) const -> strong_ordering {
     auto const variable_type_cmp{m_variable_type <=> rhs.m_variable_type};
-    if (std::strong_ordering::equal != variable_type_cmp) { return variable_type_cmp; }
+    if (std::strong_ordering::equal != variable_type_cmp) {
+        return variable_type_cmp;
+    }
 
     auto const query_substring_cmp{m_query_substring <=> rhs.m_query_substring};
-    if (std::strong_ordering::equal != query_substring_cmp) { return query_substring_cmp; }
+    if (std::strong_ordering::equal != query_substring_cmp) {
+        return query_substring_cmp;
+    }
 
     // bool does not have a <=> operator, so we have to manual order it:
     return static_cast<int>(m_contains_wildcard) <=> static_cast<int>(rhs.m_contains_wildcard);
diff --git a/tests/test-buffer-parser.cpp b/tests/test-buffer-parser.cpp
index 29f59141..ceb1ab8c 100644
--- a/tests/test-buffer-parser.cpp
+++ b/tests/test-buffer-parser.cpp
@@ -96,7 +96,9 @@ auto parse_and_validate(
         }
 
         uint32_t event_offset{0};
-        if (nullptr == event.get_timestamp()) { event_offset = 1; }
+        if (nullptr == event.get_timestamp()) {
+            event_offset = 1;
+        }
 
         REQUIRE(expected_tokens.size() == event.get_log_output_buffer()->pos() - event_offset);
         for (size_t i{0}; i < expected_tokens.size(); ++i) {
@@ -122,14 +124,18 @@ auto parse_and_validate(
                 auto optional_capture_ids{lexer.get_capture_ids_from_rule_id(token_type)};
                 REQUIRE(optional_capture_ids.has_value());
 
-                if (false == optional_capture_ids.has_value()) { return; }
+                if (false == optional_capture_ids.has_value()) {
+                    return;
+                }
 
                 for (auto const capture_id : optional_capture_ids.value()) {
                     auto const capture_name{lexer.m_id_symbol.at(capture_id)};
                     REQUIRE(expected_captures.contains(capture_name));
                     auto optional_reg_ids{lexer.get_reg_ids_from_capture_id(capture_id)};
                     REQUIRE(optional_reg_ids.has_value());
-                    if (false == optional_reg_ids.has_value()) { return; }
+                    if (false == optional_reg_ids.has_value()) {
+                        return;
+                    }
                     auto const [start_reg_id, end_reg_id]{optional_reg_ids.value()};
                     auto const actual_start_positions{
                             token.get_reversed_reg_positions(start_reg_id)
@@ -149,7 +155,9 @@ auto parse_and_validate(
 
 auto serialize_id_symbol_map(unordered_map<rule_id_t, string> const& map) -> string {
     string serialized_map;
-    for (auto const& [id, symbol] : map) { serialized_map += fmt::format("{}->{},", id, symbol); }
+    for (auto const& [id, symbol] : map) {
+        serialized_map += fmt::format("{}->{},", id, symbol);
+    }
     return serialized_map;
 }
 }  // namespace
diff --git a/tests/test-dfa.cpp b/tests/test-dfa.cpp
index 2edb1bc4..d2cdfbfc 100644
--- a/tests/test-dfa.cpp
+++ b/tests/test-dfa.cpp
@@ -46,7 +46,9 @@ auto test_dfa(std::vector<string> const& var_schemas, string const& expected_ser
 auto test_dfa(std::vector<string> const& var_schemas, string const& expected_serialized_dfa)
         -> void {
     Schema schema;
-    for (auto const& var_schema : var_schemas) { schema.add_variable(var_schema, -1); }
+    for (auto const& var_schema : var_schemas) {
+        schema.add_variable(var_schema, -1);
+    }
     auto const schema_ast = schema.release_schema_ast_ptr();
     vector<ByteLexicalRule> rules;
     for (size_t i{0}; i < var_schemas.size(); i++) {
diff --git a/tests/test-schema.cpp b/tests/test-schema.cpp
index eaedf97e..419a7381 100644
--- a/tests/test-schema.cpp
+++ b/tests/test-schema.cpp
@@ -27,8 +27,8 @@ using RegexASTGroupByte
         = log_surgeon::finite_automata::RegexASTGroup<log_surgeon::finite_automata::ByteNfaState>;
 using RegexASTLiteralByte
         = log_surgeon::finite_automata::RegexASTLiteral<log_surgeon::finite_automata::ByteNfaState>;
-using RegexASTMultiplicationByte = log_surgeon::finite_automata::RegexASTMultiplication<
-        log_surgeon::finite_automata::ByteNfaState>;
+using RegexASTMultiplicationByte = log_surgeon::finite_automata::
+        RegexASTMultiplication<log_surgeon::finite_automata::ByteNfaState>;
 
 /**
  * @ingroup unit_tests_schema
diff --git a/tools/yscope-dev-utils b/tools/yscope-dev-utils
index b965f19f..3ff7d055 160000
--- a/tools/yscope-dev-utils
+++ b/tools/yscope-dev-utils
@@ -1 +1 @@
-Subproject commit b965f19f3e11c548f32bf7ab8e28ff38906be018
+Subproject commit 3ff7d055c01b7b2b94b9288e0fdc33a5c937a64e

From ac5f4dc669c528d3ec232d187a5ec9249cd215d2 Mon Sep 17 00:00:00 2001
From: davidlion <david.lion@yscope.com>
Date: Mon, 1 Sep 2025 15:50:40 -0400
Subject: [PATCH 4/6] Raise clang-format min version to 21.1.

---
 lint-requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lint-requirements.txt b/lint-requirements.txt
index dbf21dec..44722a5c 100644
--- a/lint-requirements.txt
+++ b/lint-requirements.txt
@@ -1,4 +1,4 @@
 clang-format>=20.1
-clang-tidy>=20.1
+clang-tidy>=21.1
 gersemi>=0.16.2
 yamllint>=1.35.1

From debe5565dad91243964575565e8b6e5ed6b8ab60 Mon Sep 17 00:00:00 2001
From: davidlion <david.lion@yscope.com>
Date: Mon, 1 Sep 2025 15:51:41 -0400
Subject: [PATCH 5/6] Update gitignore per-coderabbit comment.

---
 .gitignore | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 2ad978ba..8d1177bf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
-.clang-format
-.clang-tidy
+# Linting config files sym linked from dev-utils
+/.clang-format
+/.clang-tidy
+
+# Build related directories
 .task/
 build/

From e10960f99ab980b6bb6d6266297abbc7ccb8c0ec Mon Sep 17 00:00:00 2001
From: davidlion <davidlion2@protonmail.com>
Date: Mon, 1 Sep 2025 16:00:22 -0400
Subject: [PATCH 6/6] Update .gitignore.

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 8d1177bf..4de669bf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-# Linting config files sym linked from dev-utils
+# Linting config files symlinked from dev-utils
 /.clang-format
 /.clang-tidy