Add Thread class

Author: adazem009

CMakeLists.txt

@@ -32,6 +32,7 @@ target_sources(scratchcpp
     include/scratchcpp/iengine.h
     include/scratchcpp/iextension.h
     include/scratchcpp/iblocksection.h
+    include/scratchcpp/thread.h
     include/scratchcpp/asset.h
     include/scratchcpp/costume.h
     include/scratchcpp/sound.h

include/scratchcpp/thread.h

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+#include "spimpl.h"
+
+namespace libscratchcpp
+{
+
+class VirtualMachine;
+class Target;
+class IEngine;
+class Script;
+class ThreadPrivate;
+
+/*! \brief The Thread class represents a running Scratch script. */
+class LIBSCRATCHCPP_EXPORT Thread
+{
+    public:
+        Thread(Target *target, IEngine *engine, Script *script);
+        Thread(const Thread &) = delete;
+
+        VirtualMachine *vm() const;
+        Target *target() const;
+        IEngine *engine() const;
+        Script *script() const;
+
+        void run();
+        void kill();
+        void reset();
+
+        bool isFinished() const;
+
+        void promise();
+        void resolvePromise();
+
+    private:
+        spimpl::unique_impl_ptr<ThreadPrivate> impl;
+};
+
+} // namespace libscratchcpp

include/scratchcpp/virtualmachine.h

@@ -88,14 +88,15 @@ enum Opcode
 class Target;
 class IEngine;
 class Script;
+class Thread;
 class List;
 
 /*! \brief The VirtualMachine class is a virtual machine for compiled Scratch scripts. */
 class LIBSCRATCHCPP_EXPORT VirtualMachine
 {
     public:
         VirtualMachine();
-        VirtualMachine(Target *target, IEngine *engine, Script *script);
+        VirtualMachine(Target *target, IEngine *engine, Script *script, Thread *thread = nullptr);
         VirtualMachine(const VirtualMachine &) = delete;
 
         void setProcedures(unsigned int **procedures);
@@ -121,6 +122,7 @@ class LIBSCRATCHCPP_EXPORT VirtualMachine
         Target *target() const;
         IEngine *engine() const;
         Script *script() const;
+        Thread *thread() const;
 
         const Value *getInput(unsigned int index, unsigned int argCount) const;
 

src/engine/CMakeLists.txt

@@ -9,6 +9,9 @@ target_sources(scratchcpp
     script.cpp
     script_p.cpp
     script_p.h
+    thread.cpp
+    thread_p.cpp
+    thread_p.h
     internal/engine.cpp
     internal/engine.h
     internal/clock.cpp

src/engine/thread.cpp

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/thread.h>
+#include <scratchcpp/virtualmachine.h>
+
+#include "thread_p.h"
+
+using namespace libscratchcpp;
+
+/*! Constructs Thread. */
+Thread::Thread(Target *target, IEngine *engine, Script *script) :
+    impl(spimpl::make_unique_impl<ThreadPrivate>(target, engine, script))
+{
+    impl->vm = std::make_unique<VirtualMachine>(target, engine, script, this);
+}
+
+/*! Returns the virtual machine of this thread. */
+VirtualMachine *Thread::vm() const
+{
+    return impl->vm.get();
+}
+
+/*! Returns the Target of the script. */
+Target *Thread::target() const
+{
+    return impl->target;
+}
+
+/*! Returns the engine of the project. */
+IEngine *Thread::engine() const
+{
+    return impl->engine;
+}
+
+/*! Returns the Script. */
+Script *Thread::script() const
+{
+    return impl->script;
+}
+
+/*! Runs the script until it finishes or yields. */
+void Thread::run()
+{
+    impl->vm->run();
+}
+
+/*! Stops the script. */
+void Thread::kill()
+{
+    impl->vm->kill();
+}
+
+/*! Resets the script to run from the start. */
+void Thread::reset()
+{
+    impl->vm->reset();
+}
+
+/*! Returns true if the script is stopped or finished. */
+bool Thread::isFinished() const
+{
+    return impl->vm->atEnd();
+}
+
+/*! Pauses the script (when it's executed using run() again) until resolvePromise() is called. */
+void Thread::promise()
+{
+    impl->vm->promise();
+}
+
+/*! Resolves the promise and resumes the script. */
+void Thread::resolvePromise()
+{
+    impl->vm->resolvePromise();
+}

src/engine/thread_p.cpp

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "thread_p.h"
+
+using namespace libscratchcpp;
+
+ThreadPrivate::ThreadPrivate(Target *target, IEngine *engine, Script *script) :
+    target(target),
+    engine(engine),
+    script(script)
+{
+}

src/engine/thread_p.h

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/virtualmachine.h>
+
+namespace libscratchcpp
+{
+
+struct ThreadPrivate
+{
+        ThreadPrivate(Target *target, IEngine *engine, Script *script);
+
+        std::unique_ptr<VirtualMachine> vm;
+        Target *target = nullptr;
+        IEngine *engine = nullptr;
+        Script *script = nullptr;
+};
+
+} // namespace libscratchcpp

src/engine/virtualmachine.cpp

@@ -10,13 +10,13 @@ using namespace vm;
 
 /*! Constructs VirtualMachine. */
 VirtualMachine::VirtualMachine() :
-    VirtualMachine(nullptr, nullptr, nullptr)
+    VirtualMachine(nullptr, nullptr, nullptr, nullptr)
 {
 }
 
 /*! \copydoc VirtualMachine() */
-VirtualMachine::VirtualMachine(Target *target, IEngine *engine, Script *script) :
-    impl(spimpl::make_unique_impl<VirtualMachinePrivate>(this, target, engine, script))
+VirtualMachine::VirtualMachine(Target *target, IEngine *engine, Script *script, Thread *thread) :
+    impl(spimpl::make_unique_impl<VirtualMachinePrivate>(this, target, engine, script, thread))
 {
 }
 
@@ -137,6 +137,12 @@ Script *VirtualMachine::script() const
     return impl->script;
 }
 
+/*! Returns the Thread this VM belongs to. */
+Thread *VirtualMachine::thread() const
+{
+    return impl->thread;
+}
+
 /*! Returns the register at the given index with the given argument (register) count. */
 const Value *VirtualMachine::getInput(unsigned int index, unsigned int argCount) const
 {

src/engine/virtualmachine_p.cpp

@@ -110,11 +110,12 @@ const unsigned int VirtualMachinePrivate::instruction_arg_count[] = {
     0  // OP_WARP
 };
 
-VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script) :
+VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script, Thread *thread) :
     vm(vm),
     target(target),
     engine(engine),
-    script(script)
+    script(script),
+    thread(thread)
 {
     regsVector.reserve(1024);
     for (int i = 0; i < 1024; i++)

src/engine/virtualmachine_p.h

@@ -13,13 +13,14 @@ class VirtualMachine;
 class Target;
 class IEngine;
 class Script;
+class Thread;
 class Value;
 class List;
 class IRandomGenerator;
 
 struct VirtualMachinePrivate
 {
-        VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script);
+        VirtualMachinePrivate(VirtualMachine *vm, Target *target, IEngine *engine, Script *script, Thread *thread);
         VirtualMachinePrivate(const VirtualMachinePrivate &) = delete;
         ~VirtualMachinePrivate();
 
@@ -41,6 +42,7 @@ struct VirtualMachinePrivate
         Target *target = nullptr;
         IEngine *engine = nullptr;
         Script *script = nullptr;
+        Thread *thread = nullptr;
         unsigned int *pos = nullptr;
         unsigned int *checkpoint = nullptr;
         bool running = false;