Compiler: Add API for custom while/until loops

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -103,12 +103,16 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void beginElseBranch();
         void endIf();
 
+        void beginWhileLoop(CompilerValue *cond);
+        void beginRepeatUntilLoop(CompilerValue *cond);
+        void beginLoopCondition();
+        void endLoop();
+
         void moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack);
         void moveToIfElse(CompilerValue *cond, std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
         void moveToRepeatLoop(CompilerValue *count, std::shared_ptr<Block> substack);
         void moveToWhileLoop(CompilerValue *cond, std::shared_ptr<Block> substack);
         void moveToRepeatUntilLoop(CompilerValue *cond, std::shared_ptr<Block> substack);
-        void beginLoopCondition();
         void warp();
 
         Input *input(const std::string &name) const;

src/dev/engine/compiler.cpp

@@ -54,6 +54,11 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
                 std::cerr << "error: if statement created by block '" << impl->block->opcode() << "' not terminated" << std::endl;
                 assert(false);
             }
+
+            if (impl->customLoopCount > 0) {
+                std::cerr << "error: loop created by block '" << impl->block->opcode() << "' not terminated" << std::endl;
+                assert(false);
+            }
         } else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
             impl->unsupportedBlocks.insert(impl->block->opcode());
@@ -382,6 +387,45 @@ void Compiler::endIf()
     impl->customIfStatementCount--;
 }
 
+/*!
+ * Begins a custom while loop.
+ * \note The loop must be terminated with endLoop() after compiling your block.
+ */
+void Compiler::beginWhileLoop(CompilerValue *cond)
+{
+    impl->builder->beginWhileLoop(cond);
+    impl->customLoopCount++;
+}
+
+/*!
+ * Begins a custom repeat until loop.
+ * \note The loop must be terminated with endLoop() after compiling your block.
+ */
+void Compiler::beginRepeatUntilLoop(CompilerValue *cond)
+{
+    impl->builder->beginRepeatUntilLoop(cond);
+    impl->customLoopCount++;
+}
+
+/*! Begins a while/until loop condition. */
+void Compiler::beginLoopCondition()
+{
+    impl->builder->beginLoopCondition();
+}
+
+/*! Ends custom loop. */
+void Compiler::endLoop()
+{
+    if (impl->customLoopCount == 0) {
+        std::cerr << "error: called Compiler::endLoop() without a loop";
+        assert(false);
+        return;
+    }
+
+    impl->builder->endLoop();
+    impl->customLoopCount--;
+}
+
 /*! Jumps to the given if substack. */
 void Compiler::moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack)
 {
@@ -445,12 +489,6 @@ void Compiler::moveToRepeatUntilLoop(CompilerValue *cond, std::shared_ptr<Block>
         impl->substackEnd();
 }
 
-/*! Begins a while/until loop condition. */
-void Compiler::beginLoopCondition()
-{
-    impl->builder->beginLoopCondition();
-}
-
 /*! Makes current script run without screen refresh. */
 void Compiler::warp()
 {

src/dev/engine/compiler_p.h

@@ -33,6 +33,7 @@ struct CompilerPrivate
 
         std::shared_ptr<Block> block;
         int customIfStatementCount = 0;
+        int customLoopCount = 0;
         std::vector<std::pair<std::pair<std::shared_ptr<Block>, std::shared_ptr<Block>>, SubstackType>> substackTree;
         bool substackHit = false;
         bool warp = false;

test/dev/compiler/compiler_test.cpp

@@ -892,6 +892,55 @@ TEST_F(CompilerTest, CustomIfStatement)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, CustomWhileLoop)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue arg(Compiler::StaticType::Unknown);
+        EXPECT_CALL(*m_builder, beginWhileLoop(&arg));
+        compiler->beginWhileLoop(&arg);
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->endLoop();
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CustomRepeatUntilLoop)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue arg(Compiler::StaticType::Unknown);
+        EXPECT_CALL(*m_builder, beginRepeatUntilLoop(&arg));
+        compiler->beginRepeatUntilLoop(&arg);
+        EXPECT_CALL(*m_builder, endLoop());
+        compiler->endLoop();
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, BeginLoopCondition)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        EXPECT_CALL(*m_builder, beginLoopCondition());
+        compiler->beginLoopCondition();
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, MoveToIf)
 {
     Compiler compiler(&m_engine, &m_target);
@@ -1369,19 +1418,6 @@ TEST_F(CompilerTest, MoveToRepeatUntilLoop)
     compile(compiler, l1);
 }
 
-TEST_F(CompilerTest, BeginLoopCondition)
-{
-    Compiler compiler(&m_engine, &m_target);
-    auto block = std::make_shared<Block>("a", "");
-    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
-        EXPECT_CALL(*m_builder, beginLoopCondition());
-        compiler->beginLoopCondition();
-        return nullptr;
-    });
-
-    compile(compiler, block);
-}
-
 TEST_F(CompilerTest, Input)
 {
     Compiler compiler(&m_engine, &m_target);