Add Script class for compiled scripts

adazem009 · adazem009 · commit c25935a87151 · 2023-05-20T18:20:38.000+02:00
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
@@ -3,11 +3,13 @@ target_sources(scratchcpp
     engine.cpp
     virtualmachine.cpp
     compiler.cpp
+    script.cpp
   PUBLIC
     engine.h
     global.h
     virtualmachine.h
     compiler.h
+    script.h
     iblocksection.h
     iextension.h
 )
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
@@ -5,6 +5,7 @@
 #include "../scratchconfiguration.h"
 #include "iblocksection.h"
 #include "compiler.h"
+#include "script.h"
 #include <cassert>
 #include <iostream>
 #include <thread>
@@ -76,16 +77,16 @@ void Engine::compile()
             if (block->topLevel()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
-                    auto vm = std::make_shared<VirtualMachine>(target.get(), this);
-                    m_scripts[block] = vm;
+                    auto script = std::make_shared<Script>(target.get(), this);
+                    m_scripts[block] = script;
 
                     compiler.compile(block);
 
-                    vm->setFunctions(m_functions);
-                    vm->setBytecode(compiler.bytecode());
+                    script->setFunctions(m_functions);
+                    script->setBytecode(compiler.bytecode());
                     if (block->opcode() == "procedures_definition") {
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
-                        procedureBytecodeMap[b->mutationPrototype()->procCode()] = vm->bytecode();
+                        procedureBytecodeMap[b->mutationPrototype()->procCode()] = script->bytecode();
                     }
                 } else
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
@@ -122,25 +123,26 @@ void Engine::frame()
         m_breakFrame = false;
 
         do {
-            std::string opcode;
-            for (auto const &[key, value] : m_scripts) {
-                if (value.get() == script)
-                    opcode = key->opcode();
-            }
             auto ret = script->run(m_scriptPositions[i]);
             if (script->savePos())
                 m_scriptPositions[i] = ret;
             if (script->atEnd()) {
                 for (auto &[key, value] : m_broadcastMap)
-                    value.erase(std::remove(value.begin(), value.end(), script), value.end());
-                m_scriptsToRemove.push_back(script);
+                    value.erase(std::remove(value.begin(), value.end(), script->script()), value.end());
+                m_scriptsToRemove.push_back(script.get());
             }
         } while (!script->atEnd() && !m_breakFrame);
     }
 
     for (auto script : m_scriptsToRemove) {
-        auto it = std::find(m_runningScripts.begin(), m_runningScripts.end(), script);
-        auto index = it - m_runningScripts.begin();
+        size_t index = -1;
+        for (size_t i = 0; i < m_runningScripts.size(); i++) {
+            if (m_runningScripts[i].get() == script) {
+                index = i;
+                break;
+            }
+        }
+        assert(index != -1);
         m_runningScripts.erase(m_runningScripts.begin() + index);
         m_scriptPositions.erase(m_scriptPositions.begin() + index);
     }
@@ -182,27 +184,32 @@ void Engine::startScript(std::shared_ptr<Block> topLevelBlock, std::shared_ptr<T
     }
 
     if (topLevelBlock->next()) {
-        auto vm = m_scripts[topLevelBlock].get();
-        m_runningScripts.push_back(vm);
-        m_scriptPositions.push_back(vm->bytecode());
+        auto script = m_scripts[topLevelBlock];
+        m_runningScripts.push_back(script->start());
+        m_scriptPositions.push_back(script->bytecode());
     }
 }
 
 /*! Starts the script of the broadcast with the given index. */
 void libscratchcpp::Engine::broadcast(unsigned int index, VirtualMachine *sourceScript)
 {
-    const std::vector<VirtualMachine *> &scripts = m_broadcastMap[index];
-    for (auto vm : scripts) {
-        auto it = std::find(m_runningScripts.begin(), m_runningScripts.end(), vm);
-        if (it != m_runningScripts.end()) {
+    const std::vector<Script *> &scripts = m_broadcastMap[index];
+    for (auto script : scripts) {
+        size_t index = -1;
+        for (size_t i = 0; i < m_runningScripts.size(); i++) {
+            if (m_runningScripts[i]->script() == script) {
+                index = i;
+                break;
+            }
+        }
+        if (index != -1) {
             // Reset the script if it's already running
-            auto i = it - m_runningScripts.begin();
-            m_scriptPositions[i] = m_runningScripts[i]->bytecode();
-            if (vm == sourceScript)
-                vm->stop(false, true);
+            m_scriptPositions[index] = m_runningScripts[index]->bytecode();
+            if (script == sourceScript->script())
+                sourceScript->stop(false, true);
         } else {
-            m_runningScripts.push_back(vm);
-            m_scriptPositions.push_back(vm->bytecode());
+            m_runningScripts.push_back(script->start());
+            m_scriptPositions.push_back(script->bytecode());
         }
     }
 }
@@ -223,8 +230,8 @@ void Engine::stopTarget(Target *target, VirtualMachine *exceptScript)
 {
     std::vector<VirtualMachine *> scripts;
     for (auto script : m_runningScripts) {
-        if ((script->target() == target) && (script != exceptScript))
-            scripts.push_back(script);
+        if ((script->target() == target) && (script.get() != exceptScript))
+            scripts.push_back(script.get());
     }
 
     for (auto script : scripts)
@@ -352,7 +359,7 @@ void libscratchcpp::Engine::addBroadcastScript(std::shared_ptr<Block> whenReceiv
 {
     auto id = findBroadcast(broadcast->name());
     if (m_broadcastMap.count(id) == 1) {
-        std::vector<VirtualMachine *> &scripts = m_broadcastMap[id];
+        std::vector<Script *> &scripts = m_broadcastMap[id];
         scripts.push_back(m_scripts[whenReceivedBlock].get());
     } else
         m_broadcastMap[id] = { m_scripts[whenReceivedBlock].get() };
diff --git a/src/engine/engine.h b/src/engine/engine.h
@@ -15,6 +15,7 @@ namespace libscratchcpp
 {
 
 class LIBSCRATCHCPP_EXPORT IBlockSection;
+class LIBSCRATCHCPP_EXPORT Script;
 
 /*!
  * \brief The Engine class provides an API for running Scratch projects.
@@ -73,12 +74,12 @@ class LIBSCRATCHCPP_EXPORT Engine
         std::vector<std::shared_ptr<IBlockSection>> m_sections;
         std::vector<std::shared_ptr<Target>> m_targets;
         std::vector<std::shared_ptr<Broadcast>> m_broadcasts;
-        std::unordered_map<unsigned int, std::vector<VirtualMachine *>> m_broadcastMap;
+        std::unordered_map<unsigned int, std::vector<Script *>> m_broadcastMap;
         std::vector<std::string> m_extensions;
-        std::vector<VirtualMachine *> m_runningScripts;
+        std::vector<std::shared_ptr<VirtualMachine>> m_runningScripts;
         std::vector<unsigned int *> m_scriptPositions;
         std::vector<VirtualMachine *> m_scriptsToRemove;
-        std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<VirtualMachine>> m_scripts;
+        std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> m_scripts;
         std::vector<BlockFunc> m_functions;
 
         bool m_breakFrame = false;
diff --git a/src/engine/script.cpp b/src/engine/script.cpp
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "script.h"
+
+using namespace libscratchcpp;
+
+/*! Constructs Script. */
+Script::Script(Target *target, Engine *engine) :
+    m_target(target),
+    m_engine(engine)
+{
+}
+
+/*! Returns the bytecode array. */
+unsigned int *Script::bytecode()
+{
+    return m_bytecode;
+}
+
+/*! Sets the bytecode of the script. */
+void Script::setBytecode(const std::vector<unsigned int> &code)
+{
+    m_bytecodeVector = code;
+    m_bytecode = m_bytecodeVector.data();
+}
+
+/*! Starts the script (creates a virtual machine). */
+std::shared_ptr<VirtualMachine> Script::start()
+{
+    auto vm = std::make_shared<VirtualMachine>(m_target, m_engine, this);
+    vm->setProcedures(m_procedures);
+    vm->setFunctions(m_functions);
+    vm->setConstValues(m_constValues);
+    vm->setVariables(m_variables);
+    vm->setLists(m_lists);
+    return vm;
+}
+
+/*! Sets the list of procedures (custom blocks). */
+void Script::setProcedures(const std::vector<unsigned int *> &procedures)
+{
+    m_proceduresVector = procedures;
+    m_procedures = m_proceduresVector.data();
+}
+
+/*! Sets the list of functions. */
+void Script::setFunctions(const std::vector<BlockFunc> &functions)
+{
+    m_functionsVector = functions;
+    m_functions = m_functionsVector.data();
+}
+
+/*! Sets the list of constant values. */
+void Script::setConstValues(const std::vector<Value> &values)
+{
+    m_constValuesVector = values;
+    m_constValues = m_constValuesVector.data();
+}
+
+/*! Sets the list of variables. */
+void Script::setVariables(const std::vector<Value *> &variables)
+{
+    m_variablesVector = variables;
+    m_variables = m_variablesVector.data();
+}
+
+/*! Sets the list of lists. */
+void Script::setLists(const std::vector<List *> &lists)
+{
+    m_listsVector = lists;
+    m_lists = m_listsVector.data();
+}
diff --git a/src/engine/script.h b/src/engine/script.h
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "virtualmachine.h"
+
+namespace libscratchcpp
+{
+
+/*! \brief The Script class represents a compiled Scratch script. */
+class LIBSCRATCHCPP_EXPORT Script
+{
+    public:
+        Script(Target *target, Engine *engine);
+        Script(const Script &) = delete;
+
+        unsigned int *bytecode();
+        void setBytecode(const std::vector<unsigned int> &code);
+
+        void setProcedures(const std::vector<unsigned int *> &procedures);
+        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);
+
+        std::shared_ptr<VirtualMachine> start();
+
+    private:
+        unsigned int *m_bytecode;
+        std::vector<unsigned int> m_bytecodeVector;
+
+        Target *m_target;
+        Engine *m_engine;
+
+        unsigned int **m_procedures = nullptr;
+        std::vector<unsigned int *> m_proceduresVector;
+
+        BlockFunc *m_functions;
+        std::vector<BlockFunc> m_functionsVector;
+
+        const Value *m_constValues = nullptr;
+        std::vector<Value> m_constValuesVector;
+
+        Value **m_variables = nullptr;
+        std::vector<Value *> m_variablesVector;
+
+        List **m_lists = nullptr;
+        std::vector<List *> m_listsVector;
+};
+
+} // namespace libscratchcpp
diff --git a/src/engine/virtualmachine.cpp b/src/engine/virtualmachine.cpp
@@ -94,9 +94,10 @@ VirtualMachine::VirtualMachine()
 }
 
 /*! \copydoc VirtualMachine() */
-VirtualMachine::VirtualMachine(Target *target, Engine *engine) :
+VirtualMachine::VirtualMachine(Target *target, Engine *engine, Script *script) :
     m_target(target),
-    m_engine(engine)
+    m_engine(engine),
+    m_script(script)
 {
     m_regs = new Value *[MAX_REG_COUNT];
     for (int i = 0; i < MAX_REG_COUNT; i++)
@@ -113,46 +114,40 @@ VirtualMachine::~VirtualMachine()
     delete m_regs;
 }
 
-/*! Sets the list of procedures (custom blocks). */
-void VirtualMachine::setProcedures(const std::vector<unsigned int *> &procedures)
+/*! Sets the array of procedures (custom blocks). */
+void VirtualMachine::setProcedures(unsigned int **procedures)
 {
-    m_proceduresVector = procedures;
-    m_procedures = m_proceduresVector.data();
+    m_procedures = procedures;
 }
 
 /*! Sets the list of functions. */
-void VirtualMachine::setFunctions(const std::vector<BlockFunc> &functions)
+void VirtualMachine::setFunctions(BlockFunc *functions)
 {
-    m_functionsVector = functions;
-    m_functions = m_functionsVector.data();
+    m_functions = functions;
 }
 
 /*! Sets the list of constant values. */
-void VirtualMachine::setConstValues(const std::vector<Value> &values)
+void VirtualMachine::setConstValues(const Value *values)
 {
-    m_constValuesVector = values;
-    m_constValues = m_constValuesVector.data();
+    m_constValues = values;
 }
 
 /*! Sets the list of variables. */
-void VirtualMachine::setVariables(const std::vector<Value *> &variables)
+void VirtualMachine::setVariables(Value **variables)
 {
-    m_variablesVector = variables;
-    m_variables = m_variablesVector.data();
+    m_variables = variables;
 }
 
 /*! Sets the list of lists. */
-void VirtualMachine::setLists(const std::vector<List *> &lists)
+void VirtualMachine::setLists(List **lists)
 {
-    m_listsVector = lists;
-    m_lists = m_listsVector.data();
+    m_lists = lists;
 }
 
 /*! Sets the bytecode of the script. */
-void VirtualMachine::setBytecode(const std::vector<unsigned int> &code)
+void VirtualMachine::setBytecode(unsigned int *code)
 {
-    m_bytecodeVector = code;
-    m_bytecode = m_bytecodeVector.data();
+    m_bytecode = code;
 }
 
 /*! Runs the script. */
diff --git a/src/engine/virtualmachine.h b/src/engine/virtualmachine.h

Original file line number	Diff line number	Diff line change
`@@ -94,9 +94,10 @@ VirtualMachine::VirtualMachine()`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/! \copydoc VirtualMachine() /`
`97`		`-VirtualMachine::VirtualMachine(Target target, Engine engine) :`
	`97`	`+VirtualMachine::VirtualMachine(Target target, Engine engine, Script *script) :`
`98`	`98`	`m_target(target),`
`99`		`- m_engine(engine)`
	`99`	`+ m_engine(engine),`
	`100`	`+ m_script(script)`
`100`	`101`	`{`
`101`	`102`	`m_regs = new Value *[MAX_REG_COUNT];`
`102`	`103`	`for (int i = 0; i < MAX_REG_COUNT; i++)`
`@@ -113,46 +114,40 @@ VirtualMachine::~VirtualMachine()`
`113`	`114`	`delete m_regs;`
`114`	`115`	`}`
`115`	`116`
`116`		`-/! Sets the list of procedures (custom blocks). /`
`117`		`-void VirtualMachine::setProcedures(const std::vector<unsigned int *> &procedures)`
	`117`	`+/! Sets the array of procedures (custom blocks). /`
	`118`	`+void VirtualMachine::setProcedures(unsigned int **procedures)`
`118`	`119`	`{`
`119`		`- m_proceduresVector = procedures;`
`120`		`- m_procedures = m_proceduresVector.data();`
	`120`	`+ m_procedures = procedures;`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`/! Sets the list of functions. /`
`124`		`-void VirtualMachine::setFunctions(const std::vector<BlockFunc> &functions)`
	`124`	`+void VirtualMachine::setFunctions(BlockFunc *functions)`
`125`	`125`	`{`
`126`		`- m_functionsVector = functions;`
`127`		`- m_functions = m_functionsVector.data();`
	`126`	`+ m_functions = functions;`
`128`	`127`	`}`
`129`	`128`
`130`	`129`	`/! Sets the list of constant values. /`
`131`		`-void VirtualMachine::setConstValues(const std::vector<Value> &values)`
	`130`	`+void VirtualMachine::setConstValues(const Value *values)`
`132`	`131`	`{`
`133`		`- m_constValuesVector = values;`
`134`		`- m_constValues = m_constValuesVector.data();`
	`132`	`+ m_constValues = values;`
`135`	`133`	`}`
`136`	`134`
`137`	`135`	`/! Sets the list of variables. /`
`138`		`-void VirtualMachine::setVariables(const std::vector<Value *> &variables)`
	`136`	`+void VirtualMachine::setVariables(Value **variables)`
`139`	`137`	`{`
`140`		`- m_variablesVector = variables;`
`141`		`- m_variables = m_variablesVector.data();`
	`138`	`+ m_variables = variables;`
`142`	`139`	`}`
`143`	`140`
`144`	`141`	`/! Sets the list of lists. /`
`145`		`-void VirtualMachine::setLists(const std::vector<List *> &lists)`
	`142`	`+void VirtualMachine::setLists(List **lists)`
`146`	`143`	`{`
`147`		`- m_listsVector = lists;`
`148`		`- m_lists = m_listsVector.data();`
	`144`	`+ m_lists = lists;`
`149`	`145`	`}`
`150`	`146`
`151`	`147`	`/! Sets the bytecode of the script. /`
`152`		`-void VirtualMachine::setBytecode(const std::vector<unsigned int> &code)`
	`148`	`+void VirtualMachine::setBytecode(unsigned int *code)`
`153`	`149`	`{`
`154`		`- m_bytecodeVector = code;`
`155`		`- m_bytecode = m_bytecodeVector.data();`
	`150`	`+ m_bytecode = code;`
`156`	`151`	`}`
`157`	`152`
`158`	`153`	`/! Runs the script. /`