Compile monitor blocks

Author: adazem009

src/engine/internal/engine.cpp

@@ -134,6 +134,10 @@ void Engine::resolveIds()
     for (auto monitor : m_monitors) {
         auto block = monitor->block();
         auto container = blockSectionContainer(block->opcode());
+
+        if (container)
+            block->setCompileFunction(container->resolveBlockCompileFunc(block->opcode()));
+
         const auto &fields = block->fields();
         Target *target;
 
@@ -211,6 +215,37 @@ void Engine::compile()
             }
         }
     }
+
+    // Compile monitor blocks to bytecode
+    std::cout << "Compiling stage monitors..." << std::endl;
+
+    for (auto monitor : m_monitors) {
+        Target *target = monitor->sprite() ? dynamic_cast<Target *>(monitor->sprite()) : stage();
+        Compiler compiler(this, target);
+        auto block = monitor->block();
+        auto section = blockSection(block->opcode());
+
+        if (section) {
+            auto script = std::make_shared<Script>(target, block, this);
+            monitor->setScript(script);
+            compiler.init();
+            compiler.setBlock(block);
+
+            if (block->compileFunction())
+                block->compile(&compiler);
+            else
+                std::cout << "warning: monitor block doesn't have a compile function: " << block->opcode() << std::endl;
+
+            compiler.end();
+
+            script->setBytecode(compiler.bytecode());
+            script->setFunctions(m_functions);
+            script->setConstValues(compiler.constValues());
+            script->setVariables(compiler.variables());
+            script->setLists(compiler.lists());
+        } else
+            std::cout << "warning: unsupported monitor block: " << block->opcode() << std::endl;
+    }
 }
 
 void Engine::start()

test/engine/engine_test.cpp

@@ -8,6 +8,9 @@
 #include <scratchcpp/keyevent.h>
 #include <scratchcpp/monitor.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/compiler.h>
+#include <scratchcpp/script.h>
+#include <scratchcpp/virtualmachine.h>
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
@@ -99,6 +102,37 @@ TEST(EngineTest, Clear)
     ASSERT_TRUE(engine.monitors().empty());
 }
 
+TEST(EngineTest, CompileMonitors)
+{
+    Engine engine;
+    auto stage = std::make_shared<Stage>();
+    auto sprite = std::make_shared<Sprite>();
+    engine.setTargets({ stage, sprite });
+
+    auto m1 = std::make_shared<Monitor>("a", "monitor_test1");
+    auto m2 = std::make_shared<Monitor>("b", "monitor_test2");
+    m2->setSprite(sprite.get());
+    engine.setMonitors({ m1, m2 });
+
+    auto section = std::make_shared<TestSection>();
+    engine.registerSection(section);
+    engine.addCompileFunction(section.get(), m1->opcode(), [](Compiler *compiler) { compiler->addConstValue(5.4); });
+    engine.addCompileFunction(section.get(), m2->opcode(), [](Compiler *compiler) { compiler->addConstValue("test"); });
+
+    engine.compile();
+    auto script1 = m1->script();
+    auto script2 = m2->script();
+    ASSERT_TRUE(script1 && script2);
+
+    ASSERT_EQ(script1->bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_HALT }));
+    ASSERT_EQ(script1->target(), stage.get());
+    ASSERT_EQ(script1->topBlock(), m1->block());
+
+    ASSERT_EQ(script2->bytecodeVector(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_HALT }));
+    ASSERT_EQ(script2->target(), sprite.get());
+    ASSERT_EQ(script2->topBlock(), m2->block());
+}
+
 TEST(EngineTest, IsRunning)
 {
     Engine engine;