Compile scripts to bytecode

Author: adazem009

src/engine/engine.cpp

@@ -5,6 +5,7 @@
 #include "../scratchconfiguration.h"
 #include "../scratch/runningscript.h"
 #include "iblocksection.h"
+#include "compiler.h"
 #include <cassert>
 #include <iostream>
 #include <thread>
@@ -26,12 +27,12 @@ void Engine::clear()
 }
 
 /*!
- * Turns ID references into pointers to make projects run faster.\n
- * It also resolves all block opcodes and saves them as function pointers.
+ * Compiles all scripts to bytecode.
+ * \see Compiler
  */
 void Engine::compile()
 {
-    // TODO: Compiling takes lots of time, so compile blocks when they're added by the project loader.
+    // Resolve entities by ID
     for (auto target : m_targets) {
         auto blocks = target->blocks();
         for (auto block : blocks) {
@@ -66,6 +67,33 @@ void Engine::compile()
             block->updateFieldMap();
         }
     }
+
+    // Compile scripts to bytecode
+    for (auto target : m_targets) {
+        std::vector<Variable *> variables;
+        std::vector<List *> lists;
+        std::vector<InputValue *> constInputValues;
+        auto blocks = target->blocks();
+        for (auto block : blocks) {
+            if (block->topLevel()) {
+                auto section = blockSection(block->opcode());
+                Compiler compiler(this, block);
+                compiler.setConstInputValues(constInputValues);
+                compiler.setVariables(variables);
+                compiler.setLists(lists);
+                compiler.compile();
+                variables = compiler.variables();
+                lists = compiler.lists();
+                auto vm = std::make_shared<VirtualMachine>();
+                vm->setFunctions(m_functions);
+                vm->setConstValues(compiler.constValues());
+                vm->setVariables(compiler.variablePtrs());
+                vm->setLists(lists);
+                vm->setBytecode(compiler.bytecode());
+                m_scripts[block] = vm;
+            }
+        }
+    }
 }
 
 /*!

src/engine/engine.h

@@ -70,6 +70,7 @@ class LIBSCRATCHCPP_EXPORT Engine
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
         std::vector<std::string> m_extensions;
         std::vector<std::shared_ptr<RunningScript>> m_runningScripts;
+        std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<VirtualMachine>> m_scripts;
         bool m_breakFrame = false;
         bool m_stayOnCurrentBlock = false;
         bool m_atomic = true;

src/engine/virtualmachine.cpp

@@ -47,6 +47,20 @@ void VirtualMachine::setConstValues(const std::vector<Value> &values)
     m_constValues = m_constValuesVector.data();
 }
 
+/*! Sets the list of variables. */
+void VirtualMachine::setVariables(const std::vector<Value *> &variables)
+{
+    m_variablesVector = variables;
+    m_variables = m_variablesVector.data();
+}
+
+/*! Sets the list of lists. */
+void VirtualMachine::setLists(const std::vector<List *> &lists)
+{
+    m_listsVector = lists;
+    m_lists = m_listsVector.data();
+}
+
 /*! Sets the bytecode of the script. */
 void VirtualMachine::setBytecode(const std::vector<unsigned int> &code)
 {

src/engine/virtualmachine.h

@@ -64,6 +64,8 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
 
         void setFunctions(const std::vector<BlockFunc> &functions);
         void setConstValues(const std::vector<Value> &values);
+        void setVariables(const std::vector<Value *> &variables);
+        void setLists(const std::vector<List *> &lists);
         void setBytecode(const std::vector<unsigned int> &code);
 
         const Value *getInput(unsigned int index, unsigned int argCount) const { return m_regs[m_regCount - argCount + index]; };
@@ -95,8 +97,12 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
 
         Value **m_regs = nullptr;
         size_t m_regCount = 0;
+
         Value **m_variables = nullptr;
+        std::vector<Value *> m_variablesVector;
+
         List **m_lists = nullptr;
+        std::vector<List *> m_listsVector;
 };
 
 } // namespace libscratchcpp