draft of classes

.vscode/c_cpp_properties.json

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++98",
+            "intelliSenseMode": "macos-clang-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,66 @@
+{
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "algorithm": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "cmath": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "utility": "cpp",
+        "vector": "cpp"
+    }
+}

Algorithm-visualizer/AST/assignment.cpp

@@ -0,0 +1,6 @@
+#include "assignment.hpp"
+
+Assignment::Assignment()
+{
+
+}

Algorithm-visualizer/AST/assignment.hpp

@@ -0,0 +1,63 @@
+#include "ast.hpp"
+#include "statement.hpp"
+#include "expression.hpp"
+#ifndef ASSIGNMENT_HPP
+#define ASSIGNMENT_HPP
+
+//enum var_type {
+//    unknown_var_type = 0,
+//    string = 1,
+//    integer = 2,
+//    character = 3,
+//    floating_point = 4
+
+//};
+
+//enum un_op {
+//    unknown_un_op = 0,
+//    negation = 1,
+//    plusplus = 2
+//    //inverse = 2 (if we add this as a unary operation for number -> -number)
+//};
+
+//enum bin_op {
+//    unknown_bin_op = 0,
+//    conjunction = 1,
+//    disjunction = 2,
+//    addition = 3,
+//    subtraction = 4,
+//    multiplication = 5,
+//    division = 6,
+//    lthan = 7,
+//    mthan = 8,
+//    leq = 9,
+//    meq = 10,
+//    eq = 11,
+//    eqeq = 12
+//};
+
+//enum jump_type {
+//    unknown_jump_type = 0,
+//    br = 1,
+//    cont = 2
+//};
+//enum expression_type {
+//    unknown_expression_type = 0
+//};
+
+
+class Assignment : public Statement {
+    public:
+    Assignment();
+    ~Assignment();
+    Expression* get_value(){return value;};
+    void set_value(Expression* v){value= v;}
+    std::string get_name(){return name;};
+    void set_name(std::string n){name= n;}
+    //x = 5; x = y
+    std::string get_subtype(){return "Assignment";};
+private:
+    std::string name;
+    Expression* value;
+};
+#endif // ASSIGNMENT_HPP

Algorithm-visualizer/AST/ast.hpp

@@ -1,29 +1,57 @@
 #ifndef AST_H
 #define AST_H
 
+#include <string>
+#include <iostream>
 #include <QAbstractItemModel>
+using namespace std;
 
-class AST : public QAbstractItemModel
-{
-    Q_OBJECT
+enum un_op {
+    unknown_un_op = 0,
+    negation = 1,
+    plusplus = 2
+    //inverse = 2 (if we add this as a unary operation for number -> -number)
+};
 
-public:
-    explicit AST(QObject *parent = nullptr);
+enum bin_op {
+    unknown_bin_op = 0,
+    conjunction = 1,
+    disjunction = 2,
+    addition = 3,
+    subtraction = 4,
+    multiplication = 5,
+    division = 6,
+    lthan = 7,
+    mthan = 8,
+    leq = 9,
+    meq = 10,
+    eq = 11,
+    eqeq = 12
+};
 
-    // Header:
-    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+enum jump_type {
+    unknown_jump_type = 0,
+    br = 1,
+    cont = 2
 
-    // Basic functionality:
-    QModelIndex index(int row, int column,
-                      const QModelIndex &parent = QModelIndex()) const override;
-    QModelIndex parent(const QModelIndex &index) const override;
+};
+enum expression_type {
+    unknown_expression_type = 0
 
-    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
-    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+};
 
-    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
-private:
+//AST CLASS
+
+class AST {
+protected : AST();
+protected : ~AST();
+virtual std::string get_type() = 0; // Statement or Expression   (this is an abstract method which will be defined in subclasses Statement
+//and Expression and inherited by every other subclass below)
+virtual std::string get_subtype() = 0; // Block, Declaration, UnOp, BinOp, ...
+//(this is an abstract method which will be defined in subclasses Block, Declaration, ...)
 };
 
-#endif // AST_H
+
+
+#endif

Algorithm-visualizer/AST/binop.cpp

@@ -0,0 +1,6 @@
+#include "binop.hpp"
+
+BinOp::BinOp()
+{
+
+}

Algorithm-visualizer/AST/binop.hpp

@@ -0,0 +1,143 @@
+#include "expression.hpp"
+#include "ast.hpp"
+#ifndef BINOP_HPP
+#define BINOP_HPP
+
+class Addition : public Expression {
+public : Addition();
+public : ~Addition();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") {return 0;};
+        return left_exp->get_value() + right_exp->get_value();
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Subtraction : public Expression {
+public : Subtraction();
+public : ~Subtraction();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") {return 0;};
+        return left_exp->get_value() - right_exp->get_value();
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Multiplication : public Expression {
+public : Multiplication();
+public : ~Multiplication();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") {return 0;};
+        return left_exp->get_value() * right_exp->get_value();
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Division : public Expression {
+public : Division();
+public : ~Division();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool"  or right_exp->get_value() == 0) return 0;
+        return left_exp->get_value() / right_exp->get_value();
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Mthan : public Expression {
+public : Mthan();
+public : ~Mthan();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") return 0;
+        if (left_exp->get_value() > right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Lthan : public Expression {
+public : Lthan();
+public : ~Lthan();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") return 0;
+        if (left_exp->get_value() < right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Leq : public Expression {
+public : Leq();
+public : ~Leq();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") return 0;
+        if (left_exp->get_value() <= right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Meq : public Expression {
+public : Meq();
+public : ~Meq();
+public : double get_value(){
+        if (left_exp->get_exp_type() == "bool" or right_exp->get_exp_type() == "bool") return 0;
+        if (left_exp->get_value() >= right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class Eqeq : public Expression {
+public : Eqeq();
+public : ~Eqeq();
+public : double get_value(){
+        if (left_exp->get_value() == right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class AndOp : public Expression {
+public : AndOp();
+public : ~AndOp();
+public : double get_value(){
+        if (left_exp->get_value() && right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+class OrOp : public Expression {
+public : OrOp();
+public : ~OrOp();
+public : double get_value(){
+        if (left_exp->get_value() || right_exp->get_value()) return 1;
+        return 0;
+    };
+private :
+    Expression* left_exp;
+    Expression* right_exp;
+};
+
+
+#endif // BINOP_HPP

Algorithm-visualizer/AST/binop_template.cpp

@@ -0,0 +1,6 @@
+#include "binop_template.hpp"
+
+binop_template::binop_template()
+{
+
+}