refactor Node and Token classes; remove sibling handling, add level management, and update token type string method

Author: SemoMoh

parser_gui/Data/include/Node.h

@@ -40,30 +40,27 @@ class Node {
     NodeType getType() const;
     QStringView getNodeTypeString() const;
     Node *getParent() const;
-    QList<Node *> getSiblings() const;
     QList<Node *> getChildren() const;
+    int getLevel() const;
 
     // setters
     void setValue(QString value);
     void setType(NodeType type);
     void setParent(Node *parent);
+    void setLevel(int level);
 
     // add children
     void addChild(Node *child);
 
-    // add siblings
-    void addSibling(Node *sibling);
-
     // print tree
     void printTree(int depth = 0) const;
 
 private:
     QString value;
     NodeType type;
     Node *parent;
-    QList<Node *> siblings;
     QList<Node *> children;
-
+    int level;
 
 
 

parser_gui/Data/include/Token.h

@@ -128,11 +128,6 @@ class Token {
 
     // destructor
     ~Token() = default;
-   private:
-    TokenType type; /**< The type of the token */
-    QString value;  /**< The value of the token */
-    int line;       /**< The line number of the token */
-    int column;     /**< The column number of the token */
 
     /**
      * @brief Converts the token type to a string representation.
@@ -141,7 +136,15 @@ class Token {
      *
      * @throws std::out_of_range if the token type is invalid.
      */
-    QStringView getTokenTypeString() const;
+    static QStringView getTokenTypeString(TokenType type);
+
+   private:
+    TokenType type; /**< The type of the token */
+    QString value;  /**< The value of the token */
+    int line;       /**< The line number of the token */
+    int column;     /**< The column number of the token */
+
+
 
     /**
      * @brief Static constexpr lookup table for token type string representations.

parser_gui/Data/src/Node.cpp

@@ -43,14 +43,14 @@ Node *Node::getParent() const
     return parent;
 }
 
-QList<Node *> Node::getSiblings() const
+QList<Node *> Node::getChildren() const
 {
-    return siblings;
+    return children;
 }
 
-QList<Node *> Node::getChildren() const
+int Node::getLevel() const
 {
-    return children;
+    return level;
 }
 
 void Node::setValue(QString value)
@@ -66,17 +66,18 @@ void Node::setType(NodeType type)
 void Node::setParent(Node *parent)
 {
     this->parent = parent;
+    parent->addChild(this);
 }
 
-void Node::addChild(Node *child)
+void Node::setLevel(int level)
 {
-    this->children.append(child);
+    this->level = level;
 }
 
-void Node::addSibling(Node *sibling)
+void Node::addChild(Node *child)
 {
-    this->siblings.append(sibling);
-    sibling->addSibling(this);
+    this->children.append(child);
+    child->setParent(this);
 }
 
 void Node::printTree(int depth) const

parser_gui/Data/src/Token.cpp

@@ -40,6 +40,19 @@ Token &Token::operator=(Token &&other)
     return *this;
 }
 
+QStringView Token::getTokenTypeString(TokenType type)
+{
+    size_t index = static_cast<size_t>(type);
+
+    // Ensure the index is valid and within range
+    if (index >= tokenTypeStrings.size()) {
+        throw std::out_of_range("Invalid TokenType index");
+    }
+
+    // Return the string representation of the token type
+    return QStringView(tokenTypeStrings[index].toString());
+}
+
 // Returns the type of the token
 Token::TokenType Token::getType() const {
     return type;
@@ -60,26 +73,13 @@ int Token::getColumn() const {
     return column;
 }
 
-// Converts the token type to its string representation using a lookup table
-QStringView Token::getTokenTypeString() const {
-    size_t index = static_cast<size_t>(type);
-
-    // Ensure the index is valid and within range
-    if (index >= tokenTypeStrings.size()) {
-        throw std::out_of_range("Invalid TokenType index");
-    }
-
-    // Return the string representation of the token type
-    return QStringView(tokenTypeStrings[index].toString());
-}
-
 // Converts the token to a detailed string representation
 QString Token::toString(bool includePosition) const {
     QString str;
     QTextStream stream(&str);
 
     // Include the token type and value
-    stream << value << ", " << getTokenTypeString();
+    stream << value << ", " << getTokenTypeString(type);
 
     // Optionally include the token's line and column positions
     if (includePosition) {
@@ -96,18 +96,23 @@ QString Token::toHTMLString(bool includePosition) const
     QTextStream stream(&str);
 
     // Use light gray for token value
+    if (value == "<"){
+        stream << "<span style='color:#c0c0c0;'>&lt;" << value << "&gt;</span>, ";
+
+    } else {
     stream << "<span style='color:#c0c0c0;'>" << value << "</span>, ";
+    }
 
     // Conditional formatting for token type
     if (type == TokenType::UNKNOWN) {
         // Bright red for unknown type
-        stream << "<span style='color:#ff5555; font-weight:bold;'>" << getTokenTypeString() << "</span>";
+        stream << "<span style='color:#ff5555; font-weight:bold;'>" << getTokenTypeString(type) << "</span>";
     } else if (type != TokenType::NUMBER && type != TokenType::IDENTIFIER && type != TokenType::UNKNOWN) {
         // Light blue for reserved types
-        stream << "<span style='color:#5555ff; font-weight:bold;'>" << getTokenTypeString() << "</span>";
+        stream << "<span style='color:#5555ff; font-weight:bold;'>" << getTokenTypeString(type) << "</span>";
     } else {
         // Default white for known types
-        stream << "<span style='color:#ffffff; font-weight:bold;'>" << getTokenTypeString() << "</span>";
+        stream << "<span style='color:#ffffff; font-weight:bold;'>" << getTokenTypeString(type) << "</span>";
     }
 
     // Optionally include the token's line and column positions

parser_gui/Parser/include/Parser.h

@@ -3,12 +3,49 @@
 #define PARSER_H
 
 #include <QObject>
+#include <QList>
+
+#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();
     };
 
 

parser_gui/Parser/src/Parser.cpp

@@ -1,6 +1,146 @@
 // Parser.cpp
 #include "Parser.h"
 
-namespace Tiny::Parser {
+using namespace Tiny::Parser;
+using namespace Tiny::Data;
+
+Parser::Parser(QObject *parent) : QObject(parent)
+{
+
+}
+
+Parser::~Parser()
+{}
+
+void Parser::setTokens(QList<Token> tokens)
+{
+    this->tokens = tokens;
+    currentTokenIndex = 0;
+    currentLevel = 0;
+}
+
+Node *Parser::parse()
+{
+    return parseStmtSequence();
+}
+
+void Parser::advance()
+{
+    currentTokenIndex++;
+}
+
+void Parser::expectAndSkip(Token::TokenType type)
+{
+    if(tokens[currentTokenIndex].getType() != type)
+    {
+        emit error("Expected " + Token::getTokenTypeString(type).toString() + " but got " +
+                   Token::getTokenTypeString(tokens[currentTokenIndex].getType()).toString() +
+                   ". At line: " + QString::number(tokens[currentTokenIndex].getLine()) +
+                   " column: " + QString::number(tokens[currentTokenIndex].getColumn()));
+    }
+    advance();
+}
+
+Node *Parser::consume(Token::TokenType tokenType, Node::NodeType nodeType)
+{
+    Token currentToken = tokens[currentTokenIndex];
+    if(currentToken.getType() != tokenType){
+        emit error("Expected " + Token::getTokenTypeString(tokenType).toString() + " but got " +
+                   Token::getTokenTypeString(currentToken.getType()).toString() +
+                   ". At line: " + QString::number(currentToken.getLine()) +
+                   " column: " + QString::number(currentToken.getColumn()));
+        return nullptr;
+    }
+
+    Node* node = new Node(nodeType, currentToken.getValue());
+    advance();
+    return node;
+}
+
+Node *Parser::parseStmtSequence()
+{
+    Node* firstStmt = parseStatement();
+    Node* currentStmt = firstStmt;
+    // set level
+    currentStmt->setLevel(currentLevel);
+
+    while(tokens[currentTokenIndex].getType() == Token::TokenType::SEMICOLON)
+    {
+        advance(); // consume the semicolon
+        Node* nextStmt = parseStatement();
+        if(nextStmt != nullptr)
+        {
+            currentStmt->addChild(nextStmt);
+            nextStmt->setLevel(currentLevel);
+            currentStmt = nextStmt;
+        }
+    }
+
+    return firstStmt;
+}
+
+Node *Parser::parseStatement()
+{
+
+}
+
+Node *Parser::parseIfStatement()
+{
+
+}
+
+Node *Parser::parseRepeatStatement()
+{
+
+}
+
+Node *Parser::parseAssignStatement()
+{
+
+}
+
+Node *Parser::parseReadStatement()
+{
+
+}
+
+Node *Parser::parseWriteStatement()
+{
+
+}
+
+Node *Parser::parseExp()
+{
+
+}
+
+Node *Parser::parseSimpleExp()
+{
+
+}
+
+Node *Parser::parseComparisonOp()
+{
+
+}
+
+Node *Parser::parseAddop()
+{
+
+}
+
+Node *Parser::parseTerm()
+{
+
+}
+
+Node *Parser::parseMulop()
+{
+
+}
+
+Node *Parser::parseFactor()
+{
+
+}
 
-}  // namespace Tiny::Parser

parser_gui/Widgets/include/TreeVisualiser.h

@@ -7,12 +7,14 @@
 
 #include "Node.h"
 
+using namespace Tiny::Data;
 namespace Tiny::Widgets {
     class TreeVisualiser : public QWidget {
         Q_OBJECT
        public:
         TreeVisualiser(QWidget *parent = nullptr);
-        void drawTree(Node* root);
+        void setRoot(Node* root);
+
 
     }; // class TreeVisualiser
 }  // namespace Tiny::Widgets