perf: inline global constants

mrunix00 · Apr 20, 2024 · c8aef44 · c8aef44
1 parent 32d9c32
commit c8aef44
Show file tree

Hide file tree

Showing 5 changed files with 42 additions and 3 deletions.
diff --git a/src/bytecode/builtin_functions/DefineFunction.cpp b/src/bytecode/builtin_functions/DefineFunction.cpp
@@ -11,6 +11,13 @@ namespace Bytecode::BuiltinFunctions {
         if (args[0]->type == SyntaxTreeNode::TokenNode) {
             const auto reg = program.declare_global(
                     ((TokenNode *) args[0])->getName());
+            if (args[1]->type == SyntaxTreeNode::TokenNode &&
+                ((TokenNode *) args[1])->token.type != Token::Symbol) {
+                program.declare_constant(
+                        ((TokenNode *) args[0])->getName(),
+                        StackObject(((TokenNode *) args[1])->token));
+                return;
+            }
             args[1]->compile(result, program, instructions);
             instructions.push_back(new StoreGlobal(reg));
         } else if (args[0]->type == SyntaxTreeNode::Expression) {

diff --git a/src/bytecode/compiler/Program.cpp b/src/bytecode/compiler/Program.cpp
@@ -21,4 +21,11 @@ namespace Bytecode {
             return globals_table[name];
         return -1;
     }
+    void Program::declare_constant(const std::string &name, StackObject object) {
+        constants_table[name] = object;
+    }
+    StackObject *Program::find_constant(const std::string &name) {
+        if (constants_table.find(name) == constants_table.end()) return nullptr;
+        return &constants_table[name];
+    }
 }// namespace Bytecode
diff --git a/src/bytecode/compiler/Program.h b/src/bytecode/compiler/Program.h
@@ -9,6 +9,7 @@ namespace Bytecode {
     class Program {
         std::unordered_map<std::string, size_t> globals_table;
         std::unordered_map<std::string, size_t> segments_table;
+        std::unordered_map<std::string, StackObject> constants_table;
 
     public:
         std::vector<Segment *> segments;
@@ -23,7 +24,9 @@ namespace Bytecode {
         size_t declare_global(const std::string &);
         size_t declare_function(const std::string &, Segment *);
         size_t declare_lambda(Segment *);
+        void declare_constant(const std::string &, StackObject);
         size_t find_global(const std::string &);
         size_t find_function(const std::string &);
+        StackObject *find_constant(const std::string &);
     };
 }// namespace Bytecode
diff --git a/src/bytecode/objects/StackObject.h b/src/bytecode/objects/StackObject.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "lexer/Token.h"
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
@@ -42,6 +43,25 @@ namespace Bytecode {
             // TODO: This is a dumb workaround, fix it later
             data.string = strdup(str.c_str());
         };
+        explicit StackObject(const Token &token) {
+            switch (token.type) {
+                case Token::Number:
+                    type = Number;
+                    data = {token.asNumber()};
+                    break;
+                case Token::Boolean:
+                    type = Boolean;
+                    data = {.boolean = token.token == "#true"};
+                    break;
+                case Token::String:
+                    type = String;
+                    data = {.string = strdup(token.token.c_str())};
+                    break;
+                default:
+                    type = None;
+                    break;
+            }
+        }
 
         [[nodiscard]] std::string asString() const {
             return data.string;

diff --git a/src/parser/SyntaxTreeNode.cpp b/src/parser/SyntaxTreeNode.cpp
@@ -38,7 +38,10 @@ void TokenNode::compile(
                     new Bytecode::LoadLiteral(token.asString()));
             break;
         case Token::Symbol:
-            if (segment->find_variable(token.token) != -1) {
+            if (program.find_constant(token.token) != nullptr) {
+                instructions.push_back(new Bytecode::LoadLiteral(
+                        program.find_constant(token.token)));
+            } else if (segment->find_variable(token.token) != -1) {
                 instructions.push_back(new Bytecode::LoadLocal(
                         segment->find_variable(token.asString())));
             } else if (program.find_global(token.token) != -1) {
@@ -78,8 +81,7 @@ void Expression::compile(
             {"read", new Bytecode::BuiltinFunctions::Read},
             {"not", new Bytecode::BuiltinFunctions::Not},
             {"or", new Bytecode::BuiltinFunctions::Or},
-            {"and", new Bytecode::BuiltinFunctions::And}
-    };
+            {"and", new Bytecode::BuiltinFunctions::And}};
 
     if (program.find_global(function.token) != -1) {
         for (const auto &argument: args)