Compiler: Add target and ctx function call methods

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -48,6 +48,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock);
 
         CompilerValue *addFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
+        CompilerValue *addTargetFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
+        CompilerValue *addFunctionCallWithCtx(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerConstant *addConstValue(const Value &value);
         CompilerValue *addVariableValue(Variable *variable);
         CompilerValue *addListContents(List *list);

src/dev/engine/compiler.cpp

@@ -76,14 +76,34 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
 
 /*!
  * Adds a call to the given function.\n
- * For example: extern "C" bool some_block(Target *target, double arg1, const char *arg2)
+ * For example: extern "C" bool some_block(double arg1, const char *arg2)
  */
 CompilerValue *Compiler::addFunctionCall(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
 {
     assert(argTypes.size() == args.size());
     return impl->builder->addFunctionCall(functionName, returnType, argTypes, args);
 }
 
+/*!
+ * Adds a call to the given function with a target parameter.\n
+ * For example: extern "C" bool some_block(Target *target, double arg1, const char *arg2)
+ */
+CompilerValue *Compiler::addTargetFunctionCall(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
+{
+    assert(argTypes.size() == args.size());
+    return impl->builder->addTargetFunctionCall(functionName, returnType, argTypes, args);
+}
+
+/*!
+ * Adds a call to the given function with an execution context parameter.\n
+ * For example: extern "C" bool some_block(ExecutionContext *ctx, double arg1, const char *arg2)
+ */
+CompilerValue *Compiler::addFunctionCallWithCtx(const std::string &functionName, StaticType returnType, const ArgTypes &argTypes, const Args &args)
+{
+    assert(argTypes.size() == args.size());
+    return impl->builder->addFunctionCallWithCtx(functionName, returnType, argTypes, args);
+}
+
 /*! Adds the given constant to the compiled code. */
 CompilerConstant *Compiler::addConstValue(const Value &value)
 {

test/dev/compiler/compiler_test.cpp

@@ -89,6 +89,56 @@ TEST_F(CompilerTest, AddFunctionCall)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, AddTargetFunctionCall)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    m_compareBlock = block;
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        EXPECT_EQ(compiler->block(), m_compareBlock);
+        CompilerValue arg1(Compiler::StaticType::Unknown);
+        CompilerValue arg2(Compiler::StaticType::Unknown);
+        Compiler::ArgTypes argTypes = { Compiler::StaticType::Number, Compiler::StaticType::Bool };
+        Compiler::Args args = { &arg1, &arg2 };
+        EXPECT_CALL(*m_builder, addTargetFunctionCall("test1", Compiler::StaticType::Void, argTypes, args));
+        compiler->addTargetFunctionCall("test1", Compiler::StaticType::Void, argTypes, args);
+
+        args = { &arg1 };
+        argTypes = { Compiler::StaticType::String };
+        EXPECT_CALL(*m_builder, addTargetFunctionCall("test2", Compiler::StaticType::Bool, argTypes, args));
+        compiler->addTargetFunctionCall("test2", Compiler::StaticType::Bool, argTypes, args);
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, AddFunctionCallWithCtx)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    m_compareBlock = block;
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        EXPECT_EQ(compiler->block(), m_compareBlock);
+        CompilerValue arg1(Compiler::StaticType::Unknown);
+        CompilerValue arg2(Compiler::StaticType::Unknown);
+        Compiler::ArgTypes argTypes = { Compiler::StaticType::Number, Compiler::StaticType::Bool };
+        Compiler::Args args = { &arg1, &arg2 };
+        EXPECT_CALL(*m_builder, addFunctionCallWithCtx("test1", Compiler::StaticType::Void, argTypes, args));
+        compiler->addFunctionCallWithCtx("test1", Compiler::StaticType::Void, argTypes, args);
+
+        args = { &arg1 };
+        argTypes = { Compiler::StaticType::String };
+        EXPECT_CALL(*m_builder, addFunctionCallWithCtx("test2", Compiler::StaticType::Bool, argTypes, args));
+        compiler->addFunctionCallWithCtx("test2", Compiler::StaticType::Bool, argTypes, args);
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, AddConstValue)
 {
     Compiler compiler(&m_engine, &m_target);