Add addConstValue method to Compiler

Author: adazem009

include/scratchcpp/compiler.h

@@ -56,6 +56,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void addInstruction(vm::Opcode opcode, const std::initializer_list<unsigned int> &args = {});
         void addInput(Input *input);
         void addInput(int id);
+        void addConstValue(const Value &value);
         void addFunctionCall(BlockFunc f);
         void addProcedureArg(const std::string &procCode, const std::string &argName);
         void moveToSubstack(std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2, SubstackType type);

src/engine/compiler.cpp

@@ -3,7 +3,6 @@
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/input.h>
-#include <scratchcpp/inputvalue.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
@@ -189,6 +188,14 @@ void Compiler::addInput(int id)
     addInput(input(id));
 }
 
+/*! Adds a constant value and an instruction to load it. Useful if you don't have an input for the addInput() method. */
+void libscratchcpp::Compiler::addConstValue(const Value &value)
+{
+    impl->customConstValues.push_back(std::make_unique<InputValue>());
+    impl->customConstValues.back()->setValue(value);
+    addInstruction(OP_CONST, { impl->constIndex(impl->customConstValues.back().get()) });
+}
+
 /*! Adds a function call to the bytecode (the OP_EXEC instruction). */
 void Compiler::addFunctionCall(BlockFunc f)
 {

src/engine/compiler_p.h

@@ -3,13 +3,15 @@
 #pragma once
 
 #include <scratchcpp/compiler.h>
+#include <scratchcpp/inputvalue.h>
 
 namespace libscratchcpp
 {
 
 struct CompilerPrivate
 {
         CompilerPrivate(IEngine *engine);
+        CompilerPrivate(const CompilerPrivate &) = delete;
 
         void addInstruction(vm::Opcode opcode, std::initializer_list<unsigned int> args = {});
 
@@ -25,6 +27,7 @@ struct CompilerPrivate
 
         std::vector<unsigned int> bytecode;
         std::vector<InputValue *> constValues;
+        std::vector<std::unique_ptr<InputValue>> customConstValues;
         std::unordered_map<InputValue *, std::pair<bool, std::string>> constValueMenuInfo; // input value, <whether the input points to a dropdown menu, selected menu item>
         std::vector<Variable *> variables;
         std::vector<List *> lists;

test/compiler/compiler_test.cpp

@@ -365,6 +365,27 @@ TEST_F(CompilerTest, ResolveDropdownMenuInput)
     ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
 }
 
+TEST_F(CompilerTest, AddConstValue)
+{
+    INIT_COMPILER(engine, compiler);
+    compiler.addInstruction(vm::OP_START);
+
+    compiler.addConstValue(50);
+    compiler.addInstruction(vm::OP_PRINT);
+    compiler.addConstValue(50);
+    compiler.addInstruction(vm::OP_PRINT);
+    compiler.addConstValue("hello");
+    compiler.addInstruction(vm::OP_PRINT);
+    compiler.addConstValue("world");
+    compiler.addInstruction(vm::OP_PRINT);
+
+    compiler.addInstruction(vm::OP_HALT);
+    ASSERT_EQ(
+        compiler.bytecode(),
+        std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_CONST, 1, vm::OP_PRINT, vm::OP_CONST, 2, vm::OP_PRINT, vm::OP_CONST, 3, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 50, 50, "hello", "world" }));
+}
+
 TEST_F(CompilerTest, ResolveField)
 {
     INIT_COMPILER(engine, compiler);