change naming

Author: jose-rZM

Makefile

@@ -1,5 +1,5 @@
-CXX = g++
-CXXFLAGS = -std=c++20 -O3
+CXX = clang++
+CXXFLAGS = -std=c++20 -O -Wall -Wextra -Wpedantic -Wshadow -Wold-style-cast -Wunused -Wcast-align -Wnull-dereference -Wconversion -fstrict-aliasing -fsanitize=address -fsanitize=undefined -fsanitize=leak
 SRC_DIR = src
 HPP_DIR = include
 OBJ_DIR = out

include/grammar.hpp

@@ -5,7 +5,7 @@
 
 using production = std::vector<std::string>;
 
-struct grammar {
+struct Grammar {
 
     /**
      * @brief Constructs a grammar by reading from the specified file.
@@ -15,7 +15,7 @@ struct grammar {
      * Initializes the grammar by setting the filename for input. The actual
      * grammar data is read and processed through the `read_from_file` function.
      */
-    explicit grammar(std::string filename);
+    explicit Grammar(std::string filename);
 
     /**
      * @brief Reads and loads the grammar from a file.
@@ -27,7 +27,7 @@ struct grammar {
      * @throws GrammarError if there are errors reading symbols, parsing the
      * grammar, or splitting the rules as specified in the input file.
      */
-    void read_from_file();
+    void ReadFromFile();
 
     /**
      * @brief Adds a rule to the grammar.
@@ -39,7 +39,7 @@ struct grammar {
      * consequent production. This function processes and adds each rule for
      * parsing.
      */
-    void add_rule(const std::string& antecedent, const std::string& consequent);
+    void AddRule(const std::string& antecedent, const std::string& consequent);
 
     /**
      * @brief Sets the axiom (entry point) of the grammar.
@@ -49,7 +49,7 @@ struct grammar {
      * Defines the starting point for the grammar, which is used in parsing
      * algorithms and must be a non-terminal symbol present in the grammar.
      */
-    void set_axiom(const std::string& axiom);
+    void SetAxiom(const std::string& axiom);
 
     /**
      * @brief Checks if a given antecedent has an empty production.
@@ -61,7 +61,7 @@ struct grammar {
      * An empty production is represented as `<antecedent> -> ;`, indicating
      * that the antecedent can produce an empty string.
      */
-    bool has_empty_production(const std::string& antecedent);
+    bool HasEmptyProduction(const std::string& antecedent);
 
     /**
      * @brief Filters grammar rules that contain a specific token in their
@@ -75,15 +75,15 @@ struct grammar {
      * and returns those rules.
      */
     std::vector<std::pair<const std::string, production>>
-    filter_rules_by_consequent(const std::string& arg);
+    FilterRulesByConsequent(const std::string& arg);
 
     /**
      * @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();
+    void Debug();
 
     /**
      * @brief Splits a production string into individual tokens.
@@ -96,7 +96,7 @@ struct grammar {
      * on the symbol table, allowing terminals and non-terminals to be
      * identified.
      */
-    static std::vector<std::string> split(const std::string& s);
+    static std::vector<std::string> Split(const std::string& s);
 
     /**
      * @brief Checks if a rule exhibits left recursion.
@@ -110,8 +110,8 @@ struct grammar {
      * first symbol in its consequent, which may cause issues in top-down
      * parsing algorithms.
      */
-    static bool has_left_recursion(const std::string&              antecedent,
-                                   const std::vector<std::string>& consequent);
+    static bool HasLeftRecursion(const std::string&              antecedent,
+                                 const std::vector<std::string>& consequent);
 
     /**
      * @brief Stores the grammar rules with each antecedent mapped to a list of
@@ -122,10 +122,10 @@ struct grammar {
     /**
      * @brief The axiom or entry point of the grammar.
      */
-    std::string AXIOM_;
+    std::string axiom_;
 
     /**
      * @brief The filename from which the grammar is read.
      */
-    const std::string filename_;
+    const std::string kFilename;
 };

include/lexer.hpp

@@ -1,6 +1,6 @@
 #include <boost/spirit/include/lex_lexertl.hpp>
 #include <vector>
-class lexer {
+class Lex {
     std::string              filename_;
     std::vector<std::string> tokens_;
     unsigned                 current_;
@@ -30,8 +30,8 @@ class lexer {
      * @see symbol_table::st_
      */
     template <typename Lexer>
-    struct parse_input : boost::spirit::lex::lexer<Lexer> {
-        parse_input();
+    struct ParseInput : boost::spirit::lex::lexer<Lexer> {
+        ParseInput();
     };
 
     /**
@@ -49,7 +49,7 @@ class lexer {
      *
      * @see symbol_table::token_types_r_
      */
-    struct add {
+    struct Add {
         typedef bool result_type;
         template <typename Token>
         bool operator()(Token const& t, std::vector<std::string>& tks) const;
@@ -63,7 +63,7 @@ class lexer {
      * @note The program aborts if any errors occur during lexer creation or
      * tokenization.
      */
-    explicit lexer(std::string filename);
+    explicit Lex(std::string filename);
 
     /**
      * @brief Retrieves the next token from the token vector.
@@ -73,7 +73,7 @@ class lexer {
      *
      * This function allows sequential access to tokens processed by the lexer.
      */
-    std::string next();
+    std::string Next();
 
   private:
     /**
@@ -105,5 +105,5 @@ class lexer {
      * @see tokens_
      * @see filename_
      */
-    void tokenize();
+    void Tokenize();
 };

include/ll1_parser.hpp

@@ -20,7 +20,7 @@ class LL1Parser {
      * @param gr Grammar object to parse with.
      * @param text_file Name of the file containing input to parse.
      */
-    LL1Parser(grammar gr, std::string text_file);
+    LL1Parser(Grammar gr, std::string text_file);
 
     /**
      * @brief Constructs an LL1Parser with a grammar file and an input file.
@@ -64,14 +64,14 @@ class LL1Parser {
      * to the LL(1) grammar; `false` if parsing fails due to a mismatch,
      * conflict, or unexpected input symbol.
      */
-    bool parse();
+    bool Parse();
 
     /**
      * @brief Print the LL(1) parsing table to standard output.
      *
      * Displays the LL(1) table for debugging and analysis.
      */
-    void print_table();
+    void PrintTable();
 
     /**
      * @brief Prints the remaining symbols in the parsing stack after the
@@ -83,15 +83,15 @@ class LL1Parser {
      * provides insight into where the parsing process may have diverged from
      * expected behavior.
      */
-    void print_stack_trace();
+    void PrintStackTrace();
 
     /**
-     * @brief Prints the last TRACE_SIZE symbols processed.
+     * @brief Prints the last kTraceSize symbols processed.
      *
      * Primarily used to identify the most recent tokens processed in case
      * of parsing errors.
      */
-    void print_symbol_hist();
+    void PrintSymbolHist();
 
   private:
     /**
@@ -120,7 +120,7 @@ class LL1Parser {
      * symbols that can start derivations of the rule, and possibly epsilon if
      * the rule can derive an empty string.
      */
-    void first(std::span<const std::string>     rule,
+    void First(std::span<const std::string>     rule,
                std::unordered_set<std::string>& result);
 
     /**
@@ -133,7 +133,7 @@ class LL1Parser {
      * expanding and updating the sets until no further changes occur (i.e., a
      * fixed-point is reached).
      */
-    void compute_first_sets();
+    void ComputFirstSets();
 
     /**
      * @brief Computes the FOLLOW set for a given non-terminal symbol in the
@@ -153,33 +153,33 @@ class LL1Parser {
      * @return An unordered set of strings containing symbols that form the
      * FOLLOW set for `arg`.
      */
-    std::unordered_set<std::string> follow(const std::string& arg);
+    std::unordered_set<std::string> Follow(const std::string& arg);
 
     /**
-     * @brief Computes the director symbols (prediction symbols) for a given
+     * @brief Computes the prediction symbols for a given
      * production rule.
      *
-     * The director symbols for a rule, also called prediction symbols,
+     * The prediction symbols for a rule,
      * determine the set of input symbols that can trigger this rule in the
-     * parsing table. This function calculates the director symbols based on the
-     * FIRST set of the consequent and, if epsilon (the empty symbol) is in the
-     * FIRST set, also includes the FOLLOW set of the antecedent.
+     * parsing table. This function calculates the prediction symbols based on
+     * the FIRST set of the consequent and, if epsilon (the empty symbol) is in
+     * the FIRST set, also includes the FOLLOW set of the antecedent.
      *
      * - If the FIRST set of the consequent does not contain epsilon, the
-     * director symbols are simply the FIRST symbols of the consequent.
-     * - If the FIRST set of the consequent contains epsilon, the director
+     * prediction symbols are simply the FIRST symbols of the consequent.
+     * - If the FIRST set of the consequent contains epsilon, the prediction
      * symbols are computed as (FIRST(consequent) - {epsilon}) ∪
      * FOLLOW(antecedent).
      *
      * @param antecedent The left-hand side non-terminal symbol of the rule.
      * @param consequent A vector of symbols on the right-hand side of the rule
      * (production body).
-     * @return An unordered set of strings containing the director symbols for
+     * @return An unordered set of strings containing the prediction symbols for
      * the specified rule.
      */
     std::unordered_set<std::string>
-    director_symbols(const std::string&              antecedent,
-                     const std::vector<std::string>& consequent);
+    PredictionSymbols(const std::string&              antecedent,
+                      const std::vector<std::string>& consequent);
 
     /**
      * @brief Recursive utility function to compute the FOLLOW set for a
@@ -203,9 +203,9 @@ class LL1Parser {
      * @param next_symbols An unordered set to accumulate symbols forming the
      * FOLLOW set of the target non-terminal as they are discovered.
      */
-    void follow_util(const std::string&               arg,
-                     std::unordered_set<std::string>& visited,
-                     std::unordered_set<std::string>& next_symbols);
+    void FollowUtil(const std::string&               arg,
+                    std::unordered_set<std::string>& visited,
+                    std::unordered_set<std::string>& next_symbols);
 
     /**
      * @brief Creates the LL(1) parsing table for the grammar.
@@ -228,25 +228,25 @@ class LL1Parser {
      * grammar is LL(1) compatible; `false` if any conflicts are detected,
      * showing that the grammar does not meet LL(1) requirements.
      */
-    bool create_ll1_table();
+    bool CreateLL1Table();
 
     /// @brief Size limit for symbol history trace, defaults to 5.
-    const size_t TRACE_SIZE{5};
+    const size_t kTraceSize{5};
 
     /// @brief The LL(1) parsing table, mapping non-terminals and terminals to
     /// productions.
     ll1_table ll1_t_;
 
     /// @brief Grammar object associated with this parser.
-    grammar gr_;
+    Grammar gr_;
 
     /// @brief FIRST sets for each non-terminal in the grammar.
     std::unordered_map<std::string, std::unordered_set<std::string>> first_sets;
 
     /// @brief Stack for managing parsing symbols.
     std::stack<std::string> symbol_stack_;
 
-    /// @brief Deque for tracking the most recent TRACE_SIZE symbols parsed.
+    /// @brief Deque for tracking the most recent kTraceSize symbols parsed.
     std::deque<std::string> trace_;
 
     /// @brief Path to the grammar file used in this parser.

include/symbol_table.hpp

@@ -43,51 +43,51 @@ struct symbol_table {
      * @param identifier Name of the terminal symbol.
      * @param regex Regular expression representing the terminal symbol.
      */
-    static void put_symbol(const std::string& identifier,
-                           const std::string& regex);
+    static void PutSymbol(const std::string& identifier,
+                          const std::string& regex);
 
     /**
      * @brief Adds a non-terminal symbol to the symbol table.
      *
      * @param identifier Name of the non-terminal symbol.
      */
-    static void put_symbol(const std::string& identifier);
+    static void PutSymbol(const std::string& identifier);
 
     /**
      * @brief Checks if a symbol exists in the symbol table.
      *
      * @param s Symbol identifier to search.
      * @return true if the symbol is present, otherwise false.
      */
-    static bool in(const std::string& s);
+    static bool In(const std::string& s);
 
     /**
      * @brief Checks if a symbol is a terminal.
      *
      * @param s Symbol identifier to check.
      * @return true if the symbol is terminal, otherwise false.
      */
-    static bool is_terminal(const std::string& s);
+    static bool IsTerminal(const std::string& s);
 
     /**
      * @brief Retrieves the regex pattern for a terminal symbol.
      *
      * @param terminal Terminal symbol identifier.
      * @return Regex pattern associated with the terminal symbol.
      */
-    static std::string get_value(const std::string& terminal);
+    static std::string GetValue(const std::string& terminal);
 
     /**
      * @brief Prints all symbols and their properties in the symbol table.
      *
      * Outputs the symbol table for debugging purposes.
      */
-    static void debug();
+    static void Debug();
 
     /**
      * @brief Sets the end-of-line symbol.
      *
      * @param eol String to use as the new end-of-line symbol.
      */
-    static void set_eol(const std::string& eol);
+    static void SetEol(const std::string& eol);
 };