Compiler: Add methods for local variables

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -16,6 +16,7 @@ class Target;
 class ExecutableCode;
 class CompilerValue;
 class CompilerConstant;
+class CompilerLocalVariable;
 class Variable;
 class List;
 class Input;
@@ -52,6 +53,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *addFunctionCallWithCtx(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerConstant *addConstValue(const Value &value);
         CompilerValue *addLoopIndex();
+        CompilerValue *addLocalVariableValue(CompilerLocalVariable *variable);
         CompilerValue *addVariableValue(Variable *variable);
         CompilerValue *addListContents(List *list);
         CompilerValue *addListItem(List *list, CompilerValue *index);
@@ -95,6 +97,9 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         CompilerValue *createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType);
 
+        CompilerLocalVariable *createLocalVariable(Compiler::StaticType type);
+        void createLocalVariableWrite(CompilerLocalVariable *variable, CompilerValue *value);
+
         void createVariableWrite(Variable *variable, CompilerValue *value);
 
         void createListClear(List *list);

src/dev/engine/compiler.cpp

@@ -127,6 +127,12 @@ CompilerValue *Compiler::addLoopIndex()
     return impl->builder->addLoopIndex();
 }
 
+/*! Adds the value of the given local variable to the code. */
+CompilerValue *Compiler::addLocalVariableValue(CompilerLocalVariable *variable)
+{
+    return impl->builder->addLocalVariableValue(variable);
+}
+
 /*! Adds the value of the given variable to the code. */
 CompilerValue *Compiler::addVariableValue(Variable *variable)
 {
@@ -346,6 +352,18 @@ CompilerValue *Compiler::createSelect(CompilerValue *cond, CompilerValue *trueVa
     return impl->builder->createSelect(cond, trueValue, falseValue, valueType);
 }
 
+/*! Creates a local variable with the given type. */
+CompilerLocalVariable *Compiler::createLocalVariable(StaticType type)
+{
+    return impl->builder->createLocalVariable(type);
+}
+
+/*! Creates a local variable write operation. */
+void Compiler::createLocalVariableWrite(CompilerLocalVariable *variable, CompilerValue *value)
+{
+    impl->builder->createLocalVariableWrite(variable, value);
+}
+
 /*! Creates a variable write operation. */
 void Compiler::createVariableWrite(Variable *variable, CompilerValue *value)
 {

test/dev/compiler/compiler_test.cpp

@@ -1,5 +1,6 @@
 #include <scratchcpp/dev/compiler.h>
 #include <scratchcpp/dev/compilerconstant.h>
+#include <scratchcpp/dev/compilerlocalvariable.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
@@ -180,6 +181,29 @@ TEST_F(CompilerTest, AddLoopIndex)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, AddLocalVariableValue)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("a", "");
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue ret(Compiler::StaticType::Number);
+        CompilerValue ptr1(Compiler::StaticType::Number);
+        CompilerValue ptr2(Compiler::StaticType::Bool);
+        CompilerLocalVariable var1(&ptr1);
+        CompilerLocalVariable var2(&ptr2);
+
+        EXPECT_CALL(*m_builder, addLocalVariableValue(&var1)).WillOnce(Return(&ret));
+        EXPECT_EQ(compiler->addLocalVariableValue(&var1), &ret);
+
+        EXPECT_CALL(*m_builder, addLocalVariableValue(&var2)).WillOnce(Return(nullptr));
+        EXPECT_EQ(compiler->addLocalVariableValue(&var2), nullptr);
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, AddVariableValue)
 {
     Compiler compiler(&m_engine, &m_target);
@@ -905,6 +929,46 @@ TEST_F(CompilerTest, CreateSelect)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, CreateLocalVariable)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue ptr1(Compiler::StaticType::Number);
+        CompilerLocalVariable var1(&ptr1);
+        EXPECT_CALL(*m_builder, createLocalVariable(var1.type())).WillOnce(Return(&var1));
+        EXPECT_EQ(compiler->createLocalVariable(var1.type()), &var1);
+
+        CompilerValue ptr2(Compiler::StaticType::Number);
+        CompilerLocalVariable var2(&ptr2);
+        EXPECT_CALL(*m_builder, createLocalVariable(var2.type())).WillOnce(Return(&var2));
+        EXPECT_EQ(compiler->createLocalVariable(var2.type()), &var2);
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateLocalVariableWrite)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue ptr(Compiler::StaticType::Number);
+        CompilerLocalVariable var(&ptr);
+        CompilerValue arg(Compiler::StaticType::Number);
+        EXPECT_CALL(*m_builder, createLocalVariableWrite(&var, &arg));
+        compiler->createLocalVariableWrite(&var, &arg);
+
+        return nullptr;
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, CreateVariableWrite)
 {
     Compiler compiler(&m_engine, &m_target);