Merge pull request #53 from jose-rZM/release-1.0.2

Release 1.0.2

Author: jose-rZM

.github/workflows/main.yml

@@ -117,7 +117,7 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: macos-intel
+          name: SyntaxTutor-macos-intel 
           path: SyntaxTutor-intel.zip  
   build-macos:
     runs-on: macos-latest
@@ -221,7 +221,7 @@ jobs:
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: macos-artifacts
+          name: SyntaxTutor-macos-arm64
           path: |
             SyntaxTutor.app
             
@@ -266,7 +266,7 @@ jobs:
       - name: Upload Windows ZIP
         uses: actions/upload-artifact@v4
         with:
-          name: windows-deploy
+          name: SyntaxTutor-windows-x64
           path: deploy
 
   build-linux:
@@ -321,5 +321,5 @@ jobs:
       - name: Upload Linux AppImage
         uses: actions/upload-artifact@v4
         with:
-          name: linux-appimage
+          name: SyntaxTutor-linux-x86_64
           path: '*.AppImage'

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.2] - 2025-07-16
+### Fixed
+- Fixed issue when exporting PDF in SLR mode.
+- Fixed some feedback in SLR mode
+
 ## [1.0.1] - 2025-06-17
 ### Added
 - Added `Doxyfile` for automatic documentation generation with Doxygen.

Doxyfile

@@ -1893,7 +1893,7 @@ FORMULA_MACROFILE      =
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-USE_MATHJAX            = NO
+USE_MATHJAX           = YES 
 
 # With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
 # Note that the different versions of MathJax have different requirements with
@@ -1934,8 +1934,7 @@ MATHJAX_FORMAT         = HTML-CSS
 # - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
 # - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
 # This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        =
+MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example

README.md

@@ -85,10 +85,10 @@ Precompiled builds of SyntaxTutor are available in the Releases tab:
 To build SyntaxTutor from source, you just need:
 - Qt6 (including `qmake6`)
 - A C++20-compliant compiler
-```
+```bash
 qmake6
 make
-````
+```
 ---
 
 ### 📚 Documentation

UniqueQueue.h

@@ -7,15 +7,17 @@
  * @class UniqueQueue
  * @brief A queue that ensures each element is inserted only once.
  *
- * This data structure behaves like a standard FIFO queue but prevents duplicate insertions.
+ * This data structure behaves like a standard FIFO queue but prevents duplicate
+ * insertions.
  *
- * Internally, it uses a `std::queue` for ordering and a `std::unordered_set` to track seen elements.
+ * Internally, it uses a `std::queue` for ordering and a `std::unordered_set` to
+ * track seen elements.
  *
- * @tparam T The type of elements stored in the queue. Must be hashable and comparable.
+ * @tparam T The type of elements stored in the queue. Must be hashable and
+ * comparable.
  */
-template<typename T>
-class UniqueQueue {
-public:
+template <typename T> class UniqueQueue {
+  public:
     /**
      * @brief Pushes an element to the queue if it hasn't been inserted before.
      * @param value The element to insert.
@@ -39,28 +41,25 @@ class UniqueQueue {
      * @brief Accesses the front element of the queue.
      * @return A reference to the front element.
      */
-    const T& front() const {
-        return queue_.front();
-    }
+    const T& front() const { return queue_.front(); }
 
     /**
      * @brief Checks whether the queue is empty.
      * @return true if the queue is empty; false otherwise.
      */
-    bool empty() const {
-        return queue_.empty();
-    }
+    bool empty() const { return queue_.empty(); }
 
     /**
      * @brief Clears the queue and the set of seen elements.
      */
     void clear() {
-        while(!queue_.empty()) queue_.pop();
+        while (!queue_.empty())
+            queue_.pop();
         seen_.clear();
     }
 
-private:
-    std::queue<T> queue_;        ///< Underlying FIFO queue.
-    std::unordered_set<T> seen_; ///< Set of already inserted elements.
+  private:
+    std::queue<T>         queue_; ///< Underlying FIFO queue.
+    std::unordered_set<T> seen_;  ///< Set of already inserted elements.
 };
 #endif // UNIQUEQUEUE_H

backend/grammar_factory.hpp

@@ -144,8 +144,6 @@ struct GrammarFactory {
      */
     FactoryItem CreateLv2Item();
 
-    // -------- SANITY CHECKS --------
-
     /**
      * @brief Checks if a grammar contains unreachable symbols (non-terminals
      * that cannot be derived from the start symbol).
@@ -158,9 +156,13 @@ struct GrammarFactory {
      * @brief Checks if a grammar is infinite, meaning there are non-terminal
      * symbols that can never derive a terminal string. This happens when a
      * production leads to an infinite recursion or an endless derivation
-     * without reaching terminal symbols. For example, a production like: S -> A
+     * without reaching terminal symbols.
+     * For example, a production like:
+     * \code
+     * S -> A
      * A -> a A | B
      * B -> c B
+     * \endcode
      * could lead to an infinite derivation of non-terminals.
      * @param grammar The grammar to check.
      * @return true if the grammar has infinite derivations, false otherwise.
@@ -196,28 +198,50 @@ struct GrammarFactory {
      */
     std::unordered_set<std::string> NullableSymbols(const Grammar& grammar) const;
 
-    // -------- TRANSFORMATIONS --------
     /**
-     * @brief Removes direct left recursion in a grammar. A grammar has direct
-     * left recursion when one of its productions is A -> A a, where A is a non
-     * terminal symbol and "a" the rest of the production. The procedure removes
-     * direct left recursion by adding a new non terminal. So, if the
-     * productions with left recursion are A -> A a | b, the result would be A
-     * -> b A'; A'-> a A' | EPSILON
-     * @param grammar The grammar to remove left recursion
+     * @brief Removes direct left recursion in a grammar.
+     * A grammar has direct left recursion when one of its productions is
+     * \code
+     * A -> A a
+     * \endcode
+     * where A is a non-terminal symbol and "a" the rest of the production.
+     * The procedure removes direct left recursion by adding a new
+     * non-terminal. So, if the productions with left recursion are:
+     * \code
+     * A -> A a | b
+     * \endcode
+     * the result would be:
+     * \code
+     * A  -> b A'
+     * A' -> a A' | epsilon
+     * \endcode
+     * @param grammar The grammar to remove left recursion.
      */
+
     void RemoveLeftRecursion(Grammar& grammar);
 
     /**
-     * @brief Perfoms left factorization. A grammar could be left factorized if
-     * it have productions with the same prefix for one non terminal. For
-     * example, A -> a x | a y; could be left factorized because it has "a" as
-     * the common prefix. The left factorization is done by adding a new non
-     * terminal symbol that contains the uncommon part, and by unifying the
-     * common prefix in a one producion. So, A -> a x | a y would be A -> a A';
-     * A' -> x | y.
+     * @brief Performs left factorization.
+     * A grammar can be left factorized if it has productions with the
+     * same prefix for one non-terminal. For example:
+     * \code
+     * A -> a x | a y
+     * \endcode
+     * could be left factorized because it has "a" as the common prefix.
+     * The left factorization is done by adding a new non-terminal symbol
+     * that contains the uncommon part, and by unifying the common prefix in one
+     * production. So:
+     * \code
+     * A -> a x | a y
+     * \endcode
+     * would become:
+     * \code
+     * A  -> a A'
+     * A' -> x | y
+     * \endcode
      * @param grammar The grammar to be left factorized.
      */
+
     void LeftFactorize(Grammar& grammar);
 
     /**

backend/ll1_parser.hpp

@@ -46,10 +46,10 @@ class LL1Parser {
      * production, indicating no conflicts. If conflicts are found, the function
      * will return `false`, signaling that the grammar is not LL(1).
      *
-     * - For each production rule `A -> α`, the function calculates the director
-     * symbols using the `director_symbols` function.
+     * - For each production rule \f(A \rightarrow \alpha\f), the function
+     * calculates the prediction symbols using the `PredictionSymbols` function.
      * - It then fills the parsing table at the cell corresponding to the
-     * non-terminal `A` and each director symbol in the set.
+     * non-terminal `A` and each prediction symbol in the set.
      * - If a cell already contains a production, this indicates a conflict,
      * meaning the grammar is not LL(1).
      *
@@ -103,27 +103,25 @@ class LL1Parser {
     /**
      * @brief Computes the FOLLOW sets for all non-terminal symbols in the
      * grammar.
-     *
-     * The FOLLOW set of a non-terminal symbol A contains all terminal symbols
-     * that can appear immediately after A in any sentential form derived from
-     * the grammar's start symbol. Additionally, if A can be the last symbol in
-     * a derivation, the end-of-input marker (`$`) is included in its FOLLOW
-     * set.
-     *
+     * The FOLLOW set of a non-terminal symbol A contains all terminal
+     * symbols that can appear immediately after A in any sentential form
+     * derived from the grammar's start symbol. Additionally, if A can be the
+     * last symbol in a derivation, the end-of-input marker (`\$`) is included
+     * in its FOLLOW set.
      * This function computes the FOLLOW sets using the following rules:
-     * 1. Initialize FOLLOW(S) = { $ }, where S is the start symbol.
-     * 2. For each production rule of the form A → αBβ:
-     *    - Add FIRST(β) (excluding ε) to FOLLOW(B).
-     *    - If ε ∈ FIRST(β), add FOLLOW(A) to FOLLOW(B).
+     * 1. Initialize FOLLOW(S) = { \f( \$ \f) }, where S is the start symbol.
+     * 2. For each production rule of the form \f( A \rightarrow \alpha B \beta
+     * \f):
+     *    - Add \f( FIRST(\beta) \setminus \{\epsilon\} \f) to \f( FOLLOW(B)
+     * \f).
+     *    - If \f( \epsilon \in FIRST(\beta) \f), add \f( FOLLOW(A) \f) to
+     *      \f( FOLLOW(B) \f).
      * 3. Repeat step 2 until no changes occur in any FOLLOW set.
-     *
-     * The computed FOLLOW sets are cached in the `follow_sets_` member variable
-     * for later use by the parser.
-     *
-     * @note This function assumes that the FIRST sets for all symbols have
-     * already been computed and are available in the `first_sets_` member
+     * The computed FOLLOW sets are cached in the `follow_sets_` member
+     * variable for later use by the parser.
+     * @note This function assumes that the FIRST sets for all symbols
+     * have already been computed and are available in the `first_sets_` member
      * variable.
-     *
      * @see First
      * @see follow_sets_
      */
@@ -148,20 +146,19 @@ class LL1Parser {
     /**
      * @brief Computes the prediction symbols for a given
      * production rule.
-     *
-     * 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 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
-     * prediction symbols are simply the FIRST symbols of the consequent.
+     *      * 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 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
+     *   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.
+     *   symbols are computed as
+     *   \f( FIRST(\text{consequent}) \setminus \{\epsilon\} \cup
+     * FOLLOW(\text{antecedent}) \f).
+     *      * @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 prediction symbols for

backend/lr0_item.hpp

@@ -7,10 +7,14 @@
  * @struct Lr0Item
  * @brief Represents an LR(0) item used in LR automata construction.
  *
- * An LR(0) item has a production of the form A → α·β, where the dot indicates the current parsing position.
- * This structure tracks the antecedent (left-hand side), consequent (right-hand side), the dot position,
- * and special symbols like EPSILON and end-of-line ($).
+ * An LR(0) item has a production of the form \f( A \rightarrow \alpha \bullet
+ * \beta \f), where the dot indicates the current parsing position.
+ *
+ * This structure tracks the antecedent (left-hand side), consequent (right-hand
+ * side), the dot position, and special symbols like EPSILON and end-of-line
+ * ($).
  */
+
 struct Lr0Item {
     /**
      * @brief The non-terminal on the left-hand side of the production.
@@ -23,7 +27,7 @@ struct Lr0Item {
     std::vector<std::string> consequent_;
 
     /**
-     * @brief The symbol representing the empty string (ε).
+     * @brief The symbol representing the empty string (\f(\epsilon\f)).
      */
     std::string epsilon_;