Implement control_foreach

Author: adazem009

src/dev/blocks/controlblocks.cpp

@@ -9,6 +9,7 @@
 #include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/thread.h>
 #include <scratchcpp/istacktimer.h>
+#include <scratchcpp/variable.h>
 
 #include "controlblocks.h"
 
@@ -35,6 +36,7 @@ void ControlBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "control_wait_until", &compileWaitUntil);
     engine->addCompileFunction(this, "control_repeat_until", &compileRepeatUntil);
     engine->addCompileFunction(this, "control_while", &compileWhile);
+    engine->addCompileFunction(this, "control_for_each", &compileForEach);
 }
 
 CompilerValue *ControlBlocks::compileForever(Compiler *compiler)
@@ -123,6 +125,17 @@ CompilerValue *ControlBlocks::compileWhile(Compiler *compiler)
     return nullptr;
 }
 
+CompilerValue *ControlBlocks::compileForEach(Compiler *compiler)
+{
+    Variable *var = static_cast<Variable *>(compiler->field("VARIABLE")->valuePtr().get());
+    assert(var);
+    auto substack = compiler->input("SUBSTACK");
+    compiler->moveToRepeatLoop(compiler->addInput("VALUE"), substack ? substack->valueBlock() : nullptr);
+    auto index = compiler->createAdd(compiler->addLoopIndex(), compiler->addConstValue(1));
+    compiler->createVariableWrite(var, index);
+    return nullptr;
+}
+
 extern "C" void control_stop_all(ExecutionContext *ctx)
 {
     ctx->engine()->stop();

src/dev/blocks/controlblocks.h

@@ -25,6 +25,7 @@ class ControlBlocks : public IExtension
         static CompilerValue *compileWaitUntil(Compiler *compiler);
         static CompilerValue *compileRepeatUntil(Compiler *compiler);
         static CompilerValue *compileWhile(Compiler *compiler);
+        static CompilerValue *compileForEach(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/control_blocks_test.cpp

@@ -4,10 +4,12 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
 #include <scratchcpp/dev/executablecode.h>
 #include <scratchcpp/dev/executioncontext.h>
+#include <scratchcpp/variable.h>
 
 #include <enginemock.h>
 #include <stacktimermock.h>
@@ -646,3 +648,109 @@ TEST_F(ControlBlocksTest, While)
         }
     }
 }
+
+TEST_F(ControlBlocksTest, ForEach)
+{
+    auto target = std::make_shared<Sprite>();
+    auto var1 = std::make_shared<Variable>("", "");
+    auto var2 = std::make_shared<Variable>("", "");
+    target->addVariable(var1);
+    target->addVariable(var2);
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_for_each");
+
+        auto substack = std::make_shared<Block>("", "test_print");
+        auto input = std::make_shared<Input>("STRING", Input::Type::ObscuredShadow);
+        input->primaryValue()->setValuePtr(var1);
+        substack->addInput(input);
+
+        builder.addObscuredInput("SUBSTACK", substack);
+
+        builder.addValueInput("VALUE", 5);
+        builder.addEntityField("VARIABLE", var1);
+
+        builder.addBlock("control_for_each");
+        substack = std::make_shared<Block>("", "test_print_test");
+        builder.addObscuredInput("SUBSTACK", substack);
+        builder.addNullObscuredInput("VALUE");
+        builder.addEntityField("VARIABLE", var2);
+
+        builder.build();
+
+        var1->setValue(10);
+        testing::internal::CaptureStdout();
+        builder.run();
+        ASSERT_EQ(testing::internal::GetCapturedStdout(), "1\n2\n3\n4\n5\n");
+        ASSERT_EQ(var1->value(), 5);
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+    target->addVariable(var1);
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+        builder.addBlock("control_for_each");
+
+        auto substack = std::make_shared<Block>("", "test_print");
+        auto input = std::make_shared<Input>("STRING", Input::Type::ObscuredShadow);
+        input->primaryValue()->setValuePtr(var1);
+        substack->addInput(input);
+
+        auto setVar = std::make_shared<Block>("", "test_set_var");
+        substack->setNext(setVar);
+        setVar->setParent(substack);
+        auto field = std::make_shared<Field>("VARIABLE", "");
+        setVar->addField(field);
+        input = std::make_shared<Input>("VALUE", Input::Type::Shadow);
+        input->setPrimaryValue(0);
+        setVar->addInput(input);
+
+        auto printAgain = std::make_shared<Block>("", "test_print");
+        setVar->setNext(printAgain);
+        printAgain->setParent(setVar);
+        input = std::make_shared<Input>("STRING", Input::Type::ObscuredShadow);
+        printAgain->addInput(input);
+
+        builder.addObscuredInput("SUBSTACK", substack);
+
+        builder.addValueInput("VALUE", 3);
+        builder.addEntityField("VARIABLE", var1);
+
+        field->setValuePtr(var1);
+        input->primaryValue()->setValuePtr(var1);
+
+        builder.build();
+
+        var1->setValue(7);
+        testing::internal::CaptureStdout();
+        builder.run();
+        ASSERT_EQ(testing::internal::GetCapturedStdout(), "1\n0\n2\n0\n3\n0\n");
+        ASSERT_EQ(var1->value(), 0);
+    }
+
+    m_engine->clear();
+    target = std::make_shared<Sprite>();
+    target->addVariable(var1);
+
+    {
+        ScriptBuilder builder(m_extension.get(), m_engine, target);
+        builder.addBlock("control_for_each");
+        builder.addValueInput("VALUE", "Infinity");
+        builder.addEntityField("VARIABLE", var1);
+
+        builder.build();
+        m_engine->start();
+
+        for (int i = 0; i < 2; i++) {
+            m_engine->step();
+            ASSERT_TRUE(m_engine->isRunning());
+        }
+
+        ASSERT_GT(var1->value(), 0);
+    }
+}

test/dev/blocks/util.cpp

@@ -2,6 +2,8 @@
 #include <scratchcpp/dev/compiler.h>
 #include <scratchcpp/dev/compilerconstant.h>
 #include <scratchcpp/value.h>
+#include <scratchcpp/field.h>
+#include <scratchcpp/variable.h>
 #include <iostream>
 
 #include "util.h"
@@ -30,6 +32,12 @@ void registerBlocks(IEngine *engine, IExtension *extension)
     });
 
     engine->addCompileFunction(extension, "test_condition", [](Compiler *compiler) -> CompilerValue * { return compiler->addFunctionCall("test_condition", Compiler::StaticType::Bool); });
+
+    engine->addCompileFunction(extension, "test_set_var", [](Compiler *compiler) -> CompilerValue * {
+        Variable *var = static_cast<Variable *>(compiler->field("VARIABLE")->valuePtr().get());
+        compiler->createVariableWrite(var, compiler->addInput("VALUE"));
+        return nullptr;
+    });
 }
 
 extern "C" void test_print(const char *str)