Compile obscured inputs

Author: adazem009

src/engine/compiler.cpp

@@ -126,13 +126,31 @@ void Compiler::addInput(int id)
             addInstruction(OP_CONST, { constIndex(in->primaryValue()) });
             break;
 
-        case Input::Type::NoShadow:
-            addInstruction(OP_NULL);
+        case Input::Type::NoShadow: {
+            auto previousBlock = m_block;
+            m_block = in->valueBlock();
+            assert(m_block);
+            if (m_block->compileFunction())
+                m_block->compile(this);
+            else
+                std::cout << "warning: unsupported reporter block: " << m_block->opcode() << std::endl;
+            m_block = previousBlock;
             break;
-
-        case Input::Type::ObscuredShadow:
-            // TODO
+        }
+
+        case Input::Type::ObscuredShadow: {
+            auto previousBlock = m_block;
+            m_block = in->valueBlock();
+            if (m_block) {
+                if (m_block->compileFunction())
+                    m_block->compile(this);
+                else
+                    std::cout << "warning: unsupported reporter block: " << m_block->opcode() << std::endl;
+            } else
+                in->primaryValue()->compile(this);
+            m_block = previousBlock;
             break;
+        }
     }
 }
 

src/engine/compiler.h

@@ -47,9 +47,9 @@ class LIBSCRATCHCPP_EXPORT Compiler
         std::shared_ptr<Block> inputBlock(int id) const;
         unsigned int variableIndex(std::shared_ptr<IEntity> varEntity);
         unsigned int listIndex(std::shared_ptr<IEntity> listEntity);
+        unsigned int constIndex(InputValue *value);
 
     private:
-        unsigned int constIndex(InputValue *value);
         void substackEnd();
 
         Engine *m_engine;

src/scratch/inputvalue.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "inputvalue.h"
+#include "../engine/compiler.h"
 #include <map>
 
 using namespace libscratchcpp;
@@ -22,6 +23,32 @@ InputValue::InputValue(Type type) :
 {
 }
 
+/*! Compiles the input value. */
+void InputValue::compile(Compiler *compiler)
+{
+    switch (m_type) {
+        case Type::Color:
+            // TODO: Add support for colors
+            break;
+
+        case Type::Broadcast:
+            // TODO: Add support for broadcasts
+            break;
+
+        case Type::Variable:
+            compiler->addInstruction(vm::OP_READ_VAR, { compiler->variableIndex(m_valuePtr) });
+            break;
+
+        case Type::List:
+            compiler->addInstruction(vm::OP_READ_LIST, { compiler->listIndex(m_valuePtr) });
+            break;
+
+        default:
+            compiler->addInstruction(vm::OP_CONST, { compiler->constIndex(this) });
+            break;
+    }
+}
+
 /*! Returns the type of the value. */
 InputValue::Type InputValue::type() const
 {

src/scratch/inputvalue.h

@@ -10,6 +10,7 @@ namespace libscratchcpp
 {
 
 class LIBSCRATCHCPP_EXPORT Block;
+class LIBSCRATCHCPP_EXPORT Compiler;
 
 /*! \brief The InputValue class provides methods for the value of an Input. */
 class LIBSCRATCHCPP_EXPORT InputValue
@@ -32,6 +33,8 @@ class LIBSCRATCHCPP_EXPORT InputValue
         InputValue();
         InputValue(Type type);
 
+        void compile(Compiler *compiler);
+
         Type type() const;
         void setType(Type newType);