Add edge-activated hat support to Compiler

Author: adazem009

include/scratchcpp/compiler.h

@@ -42,6 +42,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void end();
 
         const std::vector<unsigned int> &bytecode() const;
+        const std::vector<unsigned int> &hatPredicateBytecode() const;
 
         IEngine *engine() const;
         Target *target() const;

src/engine/compiler.cpp

@@ -41,6 +41,26 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
     init();
 
     impl->block = topLevelBlock;
+
+    // If this is a top-level block, it might be an edge-activated hat block with a predicate compile function
+    if (impl->block->topLevel()) {
+        HatPredicateCompileFunc f = impl->block->hatPredicateCompileFunction();
+
+        if (f) {
+            f(this);
+
+            // Workaround for register leak warning spam: pause the script after getting the reported value
+            addFunctionCall([](VirtualMachine *vm) -> unsigned int {
+                vm->stop(false, false, false);
+                return 0;
+            });
+
+            end(); // finished with the predicate
+            impl->hatPredicateBytecode = impl->bytecode;
+            init(); // now start the real compilation
+        }
+    }
+
     while (impl->block) {
         size_t substacks = impl->substackTree.size();
 
@@ -80,6 +100,12 @@ const std::vector<unsigned int> &Compiler::bytecode() const
     return impl->bytecode;
 }
 
+/*! Returns the generated hat predicate bytecode (if this is an edge-activated hat). */
+const std::vector<unsigned int> &Compiler::hatPredicateBytecode() const
+{
+    return impl->hatPredicateBytecode;
+}
+
 /*! Returns the Engine. */
 IEngine *Compiler::engine() const
 {

src/engine/compiler_p.h

@@ -28,6 +28,7 @@ struct CompilerPrivate
         bool initialized = false;
 
         std::vector<unsigned int> bytecode;
+        std::vector<unsigned int> hatPredicateBytecode;
         std::vector<InputValue *> constValues;
         std::vector<std::unique_ptr<InputValue>> customConstValues;
         std::unordered_map<InputValue *, std::pair<bool, std::string>> constValueMenuInfo; // input value, <whether the input points to a dropdown menu, selected menu item>

test/compiler/compiler_test.cpp

@@ -816,3 +816,24 @@ TEST_F(CompilerTest, MultipleTargets)
     ASSERT_EQ(vm->engine(), &engine);
     ASSERT_EQ(vm->script(), script.get());
 }
+
+TEST_F(CompilerTest, EdgeActivatedHatPredicate)
+{
+    auto hat = std::make_shared<Block>("", "");
+    hat->setCompileFunction([](Compiler *) {});
+    hat->setHatPredicateCompileFunction([](Compiler *compiler) { compiler->addConstValue(true); });
+
+    auto block = std::make_shared<Block>("", "");
+    block->setCompileFunction([](Compiler *compiler) {
+        compiler->addConstValue("test");
+        compiler->addInstruction(vm::OP_PRINT);
+    });
+    block->setParent(hat);
+    hat->setNext(block);
+
+    INIT_COMPILER(engine, compiler);
+    compiler.compile(hat);
+    ASSERT_EQ(compiler.hatPredicateBytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 1, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ true, "test" }));
+}