Implement a Stack-Based VM Interpreter

Fetch-Decode-Execute

Every interpreter follows the same loop: fetch the next instruction, decode its opcode, execute the handler. CPython's `ceval.c` and Lua's `lvm.c` are this pattern at production scale. Your `switch` statement is the same structure CPython 3.11 later replaced with computed gotos for speed.

The Operand Stack and PC

The program counter points at the next bytecode byte. Each cycle:

1. Read `bytecode[pc]` as the opcode
2. Dispatch to the handler
3. Advance `pc` (unless a jump changes it)

The operand stack is a fixed-size LIFO buffer:

• `PUSH val` grows the stack by one
• `ADD` pops two values, pushes their sum
• `PRINT` pops and displays the top

For example, `(10 + 20) * 3 - 5` compiles to a sequence of pushes and arithmetic ops ending with a single value on the stack.

```c while (running) { uint8_t op = bytecode[pc++]; switch (op) { case OP_PUSH: ... case OP_ADD: ... } } ```

Design Notes

Start with a debug print of pc and stack contents each cycle while developing. Interpreter bugs show up as impossible stack states long before you get wrong final answers. Once handlers are correct, gate the trace behind a flag so benchmarks stay meaningful.

For This Exercise

This exercise asks you to wire up a complete interpreter loop with overflow checks. You will implement `push`, `pop`, and handlers for arithmetic so later tasks add control flow without rewriting the core loop.