Compiler: Add methods for string instructions

Author: adazem009

include/scratchcpp/compiler.h

@@ -56,6 +56,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *addTargetFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerValue *addFunctionCallWithCtx(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerConstant *addConstValue(const Value &value);
+        CompilerValue *addStringChar(CompilerValue *string, CompilerValue *index);
+        CompilerValue *addStringLength(CompilerValue *string);
         CompilerValue *addLoopIndex();
         CompilerValue *addLocalVariableValue(CompilerLocalVariable *variable);
         CompilerValue *addVariableValue(Variable *variable);
@@ -104,6 +106,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *createExp(CompilerValue *num);
         CompilerValue *createExp10(CompilerValue *num);
 
+        CompilerValue *createStringConcat(CompilerValue *string1, CompilerValue *string2);
+
         CompilerValue *createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType);
 
         CompilerLocalVariable *createLocalVariable(Compiler::StaticType type);

src/engine/compiler.cpp

@@ -151,6 +151,18 @@ CompilerConstant *Compiler::addConstValue(const Value &value)
     return static_cast<CompilerConstant *>(impl->builder->addConstValue(value));
 }
 
+/*! Adds the string character with the given index to the compiled code. */
+CompilerValue *Compiler::addStringChar(CompilerValue *string, CompilerValue *index)
+{
+    return impl->builder->addStringChar(string, index);
+}
+
+/*! Adds the length of the given string to the compiled code. */
+CompilerValue *Compiler::addStringLength(CompilerValue *string)
+{
+    return impl->builder->addStringLength(string);
+}
+
 /*! Adds the index of the current repeat loop to the compiled code. */
 CompilerValue *Compiler::addLoopIndex()
 {
@@ -444,6 +456,12 @@ CompilerValue *Compiler::createExp10(CompilerValue *num)
     return impl->builder->createExp10(num);
 }
 
+/*! Creates a string concatenation operation. */
+CompilerValue *Compiler::createStringConcat(CompilerValue *string1, CompilerValue *string2)
+{
+    return impl->builder->createStringConcat(string1, string2);
+}
+
 /*! Creates a select instruction (ternary operator). */
 CompilerValue *Compiler::createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, StaticType valueType)
 {

test/compiler/compiler_test.cpp

@@ -173,6 +173,49 @@ TEST_F(CompilerTest, AddConstValue)
     compile(m_compiler.get(), block);
 }
 
+TEST_F(CompilerTest, AddStringChar)
+{
+
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue arg1(Compiler::StaticType::Unknown);
+        CompilerValue arg2(Compiler::StaticType::Unknown);
+        CompilerValue ret(Compiler::StaticType::Unknown);
+
+        EXPECT_CALL(*m_builder, addStringChar(&arg1, &arg2)).WillOnce(Return(&ret));
+        EXPECT_EQ(compiler->addStringChar(&arg1, &arg2), &ret);
+
+        EXPECT_CALL(*m_builder, addStringChar(&arg1, &arg2)).WillOnce(Return(nullptr));
+        EXPECT_EQ(compiler->addStringChar(&arg1, &arg2), nullptr);
+
+        return nullptr;
+    });
+
+    compile(m_compiler.get(), block);
+}
+
+TEST_F(CompilerTest, AddStringLength)
+{
+
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue arg(Compiler::StaticType::Unknown);
+        CompilerValue ret(Compiler::StaticType::Unknown);
+
+        EXPECT_CALL(*m_builder, addStringLength(&arg)).WillOnce(Return(&ret));
+        EXPECT_EQ(compiler->addStringLength(&arg), &ret);
+
+        EXPECT_CALL(*m_builder, addStringLength(&arg)).WillOnce(Return(nullptr));
+        EXPECT_EQ(compiler->addStringLength(&arg), nullptr);
+
+        return nullptr;
+    });
+
+    compile(m_compiler.get(), block);
+}
+
 TEST_F(CompilerTest, AddLoopIndex)
 {
 
@@ -957,6 +1000,24 @@ TEST_F(CompilerTest, CreateExp10)
     compile(m_compiler.get(), block);
 }
 
+TEST_F(CompilerTest, CreateStringConcat)
+{
+
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) -> CompilerValue * {
+        CompilerValue arg1(Compiler::StaticType::Unknown);
+        CompilerValue arg2(Compiler::StaticType::Unknown);
+        CompilerValue ret(Compiler::StaticType::Unknown);
+        EXPECT_CALL(*m_builder, createStringConcat(&arg1, &arg2)).WillOnce(Return(&ret));
+        EXPECT_EQ(compiler->createStringConcat(&arg1, &arg2), &ret);
+
+        return nullptr;
+    });
+
+    compile(m_compiler.get(), block);
+}
+
 TEST_F(CompilerTest, CreateSelect)
 {