From 7d86ce280d47d3695b801f534138ee26bd631bed Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 18:27:24 +0200
Subject: [PATCH 1/3] Add API for unsupported blocks to Compiler

---
 include/scratchcpp/compiler.h   |  3 +++
 src/engine/compiler.cpp         | 12 +++++++++++-
 src/engine/compiler_p.h         |  3 +++
 test/compiler/compiler_test.cpp | 32 ++++++++++++++++++++++++++++++++
 4 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/include/scratchcpp/compiler.h b/include/scratchcpp/compiler.h
index a8b852bb..05ab0c7c 100644
--- a/include/scratchcpp/compiler.h
+++ b/include/scratchcpp/compiler.h
@@ -4,6 +4,7 @@
 
 #include <vector>
 #include <memory>
+#include <unordered_set>
 
 #include "global.h"
 #include "spimpl.h"
@@ -82,6 +83,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         BlockPrototype *procedurePrototype() const;
         void setProcedurePrototype(BlockPrototype *prototype);
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const;
+
     private:
         spimpl::unique_impl_ptr<CompilerPrivate> impl;
 };
diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
index 0f549af6..2ff823ba 100644
--- a/src/engine/compiler.cpp
+++ b/src/engine/compiler.cpp
@@ -66,8 +66,10 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
 
         if (impl->block->compileFunction())
             impl->block->compile(this);
-        else
+        else {
             std::cout << "warning: unsupported block: " << impl->block->opcode() << std::endl;
+            impl->unsupportedBlocks.insert(impl->block->opcode());
+        }
 
         if (substacks != impl->substackTree.size())
             continue;
@@ -186,6 +188,7 @@ void Compiler::addInput(Input *input)
                         impl->block->compile(this);
                     else {
                         std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                        impl->unsupportedBlocks.insert(impl->block->opcode());
                         addInstruction(OP_NULL);
                     }
                 } else
@@ -205,6 +208,7 @@ void Compiler::addInput(Input *input)
                     impl->block->compile(this);
                 else {
                     std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                    impl->unsupportedBlocks.insert(impl->block->opcode());
                     addInstruction(OP_NULL);
                 }
             } else
@@ -356,6 +360,12 @@ void Compiler::setProcedurePrototype(BlockPrototype *prototype)
     impl->procedurePrototype = prototype;
 }
 
+/*! Returns unsupported block opcodes which were found when compiling. */
+const std::unordered_set<std::string> &libscratchcpp::Compiler::unsupportedBlocks() const
+{
+    return impl->unsupportedBlocks;
+}
+
 /*! Returns the list of custom block prototypes. */
 const std::vector<std::string> &Compiler::procedures() const
 {
diff --git a/src/engine/compiler_p.h b/src/engine/compiler_p.h
index a310eb47..5a396a7a 100644
--- a/src/engine/compiler_p.h
+++ b/src/engine/compiler_p.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <unordered_set>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/inputvalue.h>
 
@@ -38,6 +39,8 @@ struct CompilerPrivate
         std::unordered_map<std::string, std::vector<std::string>> procedureArgs;
         BlockPrototype *procedurePrototype = nullptr;
         bool warp = false;
+
+        std::unordered_set<std::string> unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
index e4691a78..e4f3fea5 100644
--- a/test/compiler/compiler_test.cpp
+++ b/test/compiler/compiler_test.cpp
@@ -300,6 +300,7 @@ TEST_F(CompilerTest, AddObscuredInput)
 
     compiler.addInstruction(vm::OP_HALT);
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
 }
 
 TEST_F(CompilerTest, AddNoShadowInput)
@@ -328,6 +329,14 @@ TEST_F(CompilerTest, AddNoShadowInput)
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CHECKPOINT, vm::OP_NULL, vm::OP_PRINT, vm::OP_CONST, 0, vm::OP_NULL, vm::OP_PRINT, vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues().size(), 1);
     ASSERT_EQ(compiler.constValues()[0], "test");
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2" }));
+
+    Input input4("TEST_INPUT4", Input::Type::NoShadow);
+    std::shared_ptr<Block> block3 = std::make_shared<Block>("", "test_block3");
+    input4.setValueBlock(block3);
+    compiler.addInput(&input4);
+    compiler.addInstruction(vm::OP_PRINT);
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "test_block2", "test_block3" }));
 }
 
 TEST_F(CompilerTest, ResolveInput)
@@ -841,3 +850,26 @@ TEST_F(CompilerTest, EdgeActivatedHatPredicate)
     ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 1, vm::OP_PRINT, vm::OP_HALT }));
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ true, "test" }));
 }
+
+TEST_F(CompilerTest, UnsupportedBlocks)
+{
+    auto block1 = std::make_shared<Block>("b1", "block1");
+
+    auto block2 = std::make_shared<Block>("b2", "block2");
+    block2->setParent(block1);
+    block1->setNext(block2);
+
+    auto block3 = std::make_shared<Block>("b3", "block3");
+    block3->setCompileFunction([](Compiler *) {});
+    block3->setParent(block2);
+    block2->setNext(block3);
+
+    auto block4 = std::make_shared<Block>("b4", "block4");
+    block4->setParent(block3);
+    block3->setNext(block4);
+
+    INIT_COMPILER(engine, compiler);
+    compiler.compile(block1);
+
+    ASSERT_EQ(compiler.unsupportedBlocks(), std::unordered_set<std::string>({ "block1", "block2", "block4" }));
+}

From f3bc87ffa317a870f8b0233a60e7908773d7f5fa Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 19:09:10 +0200
Subject: [PATCH 2/3] Do not compile top level reporter blocks

There's no reason to support this yet
---
 src/engine/internal/engine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 216dc97b..64495178 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -265,7 +265,7 @@ void Engine::compile()
         Compiler compiler(this, target.get());
         const auto &blocks = target->blocks();
         for (auto block : blocks) {
-            if (block->topLevel() && !block->shadow()) {
+            if (block->topLevel() && !block->isTopLevelReporter() && !block->shadow()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
                     auto script = std::make_shared<Script>(target.get(), block, this);

From 6037520d3a6fb8ed2b1a6c0027d787ec5bddf760 Mon Sep 17 00:00:00 2001
From: adazem009 <68537469+adazem009@users.noreply.github.com>
Date: Fri, 23 Aug 2024 19:09:38 +0200
Subject: [PATCH 3/3] Add API for unsupported blocks to IEngine

---
 include/scratchcpp/iengine.h   |   4 ++++
 src/engine/internal/engine.cpp |  25 +++++++++++++++++++++++--
 src/engine/internal/engine.h   |   4 ++++
 test/engine/engine_test.cpp    |   9 +++++++++
 test/mocks/enginemock.h        |   2 ++
 test/unsupported_blocks.sb3    | Bin 0 -> 2106 bytes
 6 files changed, 42 insertions(+), 2 deletions(-)
 create mode 100644 test/unsupported_blocks.sb3

diff --git a/include/scratchcpp/iengine.h b/include/scratchcpp/iengine.h
index 2372d42c..aa5aac94 100644
--- a/include/scratchcpp/iengine.h
+++ b/include/scratchcpp/iengine.h
@@ -5,6 +5,7 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
+#include <unordered_set>
 #include <functional>
 
 #include "global.h"
@@ -390,6 +391,9 @@ class LIBSCRATCHCPP_EXPORT IEngine
 
         /*! Sets the user agent of the last person to edit the project. */
         virtual void setUserAgent(const std::string &agent) = 0;
+
+        /*! Returns the unsupported block opcodes which were found when compiling. */
+        virtual const std::unordered_set<std::string> &unsupportedBlocks() const = 0;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/internal/engine.cpp b/src/engine/internal/engine.cpp
index 64495178..9f321549 100644
--- a/src/engine/internal/engine.cpp
+++ b/src/engine/internal/engine.cpp
@@ -95,6 +95,8 @@ void Engine::clear()
     m_edgeActivatedHatValues.clear();
 
     m_running = false;
+
+    m_unsupportedBlocks.clear();
 }
 
 // Resolves ID references and sets pointers of entities.
@@ -280,8 +282,10 @@ void Engine::compile()
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
                         procedureBytecodeMap[b->mutationPrototype()->procCode()] = script->bytecode();
                     }
-                } else
+                } else {
                     std::cout << "warning: unsupported top level block: " << block->opcode() << std::endl;
+                    m_unsupportedBlocks.insert(block->opcode());
+                }
             }
         }
 
@@ -298,6 +302,11 @@ void Engine::compile()
                 m_scripts[block]->setLists(compiler.lists());
             }
         }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 
     // Compile monitor blocks to bytecode
@@ -343,8 +352,15 @@ void Engine::compile()
             script->setConstValues(compiler.constValues());
             script->setVariables(compiler.variables());
             script->setLists(compiler.lists());
-        } else
+        } else {
             std::cout << "warning: unsupported monitor block: " << block->opcode() << std::endl;
+            m_unsupportedBlocks.insert(block->opcode());
+        }
+
+        const auto &unsupportedBlocks = compiler.unsupportedBlocks();
+
+        for (const std::string &opcode : unsupportedBlocks)
+            m_unsupportedBlocks.insert(opcode);
     }
 }
 
@@ -1622,6 +1638,11 @@ void Engine::setUserAgent(const std::string &agent)
     m_userAgent = agent;
 }
 
+const std::unordered_set<std::string> &Engine::unsupportedBlocks() const
+{
+    return m_unsupportedBlocks;
+}
+
 void Engine::finalize()
 {
     m_eventLoopMutex.lock();
diff --git a/src/engine/internal/engine.h b/src/engine/internal/engine.h
index d04f71f3..48a49708 100644
--- a/src/engine/internal/engine.h
+++ b/src/engine/internal/engine.h
@@ -168,6 +168,8 @@ class Engine : public IEngine
         const std::string &userAgent() const override;
         void setUserAgent(const std::string &agent) override;
 
+        const std::unordered_set<std::string> &unsupportedBlocks() const override;
+
         IClock *m_clock = nullptr;
         IAudioEngine *m_audioEngine = nullptr;
 
@@ -287,6 +289,8 @@ class Engine : public IEngine
         sigslot::signal<const std::string &> m_questionAsked;
         sigslot::signal<> m_questionAborted;
         sigslot::signal<const std::string &> m_questionAnswered;
+
+        std::unordered_set<std::string> m_unsupportedBlocks;
 };
 
 } // namespace libscratchcpp
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
index 0d828a1b..a5cb7961 100644
--- a/test/engine/engine_test.cpp
+++ b/test/engine/engine_test.cpp
@@ -2133,6 +2133,15 @@ TEST(EngineTest, UserAgent)
     ASSERT_EQ(engine.userAgent(), "test");
 }
 
+TEST(EngineTest, UnsupportedBlocks)
+{
+    Project p("unsupported_blocks.sb3");
+    ASSERT_TRUE(p.load());
+    ASSERT_EQ(
+        p.engine()->unsupportedBlocks(),
+        std::unordered_set<std::string>({ "ev3_motorTurnClockwise", "ev3_motorSetPower", "ev3_getMotorPosition", "ev3_whenButtonPressed", "ev3_getBrightness", "ev3_getDistance" }));
+}
+
 TEST(EngineTest, NoCrashAfterStop)
 {
     // Regtest for #186
diff --git a/test/mocks/enginemock.h b/test/mocks/enginemock.h
index c64691f6..deddb32f 100644
--- a/test/mocks/enginemock.h
+++ b/test/mocks/enginemock.h
@@ -144,6 +144,8 @@ class EngineMock : public IEngine
 
         MOCK_METHOD(const std::string &, userAgent, (), (const, override));
         MOCK_METHOD(void, setUserAgent, (const std::string &), (override));
+
+        MOCK_METHOD(const std::unordered_set<std::string> &, unsupportedBlocks, (), (const, override));
 };
 
 } // namespace libscratchcpp
diff --git a/test/unsupported_blocks.sb3 b/test/unsupported_blocks.sb3
new file mode 100644
index 0000000000000000000000000000000000000000..7098a6541e5407b4cd03d024d87b350443ce34ee
GIT binary patch
literal 2106
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
bJs|!6^Bzlc{)0^b0CbS42Q^3V-`&3e4sy|z

literal 0
HcmV?d00001