refactor: huge code refactor

mrunix00 · Apr 22, 2024 · 6520d36 · 6520d36
1 parent 42258a1
commit 6520d36
Show file tree

Hide file tree

Showing 53 changed files with 454 additions and 890 deletions.
diff --git a/src/bytecode/builtin_functions/AddFunction.cpp b/src/bytecode/builtin_functions/AddFunction.cpp
@@ -1,9 +1,5 @@
 
 #include "AddFunction.h"
-#include "bytecode/instructions/Add.h"
-#include "bytecode/instructions/AddRI.h"
-#include "bytecode/instructions/AddRR.h"
-#include "bytecode/instructions/Increment.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
@@ -25,14 +21,14 @@ namespace Bytecode::BuiltinFunctions {
         if (args[1]->type == SyntaxTreeNode::TokenNode &&
             ((TokenNode *) args[1])->getName() == "1") {
             args[0]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Increment());
+            instructions.push_back(new (Instruction){Instruction::Increment});
             return;
         }
 
         if (args[0]->type == SyntaxTreeNode::TokenNode &&
             ((TokenNode *) args[0])->getName() == "1") {
             args[1]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Increment());
+            instructions.push_back(new (Instruction){Instruction::Increment});
             return;
         }
 
@@ -41,40 +37,47 @@ namespace Bytecode::BuiltinFunctions {
             if (((TokenNode *) args[0])->token.type == Token::Symbol &&
                 ((TokenNode *) args[1])->token.type == Token::Number &&
                 segment->find_variable(((TokenNode *) args[0])->getName()) != -1) {
-                instructions.push_back(
-                        new Bytecode::AddRI(
-                                segment->find_variable(((TokenNode *) args[0])->getName()),
-                                ((TokenNode *) args[1])->token.asNumber()));
+                instructions.push_back(new (Instruction){
+                        Instruction::AddRI,
+                        {.ri_params = {
+                                 segment->find_variable(((TokenNode *) args[0])->getName()),
+                                 StackObject(((TokenNode *) args[1])->token)}},
+                });
                 return;
             }
             if (((TokenNode *) args[0])->token.type == Token::Number &&
                 ((TokenNode *) args[1])->token.type == Token::Symbol &&
                 segment->find_variable(((TokenNode *) args[1])->getName()) != -1) {
-                instructions.push_back(
-                        new Bytecode::AddRI(
-                                segment->find_variable(((TokenNode *) args[1])->getName()),
-                                ((TokenNode *) args[0])->token.asNumber()));
+                instructions.push_back(new (Instruction){
+                        Instruction::AddRI,
+                        {.ri_params = {
+                                 segment->find_variable(((TokenNode *) args[1])->getName()),
+                                 StackObject(((TokenNode *) args[0])->token)}},
+                });
                 return;
             }
             if (((TokenNode *) args[0])->token.type == Token::Symbol &&
                 ((TokenNode *) args[1])->token.type == Token::Symbol &&
                 segment->find_variable(((TokenNode *) args[0])->getName()) != -1 &&
                 segment->find_variable(((TokenNode *) args[1])->getName()) != -1) {
-                instructions.push_back(
-                        new Bytecode::AddRR(
-                                segment->find_variable(((TokenNode *) args[0])->getName()),
-                                segment->find_variable(((TokenNode *) args[1])->getName())));
+                instructions.push_back(new (Instruction){
+                        Instruction::AddRR,
+                        {.rr_params = {
+                                 segment->find_variable(((TokenNode *) args[0])->getName()),
+                                 segment->find_variable(((TokenNode *) args[1])->getName()),
+                         }},
+                });
                 return;
             }
         }
 
         args[0]->compile(segment, program, instructions);
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::Add());
+        instructions.push_back(new (Instruction){Instruction::Add});
 
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Add());
+            instructions.push_back(new (Instruction){Instruction::Add});
         }
     }
 }// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/AndFunction.cpp b/src/bytecode/builtin_functions/AndFunction.cpp
@@ -1,5 +1,4 @@
 #include "AndFunction.h"
-#include "bytecode/instructions/And.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
@@ -12,10 +11,10 @@ namespace Bytecode::BuiltinFunctions {
         args[0]->compile(segment, program, instructions);
         if (args.size() == 1) return;
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::And());
+        instructions.push_back(new (Instruction){Instruction::And});
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::And());
+            instructions.push_back(new (Instruction){Instruction::And});
         }
     }
 }// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/DefineFunction.cpp b/src/bytecode/builtin_functions/DefineFunction.cpp
@@ -1,6 +1,4 @@
 #include "DefineFunction.h"
-#include "bytecode/instructions/Return.h"
-#include "bytecode/instructions/StoreGlobal.h"
 
 namespace Bytecode::BuiltinFunctions {
     void Define::compile(
@@ -19,14 +17,14 @@ namespace Bytecode::BuiltinFunctions {
                 return;
             }
             args[1]->compile(result, program, instructions);
-            instructions.push_back(new StoreGlobal(reg));
+            instructions.push_back(new (Instruction){Instruction::StoreGlobal, {.r_param = {reg}}});
         } else if (args[0]->type == SyntaxTreeNode::Expression) {
             auto segment = new Segment({});
             program.declare_function(((Expression *) args[0])->getName(), segment);
             for (auto argument: ((Expression *) args[0])->getArgs())
                 segment->declare_variable(((TokenNode *) argument)->getName());
             args[1]->compile(segment, program, segment->instructions);
-            segment->instructions.push_back(new Bytecode::Return());
+            segment->instructions.push_back(new (Instruction){Instruction::Return});
         }
     }
 }// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/DivideFunction.cpp b/src/bytecode/builtin_functions/DivideFunction.cpp
@@ -1,7 +1,5 @@
 
 #include "DivideFunction.h"
-#include "bytecode/instructions/Divide.h"
-#include "bytecode/instructions/LoadLiteral.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
@@ -16,17 +14,21 @@ namespace Bytecode::BuiltinFunctions {
                     0,
                     0);
         if (args.size() == 1) {
-            instructions.push_back(new LoadLiteral((double) 1));
-            args[0]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Divide());
+            instructions.push_back(new (Instruction){
+                    Instruction::LoadLiteral,
+                    {.i_param = {StackObject((double) 1)}},
+            });
+            args[0]
+                    ->compile(segment, program, instructions);
+            instructions.push_back(new (Instruction){Instruction::Divide});
             return;
         }
         args[0]->compile(segment, program, instructions);
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::Divide());
+        instructions.push_back(new (Instruction){Instruction::Divide});
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Divide());
+            instructions.push_back(new (Instruction){Instruction::Divide});
         }
     }
 }// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/EqualsFunction.cpp b/src/bytecode/builtin_functions/EqualsFunction.cpp
@@ -1,11 +1,7 @@
 #include "EqualsFunction.h"
-#include "bytecode/instructions/Equals.h"
-#include "bytecode/instructions/EqualsRI.h"
-#include "bytecode/instructions/LoadLiteral.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
-
     void Equals::compile(
             const std::vector<SyntaxTreeNode *> &args,
             Program &program,
@@ -15,28 +11,33 @@ namespace Bytecode::BuiltinFunctions {
             throw SyntaxError("Invalid number of arguments for function \"=\", Expected at least 1, got 0");
         }
         if (args.size() == 1) {
-            instructions.push_back(new LoadLiteral(new StackObject(true)));
+            instructions.push_back(new (Instruction){
+                    Instruction::LoadLiteral,
+                    {.i_param = {StackObject(true)}},
+            });
             return;
         }
         if (args[0]->type == SyntaxTreeNode::TokenNode &&
             args[1]->type == SyntaxTreeNode::TokenNode &&
             segment->find_variable(((TokenNode *) args[0])->getName()) != -1) {
             if (((TokenNode *) args[0])->token.type == Token::Symbol &&
                 ((TokenNode *) args[1])->token.type == Token::Number) {
-                instructions.push_back(
-                        new Bytecode::EqualsRI(
-                                segment->find_variable(((TokenNode *) args[0])->getName()),
-                                ((TokenNode *) args[1])->token.asNumber()));
+                instructions.push_back(new (Instruction){
+                        Instruction::EqualsRI,
+                        {.ri_params = {
+                                 segment->find_variable(((TokenNode *) args[0])->getName()),
+                                 StackObject(((TokenNode *) args[1])->token),
+                         }}});
                 return;
             }
         }
 
         args[0]->compile(segment, program, instructions);
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::Equals());
+        instructions.push_back(new (Instruction){Instruction::Equals});
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::Equals());
+            instructions.push_back(new (Instruction){Instruction::Equals});
         }
     }
-}
+}// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/GreaterThanFunction.cpp b/src/bytecode/builtin_functions/GreaterThanFunction.cpp
@@ -1,7 +1,4 @@
 #include "GreaterThanFunction.h"
-#include "bytecode/instructions/GreaterThan.h"
-#include "bytecode/instructions/GreaterThanRI.h"
-#include "bytecode/instructions/LoadLiteral.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
@@ -14,28 +11,33 @@ namespace Bytecode::BuiltinFunctions {
             throw SyntaxError("Invalid number of arguments for function \">\", Expected at least 1, got 0");
         }
         if (args.size() == 1) {
-            instructions.push_back(new LoadLiteral(new StackObject(true)));
+            instructions.push_back(new (Instruction){
+                    Instruction::LoadLiteral,
+                    {.i_param = {StackObject(true)}},
+            });
             return;
         }
         if (args[0]->type == SyntaxTreeNode::TokenNode &&
             args[1]->type == SyntaxTreeNode::TokenNode &&
             segment->find_variable(((TokenNode *) args[0])->getName()) != -1) {
             if (((TokenNode *) args[0])->token.type == Token::Symbol &&
                 ((TokenNode *) args[1])->token.type == Token::Number) {
-                instructions.push_back(
-                        new Bytecode::GreaterThanRI(
-                                segment->find_variable(((TokenNode *) args[0])->getName()),
-                                ((TokenNode *) args[1])->token.asNumber()));
+                instructions.push_back(new (Instruction){
+                        Instruction::GreaterThanRI,
+                        {.ri_params = {
+                                 segment->find_variable(((TokenNode *) args[0])->getName()),
+                                 StackObject(((TokenNode *) args[1])->token)}},
+                });
                 return;
             }
         }
 
         args[0]->compile(segment, program, instructions);
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::GreaterThan());
+        instructions.push_back(new (Instruction){Instruction::GreaterThan});
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::GreaterThan());
+            instructions.push_back(new (Instruction){Instruction::GreaterThan});
         }
     }
 }// namespace Bytecode::BuiltinFunctions
diff --git a/src/bytecode/builtin_functions/IfFunction.cpp b/src/bytecode/builtin_functions/IfFunction.cpp
@@ -1,6 +1,4 @@
 #include "IfFunction.h"
-#include "bytecode/instructions/CondJumpIfNot.h"
-#include "bytecode/instructions/Jump.h"
 
 namespace Bytecode::BuiltinFunctions {
     void If::compile(
@@ -15,15 +13,18 @@ namespace Bytecode::BuiltinFunctions {
         args[1]->compile(result, program, condition_success);
         if (args.size() == 3)
             args[2]->compile(result, program, condition_failure);
-
-        result->instructions.push_back(
-                new CondJumpIfNot(
-                        result->instructions.size() + condition_success.size() +
-                        (condition_failure.empty() ? 1 : 2)));
+        result->instructions.push_back(new (Instruction){
+                Instruction::CondJumpIfNot,
+                {.r_param = {result->instructions.size() + condition_success.size() +
+                             (condition_failure.empty() ? 1 : 2)}},
+        });
         for (const auto instruction: condition_success)
             instructions.push_back(instruction);
         if (!condition_failure.empty())
-            instructions.push_back(new Jump(instructions.size() + condition_failure.size() + 1));
+            instructions.push_back(new (Instruction) {
+                    Instruction::Jump,
+                    {.r_param = {instructions.size() + condition_failure.size() + 1}},
+            });
 
         for (const auto instruction: condition_failure)
             instructions.push_back(instruction);

diff --git a/src/bytecode/builtin_functions/LessThanFunction.cpp b/src/bytecode/builtin_functions/LessThanFunction.cpp
@@ -1,41 +1,43 @@
 #include "LessThanFunction.h"
-#include "bytecode/instructions/LessThan.h"
-#include "bytecode/instructions/LessThanRI.h"
-#include "bytecode/instructions/LoadLiteral.h"
 #include "exceptions/SyntaxError.h"
 
 namespace Bytecode::BuiltinFunctions {
     void LessThan::compile(
             const std::vector<SyntaxTreeNode *> &args,
             Program &program,
             std::vector<Instruction *> &instructions,
-            Segment *segment)  {
+            Segment *segment) {
         if (args.empty()) {
             throw SyntaxError("Invalid number of arguments for function \"<\", Expected at least 1, got 0");
         }
         if (args.size() == 1) {
-            instructions.push_back(new LoadLiteral(new StackObject(true)));
+            instructions.push_back(new (Instruction){
+                    Instruction::LoadLiteral,
+                    {.i_param = {StackObject(true)}},
+            });
             return;
         }
         if (args[0]->type == SyntaxTreeNode::TokenNode &&
             args[1]->type == SyntaxTreeNode::TokenNode &&
             segment->find_variable(((TokenNode *) args[0])->getName()) != -1) {
             if (((TokenNode *) args[0])->token.type == Token::Symbol &&
                 ((TokenNode *) args[1])->token.type == Token::Number) {
-                instructions.push_back(
-                        new Bytecode::LessThanRI(
-                                segment->find_variable(((TokenNode *) args[0])->getName()),
-                                ((TokenNode *) args[1])->token.asNumber()));
+                instructions.push_back(new (Instruction){
+                        Instruction::LessThanRI,
+                        {.ri_params = {
+                                 segment->find_variable(((TokenNode *) args[0])->getName()),
+                                 StackObject(((TokenNode *) args[1])->token)}},
+                });
                 return;
             }
         }
 
         args[0]->compile(segment, program, instructions);
         args[1]->compile(segment, program, instructions);
-        instructions.push_back(new Bytecode::LessThan());
+        instructions.push_back(new (Instruction){Instruction::LessThan});
         for (int i = 2; i < args.size(); i++) {
             args[i]->compile(segment, program, instructions);
-            instructions.push_back(new Bytecode::LessThan());
+            instructions.push_back(new (Instruction){Instruction::LessThan});
         }
     }
-}
+}// namespace Bytecode::BuiltinFunctions