Implement data_deleteoflist

Author: adazem009

src/dev/blocks/listblocks.cpp

@@ -23,6 +23,7 @@ std::string ListBlocks::description() const
 void ListBlocks::registerBlocks(IEngine *engine)
 {
     engine->addCompileFunction(this, "data_addtolist", &compileAddToList);
+    engine->addCompileFunction(this, "data_deleteoflist", &compileDeleteOfList);
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -35,3 +36,58 @@ CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
 
     return nullptr;
 }
+
+CompilerValue *ListBlocks::getListIndex(Compiler *compiler, CompilerValue *input, List *list)
+{
+    CompilerLocalVariable *ret = compiler->createLocalVariable(Compiler::StaticType::Number);
+    CompilerValue *size = compiler->addListSize(list);
+
+    CompilerValue *isRandom1 = compiler->createCmpEQ(input, compiler->addConstValue("random"));
+    CompilerValue *isRandom2 = compiler->createCmpEQ(input, compiler->addConstValue("any"));
+    CompilerValue *isRandom = compiler->createOr(isRandom1, isRandom2);
+
+    compiler->beginIfStatement(isRandom);
+    {
+        CompilerValue *random = compiler->createRandomInt(compiler->addConstValue(1), size);
+        compiler->createLocalVariableWrite(ret, random);
+    }
+    compiler->beginElseBranch();
+    {
+        CompilerValue *isLast = compiler->createCmpEQ(input, compiler->addConstValue("last"));
+        compiler->createLocalVariableWrite(ret, compiler->createSelect(isLast, size, input, Compiler::StaticType::Number));
+    }
+    compiler->endIf();
+
+    return compiler->addLocalVariableValue(ret);
+}
+
+CompilerValue *ListBlocks::compileDeleteOfList(Compiler *compiler)
+{
+    List *list = static_cast<List *>(compiler->field("LIST")->valuePtr().get());
+    assert(list);
+
+    if (list) {
+        CompilerValue *index = compiler->addInput("INDEX");
+        CompilerValue *cond = compiler->createCmpEQ(index, compiler->addConstValue("all"));
+        compiler->beginIfStatement(cond);
+        {
+            compiler->createListClear(list);
+        }
+        compiler->beginElseBranch();
+        {
+            index = getListIndex(compiler, index, list);
+            index = compiler->createSub(index, compiler->addConstValue(1));
+            CompilerValue *min = compiler->addConstValue(-1);
+            CompilerValue *max = compiler->addListSize(list);
+            cond = compiler->createAnd(compiler->createCmpGT(index, min), compiler->createCmpLT(index, max));
+            compiler->beginIfStatement(cond);
+            {
+                compiler->createListRemove(list, index);
+            }
+            compiler->endIf();
+        }
+        compiler->endIf();
+    }
+
+    return nullptr;
+}

src/dev/blocks/listblocks.h

@@ -7,6 +7,8 @@
 namespace libscratchcpp
 {
 
+class List;
+
 class ListBlocks : public IExtension
 {
     public:
@@ -17,6 +19,9 @@ class ListBlocks : public IExtension
 
     private:
         static CompilerValue *compileAddToList(Compiler *compiler);
+        static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list);
+        static CompilerValue *compileDeleteOfList(Compiler *compiler);
+        static CompilerValue *compileDeleteAllOfList(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/list_blocks_test.cpp

@@ -3,14 +3,21 @@
 #include <scratchcpp/list.h>
 #include <scratchcpp/dev/compiler.h>
 #include <scratchcpp/dev/test/scriptbuilder.h>
+#include <scratchcpp/script.h>
+#include <scratchcpp/thread.h>
+#include <scratchcpp/dev/executioncontext.h>
+#include <scratchcpp/dev/executablecode.h>
 #include <enginemock.h>
+#include <randomgeneratormock.h>
 
 #include "../common.h"
 #include "dev/blocks/listblocks.h"
 
 using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
+using ::testing::Return;
+
 class ListBlocksTest : public testing::Test
 {
     public:
@@ -25,6 +32,7 @@ class ListBlocksTest : public testing::Test
         Project m_project;
         IEngine *m_engine = nullptr;
         EngineMock m_engineMock;
+        RandomGeneratorMock m_rng;
 };
 
 TEST_F(ListBlocksTest, AddToList)
@@ -59,3 +67,69 @@ TEST_F(ListBlocksTest, AddToList)
     ASSERT_EQ(list1->toString(), "test true");
     ASSERT_EQ(list2->toString(), "123 Hello world");
 }
+
+TEST_F(ListBlocksTest, DeleteOfList)
+{
+    auto target = std::make_shared<Sprite>();
+
+    auto list1 = std::make_shared<List>("", "");
+    list1->append("Lorem");
+    list1->append("ipsum");
+    list1->append("dolor");
+    list1->append(123);
+    list1->append(true);
+    target->addList(list1);
+
+    auto list2 = std::make_shared<List>("", "");
+    list2->append("Hello");
+    list2->append("world");
+    list2->append(false);
+    list2->append(-543.5);
+    list2->append("abc");
+    list2->append(52.4);
+    target->addList(list2);
+
+    auto list3 = std::make_shared<List>("", "");
+    list3->append(1);
+    list3->append(2);
+    list3->append(3);
+    target->addList(list3);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    auto addTest = [&builder](const Value &index, std::shared_ptr<List> list) {
+        builder.addBlock("data_deleteoflist");
+        builder.addValueInput("INDEX", index);
+        builder.addEntityField("LIST", list);
+        return builder.currentBlock();
+    };
+
+    auto block = addTest(1, list1);
+    addTest(3, list1);
+    addTest(2, list1);
+    addTest(0, list1);
+    addTest(3, list1);
+
+    addTest("last", list2);
+    addTest("random", list2);
+    addTest("any", list2);
+
+    addTest("all", list3);
+
+    builder.build();
+
+    Compiler compiler(&m_engineMock, target.get());
+    auto code = compiler.compile(block);
+    Script script(target.get(), block, &m_engineMock);
+    script.setCode(code);
+    Thread thread(target.get(), &m_engineMock, &script);
+    auto ctx = code->createExecutionContext(&thread);
+    ctx->setRng(&m_rng);
+
+    EXPECT_CALL(m_rng, randint(1, 5)).WillOnce(Return(2));
+    EXPECT_CALL(m_rng, randint(1, 4)).WillOnce(Return(3));
+    code->run(ctx.get());
+    ASSERT_EQ(list1->toString(), "ipsum true");
+    ASSERT_EQ(list2->toString(), "Hello false abc");
+    ASSERT_TRUE(list3->empty());
+}