fix #548: Do not use OP_READ_VAR in sensing_of block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -276,13 +276,16 @@ void SensingBlocks::compileOf(Compiler *compiler)
 
             default: {
                 // Variable
+                f = &variableOfTargetByIndex;
                 Target *target = engine->targetAt(index);
                 auto varIndex = target->findVariable(property->value().toString());
 
                 if (varIndex == -1)
                     compiler->addInstruction(vm::OP_NULL);
-                else
-                    compiler->addInstruction(vm::OP_READ_VAR, { compiler->variableIndex(target->variableAt(varIndex)) });
+                else {
+                    // NOTE: The OP_READ_VAR instruction can't be used for this (see #548)
+                    compiler->addConstValue(varIndex);
+                }
 
                 break;
             }
@@ -869,6 +872,19 @@ unsigned int SensingBlocks::variableOfTarget(VirtualMachine *vm)
     return 1;
 }
 
+unsigned int SensingBlocks::variableOfTargetByIndex(VirtualMachine *vm)
+{
+    Target *target = vm->engine()->targetAt(vm->getInput(0, 1)->toInt());
+
+    if (target) {
+        const int varIndex = vm->getInput(0, 2)->toInt();
+        vm->replaceReturnValue(target->variableAt(varIndex)->value(), 2);
+    } else
+        vm->replaceReturnValue(0, 2);
+
+    return 1;
+}
+
 unsigned int SensingBlocks::backdropNumberOfStage(VirtualMachine *vm)
 {
     Target *target = vm->engine()->targetAt(vm->engine()->findTarget(vm->getInput(0, 1)->toString()));

src/blocks/sensingblocks.h

@@ -131,6 +131,7 @@ class SensingBlocks : public IBlockSection
         static unsigned int volumeOfTarget(VirtualMachine *vm);
         static unsigned int volumeOfTargetByIndex(VirtualMachine *vm);
         static unsigned int variableOfTarget(VirtualMachine *vm);
+        static unsigned int variableOfTargetByIndex(VirtualMachine *vm);
         static unsigned int backdropNumberOfStage(VirtualMachine *vm);
         static unsigned int backdropNumberOfStageByIndex(VirtualMachine *vm);
         static unsigned int backdropNameOfStage(VirtualMachine *vm);

test/blocks/sensing_blocks_test.cpp

@@ -1356,8 +1356,8 @@ TEST_F(SensingBlocksTest, Of)
 
     compiler.init();
 
-    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).Times(9).WillRepeatedly(Return(6));
-    EXPECT_CALL(m_engineMock, findTarget("_stage_")).Times(5).WillRepeatedly(Return(0));
+    EXPECT_CALL(m_engineMock, findTarget("Sprite2")).WillRepeatedly(Return(6));
+    EXPECT_CALL(m_engineMock, findTarget("_stage_")).WillRepeatedly(Return(0));
 
     EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::xPositionOfSpriteByIndex)).WillOnce(Return(0));
     compiler.setBlock(block1);
@@ -1444,21 +1444,25 @@ TEST_F(SensingBlocksTest, Of)
     auto v2 = std::make_shared<Variable>("var2", "some variable");
     stage.addVariable(v1);
     stage.addVariable(v2);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block21);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(0)).WillOnce(Return(&stage));
     compiler.setBlock(block22);
     SensingBlocks::compileOf(&compiler);
 
     Sprite sprite;
     auto v3 = std::make_shared<Variable>("var3", "some variable");
     sprite.addVariable(v3);
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block23);
     SensingBlocks::compileOf(&compiler);
 
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::variableOfTargetByIndex)).WillOnce(Return(19));
     EXPECT_CALL(m_engineMock, targetAt(6)).WillOnce(Return(&sprite));
     compiler.setBlock(block24);
     SensingBlocks::compileOf(&compiler);
@@ -1547,21 +1551,37 @@ TEST_F(SensingBlocksTest, Of)
               vm::OP_NULL,
               vm::OP_EXEC,
               17,
-              vm::OP_READ_VAR,
-              0,
+              vm::OP_CONST,
+              10,
+              vm::OP_CONST,
+              11,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
-              vm::OP_READ_VAR,
-              1,
+              vm::OP_CONST,
+              12,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              13,
+              vm::OP_CONST,
+              14,
+              vm::OP_EXEC,
+              19,
               vm::OP_NULL,
               vm::OP_CONST,
-              10,
+              15,
+              vm::OP_EXEC,
+              19,
+              vm::OP_CONST,
+              16,
               vm::OP_NULL,
               vm::OP_EXEC,
               18,
               vm::OP_NULL,
               vm::OP_HALT }));
-    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, "some variable" }));
-    ASSERT_EQ(compiler.variables(), std::vector<Variable *>({ v2.get(), v3.get() }));
+    ASSERT_EQ(compiler.constValues(), std::vector<Value>({ 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 1, 0, 0, 0, 6, 6, "some variable" }));
+    ASSERT_TRUE(compiler.variables().empty());
 }
 
 TEST_F(SensingBlocksTest, XPositionOfSprite)