Use Thread instead of Target in ExecutionContext constructor

Author: adazem009

include/scratchcpp/dev/executablecode.h

@@ -10,7 +10,7 @@ namespace libscratchcpp
 {
 
 class ExecutionContext;
-class Target;
+class Thread;
 
 /*! \brief The ExecutableCode class represents the code of a compiled Scratch script. */
 class LIBSCRATCHCPP_EXPORT ExecutableCode
@@ -31,7 +31,7 @@ class LIBSCRATCHCPP_EXPORT ExecutableCode
         virtual bool isFinished(ExecutionContext *context) const = 0;
 
         /*! Creates an execution context for the given Target. */
-        virtual std::shared_ptr<ExecutionContext> createExecutionContext(Target *target) const = 0;
+        virtual std::shared_ptr<ExecutionContext> createExecutionContext(Thread *thread) const = 0;
 };
 
 } // namespace libscratchcpp

include/scratchcpp/dev/executioncontext.h

@@ -8,6 +8,7 @@
 namespace libscratchcpp
 {
 
+class Thread;
 class Target;
 class Promise;
 class ExecutionContextPrivate;
@@ -16,11 +17,11 @@ class ExecutionContextPrivate;
 class LIBSCRATCHCPP_EXPORT ExecutionContext
 {
     public:
-        ExecutionContext(Target *target);
+        ExecutionContext(Thread *thread);
         ExecutionContext(const ExecutionContext &) = delete;
         virtual ~ExecutionContext() { }
 
-        Target *target() const;
+        Thread *thread() const;
 
         std::shared_ptr<Promise> promise() const;
         void setPromise(std::shared_ptr<Promise> promise);

src/dev/engine/executioncontext.cpp

@@ -1,21 +1,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/dev/executioncontext.h>
+#include <scratchcpp/thread.h>
 
 #include "executioncontext_p.h"
 
 using namespace libscratchcpp;
 
 /*! Constructs ExecutionContext. */
-ExecutionContext::ExecutionContext(Target *target) :
-    impl(spimpl::make_unique_impl<ExecutionContextPrivate>(target))
+ExecutionContext::ExecutionContext(Thread *thread) :
+    impl(spimpl::make_unique_impl<ExecutionContextPrivate>(thread))
 {
 }
 
-/*! Returns the Target of this context. */
-Target *ExecutionContext::target() const
+/*! Returns the thread of this context. */
+Thread *ExecutionContext::thread() const
 {
-    return impl->target;
+    return impl->thread;
 }
 
 /*! Returns the script promise. */

src/dev/engine/executioncontext_p.cpp

@@ -4,7 +4,7 @@
 
 using namespace libscratchcpp;
 
-ExecutionContextPrivate::ExecutionContextPrivate(Target *target) :
-    target(target)
+ExecutionContextPrivate::ExecutionContextPrivate(Thread *thread) :
+    thread(thread)
 {
 }

src/dev/engine/executioncontext_p.h

@@ -7,14 +7,15 @@
 namespace libscratchcpp
 {
 
+class Thread;
 class Target;
 class Promise;
 
 struct ExecutionContextPrivate
 {
-        ExecutionContextPrivate(Target *target);
+        ExecutionContextPrivate(Thread *thread);
 
-        Target *target = nullptr;
+        Thread *thread = nullptr;
         std::shared_ptr<Promise> promise;
 };
 

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

@@ -5,6 +5,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/dev/promise.h>
+#include <scratchcpp/thread.h>
 #include <llvm/Support/Error.h>
 #include <iostream>
 
@@ -64,7 +65,7 @@ void LLVMExecutableCode::run(ExecutionContext *context)
 
         ctx->setFinished(done);
     } else {
-        Target *target = ctx->target();
+        Target *target = ctx->thread()->target();
         void *handle = m_mainFunction(context, target, target->variableData(), target->listData());
 
         if (!handle)
@@ -95,9 +96,9 @@ bool LLVMExecutableCode::isFinished(ExecutionContext *context) const
     return getContext(context)->finished();
 }
 
-std::shared_ptr<ExecutionContext> LLVMExecutableCode::createExecutionContext(Target *target) const
+std::shared_ptr<ExecutionContext> LLVMExecutableCode::createExecutionContext(Thread *thread) const
 {
-    return std::make_shared<LLVMExecutionContext>(target);
+    return std::make_shared<LLVMExecutionContext>(thread);
 }
 
 uint64_t LLVMExecutableCode::lookupFunction(const std::string &name)

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

@@ -25,7 +25,7 @@ class LLVMExecutableCode : public ExecutableCode
 
         bool isFinished(ExecutionContext *context) const override;
 
-        std::shared_ptr<ExecutionContext> createExecutionContext(Target *target) const override;
+        std::shared_ptr<ExecutionContext> createExecutionContext(Thread *thread) const override;
 
     private:
         uint64_t lookupFunction(const std::string &name);

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

@@ -4,8 +4,8 @@
 
 using namespace libscratchcpp;
 
-LLVMExecutionContext::LLVMExecutionContext(Target *target) :
-    ExecutionContext(target)
+LLVMExecutionContext::LLVMExecutionContext(Thread *thread) :
+    ExecutionContext(thread)
 {
 }
 

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

@@ -10,7 +10,7 @@ namespace libscratchcpp
 class LLVMExecutionContext : public ExecutionContext
 {
     public:
-        LLVMExecutionContext(Target *target);
+        LLVMExecutionContext(Thread *thread);
 
         void *coroutineHandle() const;
         void setCoroutineHandle(void *newCoroutineHandle);

src/engine/thread.cpp

@@ -18,8 +18,12 @@ Thread::Thread(Target *target, IEngine *engine, Script *script) :
 {
     impl->vm = std::make_unique<VirtualMachine>(target, engine, script, this);
 #ifdef USE_LLVM
-    impl->code = impl->script->code();
-    impl->executionContext = impl->code->createExecutionContext(target);
+    if (impl->script) {
+        impl->code = impl->script->code();
+
+        if (impl->code)
+            impl->executionContext = impl->code->createExecutionContext(this);
+    }
 #endif
 }