Use Compiler for whole targets

Author: adazem009

src/engine/compiler.cpp

@@ -9,20 +9,19 @@ using namespace libscratchcpp;
 using namespace vm;
 
 /*! Constructs Compiler. */
-Compiler::Compiler(Engine *engine, std::shared_ptr<Block> topLevelBlock) :
-    m_engine(engine),
-    m_block(topLevelBlock)
+Compiler::Compiler(Engine *engine) :
+    m_engine(engine)
 {
     assert(engine);
-    assert(topLevelBlock);
 }
 
 /*! Compiles the script. Use bytecode() to read the generated bytecode. */
-void Compiler::compile()
+void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
 {
     // Add start instruction
     addInstruction(OP_START);
 
+    m_block = topLevelBlock;
     while (m_block) {
         size_t substacks = m_substackTree.size();
 
@@ -66,12 +65,6 @@ std::vector<Value> Compiler::constValues() const
     return ret;
 }
 
-/*! Sets the list of constant input values. */
-void Compiler::setConstInputValues(const std::vector<InputValue *> &values)
-{
-    m_constValues = values;
-}
-
 /*! Returns the list of variables. */
 const std::vector<Variable *> &Compiler::variables() const
 {
@@ -87,24 +80,12 @@ std::vector<Value *> Compiler::variablePtrs() const
     return ret;
 }
 
-/*! Sets the list of variables. */
-void Compiler::setVariables(std::vector<Variable *> variables)
-{
-    m_variables = variables;
-}
-
 /*! Returns the list of lists. */
 const std::vector<List *> &Compiler::lists() const
 {
     return m_lists;
 }
 
-/*! Sets the list of lists. */
-void Compiler::setLists(std::vector<List *> lists)
-{
-    m_lists = lists;
-}
-
 /*! Adds an instruction to the bytecode. */
 void Compiler::addInstruction(Opcode opcode, std::initializer_list<unsigned int> args)
 {
@@ -268,12 +249,6 @@ const std::vector<std::string> &Compiler::procedures() const
     return m_procedures;
 }
 
-/*! Sets the list of custom block prototypes. */
-void Compiler::setProcedures(const std::vector<std::string> &newProcedures)
-{
-    m_procedures = newProcedures;
-}
-
 /*! Returns the current block. */
 const std::shared_ptr<Block> &Compiler::block() const
 {

src/engine/compiler.h

@@ -8,7 +8,7 @@
 namespace libscratchcpp
 {
 
-/*! \brief The Compiler class provides an API for compiling Scratch scripts to bytecode. */
+/*! \brief The Compiler class provides an API for compiling scripts of targets to bytecode. */
 class LIBSCRATCHCPP_EXPORT Compiler
 {
     public:
@@ -18,23 +18,20 @@ class LIBSCRATCHCPP_EXPORT Compiler
             IfStatement
         };
 
-        Compiler(Engine *engine, std::shared_ptr<Block> topLevelBlock);
+        Compiler(Engine *engine);
         Compiler(const Compiler &) = delete;
 
-        void compile();
+        void compile(std::shared_ptr<Block> topLevelBlock);
 
         const std::vector<unsigned int> &bytecode() const;
 
         const std::vector<InputValue *> &constInputValues() const;
         std::vector<Value> constValues() const;
-        void setConstInputValues(const std::vector<InputValue *> &values);
 
         const std::vector<Variable *> &variables() const;
         std::vector<Value *> variablePtrs() const;
-        void setVariables(std::vector<Variable *> variables);
 
         const std::vector<List *> &lists() const;
-        void setLists(std::vector<List *> lists);
 
         void addInstruction(vm::Opcode opcode, std::initializer_list<unsigned int> args = {});
         void addInput(int id);
@@ -51,7 +48,6 @@ class LIBSCRATCHCPP_EXPORT Compiler
         unsigned int procedureIndex(std::string proc);
 
         const std::vector<std::string> &procedures() const;
-        void setProcedures(const std::vector<std::string> &newProcedures);
 
         const std::shared_ptr<Block> &block() const;
 

src/engine/engine.cpp

@@ -69,32 +69,20 @@ void Engine::compile()
     // Compile scripts to bytecode
     for (auto target : m_targets) {
         std::cout << "Compiling scripts in target " << target->name() << "..." << std::endl;
-        std::vector<Variable *> variables;
-        std::vector<List *> lists;
-        std::vector<InputValue *> constInputValues;
-        std::vector<std::string> procedures;
         std::unordered_map<std::string, unsigned int *> procedureBytecodeMap;
+        Compiler compiler(this);
         auto blocks = target->blocks();
         for (auto block : blocks) {
             if (block->topLevel()) {
                 auto section = blockSection(block->opcode());
                 if (section) {
-                    Compiler compiler(this, block);
-                    compiler.setConstInputValues(constInputValues);
-                    compiler.setVariables(variables);
-                    compiler.setLists(lists);
-                    compiler.setProcedures(procedures);
-                    compiler.compile();
-                    variables = compiler.variables();
-                    lists = compiler.lists();
-                    constInputValues = compiler.constInputValues();
-                    procedures = compiler.procedures();
+                    compiler.compile(block);
 
                     auto vm = std::make_shared<VirtualMachine>(target.get(), this);
                     vm->setFunctions(m_functions);
                     vm->setConstValues(compiler.constValues());
                     vm->setVariables(compiler.variablePtrs());
-                    vm->setLists(lists);
+                    vm->setLists(compiler.lists());
                     vm->setBytecode(compiler.bytecode());
                     if (block->opcode() == "procedures_definition") {
                         auto b = block->inputAt(block->findInput("custom_block"))->valueBlock();
@@ -106,6 +94,7 @@ void Engine::compile()
             }
         }
 
+        const std::vector<std::string> &procedures = compiler.procedures();
         std::vector<unsigned int *> procedureBytecodes;
         for (const std::string &code : procedures)
             procedureBytecodes.push_back(procedureBytecodeMap[code]);