remove ParseTree class and its implementation

Author: SemoMoh

parser_gui/Data/include/Node.h

@@ -0,0 +1,91 @@
+#ifndef NODE_H
+#define NODE_H
+
+#include <QString>
+#include <QList>
+#include <QStringView>
+#include <QLatin1StringView>
+#include <QDebug>
+
+#include <array>
+
+
+namespace Tiny::Data {
+class Node {
+
+public:
+    enum class NodeType {
+        Program,
+        Statement,
+        IfStatement,
+        RepeatStatement,
+        AssignStatement,
+        ReadStatement,
+        WriteStatement,
+        Expression,
+        Comparison,
+        Addition,
+        Multiplication,
+        Factor,
+        Identifier,
+        Number
+    }; // enum class NodeType
+
+
+    explicit Node(NodeType type, QString value, Node *parent = nullptr);
+    ~Node();
+
+    // getters
+    QString getValue() const;
+    NodeType getType() const;
+    QStringView getNodeTypeString() const;
+    Node *getParent() const;
+    QList<Node *> getSiblings() const;
+    QList<Node *> getChildren() const;
+
+    // setters
+    void setValue(QString value);
+    void setType(NodeType type);
+    void setParent(Node *parent);
+
+    // 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;
+
+
+
+
+    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")
+    }; // nodeTypeStrings Lookup Table
+
+}; // class Node
+
+} // namespace Tiny::Data
+
+#endif // NODE_H

parser_gui/Data/include/ParseTree.h

@@ -41,6 +41,7 @@ class Token {
     enum class TokenType {
         IF,            /**< "if" keyword */
         THEN,          /**< "then" keyword */
+        ELSE,          /**< "else" keyword */
         END,           /**< "end" keyword */
         REPEAT,        /**< "repeat" keyword */
         UNTIL,         /**< "until" keyword */
@@ -110,6 +111,8 @@ class Token {
      */
     QString toString(bool includePosition = false) const;
 
+    QString toHTMLString(bool includePosition = false) const;
+
 
     // copy constructor
     Token(const Token &other) = default;
@@ -146,9 +149,10 @@ class Token {
      * This table maps each TokenType enum value to its corresponding string
      * representation for use in debugging and output.
      */
-    static constexpr std::array<QLatin1StringView, 20> tokenTypeStrings = {
+    static constexpr std::array<QLatin1StringView, 21> tokenTypeStrings = {
         QLatin1StringView("IF"),            /**< "if" keyword */
         QLatin1StringView("THEN"),          /**< "then" keyword */
+        QLatin1StringView("ELSE"),          /**< "else" keyword */
         QLatin1StringView("END"),           /**< "end" keyword */
         QLatin1StringView("REPEAT"),        /**< "repeat" keyword */
         QLatin1StringView("UNTIL"),         /**< "until" keyword */

parser_gui/Data/include/Token.h

@@ -0,0 +1,90 @@
+#include "Node.h"
+
+using namespace Tiny::Data;
+
+Node::Node(NodeType type, QString value, Node *parent)
+: type(type), value(value), parent(parent)
+{}
+
+Node::~Node()
+{
+    for (auto child : children)
+    {
+        delete child;
+    }
+}
+
+QString Node::getValue() const
+{
+    return value;
+}
+
+Node::NodeType Node::getType() const
+{
+    return type;
+}
+
+QStringView Node::getNodeTypeString() const
+{
+    size_t index = static_cast<size_t>(type);
+
+    // Ensure the index is valid and within range
+    if (index >= nodeTypeStrings.size())
+    {
+        throw std::out_of_range("Invalid NodeType index");
+    }
+
+    // Return the string representation of the node type
+    return QStringView(nodeTypeStrings[index].toString());
+}
+
+Node *Node::getParent() const
+{
+    return parent;
+}
+
+QList<Node *> Node::getSiblings() const
+{
+    return siblings;
+}
+
+QList<Node *> Node::getChildren() const
+{
+    return children;
+}
+
+void Node::setValue(QString value)
+{
+    this->value = value;
+}
+
+void Node::setType(NodeType type)
+{
+    this->type = type;
+}
+
+void Node::setParent(Node *parent)
+{
+    this->parent = parent;
+}
+
+void Node::addChild(Node *child)
+{
+    this->children.append(child);
+}
+
+void Node::addSibling(Node *sibling)
+{
+    this->siblings.append(sibling);
+    sibling->addSibling(this);
+}
+
+void Node::printTree(int depth) const
+{
+    qDebug().noquote() << QString(depth * 2, ' ') << this->getNodeTypeString() << ": " << value;
+    for (auto child : children)
+    {
+        child->printTree(depth + 1);
+    }
+
+}

parser_gui/Data/src/Node.cpp

@@ -90,4 +90,32 @@ QString Token::toString(bool includePosition) const {
     return str;
 }
 
+QString Token::toHTMLString(bool includePosition) const
+{
+    QString str;
+    QTextStream stream(&str);
+
+    // Use light gray for token value
+    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>";
+    } 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>";
+    } else {
+        // Default white for known types
+        stream << "<span style='color:#ffffff; font-weight:bold;'>" << getTokenTypeString() << "</span>";
+    }
+
+    // Optionally include the token's line and column positions
+    if (includePosition) {
+        stream << " <span style='color:#ff9900;'>[Line: " << line << ", Column: " << column << "]</span>";
+    }
+
+    return str;
+}
+
 }  // namespace Tiny::Data

parser_gui/Data/src/ParseTree.cpp

@@ -43,4 +43,7 @@ void MainWindow::initTabWidget() {
     // connect tolbar buttons to tab widget slots
     connect(toolbar, &Tiny::Widgets::ToolBar::newTextTab, tabWidget, &Tiny::Widgets::TabWidget::newTextTab);
     connect(toolbar, &Tiny::Widgets::ToolBar::newTokensTab, tabWidget, &Tiny::Widgets::TabWidget::newTokensTab);
+
+    // set the toolbar in the tab widget
+    tabWidget->setToolBar(toolbar);
 }

parser_gui/Data/src/Token.cpp

@@ -2,8 +2,16 @@
 #ifndef PARSER_H
 #define PARSER_H
 
+#include <QObject>
+
 namespace Tiny::Parser {
+    class Parser : public QObject {
+        Q_OBJECT
+       public:
+
+    };
+
 
 }  // namespace Tiny::Parser
 
-#endif  // PARSER_H
+#endif  // PARSER_H

parser_gui/MainWindow.cpp

@@ -61,6 +61,7 @@ class Scanner : public QObject
      */
     bool hasMoreTokens();
 
+    void setInput(const QString &input);
 private:
     QString input;     /**< The source code to be tokenized. */
     size_t pos = 0;    /**< Current position in the input string. */

parser_gui/Parser/include/Parser.h

@@ -96,7 +96,8 @@ Token Scanner::getNextToken()
             return Token(Token::TokenType::READ, identifier, line, column);
         if (identifier == "write")
             return Token(Token::TokenType::WRITE, identifier, line, column);
-
+        if (identifier == "else")
+            return Token(Token::TokenType::ELSE, identifier, line, column);
         // If not a keyword, it's an identifier
         return Token(Token::TokenType::IDENTIFIER, identifier, line, column);
     }
@@ -141,6 +142,15 @@ bool Scanner::hasMoreTokens()
     return hasMore;
 }
 
+void Scanner::setInput(const QString &input)
+{
+    // reset the scanner state
+    this->input = input;
+    pos = 0;
+    line = 1;
+    column = 1;
+}
+
 QChar Scanner::peek() const
 {
     // Return the next character if within bounds, or '\0' if at the end