Compiler: Implement repeat loop

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -40,7 +40,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         void moveToIf(std::shared_ptr<Block> substack);
         void moveToIfElse(std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
-        void moveToLoop(std::shared_ptr<Block> substack);
+        void moveToRepeatLoop(std::shared_ptr<Block> substack);
         void warp();
 
         Input *input(const std::string &name) const;

src/dev/engine/compiler.cpp

@@ -129,12 +129,13 @@ void Compiler::moveToIfElse(std::shared_ptr<Block> substack1, std::shared_ptr<Bl
         impl->substackEnd();
 }
 
-/*! Jumps to the given loop substack. */
-void Compiler::moveToLoop(std::shared_ptr<Block> substack)
+/*! Jumps to the given repeat loop substack. */
+void Compiler::moveToRepeatLoop(std::shared_ptr<Block> substack)
 {
     impl->substackHit = true;
     impl->substackTree.push_back({ { impl->block, nullptr }, CompilerPrivate::SubstackType::Loop });
     impl->block = substack;
+    impl->builder->beginRepeatLoop();
 
     if (!impl->block)
         impl->substackEnd();

src/dev/engine/compiler_p.cpp

@@ -24,8 +24,8 @@ void CompilerPrivate::substackEnd()
     switch (parent.second) {
         case SubstackType::Loop:
             // Yield at loop end if not running without screen refresh
-            if (!warp)
-                builder->yield();
+            /*if (!warp)
+                builder->yield();*/
 
             builder->endLoop();
             break;

test/dev/compiler/compiler_test.cpp

@@ -401,6 +401,84 @@ TEST_F(CompilerTest, MoveToIfElse)
     compile(compiler, if1);
 }
 
+TEST_F(CompilerTest, MoveToRepeatLoop)
+{
+    Compiler compiler(&m_engine, &m_target);
+
+    auto l1 = std::make_shared<Block>("", "loop");
+    l1->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatLoop());
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatLoop(nullptr);
+    });
+
+    auto l2 = std::make_shared<Block>("", "loop");
+    l1->setNext(l2);
+    l2->setParent(l1);
+    l2->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatLoop());
+        EXPECT_CALL(*m_builder, addConstValue(Value(2)));
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatLoop(compiler->input("SUBSTACK")->valueBlock());
+    });
+
+    auto substack = std::make_shared<Block>("", "substack");
+    substack->setParent(l2);
+    substack->setCompileFunction([](Compiler *compiler) { compiler->addConstValue(2); });
+
+    auto input = std::make_shared<Input>("SUBSTACK", Input::Type::NoShadow);
+    input->setValueBlock(substack);
+    l2->addInput(input);
+
+    // Nested
+    auto l3 = std::make_shared<Block>("", "loop");
+    l2->setNext(l3);
+    l3->setParent(l2);
+    l3->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatLoop()).Times(2);
+        EXPECT_CALL(*m_builder, endLoop()).Times(2);
+        EXPECT_CALL(*m_builder, addConstValue(Value(1)));
+        compiler->moveToRepeatLoop(compiler->input("SUBSTACK")->valueBlock());
+    });
+
+    // Begin loop
+    auto loopSubstack = std::make_shared<Block>("", "loop");
+    loopSubstack->setParent(l3);
+    loopSubstack->setCompileFunction([](Compiler *compiler) { compiler->moveToRepeatLoop(compiler->input("SUBSTACK")->valueBlock()); });
+
+    substack = std::make_shared<Block>("", "substack");
+    substack->setParent(loopSubstack);
+    substack->setCompileFunction([](Compiler *compiler) { compiler->addConstValue(1); });
+
+    input = std::make_shared<Input>("SUBSTACK", Input::Type::NoShadow);
+    input->setValueBlock(substack);
+    loopSubstack->addInput(input);
+
+    // End loop
+    input = std::make_shared<Input>("SUBSTACK", Input::Type::NoShadow);
+    input->setValueBlock(loopSubstack);
+    l3->addInput(input);
+
+    // Empty loop body
+    auto l4 = std::make_shared<Block>("", "loop");
+    l3->setNext(l4);
+    l4->setParent(l3);
+    l4->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatLoop());
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatLoop(nullptr);
+    });
+
+    // Code after the loop
+    auto block = std::make_shared<Block>("", "");
+    block->setParent(l4);
+    l4->setNext(block);
+    block->setCompileFunction([](Compiler *compiler) { compiler->addConstValue("after"); });
+
+    EXPECT_CALL(*m_builder, addConstValue(Value("after")));
+    compile(compiler, l1);
+}
+
 TEST_F(CompilerTest, Input)
 {
     Compiler compiler(&m_engine, &m_target);