Compiler: Add API for procedures

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -22,6 +22,7 @@ class Variable;
 class List;
 class Input;
 class Field;
+class BlockPrototype;
 class CompilerPrivate;
 
 /*! \brief The Compiler class provides API for compiling Scratch scripts. */
@@ -62,6 +63,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *addListItemIndex(List *list, CompilerValue *item);
         CompilerValue *addListContains(List *list, CompilerValue *item);
         CompilerValue *addListSize(List *list);
+        CompilerValue *addProcedureArgument(const std::string &name);
+
         CompilerValue *addInput(const std::string &name);
         CompilerValue *addInput(Input *input);
 
@@ -130,6 +133,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void createYield();
         void createStop();
 
+        void createProcedureCall(BlockPrototype *prototype, const Compiler::Args &args);
+
         Input *input(const std::string &name) const;
         Field *field(const std::string &name) const;
 

src/dev/engine/compiler.cpp

@@ -46,7 +46,21 @@ std::shared_ptr<libscratchcpp::Block> Compiler::block() const
 /*! Compiles the script starting with the given block. */
 std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock)
 {
-    impl->builder = impl->builderFactory->create(impl->ctx, nullptr);
+    BlockPrototype *procedurePrototype = nullptr;
+
+    if (startBlock) {
+        // TODO: Move procedure definition logic to the custom blocks extension
+        auto input = startBlock->inputAt(0);
+
+        if (input && input->valueBlock()) {
+            procedurePrototype = input->valueBlock()->mutationPrototype();
+
+            if (procedurePrototype && procedurePrototype->procCode().empty())
+                procedurePrototype = nullptr;
+        }
+    }
+
+    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype);
     impl->substackTree.clear();
     impl->substackHit = false;
     impl->emptySubstack = false;
@@ -176,6 +190,12 @@ CompilerValue *Compiler::addListSize(List *list)
     return impl->builder->addListSize(list);
 }
 
+/*! Adds the procedure argument with the given name to the code. */
+CompilerValue *Compiler::addProcedureArgument(const std::string &name)
+{
+    return impl->builder->addProcedureArgument(name);
+}
+
 /*! Compiles the given input (resolved by name) and adds it to the compiled code. */
 CompilerValue *Compiler::addInput(const std::string &name)
 {
@@ -615,6 +635,12 @@ void Compiler::createStop()
     impl->builder->createStop();
 }
 
+/*! Creates a call to the procedure with the given prototype. */
+void Compiler::createProcedureCall(BlockPrototype *prototype, const libscratchcpp::Compiler::Args &args)
+{
+    impl->builder->createProcedureCall(prototype, args);
+}
+
 /*! Convenience method which returns the field with the given name. */
 Input *Compiler::input(const std::string &name) const
 {

test/dev/compiler/compiler_test.cpp

@@ -45,11 +45,10 @@ class CompilerTest : public testing::Test
             m_testVar.reset();
         }
 
-        void compile(Compiler *compiler, std::shared_ptr<Block> block)
+        void compile(Compiler *compiler, std::shared_ptr<Block> block, BlockPrototype *procedurePrototype = nullptr)
         {
             ASSERT_EQ(compiler->block(), nullptr);
-            // TODO: Test procedures
-            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), nullptr)).WillOnce(Return(m_builder));
+            EXPECT_CALL(m_builderFactory, create(m_ctx.get(), procedurePrototype)).WillOnce(Return(m_builder));
             EXPECT_CALL(*m_builder, finalize()).WillOnce(Return(m_code));
             ASSERT_EQ(compiler->compile(block), m_code);
             ASSERT_EQ(compiler->block(), nullptr);
@@ -338,6 +337,25 @@ TEST_F(CompilerTest, AddListContains)
     compile(m_compiler.get(), block);
 }
 
+TEST_F(CompilerTest, AddProcedureArgument)
+{
+
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue ret(Compiler::StaticType::Unknown);
+
+        EXPECT_CALL(*m_builder, addProcedureArgument("arg 1")).WillOnce(Return(&ret));
+        EXPECT_EQ(compiler->addProcedureArgument("arg 1"), &ret);
+
+        EXPECT_CALL(*m_builder, addProcedureArgument("arg 2")).WillOnce(Return(nullptr));
+        EXPECT_EQ(compiler->addProcedureArgument("arg 2"), nullptr);
+
+        return nullptr;
+    });
+
+    compile(m_compiler.get(), block);
+}
+
 TEST_F(CompilerTest, AddInput)
 {
 
@@ -1572,6 +1590,25 @@ TEST_F(CompilerTest, CreateStop)
     compile(m_compiler.get(), block);
 }
 
+TEST_F(CompilerTest, CreateProcedureCall)
+{
+
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        BlockPrototype prototype;
+        CompilerValue arg1(Compiler::StaticType::Unknown);
+        CompilerValue arg2(Compiler::StaticType::Unknown);
+        Compiler::Args args = { &arg1, &arg2 };
+
+        EXPECT_CALL(*m_builder, createProcedureCall(&prototype, args));
+        compiler->createProcedureCall(&prototype, args);
+        return nullptr;
+    });
+
+    compile(m_compiler.get(), block);
+}
+
 TEST_F(CompilerTest, Input)
 {
 
@@ -1660,3 +1697,30 @@ TEST_F(CompilerTest, UnsupportedBlocks)
 
     ASSERT_EQ(m_compiler->unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "value_block1", "value_block3", "value_block5", "block4" }));
 }
+
+TEST_F(CompilerTest, Procedure)
+{
+    {
+        auto block = std::make_shared<Block>("", "");
+        auto customBlock = std::make_shared<Block>("", "");
+        customBlock->mutationPrototype()->setProcCode("");
+
+        auto input = std::make_shared<Input>("custom_block", Input::Type::ObscuredShadow);
+        input->setValueBlock(customBlock);
+        block->addInput(input);
+
+        compile(m_compiler.get(), block, nullptr);
+    }
+
+    {
+        auto block = std::make_shared<Block>("", "");
+        auto customBlock = std::make_shared<Block>("", "");
+        customBlock->mutationPrototype()->setProcCode("test");
+
+        auto input = std::make_shared<Input>("custom_block", Input::Type::ObscuredShadow);
+        input->setValueBlock(customBlock);
+        block->addInput(input);
+
+        compile(m_compiler.get(), block, customBlock->mutationPrototype());
+    }
+}