Files
akbasic/tests/value_pool.c

210 lines
7.5 KiB
C
Raw Normal View History

Stop a scalar created inside a scope costing value-pool slots A scalar now lives in the variable record (`akbasic_Variable::inlinevalue`) rather than drawing from the value pool, so a `GOSUB` local, a `FOR` counter and a `DEF` parameter cost nothing at all. The pool is a bump allocator with no free, and its comment justified that with "nothing in BASIC destroys a variable". Scope exit does: it marks the variable slot unused, `new_variable()` memsets the slot it hands back -- clearing `values` -- and `variable_init()` therefore took *fresh* slots for a variable whose old ones were still counted. Every scope that created a local leaked, with no diagnostic until the pool ran dry on whichever line happened to be unlucky. Six thousand `GOSUB`s creating one local used to die on the 4091st at `LOC# = 1` with "Array of 1 elements does not fit in the 0 remaining value slots". They now run. A `DEF` called eight thousand times used to die between the four and five thousandth -- the leaking slot was the call scope's parameter, which is a scalar -- and both forms now run. A game creating one name per tick was dead in half a minute; the Breakout in examples/ was, after twenty-five seconds. **A `@` name is the one exclusion, and it is the whole of it.** A structure or a pointer to one keeps pool storage, because a pointer into a record outlives the scope that DIMmed it -- docs/16-structures.md says nothing is reclaimed and `prev_environment()` relies on it. The name suffix is the right test rather than `structtype`, which the DIM path sets *after* calling `variable_init()`. A local array therefore still leaks, deliberately, and is now the narrow rule the tutorial teaches. `SWAP` needed the other half: it copies whole variable records, so the `values` pointer that came over named the other variable's inline slot -- which by then held this variable's own old value -- and SWAP silently did nothing. Caught by tests/language/housekeeping/verbs.bas, which is the golden corpus earning its keep. tests/value_pool.c is the new coverage. It asserts the mechanism as well as the consequence: a later change that moved arrays inline too would pass every behavioural case and quietly break the pointer guarantee. The sharpest case takes the pool's whole 4096 slots in four arrays after two hundred scope entries, so one leaked slot has nowhere to go. Chapter 17 Step 3 taught "declare every name at the top" and no longer needs to. It now teaches what is still true -- a name first seen inside a subroutine dies at RETURN, so a routine cannot answer its caller through one -- and its demonstration is the array case, which still fails. TODO.md section 6 item 30 and section 9 item 1, both struck. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Co-Authored-By: Andrew Kesterson <andrew@aklabs.net>
2026-08-01 23:47:49 -04:00
/**
* @file value_pool.c
* @brief Tests that creating a name inside a scope costs the value pool nothing.
*
* This is the defect a Breakout written against the interpreter died of after
* twenty-five seconds, and nothing in either corpus could have found it: the
* pool holds 4096 values, so it takes *thousands* of scope entries to see, and
* nothing else here runs that long.
*
* The cause was that scope exit returns the variable *slot* and not its storage.
* akbasic_runtime_prev_environment() marks the variable unused,
* akbasic_runtime_new_variable() memsets the slot it hands back -- clearing
* `values` -- and akbasic_variable_init() therefore drew fresh slots for a
* variable whose old ones were still counted. Every GOSUB that created a local
* leaked, with no diagnostic until the pool ran dry on whichever line happened
* to be unlucky.
*
* A scalar now lives in the variable itself, so the pool is not involved at all.
* Two of the counts below are past the old 4096 ceiling on purpose -- under it,
* they would pass against the broken interpreter too. The third takes the
* opposite approach and asks for the whole pool after only a few scopes, which
* is cheaper and sharper: one leaked slot and it has nowhere to go.
*/
#include <string.h>
#include <akbasic/error.h>
#include <akbasic/runtime.h>
#include "harness.h"
#include "testutil.h"
/** @brief Run a program to completion, bounded so a hang fails rather than waits. */
static akerr_ErrorContext AKERR_NOIGNORE *run_program(const char *source)
{
PREPARE_ERROR(errctx);
PASS(errctx, harness_start(NULL));
PASS(errctx, akbasic_runtime_load(&HARNESS_RUNTIME, source));
PASS(errctx, akbasic_runtime_start(&HARNESS_RUNTIME, AKBASIC_MODE_RUN));
PASS(errctx, akbasic_runtime_run(&HARNESS_RUNTIME, 2000000));
SUCCEED_RETURN(errctx);
}
/**
* @brief 6,000 GOSUBs, each creating a local, cost nothing.
*
* TODO.md section 6 item 30's reduction, unchanged. It used to fail at
* `LOC# = 1` on the 4091st call with "Array of 1 elements does not fit in the
* 0 remaining value slots" -- naming the line that was unlucky rather than the
* line that was wrong, which is most of why it cost an evening to find.
*/
static void test_scoped_scalar_costs_nothing(void)
{
TEST_REQUIRE_OK(run_program("10 X# = 0\n"
"20 FOR T# = 1 TO 6000\n"
"30 GOSUB SUBA\n"
"40 NEXT T#\n"
"50 PRINT \"OK \" + X#\n"
"60 END\n"
"70 LABEL SUBA\n"
"80 LOC# = 1\n"
"90 X# = X# + LOC#\n"
"100 RETURN\n"));
TEST_REQUIRE_STR(HARNESS_OUTPUT, "OK 6000\n");
harness_stop();
}
/**
* @brief A `FOR` counter is a name like any other, and costs nothing either.
*