refactor, perf: replace StackObject with abstract Literal class

mrunix00 · Mar 3, 2024 · 62319b0 · 62319b0
1 parent 3757d3e
commit 62319b0
Show file tree

Hide file tree

Showing 30 changed files with 130 additions and 147 deletions.
diff --git a/src/bytecode/instructions/Add.h b/src/bytecode/instructions/Add.h
@@ -10,9 +10,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object1 = vm->stackPop();
             const auto object2 = vm->stackPop();
-            auto *result = new StackObject(new NumberLiteral(
-                    ((NumberLiteral *) object2->literal)->asNumber() +
-                    ((NumberLiteral *) object1->literal)->asNumber()));
+            auto *result = new NumberLiteral(
+                    ((NumberLiteral *) object2)->asNumber() +
+                    ((NumberLiteral *) object1)->asNumber());
             delete object1;
             delete object2;
             vm->stackPush(result);

diff --git a/src/bytecode/instructions/CondJumpIfNot.h b/src/bytecode/instructions/CondJumpIfNot.h
@@ -9,7 +9,7 @@ namespace Bytecode {
         explicit CondJumpIfNot(const size_t line) : line(line) { type = InstructionType::CondJumpIfNot; }
         void execute(VM *vm) override {
             const auto cond = vm->stackPop();
-            if (!((BooleanLiteral *) cond->literal)->asBoolean())
+            if (!((BooleanLiteral *) cond)->asBoolean())
                 vm->jump(line);
             delete cond;
         }

diff --git a/src/bytecode/instructions/Divide.h b/src/bytecode/instructions/Divide.h
@@ -10,9 +10,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object1 = vm->stackPop();
             const auto object2 = vm->stackPop();
-            auto *result = new StackObject(new NumberLiteral(
-                    ((NumberLiteral *) object2->literal)->asNumber() /
-                    ((NumberLiteral *) object1->literal)->asNumber()));
+            auto *result = new NumberLiteral(
+                    ((NumberLiteral *) object2)->asNumber() /
+                    ((NumberLiteral *) object1)->asNumber());
             vm->stackPush(result);
         }
         [[nodiscard]] std::string toString() const override { return "Divide"; }

diff --git a/src/bytecode/instructions/Equals.h b/src/bytecode/instructions/Equals.h
@@ -11,9 +11,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object1 = vm->stackPop();
             const auto object2 = vm->stackPop();
-            auto *result = new StackObject(new BooleanLiteral(
-                    ((NumberLiteral *) object2->literal)->asNumber() ==
-                    ((NumberLiteral *) object1->literal)->asNumber()));
+            auto *result = new BooleanLiteral(
+                    ((NumberLiteral *) object2)->asNumber() ==
+                    ((NumberLiteral *) object1)->asNumber());
             vm->stackPush(result);
             delete object1;
             delete object2;

diff --git a/src/bytecode/instructions/GreaterThan.h b/src/bytecode/instructions/GreaterThan.h
@@ -11,9 +11,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object2 = vm->stackPop();
             const auto object1 = vm->stackPop();
-            auto *result = new StackObject(new BooleanLiteral(
-                    ((NumberLiteral *) object1->literal)->asNumber() >
-                    ((NumberLiteral *) object2->literal)->asNumber()));
+            auto *result = new BooleanLiteral(
+                    ((NumberLiteral *) object1)->asNumber() >
+                    ((NumberLiteral *) object2)->asNumber());
             vm->stackPush(result);
             delete object1;
             delete object2;

diff --git a/src/bytecode/instructions/LessThan.h b/src/bytecode/instructions/LessThan.h
@@ -11,9 +11,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object2 = vm->stackPop();
             const auto object1 = vm->stackPop();
-            auto *result = new StackObject(new BooleanLiteral(
-                    ((NumberLiteral *) object1->literal)->asNumber() <
-                    ((NumberLiteral *) object2->literal)->asNumber()));
+            auto *result = new BooleanLiteral(
+                    ((NumberLiteral *) object1)->asNumber() <
+                    ((NumberLiteral *) object2)->asNumber());
             vm->stackPush(result);
             delete object1;
             delete object2;

diff --git a/src/bytecode/instructions/LoadLiteral.h b/src/bytecode/instructions/LoadLiteral.h
@@ -6,17 +6,17 @@
 namespace Bytecode {
     class LoadLiteral final : public Instruction {
     public:
-        Literal *literal;
+        StackObject *literal;
 
         explicit LoadLiteral(double value) {
             type = InstructionType::LoadLiteral;
             literal = new NumberLiteral(value);
         };
 
-        explicit LoadLiteral(Literal *literal) : literal(literal) {}
+        explicit LoadLiteral(StackObject *literal) : literal(literal) {}
 
         void execute(VM *vm) override {
-            vm->stackPush(new StackObject(literal->copy()));
+            vm->stackPush(literal->copy());
         }
         [[nodiscard]] std::string toString() const override {
             return "LoadLiteral " + literal->toString();

diff --git a/src/bytecode/instructions/Multiply.h b/src/bytecode/instructions/Multiply.h
@@ -10,9 +10,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object2 = vm->stackPop();
             const auto object1 = vm->stackPop();
-            auto *result = new StackObject(new NumberLiteral(
-                    ((NumberLiteral *) object2->literal)->asNumber() *
-                    ((NumberLiteral *) object1->literal)->asNumber()));
+            auto *result = new NumberLiteral(
+                    ((NumberLiteral *) object2)->asNumber() *
+                    ((NumberLiteral *) object1)->asNumber());
             vm->stackPush(result);
             delete object1;
             delete object2;

diff --git a/src/bytecode/instructions/Not.h b/src/bytecode/instructions/Not.h
@@ -11,8 +11,8 @@ namespace Bytecode {
 
         void execute(VM *vm) override {
             const auto object = vm->stackPop();
-            const auto boolean = ((BooleanLiteral *) object->literal)->asBoolean();
-            const auto return_object = new StackObject(new BooleanLiteral(!boolean));
+            const auto boolean = ((BooleanLiteral *) object)->asBoolean();
+            const auto return_object = new BooleanLiteral(!boolean);
             vm->stackPush(return_object);
         }
 

diff --git a/src/bytecode/instructions/Subtract.h b/src/bytecode/instructions/Subtract.h
@@ -9,9 +9,9 @@ namespace Bytecode {
         void execute(VM *vm) override {
             const auto object2 = vm->stackPop();
             const auto object1 = vm->stackPop();
-            auto *result = new StackObject(new NumberLiteral(
-                    ((NumberLiteral *) object1->literal)->asNumber() -
-                    ((NumberLiteral *) object2->literal)->asNumber()));
+            auto *result = new NumberLiteral(
+                    ((NumberLiteral *) object1)->asNumber() -
+                    ((NumberLiteral *) object2)->asNumber());
             vm->stackPush(result);
             delete object1;
             delete object2;

diff --git a/src/bytecode/objects/BooleanLiteral.h b/src/bytecode/objects/BooleanLiteral.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "Literal.h"
+#include "StackObject.h"
 namespace Bytecode {
-    class BooleanLiteral : public Literal {
+    class BooleanLiteral : public StackObject {
         bool boolean;
 
     public:
@@ -12,15 +12,15 @@ namespace Bytecode {
 
         [[nodiscard]] bool asBoolean() const { return boolean; }
 
-        [[nodiscard]] Literal *copy() const override {
+        [[nodiscard]] StackObject *copy() const override {
             return new BooleanLiteral(boolean);
         }
 
         [[nodiscard]] std::string toString() const override {
             return "#" + (boolean ? std::string("true") : std::string("false"));
         }
 
-        bool operator==(const Literal &l) const override {
+        bool operator==(const StackObject &l) const override {
             return type == Type::Boolean &&
                    ((BooleanLiteral *) &l)->boolean == boolean;
         }

diff --git a/src/bytecode/objects/GlobalRegister.h b/src/bytecode/objects/GlobalRegister.h
@@ -16,7 +16,7 @@ namespace Bytecode {
         }
 
         StackObject *get(VM *vm) override {
-            return new StackObject(vm->getGlobal(reg)->literal->copy());
+            return vm->getGlobal(reg)->copy();
         }
 
         void store(VM *vm) override {

diff --git a/src/bytecode/objects/Literal.h b/src/bytecode/objects/Literal.h
diff --git a/src/bytecode/objects/LocalRegister.h b/src/bytecode/objects/LocalRegister.h
@@ -16,7 +16,7 @@ namespace Bytecode {
         }
 
         StackObject *get(VM *vm) override {
-            return new StackObject(vm->getLocal(reg)->literal->copy());
+            return vm->getLocal(reg)->copy();
         }
 
         void store(VM *vm) override {}

diff --git a/src/bytecode/objects/NumberLiteral.h b/src/bytecode/objects/NumberLiteral.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "Literal.h"
+#include "StackObject.h"
 #include <cstdint>
 #include <limits>
 #include <sstream>
 
 namespace Bytecode {
-    class NumberLiteral : public Literal {
+    class NumberLiteral : public StackObject {
         double number;
 
     public:
@@ -16,7 +16,7 @@ namespace Bytecode {
 
         [[nodiscard]] double asNumber() const { return number; }
 
-        [[nodiscard]] Literal *copy() const override {
+        [[nodiscard]] StackObject *copy() const override {
             return new NumberLiteral(number);
         }
 
@@ -26,7 +26,7 @@ namespace Bytecode {
             return s.str();
         }
 
-        bool operator==(const Literal &l) const override {
+        bool operator==(const StackObject &l) const override {
             if (type == Type::Number) {
                 return std::abs(((NumberLiteral *) &l)->number - number) <
                        (std::numeric_limits<double>::epsilon() * 10);

diff --git a/src/bytecode/objects/StackObject.h b/src/bytecode/objects/StackObject.h
@@ -1,16 +1,21 @@
 #pragma once
 
-#include "bytecode/objects/Literal.h"
+#include <cstdint>
+#include <string>
 
 namespace Bytecode {
     class StackObject {
     public:
-        Literal *literal;
-        ~StackObject() { delete literal; }
-        explicit StackObject(Literal *literal) : literal(literal){};
-
-        bool operator==(const StackObject &so) const {
-            return *so.literal == *literal;
-        }
+        enum Type {
+            None,
+            Number,
+            Boolean,
+            String,
+        };
+        Type type = None;
+        virtual ~StackObject() = default;
+        [[nodiscard]] virtual StackObject *copy() const = 0;
+        [[nodiscard]] virtual std::string toString() const = 0;
+        virtual bool operator==(const StackObject &l) const = 0;
     };
 }// namespace Bytecode
diff --git a/src/bytecode/objects/StdOutRegister.h b/src/bytecode/objects/StdOutRegister.h
@@ -18,21 +18,21 @@ namespace Bytecode {
         }
 
         void store(VM *vm) override {
-            const auto literal = vm->stackPop()->literal;
-            switch (literal->type) {
-                case Literal::Boolean:
-                    std::cout << (((BooleanLiteral *) literal)->asBoolean()
+            const auto stackObject = vm->stackPop();
+            switch (stackObject->type) {
+                case StackObject::Boolean:
+                    std::cout << (((BooleanLiteral *) stackObject)->asBoolean()
                                           ? std::string("#true")
                                           : std::string("#false"));
                     break;
-                case Literal::Number:
-                    std::cout << ((NumberLiteral *) literal)->asNumber();
+                case StackObject::Number:
+                    std::cout << ((NumberLiteral *) stackObject)->asNumber();
                     break;
-                case Literal::String:
-                    std::cout << ((StringLiteral *) literal)->asString();
+                case StackObject::String:
+                    std::cout << ((StringLiteral *) stackObject)->asString();
                     break;
                 default:
-                    std::cout << literal->toString();
+                    std::cout << stackObject->toString();
             }
         }
 

diff --git a/src/bytecode/objects/StringLiteral.h b/src/bytecode/objects/StringLiteral.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "Literal.h"
+#include "StackObject.h"
 #include <utility>
 
 namespace Bytecode {
-    class StringLiteral : public Literal {
+    class StringLiteral : public StackObject {
         std::string value;
 
     public:
@@ -18,7 +18,7 @@ namespace Bytecode {
 
         [[nodiscard]] std::string asString() const { return value; }
 
-        [[nodiscard]] Literal *copy() const override {
+        [[nodiscard]] StackObject *copy() const override {
             return new StringLiteral(value);
         }
 
@@ -27,7 +27,7 @@ namespace Bytecode {
             return '"' + value + '"';
         }
 
-        bool operator==(const Literal &l) const override {
+        bool operator==(const StackObject &l) const override {
             return type == Type::String &&
                    ((StringLiteral *) &l)->value == value;
         }

diff --git a/src/main.cpp b/src/main.cpp
@@ -55,10 +55,10 @@ void exec_program(const std::string &program, struct options opts) {
             if (interpreter.vm.stackTop() == nullptr)
                 continue;
 
-            if (interpreter.vm.stackTop()->literal->type == Bytecode::Literal::Type::Number)
-                std::cout << ((Bytecode::NumberLiteral *) interpreter.vm.stackTop()->literal)->asNumber() << '\n';
+            if (interpreter.vm.stackTop()->type == Bytecode::StackObject::Type::Number)
+                std::cout << ((Bytecode::NumberLiteral *) interpreter.vm.stackTop())->asNumber() << '\n';
             else
-                std::cout << interpreter.vm.stackTop()->literal->toString() << '\n';
+                std::cout << interpreter.vm.stackTop()->toString() << '\n';
 
             interpreter.vm.clearStack();
         } catch (SyntaxError &error) {

diff --git a/tests/bytecode/vm/add_test.cpp b/tests/bytecode/vm/add_test.cpp
@@ -15,12 +15,12 @@ TEST(vm_add_test, ShouldAddTwoLiterals) {
             }),
     });
 
-    const auto expected_result = new StackObject(new NumberLiteral(30));
+    const auto expected_result = NumberLiteral(30);
 
     auto interpreter = Interpreter();
     interpreter.execute(program);
 
-    EXPECT_EQ(*interpreter.vm.stackTop() == *expected_result, true);
+    EXPECT_EQ(*interpreter.vm.stackTop() == expected_result, true);
 }
 
 TEST(vm_add_test, ShouldAddTwoDecimalNumbers) {
@@ -32,12 +32,12 @@ TEST(vm_add_test, ShouldAddTwoDecimalNumbers) {
             }),
     });
 
-    const auto expected_result = new StackObject(new NumberLiteral(4.6415));
+    const auto expected_result = NumberLiteral(4.6415);
 
     auto interpreter = Interpreter();
     interpreter.execute(program);
 
-    EXPECT_EQ(*interpreter.vm.stackTop() == *expected_result, true);
+    EXPECT_EQ(*interpreter.vm.stackTop() == expected_result, true);
 }
 
 TEST(vm_add_test, ShouldAddDecimalAndIntegerNumbers) {
@@ -49,10 +49,10 @@ TEST(vm_add_test, ShouldAddDecimalAndIntegerNumbers) {
             }),
     });
 
-    const auto expected_result = new StackObject(new NumberLiteral(4.1415));
+    const auto expected_result = NumberLiteral(4.1415);
 
     auto interpreter = Interpreter();
     interpreter.execute(program);
 
-    EXPECT_EQ(*interpreter.vm.stackTop() == *expected_result, true);
+    EXPECT_EQ(*interpreter.vm.stackTop() == expected_result, true);
 }