Compiler: Implement repeat until loop

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -42,6 +42,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void moveToIfElse(std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
         void moveToRepeatLoop(std::shared_ptr<Block> substack);
         void moveToWhileLoop(std::shared_ptr<Block> substack);
+        void moveToRepeatUntilLoop(std::shared_ptr<Block> substack);
         void beginLoopCondition();
         void warp();
 

src/dev/engine/compiler.cpp

@@ -153,6 +153,18 @@ void Compiler::moveToWhileLoop(std::shared_ptr<Block> substack)
         impl->substackEnd();
 }
 
+/*! Jumps to the given until loop substack. */
+void Compiler::moveToRepeatUntilLoop(std::shared_ptr<Block> substack)
+{
+    impl->substackHit = true;
+    impl->substackTree.push_back({ { impl->block, nullptr }, CompilerPrivate::SubstackType::Loop });
+    impl->block = substack;
+    impl->builder->beginRepeatUntilLoop();
+
+    if (!impl->block)
+        impl->substackEnd();
+}
+
 /*! Begins a while/until loop condition. */
 void Compiler::beginLoopCondition()
 {

test/dev/compiler/compiler_test.cpp

@@ -557,6 +557,84 @@ TEST_F(CompilerTest, MoveToWhileLoop)
     compile(compiler, l1);
 }
 
+TEST_F(CompilerTest, MoveToRepeatUntilLoop)
+{
+    Compiler compiler(&m_engine, &m_target);
+
+    auto l1 = std::make_shared<Block>("", "loop");
+    l1->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatUntilLoop());
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatUntilLoop(nullptr);
+    });
+
+    auto l2 = std::make_shared<Block>("", "loop");
+    l1->setNext(l2);
+    l2->setParent(l1);
+    l2->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, beginRepeatUntilLoop());
+        EXPECT_CALL(*m_builder, addConstValue(Value(2)));
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatUntilLoop(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, beginRepeatUntilLoop()).Times(2);
+        EXPECT_CALL(*m_builder, endLoop()).Times(2);
+        EXPECT_CALL(*m_builder, addConstValue(Value(1)));
+        compiler->moveToRepeatUntilLoop(compiler->input("SUBSTACK")->valueBlock());
+    });
+
+    // Begin loop
+    auto loopSubstack = std::make_shared<Block>("", "loop");
+    loopSubstack->setParent(l3);
+    loopSubstack->setCompileFunction([](Compiler *compiler) { compiler->moveToRepeatUntilLoop(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, beginRepeatUntilLoop());
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->moveToRepeatUntilLoop(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, BeginLoopCondition)
 {
     Compiler compiler(&m_engine, &m_target);