Compile selected items in dropdown menus

Author: adazem009

src/engine/compiler.cpp

@@ -98,8 +98,14 @@ const std::vector<InputValue *> &Compiler::constInputValues() const
 std::vector<Value> Compiler::constValues() const
 {
     std::vector<Value> ret;
-    for (auto value : impl->constValues)
-        ret.push_back(value->value());
+    for (auto value : impl->constValues) {
+        const auto &menuInfo = impl->constValueMenuInfo.at(value);
+
+        if (menuInfo.first)
+            ret.push_back(menuInfo.second);
+        else
+            ret.push_back(value->value());
+    }
     return ret;
 }
 
@@ -139,7 +145,10 @@ void Compiler::addInput(Input *input)
     }
     switch (input->type()) {
         case Input::Type::Shadow:
-            addInstruction(OP_CONST, { constIndex(input->primaryValue()) });
+            if (input->pointsToDropdownMenu())
+                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue(), true, input->selectedMenuItem()) });
+            else
+                addInstruction(OP_CONST, { impl->constIndex(input->primaryValue()) });
             break;
 
         case Input::Type::NoShadow: {
@@ -275,11 +284,7 @@ unsigned int Compiler::listIndex(std::shared_ptr<Entity> listEntity)
 /*! Returns the index of the given constant input value. */
 unsigned int Compiler::constIndex(InputValue *value)
 {
-    auto it = std::find(impl->constValues.begin(), impl->constValues.end(), value);
-    if (it != impl->constValues.end())
-        return it - impl->constValues.begin();
-    impl->constValues.push_back(value);
-    return impl->constValues.size() - 1;
+    return impl->constIndex(value);
 }
 
 /*! Returns the index of the procedure code of the given block. */

src/engine/compiler_p.cpp

@@ -20,6 +20,16 @@ void CompilerPrivate::addInstruction(vm::Opcode opcode, std::initializer_list<un
         bytecode.push_back(arg);
 }
 
+unsigned int CompilerPrivate::constIndex(InputValue *value, bool pointsToDropdownMenu, const std::string &selectedMenuItem)
+{
+    auto it = std::find(constValues.begin(), constValues.end(), value);
+    if (it != constValues.end())
+        return it - constValues.begin();
+    constValues.push_back(value);
+    constValueMenuInfo[value] = { pointsToDropdownMenu, selectedMenuItem };
+    return constValues.size() - 1;
+}
+
 void CompilerPrivate::substackEnd()
 {
     auto parent = substackTree.back();

src/engine/compiler_p.h

@@ -13,6 +13,8 @@ struct CompilerPrivate
 
         void addInstruction(vm::Opcode opcode, std::initializer_list<unsigned int> args = {});
 
+        unsigned int constIndex(InputValue *value, bool pointsToDropdownMenu = false, const std::string &selectedMenuItem = "");
+
         void substackEnd();
 
         IEngine *engine;
@@ -23,6 +25,7 @@ struct CompilerPrivate
 
         std::vector<unsigned int> bytecode;
         std::vector<InputValue *> constValues;
+        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;
         std::vector<std::string> procedures;

test/compiler/compiler_test.cpp

@@ -329,11 +329,32 @@ TEST_F(CompilerTest, ResolveInput)
     engine.registerSection(m_section);
 
     auto block = std::make_shared<Block>("a", "test_block1");
-    auto reporter = std::make_shared<Block>("a", "test_reporter");
     auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
     input->setPrimaryValue("test");
     input->setInputId(TestBlockSection::INPUT1);
-    input->setValueBlock(reporter);
+    block->addInput(input);
+    block->updateInputMap();
+    block->setCompileFunction(&TestBlockSection::compileTestBlock1);
+
+    compiler.compile(block);
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_CONST, 0, vm::OP_PRINT, vm::OP_HALT }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ "test" }));
+}
+
+TEST_F(CompilerTest, ResolveDropdownMenuInput)
+{
+    INIT_COMPILER(engine, compiler);
+
+    engine.registerSection(m_section);
+
+    auto block = std::make_shared<Block>("a", "test_block1");
+    auto input = std::make_shared<Input>("INPUT1", Input::Type::Shadow);
+    auto menu = std::make_shared<Block>("a", "test_menu");
+    auto optionField = std::make_shared<Field>("OPTION", "test");
+    input->setInputId(TestBlockSection::INPUT1);
+    input->setValueBlock(menu);
+    menu->addField(optionField);
     block->addInput(input);
     block->updateInputMap();
     block->setCompileFunction(&TestBlockSection::compileTestBlock1);