Merge pull request #631 from scratchcpp/llvm_monitors

Implement monitors

Author: adazem009

include/scratchcpp/block.h

@@ -23,7 +23,7 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
     public:
         friend class Engine;
 
-        Block(const std::string &id, const std::string &opcode);
+        Block(const std::string &id, const std::string &opcode, bool isMonitorBlock = false);
         Block(const Block &) = delete;
 
         CompilerValue *compile(Compiler *compiler);
@@ -90,6 +90,8 @@ class LIBSCRATCHCPP_EXPORT Block : public Entity
 
         InputValue *topLevelReporterInfo();
 
+        bool isMonitorBlock() const;
+
     private:
         void updateInputMap();
         void updateFieldMap();

include/scratchcpp/compiler.h

@@ -38,6 +38,13 @@ class LIBSCRATCHCPP_EXPORT Compiler
             Unknown
         };
 
+        enum class CodeType
+        {
+            Script,
+            Reporter,
+            HatPredicate
+        };
+
         using ArgTypes = std::vector<StaticType>;
         using Args = std::vector<CompilerValue *>;
 
@@ -49,7 +56,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         Target *target() const;
         std::shared_ptr<Block> block() const;
 
-        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, bool isHatPredicate = false);
+        std::shared_ptr<ExecutableCode> compile(std::shared_ptr<Block> startBlock, CodeType codeType = CodeType::Script);
         void preoptimize();
 
         CompilerValue *addFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});

include/scratchcpp/executablecode.h

@@ -11,6 +11,7 @@ namespace libscratchcpp
 
 class ExecutionContext;
 class Thread;
+struct ValueData;
 
 /*! \brief The ExecutableCode class represents the code of a compiled Scratch script. */
 class LIBSCRATCHCPP_EXPORT ExecutableCode
@@ -21,6 +22,12 @@ class LIBSCRATCHCPP_EXPORT ExecutableCode
         /*! Runs the script until it finishes or yields. */
         virtual void run(ExecutionContext *context) = 0;
 
+        /*!
+         * Runs the reporter and returns its return value.
+         * \note Make sure to call value_free() to free the value.
+         */
+        virtual ValueData runReporter(ExecutionContext *context) = 0;
+
         /*! Runs the hat predicate and returns its return value. */
         virtual bool runPredicate(ExecutionContext *context) = 0;
 

include/scratchcpp/imonitorhandler.h

@@ -17,8 +17,7 @@ class LIBSCRATCHCPP_EXPORT IMonitorHandler
 
         virtual void init(Monitor *monitor) = 0;
 
-        // TODO: Add onValueChanged()
-        // virtual void onValueChanged(const VirtualMachine *vm) = 0;
+        virtual void onValueChanged(const Value &value) = 0;
         virtual void onXChanged(int x) = 0;
         virtual void onYChanged(int y) = 0;
         virtual void onVisibleChanged(bool visible) = 0;

include/scratchcpp/monitor.h

@@ -56,8 +56,7 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
 
         const std::string &opcode() const;
 
-        // TODO: Add updateValue()
-        // void updateValue(const VirtualMachine *vm);
+        void updateValue(const Value &value);
 
         void setValueChangeFunction(MonitorChangeFunc f);
         void changeValue(const Value &newValue);

include/scratchcpp/thread.h

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "global.h"
+#include "valuedata.h"
 #include "spimpl.h"
 
 namespace libscratchcpp
@@ -27,6 +27,7 @@ class LIBSCRATCHCPP_EXPORT Thread
         Script *script() const;
 
         void run();
+        ValueData runReporter();
         bool runPredicate();
         void kill();
         void reset();

src/blocks/listblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/list.h>
 
@@ -27,6 +28,8 @@ Rgb ListBlocks::color() const
 
 void ListBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "data_listcontents", &compileListContents);
     engine->addCompileFunction(this, "data_addtolist", &compileAddToList);
     engine->addCompileFunction(this, "data_deleteoflist", &compileDeleteOfList);
     engine->addCompileFunction(this, "data_deletealloflist", &compileDeleteAllOfList);
@@ -36,6 +39,24 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_itemnumoflist", &compileItemNumOfList);
     engine->addCompileFunction(this, "data_lengthoflist", &compileLengthOfList);
     engine->addCompileFunction(this, "data_listcontainsitem", &compileListContainsItem);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_listcontents", &listContentsMonitorName);
+}
+
+CompilerValue *ListBlocks::compileListContents(Compiler *compiler)
+{
+    auto list = compiler->field("LIST")->valuePtr();
+    assert(list);
+
+    // If this block is used in a list monitor, return the list pointer
+    if (compiler->block()->isMonitorBlock()) {
+        // TODO: Refactor this
+        // List monitors expect a reference to the list
+        // We don't have a list reference type, so cast the pointer to number
+        return compiler->addConstValue((uintptr_t)list.get());
+    } else
+        return compiler->addListContents(static_cast<List *>(list.get()));
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -194,3 +215,19 @@ CompilerValue *ListBlocks::compileListContainsItem(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &ListBlocks::listContentsMonitorName(Block *block)
+{
+    static const std::string empty = "";
+    auto field = block->fieldAt(block->findField("LIST"));
+
+    if (!field)
+        return empty;
+
+    List *list = dynamic_cast<List *>(field->valuePtr().get());
+
+    if (list)
+        return list->name();
+    else
+        return empty;
+}

src/blocks/listblocks.h

@@ -19,6 +19,7 @@ class ListBlocks : public IExtension
         void registerBlocks(IEngine *engine) override;
 
     private:
+        static CompilerValue *compileListContents(Compiler *compiler);
         static CompilerValue *compileAddToList(Compiler *compiler);
         static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list, CompilerValue *listSize);
         static CompilerValue *compileDeleteOfList(Compiler *compiler);
@@ -29,6 +30,8 @@ class ListBlocks : public IExtension
         static CompilerValue *compileItemNumOfList(Compiler *compiler);
         static CompilerValue *compileLengthOfList(Compiler *compiler);
         static CompilerValue *compileListContainsItem(Compiler *compiler);
+
+        static const std::string &listContentsMonitorName(Block *block);
 };
 
 } // namespace libscratchcpp

src/blocks/variableblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/variable.h>
@@ -28,9 +29,16 @@ Rgb VariableBlocks::color() const
 
 void VariableBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
     engine->addCompileFunction(this, "data_variable", &compileVariable);
     engine->addCompileFunction(this, "data_setvariableto", &compileSetVariableTo);
     engine->addCompileFunction(this, "data_changevariableby", &compileChangeVariableBy);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_variable", &variableMonitorName);
+
+    // Monitor change functions
+    engine->addMonitorChangeFunction(this, "data_variable", &changeVariableMonitorValue);
 }
 
 CompilerValue *VariableBlocks::compileVariable(Compiler *compiler)
@@ -70,3 +78,33 @@ CompilerValue *VariableBlocks::compileChangeVariableBy(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &VariableBlocks::variableMonitorName(Block *block)
+{
+    static const std::string empty = "";
+
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return empty;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        return var->name();
+    else
+        return empty;
+}
+
+void VariableBlocks::changeVariableMonitorValue(Block *block, const Value &newValue)
+{
+    auto field = block->fieldAt(block->findField("VARIABLE"));
+
+    if (!field)
+        return;
+
+    Variable *var = dynamic_cast<Variable *>(field->valuePtr().get());
+
+    if (var)
+        var->setValue(newValue);
+}

src/blocks/variableblocks.h

@@ -20,6 +20,9 @@ class VariableBlocks : public IExtension
         static CompilerValue *compileVariable(Compiler *compiler);
         static CompilerValue *compileSetVariableTo(Compiler *compiler);
         static CompilerValue *compileChangeVariableBy(Compiler *compiler);
+
+        static const std::string &variableMonitorName(Block *block);
+        static void changeVariableMonitorValue(Block *block, const Value &newValue);
 };
 
 } // namespace libscratchcpp