How would I be able to make a register-based virtual machine code off of a Binary Tree for math interpretation

Question

My code is represented in Dart, but this is more general to the Binary Tree data structure and Register-based VM implementation. I have commented the code for you to understand if you do not know Dart as well.

So, here are my nodes:

enum NodeType {
  numberNode,
  addNode,
  subtractNode,
  multiplyNode,
  divideNode,
  plusNode,
  minusNode,
}

NumberNode has a number value in it.

AddNode, SubtractNode, MultiplyNode, DivideNode, they are really just Binary Op Nodes .

PlusNode, MinusNode, are Unary Operator nodes.

The tree is generated based off Order of Operations. Unary Operation first, then multiplication and division, and then addition and subtraction. E.g. "1 + 2 * -3" becomes "(1 + (2 * (-3)))"

Here is my code to trying to walk over the AST:

/// Converts tree to Register-based VM code
List<Opcode> convertNodeToCode(Node node) {
  List<Opcode> result = [const Opcode(OpcodeKind.loadn, 2, -1)];
  bool counterHasBeenZero = false;
  bool binOpDebounce = false;
  int counter = 0;

  List<Opcode> convert(Node node) {
    switch (node.nodeType) {
      case NodeType.numberNode:
        counter = counter == 0 ? 1 : 0;
        if (counter == 0 && !counterHasBeenZero) {
          counterHasBeenZero = true;
        } else {
          counter = 1;
        }
        return [Opcode(OpcodeKind.loadn, counter, (node as NumberNode).value)];
      case NodeType.addNode:
        var aNode = node as AddNode;
        return convert(aNode.nodeA) +
            convert(aNode.nodeB) +
            [
              const Opcode(
                OpcodeKind.addn,
                0,
                1,
              )
            ];
      case NodeType.subtractNode:
        var sNode = node as SubtractNode;
        var result = convert(sNode.nodeA) +
            convert(sNode.nodeB) +
            (binOpDebounce
                ? [
                    const Opcode(
                      OpcodeKind.subn,
                      0,
                      0,
                      1,
                    )
                  ]
                : [
                    const Opcode(
                      OpcodeKind.subn,
                      0,
                      1,
                    )
                  ]);
        if (!binOpDebounce) binOpDebounce = true;
        return result;
      case NodeType.multiplyNode:
        var mNode = node as MultiplyNode;
        var result = convert(mNode.nodeA) +
            convert(mNode.nodeB) +
            (binOpDebounce
                ? [
                    const Opcode(
                      OpcodeKind.muln,
                      0,
                      0,
                      1,
                    )
                  ]
                : [
                    const Opcode(
                      OpcodeKind.muln,
                      0,
                      1,
                    )
                  ]);
        if (!binOpDebounce) binOpDebounce = true;
        return result;
      case NodeType.divideNode:
        var dNode = node as DivideNode;
        var result = convert(dNode.nodeA) +
            convert(dNode.nodeB) +
            (binOpDebounce
                ? [
                    const Opcode(
                      OpcodeKind.divn,
                      0,
                      0,
                      1,
                    )
                  ]
                : [
                    const Opcode(
                      OpcodeKind.divn,
                      0,
                      1,
                    )
                  ]);
        if (!binOpDebounce) binOpDebounce = true;
        return result;
      case NodeType.plusNode:
        return convert((node as PlusNode).node);
      case NodeType.minusNode:
        return convert((node as MinusNode).node) +
            [Opcode(OpcodeKind.muln, 1, 2)];
      default:
        throw Exception('Non-existent node type');
    }
  }

  return result + convert(node) + [const Opcode(OpcodeKind.exit)];
}

I tried a method to just use 2-3 registers and using a counter to track where I loaded the number in the register, but the code gets ugly real quick and when I'm trying to do Order of Operations, it gets really hard to track where the numbers are with the counter. Basically, how I tried to make this code work is just store the number in register 1 or 0 and load the number if needed to and add the registers together to equal to register 0. Example, 1 + 2 + 3 + 4 becomes [r2 = -1.0, r1 = 1.0, r0 = 2.0, r0 = r1 + r0, r1 = 3.0, r0 = r1 + r0, r1 = 4.0, r0 = r1 + r0, exit]. When I tried this with multiplication though, this became very hard as it incorrectly multiplied the wrong number which is possibly because of the order of operations.

I tried to see if this way could be done as well:

  // (1 + (2 * ((-2) + 3) * 5))
  const code = [
    // (-2)
    Opcode(OpcodeKind.loadn, 1, -2), // r1 = -2;

    // (2 + 3)
    Opcode(OpcodeKind.loadn, 1, 2), // r1 = 2;
    Opcode(OpcodeKind.loadn, 2, 3), // r2 = 3;
    Opcode(OpcodeKind.addn, 2, 1, 2), // r2 = r1 + r2;

    // (2 * (result) * 5)
    Opcode(OpcodeKind.loadn, 1, 2), // r1 = 2;
    Opcode(OpcodeKind.loadn, 3, 5), // r3 = 5;
    Opcode(OpcodeKind.muln, 2, 1, 2), // r2 = r1 * r2;
    Opcode(OpcodeKind.muln, 2, 2, 3), // r2 = r2 * r3;

    // (1 + (result))
    Opcode(OpcodeKind.loadn, 1, 1), // r1 = 1;
    Opcode(OpcodeKind.addn, 1, 1, 2), // r1 = r1 + r2;

    Opcode(OpcodeKind.exit), // exit halt
  ];

I knew this method would not work because if I'm going to iterate through the nodes I need to know the position of the numbers and registers beforehand, so I'd have to use another method or way to find the number/register.

You don't need to read all of above; those were just my attempts to try to produce register-based virtual machine code.

I want to see how you guys would do it or how you would make it.