Add Function Calls with a Call Stack

The Call Stack

Functions need a call stack separate from the operand stack. Each invocation pushes a frame storing the return address, locals, and a link to the caller's frame. CPython's `PyFrameObject` and the JVM's per-method frame are production versions of what you build here.

CALL and RETURN

• `CALL addr`: push a frame, save `pc` as return address, jump to `addr`
• `RETURN`: pop the frame, restore `pc`, leave the return value on the operand stack
• Arguments typically sit on the operand stack before `CALL`

Recursion works because each call gets fresh locals. Python's default recursion limit of 1000 frames exists because this stack is finite.

For example, `factorial(5)` nests five frames, each with its own `n` local, before unwinding via `RETURN`.

Frame layout:

• Return address (where to resume)
• Local variable array (parameters and temporaries)
• Pointer to enclosing frame

Design Notes

Size each frame's local array to the function's needs and zero it on entry. Stale locals from a previous invocation are a subtle bug that only shows up when callers reuse overlapping stack slots without clearing state.

For This Exercise

This exercise asks you to add `CALL` and `RETURN` with a `CallFrame` struct. You will implement recursive factorial in bytecode to prove frames push and pop correctly under nested calls.