Add API for unsupported blocks

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;
 };

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

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
 {

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

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.
@@ -265,7 +267,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);
@@ -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();

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

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" }));
+}

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

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