[jeany55]

Functions that call themselves, in a map of our own (no eudplib, no Python). The meaning is the Python side's: a
call that may come back into the function it is in keeps that function's variables and where it goes back to around
the call; past the depth the script's settings allow, the program says so in red and stops for good.

How (compiler/backend/emit.ts, layout.ts, graph.ts; plan section "Recursion on our own backend"):

• A stack of cell triggers, the routed copies' (72 bytes apart, overlapped). Keeping a frame is one trigger, a Set
  Deaths a variable, its destination a place of the stack's sp; a cell comes back through one trigger and a jump.
  eudplib's build reads a cell back a bit at a time (about 35 triggers).
• A stack for each function that calls itself: one for all of them gave sp a place at every call of every such
  function, and each call wrote them all twice. The depth that runs out is still one count for all.
• Only what is read again is kept: liveAfterCalls works out, backwards over the function's statements, what is
  read after each call before it is written. saves lists every variable of the function, on purpose; fib keeps two
  cells a call instead of three.
• Where a function goes back to is written by each call into all its places (a label), not copied before each
  store. A frame keeps the calling function's, as the Python side's does (two functions calling each other differ).

probes/own-recursion.ts, the frame of fib(18) (8361 calls) and down(1000), lifted game, Remastered's weights:

	ms
One stack	32.05
A stack for each function	17.78
Only what is read again	13.06
Where it goes back to written by each call	11.64
Through eudplib	26.06

Going past the depth: 0.25 ms against eudplib's 0.51.

Checked: random programs with functions that call themselves (a depth that goes down, one or two calls of itself
with the front end's saves, inside loops and ifs) as written, as graphs and from the laid-out payload's bytes:
1500 in the suite, 14,000 once — the test found two mistakes of the liveness on the way, both fixed. The probe's lines
the same at the same frames built both ways, every one ok, the overflow in red with nothing after it; game-check: 3605
accesses, none ending the game; the whole suite; the calls and own-loader probes still all ok. Played in
Remastered: trigscript-own-recursion.scx printed all nine lines as the lifted game does, the overflow line red and
nothing after it, no stutter seen on the frame of about 9,400 calls.

Not yet: a growing array declared in a function that calls itself, units and texts on the stack (refused, and said).

🤖 Generated with Claude Code

https://claude.ai/code/session_01T1CM9pLuTuAn3mgTEkjgVg