LLVM: Implement promises

CMakeLists.txt

@@ -76,6 +76,7 @@ if (LIBSCRATCHCPP_USE_LLVM)
         include/scratchcpp/dev/compilerconstant.h
         include/scratchcpp/dev/executablecode.h
         include/scratchcpp/dev/executioncontext.h
+        include/scratchcpp/dev/promise.h
     )
 
     if(LIBSCRATCHCPP_PRINT_LLVM_IR)

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);
@@ -101,12 +103,16 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void beginElseBranch();
         void endIf();
 
+        void beginWhileLoop(CompilerValue *cond);
+        void beginRepeatUntilLoop(CompilerValue *cond);
+        void beginLoopCondition();
+        void endLoop();
+
         void moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack);
         void moveToIfElse(CompilerValue *cond, std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
         void moveToRepeatLoop(CompilerValue *count, std::shared_ptr<Block> substack);
         void moveToWhileLoop(CompilerValue *cond, std::shared_ptr<Block> substack);
         void moveToRepeatUntilLoop(CompilerValue *cond, std::shared_ptr<Block> substack);
-        void beginLoopCondition();
         void warp();
 
         Input *input(const std::string &name) const;

include/scratchcpp/dev/executablecode.h

@@ -30,12 +30,6 @@ class LIBSCRATCHCPP_EXPORT ExecutableCode
         /*! Returns true if the code is stopped or finished. */
         virtual bool isFinished(ExecutionContext *context) const = 0;
 
-        /*! Pauses the script (when it's executed using run() again) until resolvePromise() is called. */
-        virtual void promise() = 0;
-
-        /*! Resolves the promise and resumes the script. */
-        virtual void resolvePromise() = 0;
-
         /*! Creates an execution context for the given Target. */
         virtual std::shared_ptr<ExecutionContext> createExecutionContext(Target *target) const = 0;
 };

include/scratchcpp/dev/executioncontext.h

@@ -9,6 +9,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class Promise;
 class ExecutionContextPrivate;
 
 /*! \brief The ExecutionContext represents the execution context of a target (can be a clone) with variables, lists, etc. */
@@ -21,6 +22,9 @@ class LIBSCRATCHCPP_EXPORT ExecutionContext
 
         Target *target() const;
 
+        std::shared_ptr<Promise> promise() const;
+        void setPromise(std::shared_ptr<Promise> promise);
+
     private:
         spimpl::unique_impl_ptr<ExecutionContextPrivate> impl;
 };

include/scratchcpp/dev/promise.h

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../global.h"
+#include "../spimpl.h"
+
+namespace libscratchcpp
+{
+
+class PromisePrivate;
+
+/*! \brief The Promise class represents the eventual completion of an asynchronous operation. */
+class LIBSCRATCHCPP_EXPORT Promise
+{
+    public:
+        Promise();
+        Promise(const Promise &) = delete;
+
+        bool isResolved() const;
+        void resolve();
+
+    private:
+        spimpl::unique_impl_ptr<PromisePrivate> impl;
+};
+
+} // namespace libscratchcpp

include/scratchcpp/thread.h

@@ -10,6 +10,9 @@ namespace libscratchcpp
 
 class VirtualMachine;
 class Target;
+#ifdef USE_LLVM
+class Promise;
+#endif
 class IEngine;
 class Script;
 class ThreadPrivate;
@@ -32,8 +35,13 @@ class LIBSCRATCHCPP_EXPORT Thread
 
         bool isFinished() const;
 
+#ifdef USE_LLVM
+        std::shared_ptr<Promise> promise() const;
+        void setPromise(std::shared_ptr<Promise> promise);
+#else
         void promise();
         void resolvePromise();
+#endif
 
     private:
         spimpl::unique_impl_ptr<ThreadPrivate> impl;

src/dev/engine/CMakeLists.txt

@@ -12,6 +12,9 @@ target_sources(scratchcpp
     executioncontext.cpp
     executioncontext_p.cpp
     executioncontext_p.h
+    promise.cpp
+    promise_p.cpp
+    promise_p.h
     internal/icodebuilder.h
     internal/icodebuilderfactory.h
     internal/codebuilderfactory.cpp

src/dev/engine/compiler.cpp

@@ -54,6 +54,11 @@ std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBl
                 std::cerr << "error: if statement created by block '" << impl->block->opcode() << "' not terminated" << std::endl;
                 assert(false);
             }
+
+            if (impl->customLoopCount > 0) {
+                std::cerr << "error: loop created by block '" << impl->block->opcode() << "' not terminated" << std::endl;
+                assert(false);
+            }
         } else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
             impl->unsupportedBlocks.insert(impl->block->opcode());
@@ -76,14 +81,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)
 {
@@ -362,6 +387,45 @@ void Compiler::endIf()
     impl->customIfStatementCount--;
 }
 
+/*!
+ * Begins a custom while loop.
+ * \note The loop must be terminated with endLoop() after compiling your block.
+ */
+void Compiler::beginWhileLoop(CompilerValue *cond)
+{
+    impl->builder->beginWhileLoop(cond);
+    impl->customLoopCount++;
+}
+
+/*!
+ * Begins a custom repeat until loop.
+ * \note The loop must be terminated with endLoop() after compiling your block.
+ */
+void Compiler::beginRepeatUntilLoop(CompilerValue *cond)
+{
+    impl->builder->beginRepeatUntilLoop(cond);
+    impl->customLoopCount++;
+}
+
+/*! Begins a while/until loop condition. */
+void Compiler::beginLoopCondition()
+{
+    impl->builder->beginLoopCondition();
+}
+
+/*! Ends custom loop. */
+void Compiler::endLoop()
+{
+    if (impl->customLoopCount == 0) {
+        std::cerr << "error: called Compiler::endLoop() without a loop";
+        assert(false);
+        return;
+    }
+
+    impl->builder->endLoop();
+    impl->customLoopCount--;
+}
+
 /*! Jumps to the given if substack. */
 void Compiler::moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack)
 {
@@ -425,12 +489,6 @@ void Compiler::moveToRepeatUntilLoop(CompilerValue *cond, std::shared_ptr<Block>
         impl->substackEnd();
 }
 
-/*! Begins a while/until loop condition. */
-void Compiler::beginLoopCondition()
-{
-    impl->builder->beginLoopCondition();
-}
-
 /*! Makes current script run without screen refresh. */
 void Compiler::warp()
 {

src/dev/engine/compiler_p.h

@@ -33,6 +33,7 @@ struct CompilerPrivate
 
         std::shared_ptr<Block> block;
         int customIfStatementCount = 0;
+        int customLoopCount = 0;
         std::vector<std::pair<std::pair<std::shared_ptr<Block>, std::shared_ptr<Block>>, SubstackType>> substackTree;
         bool substackHit = false;
         bool warp = false;

src/dev/engine/executioncontext.cpp

@@ -17,3 +17,15 @@ Target *ExecutionContext::target() const
 {
     return impl->target;
 }
+
+/*! Returns the script promise. */
+std::shared_ptr<Promise> ExecutionContext::promise() const
+{
+    return impl->promise;
+}
+
+/*! Sets the script promise (yields until the promise is resolved). */
+void ExecutionContext::setPromise(std::shared_ptr<Promise> promise)
+{
+    impl->promise = promise;
+}

src/dev/engine/executioncontext_p.h

@@ -2,16 +2,20 @@
 
 #pragma once
 
+#include <memory>
+
 namespace libscratchcpp
 {
 
 class Target;
+class Promise;
 
 struct ExecutionContextPrivate
 {
         ExecutionContextPrivate(Target *target);
 
         Target *target = nullptr;
+        std::shared_ptr<Promise> promise;
 };
 
 } // namespace libscratchcpp

src/dev/engine/internal/icodebuilder.h

@@ -20,6 +20,8 @@ class ICodeBuilder
         virtual std::shared_ptr<ExecutableCode> finalize() = 0;
 
         virtual CompilerValue *addFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;
+        virtual CompilerValue *addTargetFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;
+        virtual CompilerValue *addFunctionCallWithCtx(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;
         virtual CompilerConstant *addConstValue(const Value &value) = 0;
         virtual CompilerValue *addVariableValue(Variable *variable) = 0;
         virtual CompilerValue *addListContents(List *list) = 0;

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

@@ -58,13 +58,14 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
     m_builder.setFastMathFlags(fmf);
 
     // Create function
-    // void *f(Target *, ValueData **, List **)
+    // void *f(ExecutionContext *, Target *, ValueData **, List **)
     llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0);
-    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType, pointerType }, false);
+    llvm::FunctionType *funcType = llvm::FunctionType::get(pointerType, { pointerType, pointerType, pointerType, pointerType }, false);
     llvm::Function *func = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "f", m_module.get());
-    llvm::Value *targetPtr = func->getArg(0);
-    llvm::Value *targetVariables = func->getArg(1);
-    llvm::Value *targetLists = func->getArg(2);
+    llvm::Value *executionContextPtr = func->getArg(0);
+    llvm::Value *targetPtr = func->getArg(1);
+    llvm::Value *targetVariables = func->getArg(2);
+    llvm::Value *targetLists = func->getArg(3);
 
     llvm::BasicBlock *entry = llvm::BasicBlock::Create(m_ctx, "entry", func);
     m_builder.SetInsertPoint(entry);
@@ -117,9 +118,17 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 std::vector<llvm::Type *> types;
                 std::vector<llvm::Value *> args;
 
+                // Add execution context arg
+                if (step.functionCtxArg) {
+                    types.push_back(llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0));
+                    args.push_back(executionContextPtr);
+                }
+
                 // Add target pointer arg
-                types.push_back(llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0));
-                args.push_back(targetPtr);
+                if (step.functionTargetArg) {
+                    types.push_back(llvm::PointerType::get(llvm::Type::getInt8Ty(m_ctx), 0));
+                    args.push_back(targetPtr);
+                }
 
                 // Args
                 for (auto &arg : step.args) {
@@ -950,6 +959,20 @@ CompilerValue *LLVMCodeBuilder::addFunctionCall(const std::string &functionName,
     return nullptr;
 }
 
+CompilerValue *LLVMCodeBuilder::addTargetFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args)
+{
+    CompilerValue *ret = addFunctionCall(functionName, returnType, argTypes, args);
+    m_instructions.back().functionTargetArg = true;
+    return ret;
+}
+
+CompilerValue *LLVMCodeBuilder::addFunctionCallWithCtx(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args)
+{
+    CompilerValue *ret = addFunctionCall(functionName, returnType, argTypes, args);
+    m_instructions.back().functionCtxArg = true;
+    return ret;
+}
+
 CompilerConstant *LLVMCodeBuilder::addConstValue(const Value &value)
 {
     auto constReg = std::make_shared<LLVMConstantRegister>(TYPE_MAP[value.type()], value);

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

@@ -27,6 +27,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         std::shared_ptr<ExecutableCode> finalize() override;
 
         CompilerValue *addFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) override;
+        CompilerValue *addTargetFunctionCall(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) override;
+        CompilerValue *addFunctionCallWithCtx(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) override;
         CompilerConstant *addConstValue(const Value &value) override;
         CompilerValue *addVariableValue(Variable *variable) override;
         CompilerValue *addListContents(List *list) override;