fix #178: Store registers in a vector

Author: adazem009

src/engine/virtualmachine_p.cpp

@@ -10,11 +10,16 @@
 #include "virtualmachine_p.h"
 #include "internal/randomgenerator.h"
 
-#define MAX_REG_COUNT 1024
-
 #define DISPATCH() goto *dispatch_table[*++pos]
 #define FREE_REGS(count) regCount -= count
-#define ADD_RET_VALUE(value) *regs[regCount++] = value
+#define ADD_RET_VALUE(value)                                                                                                                                                                           \
+    if (regCount + 1 >= regsVector.size()) {                                                                                                                                                           \
+        regsVector.reserve(regsVector.size() + 1024);                                                                                                                                                  \
+        for (size_t i = 0; i < 1024; i++)                                                                                                                                                              \
+            regsVector.push_back(new Value());                                                                                                                                                         \
+        regs = regsVector.data();                                                                                                                                                                      \
+    }                                                                                                                                                                                                  \
+    *regs[regCount++] = value
 #define REPLACE_RET_VALUE(value, offset) *regs[regCount - offset] = value
 #define GET_NEXT_ARG() constValues[*++pos]
 #define READ_REG(index, count) regs[regCount - count + index]
@@ -103,9 +108,10 @@ VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target,
     engine(engine),
     script(script)
 {
-    regs = new Value *[MAX_REG_COUNT];
-    for (int i = 0; i < MAX_REG_COUNT; i++)
-        regs[i] = new Value();
+    regsVector.reserve(1024);
+    for (int i = 0; i < 1024; i++)
+        regsVector.push_back(new Value());
+    regs = regsVector.data();
     loops.reserve(256);
     callTree.reserve(1024);
 
@@ -115,9 +121,8 @@ VirtualMachinePrivate::VirtualMachinePrivate(VirtualMachine *vm, Target *target,
 
 VirtualMachinePrivate::~VirtualMachinePrivate()
 {
-    for (int i = 0; i < MAX_REG_COUNT; i++)
-        delete regs[i];
-    delete regs;
+    for (int i = 0; i < regsVector.size(); i++)
+        delete regsVector[i];
 }
 
 unsigned int *VirtualMachinePrivate::run(unsigned int *pos, bool reset)

src/engine/virtualmachine_p.h

@@ -66,6 +66,7 @@ struct VirtualMachinePrivate
         std::vector<List *> listsVector;
 
         Value **regs = nullptr;
+        std::vector<Value *> regsVector;
         size_t regCount = 0;
 
         static IRandomGenerator *rng;

test/virtual_machine/virtual_machine_test.cpp

@@ -133,6 +133,35 @@ TEST(VirtualMachineTest, MinimalScript)
     ASSERT_EQ(vm.registerCount(), 0);
 }
 
+TEST(VirtualMachineTest, RegCountLimit)
+{
+    static unsigned int bytecode[20482] = { OP_START };
+
+    for (int i = 0; i < 10240; i++) {
+        bytecode[2 * i + 1] = OP_CONST;
+        bytecode[2 * i + 2] = 0;
+    }
+
+    bytecode[20481] = OP_HALT;
+
+    static Value constValues[] = { 1 };
+
+    VirtualMachine vm;
+    vm.setBytecode(bytecode);
+    vm.setConstValues(constValues);
+    vm.run();
+    ASSERT_EQ(vm.registerCount(), 10240);
+
+    for (int i = 1; i < 10240; i++)
+        bytecode[i] = OP_ADD;
+
+    bytecode[10240] = OP_HALT;
+    vm.setBytecode(bytecode);
+    vm.run();
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toInt(), 10240);
+}
+
 TEST(VirtualMachineTest, OP_CONST)
 {
     static unsigned int bytecode[] = { OP_START, OP_CONST, 0, OP_HALT };