Implement operator_letter_of

Author: adazem009

src/dev/blocks/operatorblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/dev/compiler.h>
 #include <scratchcpp/dev/compilervalue.h>
+#include <utf8.h>
 
 #include "operatorblocks.h"
 
@@ -32,6 +33,7 @@ void OperatorBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "operator_or", &compileOr);
     engine->addCompileFunction(this, "operator_not", &compileNot);
     engine->addCompileFunction(this, "operator_join", &compileJoin);
+    engine->addCompileFunction(this, "operator_letter_of", &compileLetterOf);
 }
 
 CompilerValue *OperatorBlocks::compileAdd(Compiler *compiler)
@@ -98,6 +100,13 @@ CompilerValue *OperatorBlocks::compileJoin(Compiler *compiler)
     return compiler->addFunctionCall("operator_join", Compiler::StaticType::String, { Compiler::StaticType::String, Compiler::StaticType::String }, { string1, string2 });
 }
 
+CompilerValue *OperatorBlocks::compileLetterOf(Compiler *compiler)
+{
+    auto letter = compiler->addInput("LETTER");
+    auto string = compiler->addInput("STRING");
+    return compiler->addFunctionCall("operator_letter_of", Compiler::StaticType::String, { Compiler::StaticType::Number, Compiler::StaticType::String }, { letter, string });
+}
+
 extern "C" char *operator_join(const char *string1, const char *string2)
 {
     const size_t len1 = strlen(string1);
@@ -114,3 +123,22 @@ extern "C" char *operator_join(const char *string1, const char *string2)
 
     return ret;
 }
+
+extern "C" char *operator_letter_of(double letter, const char *string)
+{
+    const size_t len = strlen(string);
+
+    if (letter < 1 || letter > len) {
+        char *ret = (char *)malloc(sizeof(char));
+        ret[0] = '\0';
+        return ret;
+    }
+
+    // TODO: Rewrite this
+    std::u16string u16 = utf8::utf8to16(std::string(string));
+    std::string str = utf8::utf16to8(std::u16string({ u16[(size_t)letter - 1] }));
+    char *ret = (char *)malloc((str.size() + 1) * sizeof(char));
+    strcpy(ret, str.c_str());
+
+    return ret;
+}

src/dev/blocks/operatorblocks.h

@@ -30,6 +30,7 @@ class OperatorBlocks : public IExtension
         static CompilerValue *compileOr(Compiler *compiler);
         static CompilerValue *compileNot(Compiler *compiler);
         static CompilerValue *compileJoin(Compiler *compiler);
+        static CompilerValue *compileLetterOf(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/operator_blocks_test.cpp

@@ -378,3 +378,46 @@ TEST_F(OperatorBlocksTest, Join)
     ASSERT_EQ(Value(values[0]), "abcdef");
     ASSERT_EQ(Value(values[1]), "Hello world");
 }
+
+TEST_F(OperatorBlocksTest, LetterOf)
+{
+    auto target = std::make_shared<Sprite>();
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    builder.addBlock("operator_letter_of");
+    builder.addValueInput("LETTER", 2);
+    builder.addValueInput("STRING", "abc");
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("operator_letter_of");
+    builder.addValueInput("LETTER", 7);
+    builder.addValueInput("STRING", "Hello world");
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("operator_letter_of");
+    builder.addValueInput("LETTER", 0);
+    builder.addValueInput("STRING", "Hello world");
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("operator_letter_of");
+    builder.addValueInput("LETTER", 12);
+    builder.addValueInput("STRING", "Hello world");
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("operator_letter_of");
+    builder.addValueInput("LETTER", 1);
+    builder.addValueInput("STRING", "Ábč");
+    builder.captureBlockReturnValue();
+
+    builder.build();
+    builder.run();
+
+    List *valueList = builder.capturedValues();
+    ValueData *values = valueList->data();
+    ASSERT_EQ(valueList->size(), 5);
+    ASSERT_EQ(Value(values[0]), "b");
+    ASSERT_EQ(Value(values[1]), "w");
+    ASSERT_EQ(Value(values[2]), "");
+    ASSERT_EQ(Value(values[3]), "");
+    ASSERT_EQ(Value(values[4]), "Á");
+}