Merge pull request #4 from OrcaLinux/parser

refactor Node class; simplify constructor, update node type strings, …

Author: SemoMoh

parser_gui/Data/include/Node.h

@@ -15,24 +15,18 @@ class Node {
 
 public:
     enum class NodeType {
-        Program,
-        Statement,
-        IfStatement,
-        RepeatStatement,
-        AssignStatement,
-        ReadStatement,
-        WriteStatement,
-        Expression,
-        Comparison,
-        Addition,
-        Multiplication,
-        Factor,
-        Identifier,
-        Number
+        Read,
+        Write,
+        If,
+        Repeat,
+        Assign,
+        Op,
+        Id,
+        Const
     }; // enum class NodeType
 
 
-    explicit Node(NodeType type, QString value, Node *parent = nullptr);
+    explicit Node(NodeType type);
     ~Node();
 
     // getters
@@ -64,21 +58,15 @@ class Node {
 
 
 
-    static constexpr std::array<QLatin1StringView, 14> nodeTypeStrings = {
-        QLatin1StringView("Program"),
-        QLatin1StringView("Statement"),
-        QLatin1StringView("IfStatement"),
-        QLatin1StringView("RepeatStatement"),
-        QLatin1StringView("AssignStatement"),
-        QLatin1StringView("ReadStatement"),
-        QLatin1StringView("WriteStatement"),
-        QLatin1StringView("Expression"),
-        QLatin1StringView("Comparison"),
-        QLatin1StringView("Addition"),
-        QLatin1StringView("Multiplication"),
-        QLatin1StringView("Factor"),
-        QLatin1StringView("Identifier"),
-        QLatin1StringView("Number")
+    static constexpr std::array<QLatin1StringView, 8> nodeTypeStrings = {
+        QLatin1StringView("Read"),
+        QLatin1StringView("Write"),
+        QLatin1StringView("If"),
+        QLatin1StringView("Repeat"),
+        QLatin1StringView("Assign"),
+        QLatin1StringView("Op"),
+        QLatin1StringView("Id"),
+        QLatin1StringView("Const")
     }; // nodeTypeStrings Lookup Table
 
 }; // class Node

parser_gui/Data/src/Node.cpp

@@ -2,9 +2,14 @@
 
 using namespace Tiny::Data;
 
-Node::Node(NodeType type, QString value, Node *parent)
-: type(type), value(value), parent(parent)
-{}
+Node::Node(NodeType type)
+: type(type)
+{
+    this->value = "";
+    this->parent = nullptr;
+    this->level = 0;
+    this->children = QList<Node*>();
+}
 
 Node::~Node()
 {
@@ -66,7 +71,6 @@ void Node::setType(NodeType type)
 void Node::setParent(Node *parent)
 {
     this->parent = parent;
-    parent->addChild(this);
 }
 
 void Node::setLevel(int level)
@@ -77,12 +81,11 @@ void Node::setLevel(int level)
 void Node::addChild(Node *child)
 {
     this->children.append(child);
-    child->setParent(this);
 }
 
 void Node::printTree(int depth) const
 {
-    qDebug().noquote() << QString(depth * 2, ' ') << this->getNodeTypeString() << ": " << value;
+    qDebug().noquote() << QString(depth * 2, ' ') << this->getNodeTypeString() << ": " << value << " level: " << level;
     for (auto child : children)
     {
         child->printTree(depth + 1);

parser_gui/Parser/include/Parser.h

@@ -1,54 +1,93 @@
-// Parser.h
 #ifndef PARSER_H
 #define PARSER_H
 
 #include <QObject>
 #include <QList>
+#include <stdexcept>
+#include <QListIterator>
 
 #include "Token.h"
 #include "Node.h"
 
-using namespace Tiny::Data;
-
-namespace Tiny::Parser {
-    class Parser : public QObject {
-        Q_OBJECT
-       public:
-        explicit Parser(QObject *parent = nullptr);
-        ~Parser() override;
-
-        void setTokens(QList<Token> tokens);
-        Node* parse();
-        signals:
-            void error(QString message);
-        private:
-            QList<Token> tokens;
-            int currentTokenIndex;
-            int currentLevel;
-
-            void advance();
-
-            void expectAndSkip(Token::TokenType type);
-            Node* consume(Token::TokenType tokenType, Tiny::Data::Node::NodeType nodeType);
-
-            // rules
-            Node* parseStmtSequence();
-            Node* parseStatement();
-            Node* parseIfStatement();
-            Node* parseRepeatStatement();
-            Node* parseAssignStatement();
-            Node* parseReadStatement();
-            Node* parseWriteStatement();
-            Node* parseExp();
-            Node* parseSimpleExp();
-            Node* parseComparisonOp();
-            Node* parseAddop();
-            Node* parseTerm();
-            Node* parseMulop();
-            Node* parseFactor();
-    };
-
-
-}  // namespace Tiny::Parser
-
-#endif  // PARSER_H
+namespace Tiny {
+namespace Parser {
+
+/**
+ * @class Parser
+ * @brief A parser for the TINY language that constructs a syntax tree from a list of tokens.
+ *
+ * The Parser class takes a list of tokens (produced by the scanner) and attempts to construct a
+ * syntax tree according to the TINY language grammar rules. It emits errors or throws exceptions
+ * if unexpected tokens or end-of-file conditions occur.
+ *
+ * Usage:
+ * 1. Create a Parser object.
+ * 2. Call setTokens() with the token list.
+ * 3. Call parse() to parse the entire token list and produce a syntax tree root Node.
+ * 4. If parsing is successful, you get a syntax tree. If errors occur, handle them as needed.
+ */
+class Parser : public QObject {
+    Q_OBJECT
+public:
+    explicit Parser(QObject *parent = nullptr);
+    ~Parser() override;
+
+    /**
+     * @brief Set the token list to be parsed.
+     * @param tokens The list of tokens produced by the scanner.
+     */
+    void setTokens(QList<Tiny::Data::Token> tokens);
+
+    /**
+     * @brief Parse the entire set of tokens and build a syntax tree.
+     * @return A pointer to the root Node of the syntax tree if successful, or nullptr if empty.
+     * @throws std::out_of_range if unexpected end of file (no more tokens) is encountered improperly.
+     * @throws std::invalid_argument if a token does not match the expected type.
+     */
+    Tiny::Data::Node* parse();
+
+signals:
+    /**
+     * @brief Emitted when a parsing error occurs (e.g., unexpected token or EOF).
+     * @param message A descriptive error message.
+     */
+    void error(QString message);
+
+private:
+    QList<Tiny::Data::Token> tokens;  ///< The list of tokens to parse.
+    QListIterator<Tiny::Data::Token> tokenIterator;  ///< Iterator for the token list.
+    int currentLevel;                 ///< Current nesting level for the syntax tree.
+    bool hasError;                    ///< Flag indicating if an error occurred during parsing.
+
+    /**
+     * @brief Peek at the current token without consuming it.
+     * @return The current token.
+     * @throws std::out_of_range if no more tokens.
+     */
+    Tiny::Data::Token peek();
+
+    void match(Tiny::Data::Token::TokenType expectedType);
+
+    void assignLevels(Tiny::Data::Node* node, int baseLevel);
+
+    // Grammar rules:
+    Tiny::Data::Node* parseStmtSequence();
+    Tiny::Data::Node* parseStatement();
+    Tiny::Data::Node* parseIfStatement();
+    Tiny::Data::Node* parseRepeatStatement();
+    Tiny::Data::Node* parseAssignStatement();
+    Tiny::Data::Node* parseReadStatement();
+    Tiny::Data::Node* parseWriteStatement();
+    Tiny::Data::Node* parseExp();
+    Tiny::Data::Node* parseSimpleExp();
+    Tiny::Data::Node* parseComparisonOp();
+    Tiny::Data::Node* parseAddop();
+    Tiny::Data::Node* parseTerm();
+    Tiny::Data::Node* parseMulop();
+    Tiny::Data::Node* parseFactor();
+};
+
+} // namespace Parser
+} // namespace Tiny
+
+#endif // PARSER_H