Implement data_insertatlist

Author: adazem009

src/dev/blocks/listblocks.cpp

@@ -25,6 +25,7 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_addtolist", &compileAddToList);
     engine->addCompileFunction(this, "data_deleteoflist", &compileDeleteOfList);
     engine->addCompileFunction(this, "data_deletealloflist", &compileDeleteAllOfList);
+    engine->addCompileFunction(this, "data_insertatlist", &compileInsertAtList);
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -38,24 +39,23 @@ CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
     return nullptr;
 }
 
-CompilerValue *ListBlocks::getListIndex(Compiler *compiler, CompilerValue *input, List *list)
+CompilerValue *ListBlocks::getListIndex(Compiler *compiler, CompilerValue *input, List *list, CompilerValue *listSize)
 {
     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);
+        CompilerValue *random = compiler->createRandomInt(compiler->addConstValue(1), listSize);
         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->createLocalVariableWrite(ret, compiler->createSelect(isLast, listSize, input, Compiler::StaticType::Number));
     }
     compiler->endIf();
 
@@ -76,10 +76,10 @@ CompilerValue *ListBlocks::compileDeleteOfList(Compiler *compiler)
         }
         compiler->beginElseBranch();
         {
-            index = getListIndex(compiler, index, list);
-            index = compiler->createSub(index, compiler->addConstValue(1));
             CompilerValue *min = compiler->addConstValue(-1);
             CompilerValue *max = compiler->addListSize(list);
+            index = getListIndex(compiler, index, list, max);
+            index = compiler->createSub(index, compiler->addConstValue(1));
             cond = compiler->createAnd(compiler->createCmpGT(index, min), compiler->createCmpLT(index, max));
             compiler->beginIfStatement(cond);
             {
@@ -103,3 +103,26 @@ CompilerValue *ListBlocks::compileDeleteAllOfList(Compiler *compiler)
 
     return nullptr;
 }
+
+CompilerValue *ListBlocks::compileInsertAtList(Compiler *compiler)
+{
+    List *list = static_cast<List *>(compiler->field("LIST")->valuePtr().get());
+    assert(list);
+
+    if (list) {
+        CompilerValue *index = compiler->addInput("INDEX");
+        CompilerValue *min = compiler->addConstValue(-1);
+        CompilerValue *max = compiler->createAdd(compiler->addListSize(list), compiler->addConstValue(1));
+        index = getListIndex(compiler, index, list, max);
+        index = compiler->createSub(index, compiler->addConstValue(1));
+        CompilerValue *cond = compiler->createAnd(compiler->createCmpGT(index, min), compiler->createCmpLT(index, max));
+        compiler->beginIfStatement(cond);
+        {
+            CompilerValue *item = compiler->addInput("ITEM");
+            compiler->createListInsert(list, index, item);
+        }
+        compiler->endIf();
+    }
+
+    return nullptr;
+}

src/dev/blocks/listblocks.h

@@ -19,9 +19,10 @@ class ListBlocks : public IExtension
 
     private:
         static CompilerValue *compileAddToList(Compiler *compiler);
-        static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list);
+        static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list, CompilerValue *listSize);
         static CompilerValue *compileDeleteOfList(Compiler *compiler);
         static CompilerValue *compileDeleteAllOfList(Compiler *compiler);
+        static CompilerValue *compileInsertAtList(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/list_blocks_test.cpp

@@ -154,3 +154,60 @@ TEST_F(ListBlocksTest, DeleteAllOfList)
     builder.run();
     ASSERT_TRUE(list->empty());
 }
+
+TEST_F(ListBlocksTest, InsertAtList)
+{
+    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);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    auto addTest = [&builder](const Value &item, const Value &index, std::shared_ptr<List> list) {
+        builder.addBlock("data_insertatlist");
+        builder.addValueInput("ITEM", item);
+        builder.addValueInput("INDEX", index);
+        builder.addEntityField("LIST", list);
+        return builder.currentBlock();
+    };
+
+    auto block = addTest("sit", 4, list1);
+    addTest(false, 7, list1);
+    addTest("test", 0, list1);
+    addTest("test", 9, list1);
+
+    addTest("lorem", "last", list2);
+    addTest("ipsum", "random", list2);
+    addTest("dolor", "any", list2);
+
+    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, 8)).WillOnce(Return(8));
+    EXPECT_CALL(m_rng, randint(1, 9)).WillOnce(Return(3));
+    code->run(ctx.get());
+    ASSERT_EQ(list1->toString(), "Lorem ipsum dolor sit 123 true false");
+    ASSERT_EQ(list2->toString(), "Hello world dolor false -543.5 abc 52.4 lorem ipsum");
+}