Add API for compiling blocks without using Compiler::compile()

Author: adazem009

include/scratchcpp/compiler.h

@@ -37,7 +37,9 @@ class LIBSCRATCHCPP_EXPORT Compiler
         Compiler(IEngine *engine);
         Compiler(const Compiler &) = delete;
 
+        void init();
         void compile(std::shared_ptr<Block> topLevelBlock);
+        void end();
 
         const std::vector<unsigned int> &bytecode() const;
 
@@ -73,6 +75,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         const std::vector<std::string> &procedures() const;
 
         const std::shared_ptr<Block> &block() const;
+        void setBlock(std::shared_ptr<Block> block);
 
         BlockPrototype *procedurePrototype() const;
         void setProcedurePrototype(BlockPrototype *prototype);

src/engine/compiler.cpp

@@ -20,9 +20,12 @@ Compiler::Compiler(IEngine *engine) :
 {
 }
 
-/*! Compiles the script. Use bytecode() to read the generated bytecode. */
-void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
+/*! Initializes the Compiler. Useful if you don't use compile(). */
+void Compiler::init()
 {
+    if (impl->initialized)
+        return;
+
     impl->bytecode.clear();
     impl->procedurePrototype = nullptr;
     impl->atomic = true;
@@ -31,6 +34,14 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
     // Add start instruction
     addInstruction(OP_START);
 
+    impl->initialized = true;
+}
+
+/*! Compiles the script. Use bytecode() to read the generated bytecode. */
+void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
+{
+    init();
+
     impl->block = topLevelBlock;
     while (impl->block) {
         size_t substacks = impl->substackTree.size();
@@ -50,8 +61,19 @@ void Compiler::compile(std::shared_ptr<Block> topLevelBlock)
             impl->substackEnd();
     }
 
+    end();
+}
+
+/*! Finalizes the bytecode. Useful if you don't use compile(). */
+void Compiler::end()
+{
+    if (!impl->initialized)
+        return;
+
     // Add end instruction (halt)
     addInstruction(OP_HALT);
+
+    impl->initialized = false;
 }
 
 /*! Returns the generated bytecode. */
@@ -308,3 +330,9 @@ const std::shared_ptr<Block> &Compiler::block() const
 {
     return impl->block;
 }
+
+/*! Sets the current block. Useful if you don't use compile(). */
+void Compiler::setBlock(std::shared_ptr<Block> block)
+{
+    impl->block = block;
+}

src/engine/compiler_p.h

@@ -19,6 +19,8 @@ struct CompilerPrivate
         std::shared_ptr<Block> block;
         std::vector<std::pair<std::pair<std::shared_ptr<Block>, std::shared_ptr<Block>>, Compiler::SubstackType>> substackTree;
 
+        bool initialized = false;
+
         std::vector<unsigned int> bytecode;
         std::vector<InputValue *> constValues;
         std::vector<Variable *> variables;

test/compiler/compiler_test.cpp

@@ -48,6 +48,57 @@ TEST_F(CompilerTest, Constructors)
     ASSERT_EQ(compiler.engine(), &engine);
 }
 
+TEST_F(CompilerTest, Block)
+{
+    Engine engine;
+    Compiler compiler(&engine);
+    ASSERT_EQ(compiler.block(), nullptr);
+    auto block = std::make_shared<Block>("", "");
+    compiler.setBlock(block);
+    ASSERT_EQ(compiler.block(), block);
+}
+
+TEST_F(CompilerTest, Init)
+{
+    Engine engine;
+    Compiler compiler(&engine);
+    ASSERT_TRUE(compiler.bytecode().empty());
+
+    BlockPrototype prototype;
+    compiler.setProcedurePrototype(&prototype);
+    compiler.init();
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START }));
+    ASSERT_EQ(compiler.procedurePrototype(), nullptr);
+
+    compiler.setProcedurePrototype(&prototype);
+    compiler.init();
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START }));
+    ASSERT_EQ(compiler.procedurePrototype(), &prototype);
+}
+
+TEST_F(CompilerTest, End)
+{
+    Engine engine;
+    Compiler compiler(&engine);
+    ASSERT_TRUE(compiler.bytecode().empty());
+
+    compiler.end();
+    ASSERT_TRUE(compiler.bytecode().empty());
+
+    compiler.init();
+    compiler.end();
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+    compiler.end();
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+
+    compiler.init();
+    compiler.init();
+    compiler.end();
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_HALT }));
+
+    compiler.init();
+}
+
 TEST_F(CompilerTest, ConstValues)
 {
     InputValue v1;