format

Author: jose-rZM

backend/grammar.cpp

@@ -19,8 +19,8 @@
 #include "grammar.hpp"
 #include "symbol_table.hpp"
 #include <algorithm>
-#include <ranges>
 #include <iostream>
+#include <ranges>
 #include <unordered_map>
 #include <vector>
 
@@ -41,28 +41,25 @@ Grammar::Grammar(
             }
         }
     }
-    axiom_ = "S";
-    g_ = grammar;
+    axiom_     = "S";
+    g_         = grammar;
     g_[axiom_] = {{"A", st_.EOL_}};
     st_.PutSymbol(axiom_, false);
 }
 
-void Grammar::SetAxiom(const std::string& axiom)
-{
+void Grammar::SetAxiom(const std::string& axiom) {
     axiom_ = axiom;
 }
 
-bool Grammar::HasEmptyProduction(const std::string& antecedent) const
-{
+bool Grammar::HasEmptyProduction(const std::string& antecedent) const {
     auto rules{g_.at(std::string{antecedent})};
     return std::ranges::find_if(rules, [&](const auto& rule) {
                return rule[0] == st_.EPSILON_;
            }) != rules.end();
 }
 
-std::vector<std::pair<const std::string, production>> Grammar::FilterRulesByConsequent(
-    const std::string& arg) const
-{
+std::vector<std::pair<const std::string, production>>
+Grammar::FilterRulesByConsequent(const std::string& arg) const {
     std::vector<std::pair<const std::string, production>> rules;
     for (const auto& [nt, prods] : g_) {
         for (const production& prod : prods) {
@@ -76,7 +73,7 @@ std::vector<std::pair<const std::string, production>> Grammar::FilterRulesByCons
 
 // GCOVR_EXCL_START
 // LCOV_EXCL_START
-void Grammar::Debug() const //NOSONAR
+void Grammar::Debug() const // NOSONAR
 {
     std::cout << "Grammar:\n";
     for (const auto& entry : g_) {
@@ -103,26 +100,25 @@ std::vector<std::string> Grammar::Split(const std::string& s) {
         return {st_.EPSILON_};
     }
     std::vector<std::string> splitted;
-    std::string str;
-    unsigned start{0};
-    unsigned end{1};
+    std::string              str;
+    unsigned                 start{0};
+    unsigned                 end{1};
 
     while (end <= s.size()) {
         str = s.substr(start, end - start);
 
         if (st_.In(str)) {
             unsigned lookahead = end + 1;
             while (lookahead <= s.size()) {
-                if (std::string extended =
-                        s.substr(start, lookahead - start);
+                if (std::string extended = s.substr(start, lookahead - start);
                     st_.In(extended)) {
                     end = lookahead;
                 }
                 ++lookahead;
             }
             splitted.push_back(s.substr(start, end - start));
             start = end;
-            end = start + 1;
+            end   = start + 1;
         } else {
             ++end;
         }

backend/grammar.hpp

@@ -35,11 +35,13 @@ using production = std::vector<std::string>;
 
 /**
  * @struct Grammar
- * @brief Represents a context-free grammar, including its rules, symbol table, and starting symbol.
+ * @brief Represents a context-free grammar, including its rules, symbol table,
+ * and starting symbol.
  *
- * This structure encapsulates all components required to define and manipulate a grammar,
- * including production rules, the associated symbol table, and metadata such as the start symbol.
- * It supports construction, transformation, and analysis of grammars.
+ * This structure encapsulates all components required to define and manipulate
+ * a grammar, including production rules, the associated symbol table, and
+ * metadata such as the start symbol. It supports construction, transformation,
+ * and analysis of grammars.
  */
 struct Grammar {
 
@@ -48,7 +50,6 @@ struct Grammar {
         const std::unordered_map<std::string, std::vector<production>>&
             grammar);
 
-
     /**
      * @brief Sets the axiom (entry point) of the grammar.
      *
@@ -82,40 +83,43 @@ struct Grammar {
      * Searches for rules in which the specified token is part of the consequent
      * and returns those rules.
      */
-    std::vector<std::pair<const std::string, production>> FilterRulesByConsequent(
-        const std::string& arg) const;
+    std::vector<std::pair<const std::string, production>>
+    FilterRulesByConsequent(const std::string& arg) const;
 
     /**
      * @brief Prints the current grammar structure to standard output.
      *
      * This function provides a debug view of the grammar by printing out all
      * rules, the axiom, and other relevant details.
      */
-    void Debug() const; //NOSONAR
+    void Debug() const; // NOSONAR
 
     /**
-    * @brief Adds a production rule to the grammar and updates the symbol table.
-    *
-    * This function inserts a new production of the form A → α into the grammar,
-    * where `antecedent` is the non-terminal A and `consequent` is the sequence α.
-    * It also updates the internal symbol table to reflect any new symbols introduced.
-    *
-    * @param antecedent The left-hand side non-terminal of the production.
-    * @param consequent The right-hand side sequence of grammar symbols.
-    */
+     * @brief Adds a production rule to the grammar and updates the symbol
+     * table.
+     *
+     * This function inserts a new production of the form A → α into the
+     * grammar, where `antecedent` is the non-terminal A and `consequent` is the
+     * sequence α. It also updates the internal symbol table to reflect any new
+     * symbols introduced.
+     *
+     * @param antecedent The left-hand side non-terminal of the production.
+     * @param consequent The right-hand side sequence of grammar symbols.
+     */
     void AddProduction(const std::string&              antecedent,
                        const std::vector<std::string>& consequent);
 
     /**
-    * @brief Splits a string into grammar symbols using the current symbol table.
-    *
-    * This function tokenizes the input string `s` into a sequence of grammar symbols
-    * based on the known entries in the symbol table. It uses a greedy approach,
-    * matching the longest valid symbol at each step.
-    *
-    * @param s The input string to split.
-    * @return A vector of grammar symbols extracted from the string.
-    */
+     * @brief Splits a string into grammar symbols using the current symbol
+     * table.
+     *
+     * This function tokenizes the input string `s` into a sequence of grammar
+     * symbols based on the known entries in the symbol table. It uses a greedy
+     * approach, matching the longest valid symbol at each step.
+     *
+     * @param s The input string to split.
+     * @return A vector of grammar symbols extracted from the string.
+     */
     std::vector<std::string> Split(const std::string& s);
 
     /**

backend/grammar_factory.cpp

@@ -20,10 +20,10 @@
 #include "ll1_parser.hpp"
 #include "slr1_parser.hpp"
 #include <algorithm>
-#include <ranges>
 #include <iostream>
 #include <queue>
 #include <random>
+#include <ranges>
 
 void GrammarFactory::Init() {
     items.emplace_back(
@@ -394,7 +394,8 @@ GrammarFactory::NullableSymbols(const Grammar& grammar) const {
                 } else {
                     bool all_nullable = true;
                     for (const std::string& sym : prod) {
-                        if (!nullable.contains(sym) && sym != grammar.st_.EOL_) {
+                        if (!nullable.contains(sym) &&
+                            sym != grammar.st_.EOL_) {
                             all_nullable = false;
                             break;
                         }
@@ -476,7 +477,8 @@ void GrammarFactory::LeftFactorize(Grammar& grammar) {
 
                     std::vector<std::string> new_production = common_prefix;
                     new_production.push_back(new_non_terminal);
-                    factored_productions.emplace_back(std::move(new_production));
+                    factored_productions.emplace_back(
+                        std::move(new_production));
 
                     std::vector<production> new_remaining_productions;
                     for (const auto& prod : remaining_productions) {
@@ -486,9 +488,11 @@ void GrammarFactory::LeftFactorize(Grammar& grammar) {
                                 prod.end());
                             if (remaining_part.empty()) {
                                 remaining_part.push_back(grammar.st_.EPSILON_);
-                                grammar.st_.PutSymbol(grammar.st_.EPSILON_, true);
+                                grammar.st_.PutSymbol(grammar.st_.EPSILON_,
+                                                      true);
                             }
-                            new_remaining_productions.emplace_back(std::move(remaining_part));
+                            new_remaining_productions.emplace_back(
+                                std::move(remaining_part));
                         } else {
                             factored_productions.emplace_back(prod);
                         }
@@ -566,8 +570,8 @@ GrammarFactory::FactoryItem::FactoryItem(
     g_ = grammar;
 }
 
-void GrammarFactory::NormalizeNonTerminals(FactoryItem& item,
-                                            const std::string& nt) const {
+void GrammarFactory::NormalizeNonTerminals(FactoryItem&       item,
+                                           const std::string& nt) const {
     std::unordered_map<std::string, std::vector<production>> updated;
     for (auto& [old_nt, prods] : item.g_) {
         for (auto& prod : prods) {
@@ -600,7 +604,7 @@ void GrammarFactory::AdjustTerminals(FactoryItem& base, const FactoryItem& cmb,
     }
     std::vector<std::string> remaining(alphabet.begin(), alphabet.end());
     std::uniform_int_distribution<size_t> dist(0, remaining.size() - 1);
-    std::string new_terminal = remaining[dist(gen)];
+    std::string                           new_terminal = remaining[dist(gen)];
 
     std::vector<std::string> base_terms(base.st_.terminals_wtho_eol_.begin(),
                                         base.st_.terminals_wtho_eol_.end());
@@ -622,8 +626,8 @@ void GrammarFactory::AdjustTerminals(FactoryItem& base, const FactoryItem& cmb,
     base_terms.assign(base.st_.terminals_wtho_eol_.begin(),
                       base.st_.terminals_wtho_eol_.end());
     base_dist = std::uniform_int_distribution<size_t>(0, base_terms.size() - 1);
-    to_replace = *std::next(base.st_.terminals_wtho_eol_.begin(),
-                            base_dist(gen));
+    to_replace =
+        *std::next(base.st_.terminals_wtho_eol_.begin(), base_dist(gen));
     for (auto& [nt, prods] : base.g_) {
         for (auto& prod : prods) {
             for (auto& symbol : prod) {

backend/grammar_factory.hpp

@@ -52,7 +52,9 @@ struct GrammarFactory {
          * grammar.
          * @param grammar The grammar to initialize the FactoryItem with.
          */
-        explicit FactoryItem(const std::unordered_map<std::string, std::vector<production>> &grammar);
+        explicit FactoryItem(
+            const std::unordered_map<std::string, std::vector<production>>&
+                grammar);
     };
 
     /**
@@ -206,14 +208,17 @@ struct GrammarFactory {
      * @param graph The directed graph.
      * @return true if grammar has cycle.
      */
-    bool HasCycle(const std::unordered_map<std::string, std::unordered_set<std::string>>& graph) const;
+    bool HasCycle(
+        const std::unordered_map<std::string, std::unordered_set<std::string>>&
+            graph) const;
 
     /**
      * @brief Find nullable symbols in a grammar.
      * @param grammar The grammar to check.
      * @return set of nullable symbols.
      */
-    std::unordered_set<std::string> NullableSymbols(const Grammar& grammar) const;
+    std::unordered_set<std::string>
+    NullableSymbols(const Grammar& grammar) const;
 
     /**
      * @brief Removes direct left recursion in a grammar.
@@ -307,41 +312,47 @@ struct GrammarFactory {
                                        const std::string& base);
 
     /**
-    * @brief Replaces all non-terminal symbols in a grammar item with a single target non-terminal.
-    *
-    * This function is used during grammar combination to normalize the non-terminal
-    * symbols in a given FactoryItem, so that they are consistent and compatible
-    * with another item.
-    *
-    * @param item The grammar item whose non-terminals will be renamed.
-    * @param nt The new non-terminal symbol that will replace all existing ones.
-    */
+     * @brief Replaces all non-terminal symbols in a grammar item with a single
+     * target non-terminal.
+     *
+     * This function is used during grammar combination to normalize the
+     * non-terminal symbols in a given FactoryItem, so that they are consistent
+     * and compatible with another item.
+     *
+     * @param item The grammar item whose non-terminals will be renamed.
+     * @param nt The new non-terminal symbol that will replace all existing
+     * ones.
+     */
     void NormalizeNonTerminals(FactoryItem& item, const std::string& nt) const;
 
     /**
-    * @brief Adjusts the terminal symbols between two grammar items.
-    *
-    * This function modifies the terminal symbols of a base grammar item so that
-    * they do not conflict with those of the item being combined. It also renames
-    * terminals to ensure consistency and inserts the target non-terminal where appropriate.
-    *
-    * @param base The base grammar item to adjust.
-    * @param cmb The grammar item being combined with the base.
-    * @param target_nt The target non-terminal symbol used for replacement.
-    */
+     * @brief Adjusts the terminal symbols between two grammar items.
+     *
+     * This function modifies the terminal symbols of a base grammar item so
+     * that they do not conflict with those of the item being combined. It also
+     * renames terminals to ensure consistency and inserts the target
+     * non-terminal where appropriate.
+     *
+     * @param base The base grammar item to adjust.
+     * @param cmb The grammar item being combined with the base.
+     * @param target_nt The target non-terminal symbol used for replacement.
+     */
     void AdjustTerminals(FactoryItem& base, const FactoryItem& cmb,
                          const std::string& target_nt) const;
 
     /**
-    * @brief Merges the grammar rules of two grammar items into a single grammar.
-    *
-    * This function performs a raw combination of the production rules from both
-    * grammar items, resulting in a single grammar map that contains all productions.
-    *
-    * @param base The first grammar item.
-    * @param cmb The second grammar item.
-    * @return A merged grammar map containing all production rules from both inputs.
-    */
+     * @brief Merges the grammar rules of two grammar items into a single
+     * grammar.
+     *
+     * This function performs a raw combination of the production rules from
+     * both grammar items, resulting in a single grammar map that contains all
+     * productions.
+     *
+     * @param base The first grammar item.
+     * @param cmb The second grammar item.
+     * @return A merged grammar map containing all production rules from both
+     * inputs.
+     */
     std::unordered_map<std::string, std::vector<production>>
     Merge(const FactoryItem& base, const FactoryItem& cmb) const;