Compiler: Add methods for math instructions

Author: adazem009

include/scratchcpp/dev/compiler.h

@@ -61,6 +61,23 @@ class LIBSCRATCHCPP_EXPORT Compiler
         void createOr();
         void createNot();
 
+        void createMod();
+        void createRound();
+        void createAbs();
+        void createFloor();
+        void createCeil();
+        void createSqrt();
+        void createSin();
+        void createCos();
+        void createTan();
+        void createAsin();
+        void createAcos();
+        void createAtan();
+        void createLn();
+        void createLog10();
+        void createExp();
+        void createExp10();
+
         void moveToIf(std::shared_ptr<Block> substack);
         void moveToIfElse(std::shared_ptr<Block> substack1, std::shared_ptr<Block> substack2);
         void moveToRepeatLoop(std::shared_ptr<Block> substack);

src/dev/engine/compiler.cpp

@@ -160,6 +160,102 @@ void Compiler::createNot()
     impl->builder->createNot();
 }
 
+/*! Creates a remainder operation using the last 2 values. */
+void Compiler::createMod()
+{
+    impl->builder->createMod();
+}
+
+/*! Creates a round operation using the last value. */
+void Compiler::createRound()
+{
+    impl->builder->createRound();
+}
+
+/*! Creates an abs operation using the last value. */
+void Compiler::createAbs()
+{
+    impl->builder->createAbs();
+}
+
+/*! Creates a floor operation using the last value. */
+void Compiler::createFloor()
+{
+    impl->builder->createFloor();
+}
+
+/*! Creates a ceiling operation using the last value. */
+void Compiler::createCeil()
+{
+    impl->builder->createCeil();
+}
+
+/*! Creates a square root operation using the last value. */
+void Compiler::createSqrt()
+{
+    impl->builder->createSqrt();
+}
+
+/*! Creates a sin operation using the last value. */
+void Compiler::createSin()
+{
+    impl->builder->createSin();
+}
+
+/*! Creates a cos operation using the last value. */
+void Compiler::createCos()
+{
+    impl->builder->createCos();
+}
+
+/*! Creates a tan operation using the last value. */
+void Compiler::createTan()
+{
+    impl->builder->createTan();
+}
+
+/*! Creates an asin operation using the last value. */
+void Compiler::createAsin()
+{
+    impl->builder->createAsin();
+}
+
+/*! Creates an acos operation using the last value. */
+void Compiler::createAcos()
+{
+    impl->builder->createAcos();
+}
+
+/*! Creates an atan operation using the last value. */
+void Compiler::createAtan()
+{
+    impl->builder->createAtan();
+}
+
+/*! Creates an ln operation using the last value. */
+void Compiler::createLn()
+{
+    impl->builder->createLn();
+}
+
+/*! Creates a log10 operation using the last value. */
+void Compiler::createLog10()
+{
+    impl->builder->createLog10();
+}
+
+/*! Creates an e^x operation using the last value. */
+void Compiler::createExp()
+{
+    impl->builder->createExp();
+}
+
+/*! Creates a 10^x operation using the last value. */
+void Compiler::createExp10()
+{
+    impl->builder->createExp10();
+}
+
 /*! Jumps to the given if substack. */
 void Compiler::moveToIf(std::shared_ptr<Block> substack)
 {

test/dev/compiler/compiler_test.cpp

@@ -349,6 +349,214 @@ TEST_F(CompilerTest, CreateNot)
     compile(compiler, block);
 }
 
+TEST_F(CompilerTest, CreateMod)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createMod);
+        compiler->createMod();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateRound)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createRound);
+        compiler->createRound();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateAbs)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createAbs);
+        compiler->createAbs();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateFloor)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createFloor);
+        compiler->createFloor();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateCeil)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createCeil);
+        compiler->createCeil();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateSqrt)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createSqrt);
+        compiler->createSqrt();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateSin)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createSin);
+        compiler->createSin();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateCos)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createCos);
+        compiler->createCos();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateTan)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createTan);
+        compiler->createTan();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateAsin)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createAsin);
+        compiler->createAsin();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateAcos)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createAcos);
+        compiler->createAcos();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateAtan)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createAtan);
+        compiler->createAtan();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateLn)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createLn);
+        compiler->createLn();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateLog10)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createLog10);
+        compiler->createLog10();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateExp)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createExp);
+        compiler->createExp();
+    });
+
+    compile(compiler, block);
+}
+
+TEST_F(CompilerTest, CreateExp10)
+{
+    Compiler compiler(&m_engine, &m_target);
+    auto block = std::make_shared<Block>("", "");
+
+    block->setCompileFunction([](Compiler *compiler) {
+        EXPECT_CALL(*m_builder, createExp10);
+        compiler->createExp10();
+    });
+
+    compile(compiler, block);
+}
+
 TEST_F(CompilerTest, MoveToIf)
 {
     Compiler compiler(&m_engine, &m_target);