Use VirtualMachine to run scripts

Author: adazem009

src/engine/compiler.cpp

@@ -3,6 +3,7 @@
 #include "compiler.h"
 #include "engine.h"
 #include <cassert>
+#include <iostream>
 
 using namespace libscratchcpp;
 using namespace vm;

src/engine/engine.cpp

@@ -85,13 +85,13 @@ void Engine::compile()
                     variables = compiler.variables();
                     lists = compiler.lists();
                     constInputValues = compiler.constInputValues();
-                    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;
+                    m_scripts[block] = VirtualMachine(target.get(), this);
+                    VirtualMachine &vm = m_scripts[block];
+                    vm.setFunctions(m_functions);
+                    vm.setConstValues(compiler.constValues());
+                    vm.setVariables(compiler.variablePtrs());
+                    vm.setLists(lists);
+                    vm.setBytecode(compiler.bytecode());
                 } else
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
             }
@@ -106,53 +106,24 @@ void Engine::compile()
  * \note Nothing will happen until start() is called.
  * \param[in] timeLimit The time limit for the frame (for atomic scripts). Set to 0 for no limit.
  */
-void Engine::frame(std::chrono::milliseconds timeLimit)
+void Engine::frame()
 {
-    auto frameStartTime = std::chrono::steady_clock::now();
-    std::vector<std::shared_ptr<RunningScript>> scriptsToRemove;
-    auto scripts = m_runningScripts;
-    for (auto script : scripts) {
-        std::shared_ptr<Block> block;
+    for (VirtualMachine &script : m_runningScripts) {
         m_breakFrame = false;
-        m_atomic = true;
 
         do {
-            block = script->currentBlock();
-            if (!script->currentBlock()) {
-                std::cout << "warning: encountered a null block in one of the scripts" << std::endl;
-                scriptsToRemove.push_back(script);
-                continue;
-            }
-
-            // Call the implementation of the block (if it has an implementation)
-            block->run(script.get());
-
-            // Move to next block
-            if (m_stayOnCurrentBlock) {
-                m_stayOnCurrentBlock = false;
-                block = script->currentBlock();
-            } else {
-                script->moveToNextBlock();
-                block = script->currentBlock();
-                if (!block) {
-                    // There isn't any block to move to
-                    // This means the script has finished
-                    scriptsToRemove.push_back(script);
-                }
-            }
-
-            if (timeLimit.count() > 0) {
-                auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - frameStartTime);
-                if (duration > timeLimit)
-                    break;
-            }
-        } while (block != nullptr && !m_breakFrame);
+            script.run(nullptr);
+        } while (script.atEnd() && !m_breakFrame);
     }
 
-    for (auto script : scriptsToRemove) {
-        m_runningScripts.erase(std::remove(m_runningScripts.begin(), m_runningScripts.end(), script), m_runningScripts.end());
+    for (auto script : m_scriptsToRemove) {
+        auto it = std::find(m_runningScriptPtrs.begin(), m_runningScriptPtrs.end(), script);
+        auto index = it - m_runningScriptPtrs.begin();
+        m_runningScripts.erase(m_runningScripts.begin() + index);
+        m_runningScriptPtrs.erase(m_runningScriptPtrs.begin() + index);
         scriptCount--;
     }
+    m_scriptsToRemove.clear();
 }
 
 /*!
@@ -191,40 +162,30 @@ void Engine::startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<T
     }
 
     if (topLevelBlock->next()) {
-        auto script = std::make_shared<RunningScript>(topLevelBlock, target, this);
-        m_runningScripts.push_back(script);
-        script->moveToNextBlock();
+        m_runningScripts.push_back(m_scripts[topLevelBlock]);
+        m_runningScriptPtrs.push_back(&m_runningScripts.back());
         scriptCount++;
     }
 }
 
 /*! Stops the given script. */
-void Engine::stopScript(RunningScript *script)
+void Engine::stopScript(VirtualMachine *vm)
 {
-    assert(script);
-    int i = 0;
-    for (auto s : m_runningScripts) {
-        if (s.get() == script) {
-            m_runningScripts.erase(m_runningScripts.begin() + i);
-            break;
-        }
-        i++;
-    }
-    scriptCount--;
+    assert(vm);
+    m_scriptsToRemove.push_back(vm);
 }
 
 /*!
  * Stops all scripts in the given target.
  * \param[in] target The Target to stop.
  * \param[in] exceptScript Sets this parameter to stop all scripts except the given script.
  */
-void Engine::stopTarget(Target *target, RunningScript *exceptScript)
+void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
 {
-    std::vector<RunningScript *> scripts;
-    for (auto script : m_runningScripts) {
-        RunningScript *s = script.get();
-        if ((script->target().get() == target) && (s != exceptScript))
-            scripts.push_back(s);
+    std::vector<VirtualMachine *> scripts;
+    for (VirtualMachine &script : m_runningScripts) {
+        if ((script.target() == target) && (&script != exceptScript))
+            scripts.push_back(&script);
     }
 
     for (auto script : scripts)
@@ -245,7 +206,7 @@ void Engine::run()
     while (true) {
         auto lastFrameTime = std::chrono::steady_clock::now();
         // Execute the frame
-        frame(frameDuration);
+        frame();
         if (scriptCount <= 0)
             break;
 

src/engine/engine.h

@@ -7,6 +7,7 @@
 #include "../scratch/runningscript.h"
 #include "../scratch/target.h"
 #include "global.h"
+#include "virtualmachine.h"
 #include <map>
 #include <memory>
 #include <chrono>
@@ -31,12 +32,12 @@ class LIBSCRATCHCPP_EXPORT Engine
         void clear();
         void compile();
 
-        void frame(std::chrono::milliseconds timeLimit = std::chrono::milliseconds(0));
+        void frame();
         void start();
         void stop();
         void startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<Target> target);
-        void stopScript(RunningScript *script);
-        void stopTarget(Target *target, RunningScript *exceptScript = nullptr);
+        void stopScript(VirtualMachine *vm);
+        void stopTarget(Target *target, VirtualMachine *exceptScript);
         void run();
 
         void breakFrame();
@@ -71,8 +72,10 @@ class LIBSCRATCHCPP_EXPORT Engine
         std::vector<std::shared_ptr<Target>> m_targets;
         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;
+        std::vector<VirtualMachine> m_runningScripts;
+        std::vector<VirtualMachine *> m_runningScriptPtrs;
+        std::vector<VirtualMachine *> m_scriptsToRemove;
+        std::unordered_map<std::shared_ptr<Block>, VirtualMachine> m_scripts;
         std::vector<BlockFunc> m_functions;
 
         bool m_breakFrame = false;

src/engine/virtualmachine.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "virtualmachine.h"
+#include <iostream>
 
 #define MAX_REG_COUNT 1024
 
@@ -21,6 +22,13 @@ using namespace vm;
 
 /*! Constructs VirtualMachine. */
 VirtualMachine::VirtualMachine()
+{
+}
+
+/*! \copydoc VirtualMachine() */
+VirtualMachine::VirtualMachine(Target *target, Engine *engine) :
+    m_target(target),
+    m_engine(engine)
 {
     m_regs = new Value *[MAX_REG_COUNT];
     for (int i = 0; i < MAX_REG_COUNT; i++)

src/engine/virtualmachine.h

@@ -60,7 +60,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
 {
     public:
         VirtualMachine();
-        VirtualMachine(const VirtualMachine &) = delete;
+        VirtualMachine(Target *target, Engine *engine);
         ~VirtualMachine();
 
         void setFunctions(const std::vector<BlockFunc> &functions);
@@ -69,6 +69,9 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         void setLists(const std::vector<List *> &lists);
         void setBytecode(const std::vector<unsigned int> &code);
 
+        Target *target() const { return m_target; };
+        Engine *engine() const { return m_engine; };
+
         const Value *getInput(unsigned int index, unsigned int argCount) const { return m_regs[m_regCount - argCount + index]; };
         unsigned int getFieldIndex(unsigned int index) const { return m_globalPos[index]; };