LLVMCodeBuilder: Implement list clear

Author: adazem009

src/dev/engine/internal/icodebuilder.h

@@ -56,6 +56,8 @@ class ICodeBuilder
 
         virtual void createVariableWrite(Variable *variable) = 0;
 
+        virtual void createListClear(List *list) = 0;
+
         virtual void beginIfStatement() = 0;
         virtual void beginElseBranch() = 0;
         virtual void endIf() = 0;

src/dev/engine/internal/llvm/llvmcodebuilder.cpp

@@ -477,6 +477,13 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::ClearList: {
+                assert(step.args.size() == 0);
+                const LLVMListPtr &listPtr = m_listPtrs[step.workList];
+                m_builder.CreateCall(resolve_list_clear(), listPtr.ptr);
+                break;
+            }
+
             case LLVMInstruction::Type::Yield:
                 if (!m_warp) {
                     freeHeap();
@@ -932,6 +939,13 @@ void LLVMCodeBuilder::createVariableWrite(Variable *variable)
     m_variablePtrs[variable] = LLVMVariablePtr();
 }
 
+void LLVMCodeBuilder::createListClear(List *list)
+{
+    LLVMInstruction &ins = createOp(LLVMInstruction::Type::ClearList, Compiler::StaticType::Void, Compiler::StaticType::Void, 0);
+    ins.workList = list;
+    m_listPtrs[list] = LLVMListPtr();
+}
+
 void LLVMCodeBuilder::beginIfStatement()
 {
     LLVMInstruction ins(LLVMInstruction::Type::BeginIf);
@@ -1822,6 +1836,12 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_value_lower()
     return resolveFunction("value_lower", llvm::FunctionType::get(m_builder.getInt1Ty(), { valuePtr, valuePtr }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_list_clear()
+{
+    llvm::Type *listPtr = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
+    return resolveFunction("list_clear", llvm::FunctionType::get(m_builder.getInt1Ty(), { listPtr }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_strcasecmp()
 {
     llvm::Type *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);

src/dev/engine/internal/llvm/llvmcodebuilder.h

@@ -62,6 +62,8 @@ class LLVMCodeBuilder : public ICodeBuilder
 
         void createVariableWrite(Variable *variable) override;
 
+        void createListClear(List *list) override;
+
         void beginIfStatement() override;
         void beginElseBranch() override;
         void endIf() override;
@@ -132,6 +134,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_value_equals();
         llvm::FunctionCallee resolve_value_greater();
         llvm::FunctionCallee resolve_value_lower();
+        llvm::FunctionCallee resolve_list_clear();
         llvm::FunctionCallee resolve_strcasecmp();
 
         Target *m_target = nullptr;

src/dev/engine/internal/llvm/llvminstruction.h

@@ -42,6 +42,7 @@ struct LLVMInstruction
             Exp10,
             WriteVariable,
             ReadVariable,
+            ClearList,
             Yield,
             BeginIf,
             BeginElse,

test/dev/llvm/llvmcodebuilder_test.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/stage.h>
 #include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
 #include <dev/engine/internal/llvm/llvmcodebuilder.h>
 #include <gmock/gmock.h>
 #include <targetmock.h>
@@ -1899,6 +1900,80 @@ TEST_F(LLVMCodeBuilderTest, ReadVariable)
     ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
 }
 
+TEST_F(LLVMCodeBuilderTest, ClearList)
+{
+    EngineMock engine;
+    Stage stage;
+    Sprite sprite;
+    sprite.setEngine(&engine);
+    EXPECT_CALL(engine, stage()).WillRepeatedly(Return(&stage));
+
+    std::unordered_map<List *, std::string> strings;
+
+    auto globalList1 = std::make_shared<List>("", "");
+    auto globalList2 = std::make_shared<List>("", "");
+    auto globalList3 = std::make_shared<List>("", "");
+    stage.addList(globalList1);
+    stage.addList(globalList2);
+    stage.addList(globalList3);
+
+    auto localList1 = std::make_shared<List>("", "");
+    auto localList2 = std::make_shared<List>("", "");
+    auto localList3 = std::make_shared<List>("", "");
+    sprite.addList(localList1);
+    sprite.addList(localList2);
+    sprite.addList(localList3);
+
+    globalList1->append(1);
+    globalList1->append(2);
+    globalList1->append(3);
+    strings[globalList1.get()] = globalList1->toString();
+
+    globalList2->append("Lorem");
+    globalList2->append("ipsum");
+    globalList2->append(-4.52);
+    strings[globalList2.get()] = globalList2->toString();
+
+    globalList3->append(true);
+    globalList3->append(false);
+    globalList3->append(true);
+    strings[globalList3.get()] = globalList3->toString();
+
+    localList1->append("dolor");
+    localList1->append("sit");
+    localList1->append("amet");
+    strings[localList1.get()] = localList1->toString();
+
+    localList2->append(10);
+    localList2->append(9.8);
+    localList2->append(true);
+    strings[localList2.get()] = localList2->toString();
+
+    localList3->append("test");
+    localList3->append(1.2);
+    localList3->append(false);
+    strings[localList3.get()] = localList3->toString();
+
+    createBuilder(&sprite, true);
+
+    m_builder->createListClear(globalList1.get());
+    m_builder->createListClear(globalList3.get());
+    m_builder->createListClear(localList1.get());
+    m_builder->createListClear(localList2.get());
+
+    auto code = m_builder->finalize();
+    auto ctx = code->createExecutionContext(&sprite);
+    code->run(ctx.get());
+
+    ASSERT_TRUE(globalList1->empty());
+    ASSERT_EQ(globalList2->toString(), strings[globalList2.get()]);
+    ASSERT_TRUE(globalList3->empty());
+
+    ASSERT_TRUE(localList1->empty());
+    ASSERT_TRUE(localList2->empty());
+    ASSERT_EQ(localList3->toString(), strings[localList3.get()]);
+}
+
 TEST_F(LLVMCodeBuilderTest, Yield)
 {
     auto build = [this]() {

test/mocks/codebuildermock.h

@@ -46,6 +46,8 @@ class CodeBuilderMock : public ICodeBuilder
 
         MOCK_METHOD(void, createVariableWrite, (Variable *), (override));
 
+        MOCK_METHOD(void, createListClear, (List *), (override));
+
         MOCK_METHOD(void, beginIfStatement, (), (override));
         MOCK_METHOD(void, beginElseBranch, (), (override));
         MOCK_METHOD(void, endIf, (), (override));