refactor: split Store into StoreGlobal and StoreLocal

mrunix00 · Mar 8, 2024 · 623d29c · 623d29c
1 parent 689e5aa
commit 623d29c
Show file tree

Hide file tree

Showing 13 changed files with 72 additions and 82 deletions.
diff --git a/src/bytecode/builtin_functions/DefineFunction.h b/src/bytecode/builtin_functions/DefineFunction.h
@@ -2,7 +2,7 @@
 
 #include "Function.h"
 #include "bytecode/instructions/Store.h"
-#include "bytecode/objects/GlobalRegister.h"
+#include "bytecode/instructions/StoreGlobal.h"
 
 namespace Bytecode::BuiltinFunctions {
     class Define final : public Function {
@@ -14,7 +14,7 @@ namespace Bytecode::BuiltinFunctions {
             if (args[1]->children.empty()) {
                 compiler.compile(*args[1], result, instructions);
                 const auto reg = compiler.program.declare_global(args[0]->token.token);
-                instructions.push_back(new Store(new GlobalRegister(reg)));
+                instructions.push_back(new StoreGlobal(reg));
             } else {
                 auto segment = new Segment({});
                 compiler.program.declare_function(args[0]->token.asString(), segment);

diff --git a/src/bytecode/instructions/Instruction.h b/src/bytecode/instructions/Instruction.h
@@ -21,6 +21,8 @@ namespace Bytecode {
         CondJumpIfNot,
         Jump,
         LoadGlobal,
+        StoreLocal,
+        StoreGlobal,
     };
 
     class Instruction {

diff --git a/src/bytecode/instructions/LoadLocal.h b/src/bytecode/instructions/LoadLocal.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Instruction.h"
-#include "bytecode/objects/LocalRegister.h"
 #include "bytecode/objects/Register.h"
 
 namespace Bytecode {

diff --git a/src/bytecode/instructions/Store.h b/src/bytecode/instructions/Store.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Instruction.h"
-#include "bytecode/objects/LocalRegister.h"
 #include "bytecode/objects/Register.h"
 #include <string>
 

diff --git a/src/bytecode/instructions/StoreGlobal.h b/src/bytecode/instructions/StoreGlobal.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Instruction.h"
+#include "bytecode/objects/Register.h"
+#include <string>
+
+namespace Bytecode {
+    class StoreGlobal final : public Instruction {
+        size_t reg;
+
+    public:
+        explicit StoreGlobal(size_t reg) : reg(reg) {
+            type = InstructionType::StoreGlobal;
+        }
+
+        void execute(VM *vm) override {
+            vm->setGlobal(0, vm->program_stack.pop());
+        }
+        [[nodiscard]] std::string toString() const override {
+            return "Store $r" + std::to_string(reg);
+        }
+        bool operator==(const Instruction &instruction) const override {
+            return instruction.type == type &&
+                   dynamic_cast<const StoreGlobal *>(&instruction)->reg == reg;
+        }
+    };
+}// namespace Bytecode
diff --git a/src/bytecode/instructions/StoreLocal.h b/src/bytecode/instructions/StoreLocal.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Instruction.h"
+#include "bytecode/objects/Register.h"
+#include <string>
+
+namespace Bytecode {
+    class StoreLocal final : public Instruction {
+        size_t reg;
+
+    public:
+        explicit StoreLocal(size_t reg) : reg(reg) {
+            type = InstructionType::StoreLocal;
+        }
+
+        void execute(VM *vm) override {
+            vm->call_stack.setLocal(0, vm->program_stack.pop());
+        }
+        [[nodiscard]] std::string toString() const override {
+            return "StoreLocal $r" + std::to_string(reg);
+        }
+        bool operator==(const Instruction &instruction) const override {
+            return instruction.type == type &&
+                   dynamic_cast<const StoreLocal *>(&instruction)->reg == reg;
+        }
+    };
+}// namespace Bytecode
diff --git a/src/bytecode/objects/GlobalRegister.h b/src/bytecode/objects/GlobalRegister.h
diff --git a/src/bytecode/objects/LocalRegister.h b/src/bytecode/objects/LocalRegister.h
diff --git a/tests/bytecode/compiler/add_test.cpp b/tests/bytecode/compiler/add_test.cpp
@@ -2,8 +2,7 @@
 #include "bytecode/instructions/Add.h"
 #include "bytecode/instructions/LoadGlobal.h"
 #include "bytecode/instructions/LoadLiteral.h"
-#include "bytecode/instructions/Store.h"
-#include "bytecode/objects/GlobalRegister.h"
+#include "bytecode/instructions/StoreGlobal.h"
 #include "parser/SyntaxTreeNode.h"
 #include <gtest/gtest.h>
 
@@ -71,7 +70,7 @@ TEST(compiler_add, DontOptimizeIfNotPossible) {
             new Segment(
                     {
                             new LoadLiteral(12),
-                            new Store(new GlobalRegister(0)),
+                            new StoreGlobal(0),
                             new LoadGlobal(0),
                             new LoadLiteral(74),
                             new Add(),

diff --git a/tests/bytecode/compiler/multiply_test.cpp b/tests/bytecode/compiler/multiply_test.cpp
@@ -2,8 +2,7 @@
 #include "bytecode/instructions/LoadGlobal.h"
 #include "bytecode/instructions/LoadLiteral.h"
 #include "bytecode/instructions/Multiply.h"
-#include "bytecode/instructions/Store.h"
-#include "bytecode/objects/GlobalRegister.h"
+#include "bytecode/instructions/StoreGlobal.h"
 #include "parser/SyntaxTreeNode.h"
 #include <gtest/gtest.h>
 
@@ -70,7 +69,7 @@ TEST(compiler_multiply, IgnoreOptimizationWhenNotPossible) {
     auto expected_result = Program({
             new Segment({
                     new LoadLiteral(12),
-                    new Store(new GlobalRegister(0)),
+                    new StoreGlobal(0),
                     new LoadGlobal(0),
                     new LoadLiteral(74),
                     new Multiply(),

diff --git a/tests/bytecode/compiler/to_string_test.cpp b/tests/bytecode/compiler/to_string_test.cpp
@@ -6,7 +6,7 @@
 #include "bytecode/instructions/LoadLiteral.h"
 #include "bytecode/instructions/LoadLocal.h"
 #include "bytecode/instructions/Multiply.h"
-#include "bytecode/instructions/Store.h"
+#include "bytecode/instructions/StoreLocal.h"
 #include "bytecode/instructions/Subtract.h"
 #include <gtest/gtest.h>
 
@@ -55,8 +55,8 @@ TEST(instruction_to_string, load_literal) {
 }
 
 TEST(instruction_to_string, store) {
-    const auto instruction = Store(new LocalRegister(12));
-    const auto expected_result = "Store $r12";
+    const auto instruction = StoreLocal(12);
+    const auto expected_result = "StoreLocal $r12";
     const auto actual_result = instruction.toString();
     EXPECT_EQ(expected_result, actual_result);
 }

diff --git a/tests/bytecode/compiler/variables_test.cpp b/tests/bytecode/compiler/variables_test.cpp
@@ -1,8 +1,7 @@
 #include "bytecode/compiler/Compiler.h"
 #include "bytecode/instructions/LoadGlobal.h"
 #include "bytecode/instructions/LoadLiteral.h"
-#include "bytecode/instructions/Store.h"
-#include "bytecode/objects/GlobalRegister.h"
+#include "bytecode/instructions/StoreGlobal.h"
 #include "parser/SyntaxTreeNode.h"
 #include <gtest/gtest.h>
 
@@ -20,7 +19,7 @@ TEST(compiler_variables, GlobalVariableDefinition) {
     const auto expected_result = Program({
             new Segment({
                     new LoadLiteral(10),
-                    new Store(new GlobalRegister(0)),
+                    new StoreGlobal(0),
             }),
     });
 
@@ -48,9 +47,9 @@ TEST(compiler_variables, MultipleGlobalVariablesDefinitions) {
     auto expected_result = Program({
             new Segment({
                     new LoadLiteral(10),
-                    new Store(new GlobalRegister(0)),
+                    new StoreGlobal(0),
                     new LoadLiteral(15),
-                    new Store(new GlobalRegister(1)),
+                    new StoreGlobal(1),
             }),
     });
 
@@ -75,7 +74,7 @@ TEST(compiler_variables, UseGlobalVariableInAnExpression) {
     auto expected_result = Program({
             new Segment({
                     new LoadLiteral(10),
-                    new Store(new GlobalRegister(0)),
+                    new StoreGlobal(0),
                     new LoadGlobal(0),
             }),
     });

diff --git a/tests/bytecode/vm/load_test.cpp b/tests/bytecode/vm/load_test.cpp
@@ -2,7 +2,7 @@
 #include "bytecode/instructions/LoadGlobal.h"
 #include "bytecode/instructions/LoadLiteral.h"
 #include "bytecode/instructions/Store.h"
-#include "bytecode/objects/GlobalRegister.h"
+#include "bytecode/instructions/StoreGlobal.h"
 #include "bytecode/objects/StackObject.h"
 #include "bytecode/vm/Interpreter.h"
 #include <gtest/gtest.h>
@@ -26,7 +26,7 @@ TEST(vm_load_test, ShouldLoadGlobalVariableIntoStack) {
     const auto program = Program({
             new Segment({
                     new LoadLiteral(10),
-                    new Store(new GlobalRegister(0)),
+                    new StoreGlobal(0),
                     new LoadGlobal(0),
             }),
     });