Use shared_ptr for blocks only in targets

Author: adazem009

include/scratchcpp/block.h

@@ -18,7 +18,9 @@ class InputValue;
 class BlockPrivate;
 
 /*! \brief The Block class represents a Scratch block. */
-class LIBSCRATCHCPP_EXPORT Block : public Entity
+class LIBSCRATCHCPP_EXPORT Block
+    : public Entity
+    , public std::enable_shared_from_this<Block>
 {
     public:
         friend class Engine;
@@ -30,14 +32,14 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         const std::string &opcode() const;
 
-        std::shared_ptr<Block> next() const;
+        Block *next() const;
         const std::string &nextId() const;
-        void setNext(std::shared_ptr<Block> block);
+        void setNext(Block *block);
         void setNextId(const std::string &nextId);
 
-        std::shared_ptr<Block> parent() const;
+        Block *parent() const;
         const std::string &parentId() const;
-        void setParent(std::shared_ptr<Block> block);
+        void setParent(Block *block);
         void setParentId(const std::string &id);
 
         const std::vector<std::shared_ptr<Input>> &inputs() const;

include/scratchcpp/compiler.h

@@ -54,9 +54,9 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         IEngine *engine() const;
         Target *target() const;
-        std::shared_ptr<Block> block() const;
+        Block *block() const;
 
-        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, CodeType codeType = CodeType::Script);
+        std::shared_ptr<ExecutableCode> compile(Block *startBlock, CodeType codeType = CodeType::Script);
         void preoptimize();
 
         CompilerValue *addFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
@@ -137,11 +137,11 @@ class LIBSCRATCHCPP_EXPORT Compiler
         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 moveToIf(CompilerValue *cond, Block *substack);
+        void moveToIfElse(CompilerValue *cond, Block *substack1, Block *substack2);
+        void moveToRepeatLoop(CompilerValue *count, Block *substack);
+        void moveToWhileLoop(CompilerValue *cond, Block *substack);
+        void moveToRepeatUntilLoop(CompilerValue *cond, Block *substack);
         void warp();
 
         void createYield();

include/scratchcpp/iengine.h

@@ -60,7 +60,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void stop() = 0;
 
         /*! Starts a script with the given top level block as the given Target (a sprite or the stage). */
-        virtual Thread *startScript(std::shared_ptr<Block> topLevelBlock, Target *) = 0;
+        virtual Thread *startScript(Block *topLevelBlock, Target *) = 0;
 
         /*! Starts the scripts of the broadcast with the given index. */
         virtual void broadcast(int index, Thread *sender, bool wait) = 0;
@@ -283,28 +283,28 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual int findBroadcastById(const std::string &broadcastId) const = 0;
 
         /* Registers the given "when touching object" script. */
-        virtual void addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addWhenTouchingObjectScript(Block *hatBlock) = 0;
 
         /*! Registers the "green flag" script. */
-        virtual void addGreenFlagScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addGreenFlagScript(Block *hatBlock) = 0;
 
         /*! Registers the broadcast script. */
-        virtual void addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field *field, Broadcast *broadcast) = 0;
+        virtual void addBroadcastScript(Block *whenReceivedBlock, Field *field, Broadcast *broadcast) = 0;
 
         /*! Registers the backdrop change script. */
-        virtual void addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *field) = 0;
+        virtual void addBackdropChangeScript(Block *hatBlock, Field *field) = 0;
 
         /* Registers the given "when I start as clone" script. */
-        virtual void addCloneInitScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addCloneInitScript(Block *hatBlock) = 0;
 
         /* Registers the given "when key pressed" script. */
-        virtual void addKeyPressScript(std::shared_ptr<Block> hatBlock, Field *field) = 0;
+        virtual void addKeyPressScript(Block *hatBlock, Field *field) = 0;
 
         /* Registers the given "when this sprite/stage clicked" script. */
-        virtual void addTargetClickScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addTargetClickScript(Block *hatBlock) = 0;
 
         /* Registers the given "when greater than" script. */
-        virtual void addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock) = 0;
+        virtual void addWhenGreaterThanScript(Block *hatBlock) = 0;
 
         /*! Returns the list of targets. */
         virtual const std::vector<std::shared_ptr<Target>> &targets() const = 0;
@@ -377,7 +377,7 @@ class LIBSCRATCHCPP_EXPORT IEngine
         virtual void setExtensions(const std::vector<std::string> &newExtensions) = 0;
 
         /*! Returns the map of scripts (each top level block has a Script object). */
-        virtual const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &scripts() const = 0;
+        virtual const std::unordered_map<Block *, std::shared_ptr<Script>> &scripts() const = 0;
 
         /*! Returns the user agent of the last person to edit the project. */
         virtual const std::string &userAgent() const = 0;

include/scratchcpp/input.h

@@ -40,9 +40,9 @@ class LIBSCRATCHCPP_EXPORT Input
         void setPrimaryValue(const Value &value);
         void setSecondaryValue(const Value &value);
 
-        std::shared_ptr<Block> valueBlock() const;
+        Block *valueBlock() const;
         const std::string &valueBlockId() const;
-        void setValueBlock(std::shared_ptr<Block> block);
+        void setValueBlock(Block *block);
         void setValueBlockId(const std::string &id);
 
         bool pointsToDropdownMenu() const;

include/scratchcpp/inputvalue.h

@@ -43,8 +43,8 @@ class LIBSCRATCHCPP_EXPORT InputValue
         const Value &value() const;
         void setValue(const Value &newValue);
 
-        const std::shared_ptr<Block> &valueBlock() const;
-        void setValueBlock(const std::shared_ptr<Block> &newValueBlock);
+        Block *valueBlock() const;
+        void setValueBlock(Block *newValueBlock);
 
         const std::string &valueBlockId() const;
         void setValueBlockId(const std::string &newValueBlockId);

include/scratchcpp/script.h

@@ -22,11 +22,11 @@ class ScriptPrivate;
 class LIBSCRATCHCPP_EXPORT Script
 {
     public:
-        Script(Target *target, std::shared_ptr<Block> topBlock, IEngine *engine);
+        Script(Target *target, Block *topBlock, IEngine *engine);
         Script(const Script &) = delete;
 
         Target *target() const;
-        std::shared_ptr<Block> topBlock() const;
+        Block *topBlock() const;
 
         ExecutableCode *code() const;
         void setCode(std::shared_ptr<ExecutableCode> code);

include/scratchcpp/test/scriptbuilder.h

@@ -46,7 +46,7 @@ class LIBSCRATCHCPP_EXPORT ScriptBuilder
         void addEntityInput(const std::string &name, const std::string &entityName, InputValue::Type entityType, std::shared_ptr<Entity> entity);
         void addEntityField(const std::string &name, std::shared_ptr<Entity> entity);
 
-        std::shared_ptr<Block> currentBlock();
+        Block *currentBlock();
         std::shared_ptr<Block> takeBlock();
 
         void build();

src/engine/compiler.cpp

@@ -38,13 +38,13 @@ Target *Compiler::target() const
 }
 
 /*! Returns currently compiled block. */
-std::shared_ptr<libscratchcpp::Block> Compiler::block() const
+Block *Compiler::block() const
 {
     return impl->block;
 }
 
 /*! Compiles the script starting with the given block. */
-std::shared_ptr<ExecutableCode> Compiler::compile(std::shared_ptr<Block> startBlock, CodeType codeType)
+std::shared_ptr<ExecutableCode> Compiler::compile(Block *startBlock, CodeType codeType)
 {
     BlockPrototype *procedurePrototype = nullptr;
 
@@ -607,7 +607,7 @@ void Compiler::endLoop()
 }
 
 /*! Jumps to the given if substack. */
-void Compiler::moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack)
+void Compiler::moveToIf(CompilerValue *cond, Block *substack)
 {
     if (!substack)
         return; // ignore empty if statements
@@ -619,7 +619,7 @@ void Compiler::moveToIf(CompilerValue *cond, std::shared_ptr<Block> substack)
 }
 
 /*! Jumps to the given if/else substack. The second substack is used for the else branch. */
-void Compiler::moveToIfElse(CompilerValue *cond, std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2)
+void Compiler::moveToIfElse(CompilerValue *cond, Block *substack1, Block *substack2)
 {
     if (!substack1 && !substack2)
         return; // ignore empty if statements
@@ -634,7 +634,7 @@ void Compiler::moveToIfElse(CompilerValue *cond, std::shared_ptr<Block> substack
 }
 
 /*! Jumps to the given repeat loop substack. */
-void Compiler::moveToRepeatLoop(CompilerValue *count, std::shared_ptr<Block> substack)
+void Compiler::moveToRepeatLoop(CompilerValue *count, Block *substack)
 {
     impl->substackHit = true;
     impl->substackTree.push_back({ { impl->block, nullptr }, CompilerPrivate::SubstackType::Loop });
@@ -646,7 +646,7 @@ void Compiler::moveToRepeatLoop(CompilerValue *count, std::shared_ptr<Block> sub
 }
 
 /*! Jumps to the given while loop substack. */
-void Compiler::moveToWhileLoop(CompilerValue *cond, std::shared_ptr<Block> substack)
+void Compiler::moveToWhileLoop(CompilerValue *cond, Block *substack)
 {
     impl->substackHit = true;
     impl->substackTree.push_back({ { impl->block, nullptr }, CompilerPrivate::SubstackType::Loop });
@@ -658,7 +658,7 @@ void Compiler::moveToWhileLoop(CompilerValue *cond, std::shared_ptr<Block> subst
 }
 
 /*! Jumps to the given until loop substack. */
-void Compiler::moveToRepeatUntilLoop(CompilerValue *cond, std::shared_ptr<Block> substack)
+void Compiler::moveToRepeatUntilLoop(CompilerValue *cond, Block *substack)
 {
     impl->substackHit = true;
     impl->substackTree.push_back({ { impl->block, nullptr }, CompilerPrivate::SubstackType::Loop });

src/engine/compiler_p.h

@@ -35,10 +35,10 @@ struct CompilerPrivate
         std::shared_ptr<CompilerContext> ctxPtr; // for self-managed contexts
         CompilerContext *ctx = nullptr;
 
-        std::shared_ptr<Block> block;
+        Block *block = nullptr;
         int customIfStatementCount = 0;
         int customLoopCount = 0;
-        std::vector<std::pair<std::pair<std::shared_ptr<Block>, std::shared_ptr<Block>>, SubstackType>> substackTree;
+        std::vector<std::pair<std::pair<Block *, Block *>, SubstackType>> substackTree;
         bool substackHit = false;
         bool emptySubstack = false;
         bool warp = false;

src/engine/internal/engine.cpp

@@ -106,8 +106,8 @@ void Engine::resolveIds()
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
             IExtension *ext = blockExtension(block->opcode());
-            block->setNext(getBlock(block->nextId(), target.get()));
-            block->setParent(getBlock(block->parentId(), target.get()));
+            block->setNext(getBlock(block->nextId(), target.get()).get());
+            block->setParent(getBlock(block->parentId(), target.get()).get());
 
             if (ext) {
                 block->setCompileFunction(resolveBlockCompileFunc(ext, block->opcode()));
@@ -116,7 +116,7 @@ void Engine::resolveIds()
 
             const auto &inputs = block->inputs();
             for (const auto &input : inputs) {
-                input->setValueBlock(getBlock(input->valueBlockId(), target.get()));
+                input->setValueBlock(getBlock(input->valueBlockId(), target.get()).get());
 
                 if (ext)
                     input->setInputId(resolveInput(ext, input->name()));
@@ -271,12 +271,12 @@ void Engine::compile()
             if (block->topLevel() && !block->isTopLevelReporter() && !block->shadow()) {
                 auto ext = blockExtension(block->opcode());
                 if (ext) {
-                    auto script = std::make_shared<Script>(target.get(), block, this);
-                    m_scripts[block] = script;
-                    script->setCode(compiler.compile(block));
+                    auto script = std::make_shared<Script>(target.get(), block.get(), this);
+                    m_scripts[block.get()] = script;
+                    script->setCode(compiler.compile(block.get()));
 
                     if (block->hatPredicateCompileFunction())
-                        script->setHatPredicateCode(compiler.compile(block, Compiler::CodeType::HatPredicate));
+                        script->setHatPredicateCode(compiler.compile(block.get(), Compiler::CodeType::HatPredicate));
                 } else {
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
                     m_unsupportedBlocks.insert(block->opcode());
@@ -364,7 +364,7 @@ void Engine::stop()
     m_stopped();
 }
 
-Thread *Engine::startScript(std::shared_ptr<Block> topLevelBlock, Target *target)
+Thread *Engine::startScript(Block *topLevelBlock, Target *target)
 {
     return pushThread(topLevelBlock, target).get();
 }
@@ -499,10 +499,10 @@ void Engine::step()
 
                 Target *target = hatBlock->target();
                 assert(target);
-                auto it = m_edgeActivatedHatValues.find(hatBlock.get());
+                auto it = m_edgeActivatedHatValues.find(hatBlock);
 
                 if (it == m_edgeActivatedHatValues.cend()) {
-                    m_edgeActivatedHatValues[hatBlock.get()] = {};
+                    m_edgeActivatedHatValues[hatBlock] = {};
                 } else {
                     auto &map = it->second;
                     auto it = map.find(target);
@@ -513,7 +513,7 @@ void Engine::step()
 
                 bool newValue = thread->script()->runHatPredicate(hatBlock->target());
                 bool edgeWasActivated = !oldValue && newValue; // changed from false true
-                m_edgeActivatedHatValues[hatBlock.get()][target] = newValue;
+                m_edgeActivatedHatValues[hatBlock][target] = newValue;
 
                 if (!edgeWasActivated)
                     stopThread(thread.get());
@@ -1036,18 +1036,18 @@ int Engine::findBroadcastById(const std::string &broadcastId) const
         return it - m_broadcasts.begin();
 }
 
-void Engine::addWhenTouchingObjectScript(std::shared_ptr<Block> hatBlock)
+void Engine::addWhenTouchingObjectScript(Block *hatBlock)
 {
     addHatToMap(m_whenTouchingObjectHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addGreenFlagScript(std::shared_ptr<Block> hatBlock)
+void Engine::addGreenFlagScript(Block *hatBlock)
 {
     std::cout << "passed block: " << hatBlock << std::endl;
     addHatToMap(m_greenFlagHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field *field, Broadcast *broadcast)
+void Engine::addBroadcastScript(Block *whenReceivedBlock, Field *field, Broadcast *broadcast)
 {
     assert(!broadcast->isBackdropBroadcast());
     Script *script = m_scripts[whenReceivedBlock].get();
@@ -1066,7 +1066,7 @@ void Engine::addBroadcastScript(std::shared_ptr<Block> whenReceivedBlock, Field
     addHatField(script, HatField::BroadcastOption, field);
 }
 
-void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *field)
+void Engine::addBackdropChangeScript(Block *hatBlock, Field *field)
 {
     Stage *stage = this->stage();
 
@@ -1103,24 +1103,24 @@ void Engine::addBackdropChangeScript(std::shared_ptr<Block> hatBlock, Field *fie
     addHatField(script, HatField::Backdrop, field);
 }
 
-void Engine::addCloneInitScript(std::shared_ptr<Block> hatBlock)
+void Engine::addCloneInitScript(Block *hatBlock)
 {
     addHatToMap(m_cloneInitHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addKeyPressScript(std::shared_ptr<Block> hatBlock, Field *field)
+void Engine::addKeyPressScript(Block *hatBlock, Field *field)
 {
     Script *script = m_scripts[hatBlock].get();
     addHatToMap(m_whenKeyPressedHats, script);
     addHatField(script, HatField::KeyOption, field);
 }
 
-void Engine::addTargetClickScript(std::shared_ptr<Block> hatBlock)
+void Engine::addTargetClickScript(Block *hatBlock)
 {
     addHatToMap(m_whenTargetClickedHats, m_scripts[hatBlock].get());
 }
 
-void Engine::addWhenGreaterThanScript(std::shared_ptr<Block> hatBlock)
+void Engine::addWhenGreaterThanScript(Block *hatBlock)
 {
     Script *script = m_scripts[hatBlock].get();
     addHatToMap(m_whenGreaterThanHats, script);
@@ -1434,7 +1434,7 @@ void Engine::setExtensions(const std::vector<std::string> &newExtensions)
     }
 }
 
-const std::unordered_map<std::shared_ptr<Block>, std::shared_ptr<Script>> &Engine::scripts() const
+const std::unordered_map<Block *, std::shared_ptr<Script>> &Engine::scripts() const
 {
     return m_scripts;
 }
@@ -1866,9 +1866,9 @@ void Engine::compileMonitor(std::shared_ptr<Monitor> monitor)
         MonitorChangeFunc changeFunc = resolveMonitorChangeFunc(ext, block->opcode());
         monitor->setValueChangeFunction(changeFunc);
 
-        auto script = std::make_shared<Script>(target, block, this);
+        auto script = std::make_shared<Script>(target, block.get(), this);
         monitor->setScript(script);
-        auto code = compiler.compile(block, Compiler::CodeType::Reporter);
+        auto code = compiler.compile(block.get(), Compiler::CodeType::Reporter);
         script->setCode(code);
         m_monitorCompilerContexts[monitor.get()] = ctx;
 
@@ -1975,7 +1975,7 @@ void Engine::addBroadcastPromise(Broadcast *broadcast, Thread *sender, bool wait
         m_broadcastSenders[broadcast] = sender;
 }
 
-std::shared_ptr<Thread> Engine::pushThread(std::shared_ptr<Block> block, Target *target)
+std::shared_ptr<Thread> Engine::pushThread(Block *block, Target *target)
 {
     // https://github.com/scratchfoundation/scratch-vm/blob/f1aa92fad79af17d9dd1c41eeeadca099339a9f1/src/engine/runtime.js#L1649-L1661
     if (!block) {