do loop goto bug fixed

Author: omiq

CHANGELOG.md

@@ -1,5 +1,26 @@
 ## Changelog
 
+### Fix: GOTO inside a FUNCTION no longer corrupts the caller's DO/LOOP (2026-06-01)
+
+A `GOTO` executed inside a `FUNCTION` while the caller was sitting inside a
+`DO ... LOOP` used to clear the `DO` bookkeeping globally (`do_top = 0` in
+`goto_unwind_structured_stacks()`), so the caller's matching `LOOP` later halted
+with `LOOP without DO`. `WHILE`/`FOR`/`IF` were already snapshotted per function
+call (`udf_call_frame`), but `DO` was not, and the unwind cleared it to zero
+instead of to the current function's floor.
+
+Fix mirrors the earlier FOR-body fix (2026-05-23): the `udf_call_frame` now also
+saves `do_top` on entry, `statement_return` / `statement_end_function` restore
+it, and `goto_unwind_structured_stacks()` clears `do_top` down to the running
+UDF's floor (0 at top level) rather than unconditionally to zero. A `GOTO` now
+only unwinds the `DO` blocks the running function itself opened; the caller's
+loop frame survives the call.
+
+This is what lets a state-machine main loop (`DO ... LOOP UNTIL done`) dispatch
+to handler functions that use their own internal `GOTO`s. Surfaced while
+rewriting `examples/trek-new.bas` into a `GOSUB`-free state machine. Regression
+test: `tests/do_loop_func_goto_test.bas`.
+
 ### `tests/run-wasm.js` headless WASM runner (2026-05-23)
 
 Wishlist §3f. A permanent node runner that drives the `basic-wasm` build

README.md

@@ -600,6 +600,10 @@ The `examples` folder (included in release archives) contains:
   - You may `THEN` jump to a line number (`IF A>10 THEN 100`) or execute inline statements after `THEN`.
 - **Random numbers**:
   - `RND(X)` behaves like classic BASIC; a negative argument reseeds the generator.
+- **Structured loops and `GOTO`**:
+  - `DO ... LOOP [UNTIL]`, `WHILE ... WEND`, `FOR ... NEXT` and block `IF ... ELSE IF ... END IF` can be mixed freely with `GOTO`.
+  - A `GOTO` abandons any block frames opened since the current routine started (the classic unstructured behaviour), but it no longer disturbs blocks owned by a *caller*.
+  - **Fixed bug (2026-06-01):** a `GOTO` inside a `FUNCTION` that ran while the caller was sitting inside a `DO ... LOOP` used to clear the loop bookkeeping globally, so the caller's matching `LOOP` later failed with `LOOP without DO`. The block stack (`DO`/`WHILE`/`FOR`/`IF`) is now snapshotted per function call and restored on return, so `GOTO` only unwinds the blocks that the running function itself opened. This is what lets a state-machine main loop (`DO ... LOOP UNTIL done`) dispatch to handler functions that use their own internal `GOTO`s, as in `examples/trek-new.bas`. Regression test: `tests/do_loop_func_goto_test.bas`.
 
 This README describes the current feature set of the interpreter as implemented in `basic.c` and is subject to change without notice.
 

basic.c

@@ -2103,6 +2103,7 @@ struct udf_call_frame {
     int saved_while_top;   /* WHILE/WEND nesting at call site */
     int saved_for_top;     /* FOR/NEXT nesting at call site */
     int saved_if_depth;    /* block IF/END IF nesting at call site */
+    int saved_do_top;      /* DO/LOOP nesting at call site */
     struct value saved_params[MAX_UDF_PARAMS];
 };
 
@@ -14435,6 +14436,7 @@ static struct value invoke_udf(int func_index, struct value *args, int nargs)
     udf_call_stack[udf_call_depth].saved_while_top = while_top;
     udf_call_stack[udf_call_depth].saved_for_top   = for_top;
     udf_call_stack[udf_call_depth].saved_if_depth  = if_depth;
+    udf_call_stack[udf_call_depth].saved_do_top    = do_top;
     for (i = 0; i < uf->param_count; i++) {
         param_var = find_or_create_var(uf->param_names[i], uf->param_is_string[i], 0, 0, NULL, 0);
         if (param_var && i < nargs) {
@@ -17555,16 +17557,20 @@ static void goto_unwind_structured_stacks(void)
 {
     int floor_while = 0;
     int floor_if    = 0;
+    int floor_do    = 0;
     if (udf_call_depth > 0) {
         floor_while = udf_call_stack[udf_call_depth - 1].saved_while_top;
         floor_if    = udf_call_stack[udf_call_depth - 1].saved_if_depth;
+        floor_do    = udf_call_stack[udf_call_depth - 1].saved_do_top;
     }
     if (while_top > floor_while) while_top = floor_while;
     if (if_depth  > floor_if)    if_depth  = floor_if;
-    /* DO frames are not saved per-UDF (yet) — clear to 0. Re-entering
-     * the DO body via GOTO is the same misuse as IF/WHILE: caller has
-     * to RUN the program from a clean state if they want it back. */
-    do_top = 0;
+    /* DO frames clear down to the current UDF's floor — a GOTO inside a
+     * function discards only the DO blocks that function opened, leaving
+     * the caller's DO/LOOP frame (and any outer ones) intact. At top
+     * level the floor is 0, matching classic line-numbered BASIC where
+     * GOTO abandons structured state. */
+    if (do_top > floor_do) do_top = floor_do;
 }
 
 static void statement_goto(char **p)
@@ -17686,11 +17692,12 @@ static void statement_return(char **p)
         udf_call_depth--;
         current_line = udf_call_stack[udf_call_depth].saved_line;
         statement_pos = udf_call_stack[udf_call_depth].saved_pos;
-        /* Unwind any WHILE / FOR / IF blocks the UDF entered but did
+        /* Unwind any WHILE / FOR / IF / DO blocks the UDF entered but did
          * not close — the caller resumes with its own stacks intact. */
         while_top = udf_call_stack[udf_call_depth].saved_while_top;
         for_top   = udf_call_stack[udf_call_depth].saved_for_top;
         if_depth  = udf_call_stack[udf_call_depth].saved_if_depth;
+        do_top    = udf_call_stack[udf_call_depth].saved_do_top;
         return;
     }
     if (gosub_top <= 0) {
@@ -18134,10 +18141,11 @@ static void statement_end_function(char **p)
     udf_call_depth--;
     current_line = udf_call_stack[udf_call_depth].saved_line;
     statement_pos = udf_call_stack[udf_call_depth].saved_pos;
-    /* Unwind WHILE / FOR / IF stacks the UDF body left dangling. */
+    /* Unwind WHILE / FOR / IF / DO stacks the UDF body left dangling. */
     while_top = udf_call_stack[udf_call_depth].saved_while_top;
     for_top   = udf_call_stack[udf_call_depth].saved_for_top;
     if_depth  = udf_call_stack[udf_call_depth].saved_if_depth;
+    do_top    = udf_call_stack[udf_call_depth].saved_do_top;
 }
 
 static void statement_while(char **p, char *while_pos)