OperatorBlocks: Add compile functions

Author: adazem009

src/blocks/operatorblocks.cpp

@@ -1,12 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "operatorblocks.h"
+#include "../engine/compiler.h"
 
 using namespace libscratchcpp;
 
 OperatorBlocks::OperatorBlocks()
 {
     // Blocks
+    addCompileFunction("operator_add", &OperatorBlocks::compileAdd);
+    addCompileFunction("operator_subtract", &OperatorBlocks::compileSubtract);
+    addCompileFunction("operator_multiply", &OperatorBlocks::compileMultiply);
+    addCompileFunction("operator_divide", &OperatorBlocks::compileDivide);
+    addCompileFunction("operator_random", &OperatorBlocks::compilePickRandom);
+    addCompileFunction("operator_lt", &OperatorBlocks::compileLessThan);
+    addCompileFunction("operator_equals", &OperatorBlocks::compileEquals);
+    addCompileFunction("operator_gt", &OperatorBlocks::compileGreaterThan);
+    addCompileFunction("operator_and", &OperatorBlocks::compileAnd);
+    addCompileFunction("operator_or", &OperatorBlocks::compileOr);
+    addCompileFunction("operator_not", &OperatorBlocks::compileNot);
     addBlock("operator_add", &OperatorBlocks::add);
     addBlock("operator_subtract", &OperatorBlocks::subtract);
     addBlock("operator_multiply", &OperatorBlocks::multiply);
@@ -34,6 +46,82 @@ std::string OperatorBlocks::name() const
     return "Operators";
 }
 
+void OperatorBlocks::compileAdd(Compiler *compiler)
+{
+    compiler->addInput(NUM1);
+    compiler->addInput(NUM2);
+    compiler->addInstruction(vm::OP_ADD);
+}
+
+void OperatorBlocks::compileSubtract(Compiler *compiler)
+{
+    compiler->addInput(NUM1);
+    compiler->addInput(NUM2);
+    compiler->addInstruction(vm::OP_SUBTRACT);
+}
+
+void OperatorBlocks::compileMultiply(Compiler *compiler)
+{
+    compiler->addInput(NUM1);
+    compiler->addInput(NUM2);
+    compiler->addInstruction(vm::OP_MULTIPLY);
+}
+
+void OperatorBlocks::compileDivide(Compiler *compiler)
+{
+    compiler->addInput(NUM1);
+    compiler->addInput(NUM2);
+    compiler->addInstruction(vm::OP_DIVIDE);
+}
+
+void OperatorBlocks::compilePickRandom(Compiler *compiler)
+{
+    compiler->addInput(FROM);
+    compiler->addInput(TO);
+    compiler->addInstruction(vm::OP_RANDOM);
+}
+
+void OperatorBlocks::compileLessThan(Compiler *compiler)
+{
+    compiler->addInput(OPERAND1);
+    compiler->addInput(OPERAND2);
+    compiler->addInstruction(vm::OP_LESS_THAN);
+}
+
+void OperatorBlocks::compileEquals(Compiler *compiler)
+{
+    compiler->addInput(OPERAND1);
+    compiler->addInput(OPERAND2);
+    compiler->addInstruction(vm::OP_EQUALS);
+}
+
+void OperatorBlocks::compileGreaterThan(Compiler *compiler)
+{
+    compiler->addInput(OPERAND1);
+    compiler->addInput(OPERAND2);
+    compiler->addInstruction(vm::OP_GREATER_THAN);
+}
+
+void OperatorBlocks::compileAnd(Compiler *compiler)
+{
+    compiler->addInput(OPERAND1);
+    compiler->addInput(OPERAND2);
+    compiler->addInstruction(vm::OP_AND);
+}
+
+void OperatorBlocks::compileOr(Compiler *compiler)
+{
+    compiler->addInput(OPERAND1);
+    compiler->addInput(OPERAND2);
+    compiler->addInstruction(vm::OP_OR);
+}
+
+void OperatorBlocks::compileNot(Compiler *compiler)
+{
+    compiler->addInput(OPERAND);
+    compiler->addInstruction(vm::OP_NOT);
+}
+
 Value OperatorBlocks::add(const BlockArgs &args)
 {
     return args.input(NUM1)->value() + args.input(NUM2)->value();

src/blocks/operatorblocks.h

@@ -26,6 +26,17 @@ class LIBSCRATCHCPP_EXPORT OperatorBlocks : public IBlockSection
 
         std::string name() const override;
 
+        static void compileAdd(Compiler *compiler);
+        static void compileSubtract(Compiler *compiler);
+        static void compileMultiply(Compiler *compiler);
+        static void compileDivide(Compiler *compiler);
+        static void compilePickRandom(Compiler *compiler);
+        static void compileLessThan(Compiler *compiler);
+        static void compileEquals(Compiler *compiler);
+        static void compileGreaterThan(Compiler *compiler);
+        static void compileAnd(Compiler *compiler);
+        static void compileOr(Compiler *compiler);
+        static void compileNot(Compiler *compiler);
         static Value add(const BlockArgs &args);
         static Value subtract(const BlockArgs &args);
         static Value multiply(const BlockArgs &args);