Get functions from engine in Script

Author: adazem009

include/scratchcpp/script.h

@@ -38,7 +38,6 @@ class LIBSCRATCHCPP_EXPORT Script
         bool runHatPredicate();
 
         void setProcedures(const std::vector<unsigned int *> &procedures);
-        void setFunctions(const std::vector<BlockFunc> &functions);
         void setConstValues(const std::vector<Value> &values);
         void setVariables(const std::vector<Variable *> &variables);
         void setLists(const std::vector<List *> &lists);
@@ -47,6 +46,8 @@ class LIBSCRATCHCPP_EXPORT Script
         std::shared_ptr<VirtualMachine> start(Target *target);
 
     private:
+        BlockFunc *getFunctions() const;
+
         spimpl::unique_impl_ptr<ScriptPrivate> impl;
 };
 

src/engine/internal/engine.cpp

@@ -244,7 +244,6 @@ void Engine::compile()
 
         for (auto block : blocks) {
             if (m_scripts.count(block) == 1) {
-                m_scripts[block]->setFunctions(m_functions);
                 m_scripts[block]->setProcedures(procedureBytecodes);
                 m_scripts[block]->setConstValues(compiler.constValues());
                 m_scripts[block]->setVariables(compiler.variables());
@@ -293,7 +292,6 @@ void Engine::compile()
             compiler.end();
 
             script->setBytecode(compiler.bytecode());
-            script->setFunctions(m_functions);
             script->setConstValues(compiler.constValues());
             script->setVariables(compiler.variables());
             script->setLists(compiler.lists());

src/engine/script.cpp

@@ -57,7 +57,6 @@ void Script::setHatPredicateBytecode(const std::vector<unsigned int> &code)
     if (impl->engine && !code.empty()) {
         impl->hatPredicateVm = std::make_shared<VirtualMachine>(impl->engine->stage(), impl->engine, this);
         impl->hatPredicateVm->setBytecode(impl->hatPredicateBytecodeVector.data());
-        impl->hatPredicateVm->setFunctions(impl->functions);
         impl->hatPredicateVm->setConstValues(impl->constValues);
     }
 }
@@ -70,6 +69,7 @@ bool Script::runHatPredicate()
 {
     if (impl->hatPredicateVm && impl->hatPredicateVm->bytecode()) {
         impl->hatPredicateVm->reset();
+        impl->hatPredicateVm->setFunctions(getFunctions());
         impl->hatPredicateVm->run();
         assert(impl->hatPredicateVm->registerCount() == 1);
 
@@ -92,14 +92,14 @@ std::shared_ptr<VirtualMachine> Script::start(Target *target)
     auto vm = std::make_shared<VirtualMachine>(target, impl->engine, this);
     vm->setBytecode(impl->bytecode);
     vm->setProcedures(impl->procedures);
-    vm->setFunctions(impl->functions);
+    vm->setFunctions(getFunctions());
     vm->setConstValues(impl->constValues);
 
     Sprite *sprite = nullptr;
     if (target && !target->isStage())
         sprite = dynamic_cast<Sprite *>(target);
 
-    if (impl->target && sprite && sprite->isClone() && impl->engine) {
+    if (impl->target && sprite && sprite->isClone()) {
         Target *root = sprite->cloneSprite();
 
         if (root != impl->target) {
@@ -156,16 +156,6 @@ void Script::setProcedures(const std::vector<unsigned int *> &procedures)
     impl->procedures = impl->proceduresVector.data();
 }
 
-/*! Sets the list of functions. */
-void Script::setFunctions(const std::vector<BlockFunc> &functions)
-{
-    impl->functionsVector = functions;
-    impl->functions = impl->functionsVector.data();
-
-    if (impl->hatPredicateVm)
-        impl->hatPredicateVm->setFunctions(impl->functions);
-}
-
 /*! Sets the list of constant values. */
 void Script::setConstValues(const std::vector<Value> &values)
 {
@@ -191,3 +181,11 @@ void Script::setLists(const std::vector<List *> &lists)
 {
     impl->lists = lists;
 }
+
+BlockFunc *Script::getFunctions() const
+{
+    if (impl->engine)
+        return const_cast<BlockFunc *>(impl->engine->blockFunctions().data());
+
+    return nullptr;
+}

src/engine/script_p.h

@@ -33,9 +33,6 @@ struct ScriptPrivate
         unsigned int **procedures = nullptr;
         std::vector<unsigned int *> proceduresVector;
 
-        BlockFunc *functions = nullptr;
-        std::vector<BlockFunc> functionsVector;
-
         const Value *constValues = nullptr;
         std::vector<Value> constValuesVector;
 

test/script/script_test.cpp

@@ -12,6 +12,7 @@
 using namespace libscratchcpp;
 
 using ::testing::Return;
+using ::testing::ReturnRef;
 using ::testing::_;
 
 class ScriptTest : public testing::Test
@@ -73,10 +74,13 @@ TEST_F(ScriptTest, HatPredicate)
         return 0;
     };
 
+    std::vector<BlockFunc> functions1 = { f1 };
+    std::vector<BlockFunc> functions2 = { f1, f2, f3 };
+
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions1));
     stageTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
-    script.setFunctions({ f1 });
     script.setConstValues({ "test" });
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 0, vm::OP_HALT });
     testing::internal::CaptureStdout();
@@ -86,11 +90,11 @@ TEST_F(ScriptTest, HatPredicate)
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
     stageTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
     script.setHatPredicateBytecode({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_EXEC, 1, vm::OP_HALT });
-    script.setFunctions({ f1, f2, f3 });
     script.setConstValues({ 5 });
     testing::internal::CaptureStdout();
     ASSERT_TRUE(script.runHatPredicate());
@@ -99,6 +103,7 @@ TEST_F(ScriptTest, HatPredicate)
     ASSERT_EQ(engineTest, &m_engine);
     ASSERT_EQ(scriptTest, &script);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions2));
     stageTest = nullptr;
     engineTest = nullptr;
     scriptTest = nullptr;
@@ -119,6 +124,7 @@ TEST_F(ScriptTest, Start)
     static std::vector<unsigned int> bytecode = { vm::OP_START, vm::OP_HALT };
     static std::vector<unsigned int *> procedures = { bytecode.data() };
     static std::vector<BlockFunc> functions = { &testFunction };
+    static std::vector<BlockFunc> noFunctions;
     static std::vector<Value> constValues = { "test" };
 
     std::shared_ptr<Variable> var1 = std::make_unique<Variable>("a", "", Value());
@@ -144,6 +150,7 @@ TEST_F(ScriptTest, Start)
 
     Script script2(&m_target, nullptr, &m_engine);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(noFunctions));
     vm = script2.start();
     ASSERT_TRUE(vm);
     ASSERT_EQ(vm->target(), &m_target);
@@ -152,11 +159,11 @@ TEST_F(ScriptTest, Start)
     Script script3(&m_target, nullptr, &m_engine);
     script3.setBytecode(bytecode);
     script3.setProcedures(procedures);
-    script3.setFunctions(functions);
     script3.setConstValues(constValues);
     script3.setVariables(variables);
     script3.setLists(lists);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
     vm = script3.start();
     ASSERT_TRUE(vm);
     ASSERT_EQ(vm->bytecode()[0], bytecode[0]);
@@ -166,6 +173,7 @@ TEST_F(ScriptTest, Start)
     ASSERT_EQ(vm->variables()[0], variables[0]->valuePtr());
     ASSERT_EQ(vm->lists()[0], lists[0]);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
     Target target;
     target.addVariable(var1);
     target.addList(list1);
@@ -194,11 +202,11 @@ TEST_F(ScriptTest, Start)
     Script script4(&root, nullptr, &m_engine);
     script4.setBytecode(bytecode);
     script4.setProcedures(procedures);
-    script4.setFunctions(functions);
     script4.setConstValues(constValues);
     script4.setVariables(variables);
     script4.setLists(lists);
 
+    EXPECT_CALL(m_engine, blockFunctions()).WillOnce(ReturnRef(functions));
     vm = script4.start(clone.get());
 
     ASSERT_TRUE(vm);