Compiler: Make addInput(Input*) public

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -63,6 +63,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *addListContains(List *list, CompilerValue *item);
         CompilerValue *addListSize(List *list);
         CompilerValue *addInput(const std::string &name);
+        CompilerValue *addInput(Input *input);
 
         CompilerValue *createAdd(CompilerValue *operand1, CompilerValue *operand2);
         CompilerValue *createSub(CompilerValue *operand1, CompilerValue *operand2);
@@ -137,8 +138,6 @@ class LIBSCRATCHCPP_EXPORT Compiler
         static std::shared_ptr<CompilerContext> createContext(IEngine *engine, Target *target);
 
     private:
-        CompilerValue *addInput(Input *input);
-
         spimpl::unique_impl_ptr<CompilerPrivate> impl;
 };
 

src/dev/engine/compiler.cpp

@@ -182,6 +182,62 @@ CompilerValue *Compiler::addInput(const std::string &name)
     return addInput(impl->block->inputAt(impl->block->findInput(name)).get());
 }
 
+/*! Compiles the given input and adds it to the compiled code. */
+CompilerValue *Compiler::addInput(Input *input)
+{
+    if (!input)
+        return addConstValue(Value());
+
+    switch (input->type()) {
+        case Input::Type::Shadow:
+        case Input::Type::NoShadow: {
+            if (input->pointsToDropdownMenu())
+                return addConstValue(input->selectedMenuItem());
+            else {
+                CompilerValue *ret = nullptr;
+                auto previousBlock = impl->block;
+                impl->block = input->valueBlock();
+
+                if (impl->block) {
+                    if (impl->block->compileFunction())
+                        ret = impl->block->compile(this);
+                    else {
+                        std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                        impl->unsupportedBlocks.insert(impl->block->opcode());
+                        ret = addConstValue(Value());
+                    }
+                } else
+                    ret = addConstValue(input->primaryValue()->value());
+
+                impl->block = previousBlock;
+                return ret;
+            }
+        }
+
+        case Input::Type::ObscuredShadow: {
+            CompilerValue *ret = nullptr;
+            auto previousBlock = impl->block;
+            impl->block = input->valueBlock();
+
+            if (impl->block) {
+                if (impl->block->compileFunction())
+                    ret = impl->block->compile(this);
+                else {
+                    std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
+                    impl->unsupportedBlocks.insert(impl->block->opcode());
+                    ret = addConstValue(Value());
+                }
+            } else
+                ret = input->primaryValue()->compile(this);
+
+            impl->block = previousBlock;
+            return ret;
+        }
+    }
+
+    return nullptr;
+}
+
 /*! Creates an add instruction. */
 CompilerValue *Compiler::createAdd(CompilerValue *operand1, CompilerValue *operand2)
 {
@@ -583,58 +639,3 @@ std::shared_ptr<CompilerContext> Compiler::createContext(IEngine *engine, Target
     CompilerPrivate::initBuilderFactory();
     return CompilerPrivate::builderFactory->createCtx(engine, target);
 }
-
-CompilerValue *Compiler::addInput(Input *input)
-{
-    if (!input)
-        return addConstValue(Value());
-
-    switch (input->type()) {
-        case Input::Type::Shadow:
-        case Input::Type::NoShadow: {
-            if (input->pointsToDropdownMenu())
-                return addConstValue(input->selectedMenuItem());
-            else {
-                CompilerValue *ret = nullptr;
-                auto previousBlock = impl->block;
-                impl->block = input->valueBlock();
-
-                if (impl->block) {
-                    if (impl->block->compileFunction())
-                        ret = impl->block->compile(this);
-                    else {
-                        std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
-                        impl->unsupportedBlocks.insert(impl->block->opcode());
-                        ret = addConstValue(Value());
-                    }
-                } else
-                    ret = addConstValue(input->primaryValue()->value());
-
-                impl->block = previousBlock;
-                return ret;
-            }
-        }
-
-        case Input::Type::ObscuredShadow: {
-            CompilerValue *ret = nullptr;
-            auto previousBlock = impl->block;
-            impl->block = input->valueBlock();
-
-            if (impl->block) {
-                if (impl->block->compileFunction())
-                    ret = impl->block->compile(this);
-                else {
-                    std::cout << "warning: unsupported reporter block: " << impl->block->opcode() << std::endl;
-                    impl->unsupportedBlocks.insert(impl->block->opcode());
-                    ret = addConstValue(Value());
-                }
-            } else
-                ret = input->primaryValue()->compile(this);
-
-            impl->block = previousBlock;
-            return ret;
-        }
-    }
-
-    return nullptr;
-}

test/dev/compiler/compiler_test.cpp

@@ -418,10 +418,10 @@ TEST_F(CompilerTest, AddInput)
         EXPECT_EQ(compiler->addInput("OBSCURED_SHADOW"), &constRet);
 
         EXPECT_CALL(*m_builder, addVariableValue(m_testVar.get())).WillOnce(Return(&ret));
-        EXPECT_EQ(compiler->addInput("OBSCURED_SHADOW_VARIABLE"), &ret);
+        EXPECT_EQ(compiler->addInput(compiler->input("OBSCURED_SHADOW_VARIABLE")), &ret);
 
         EXPECT_CALL(*m_builder, addConstValue(Value("value block"))).WillOnce(Return(&constRet));
-        EXPECT_EQ(compiler->addInput("OBSCURED_SHADOW_BLOCK"), &constRet);
+        EXPECT_EQ(compiler->addInput(compiler->input("OBSCURED_SHADOW_BLOCK")), &constRet);
 
         return nullptr;
     });