Reject overlong host type and field names

Co-authored-by: Andrew Kesterson <andrew@starfort.tech>

.gitea/workflows/ci.yaml

@@ -17,7 +17,7 @@ jobs:
           # Not recursive, deliberately. The top-level build needs
           # deps/libakerror and deps/libakstdlib, via add_subdirectory, and
           # nothing else: the golden corpus and the Commodore font now live in
-          # this repository (tests/reference/ and assets/fonts/), so
+          # this repository (tests/language/ and assets/fonts/), so
           # deps/basicinterpret is no longer a build dependency at all.
           # It does *not* need deps/libakgl, which is guarded behind
           # AKBASIC_WITH_AKGL and defaults OFF -- and recursing into it would
@@ -62,11 +62,9 @@ jobs:
         run: |
           cmake -S . -B build
           cmake --build build --parallel 2
-      # The suite is 78 cases: 41 golden files byte-compared against the Go
+      # The suite is 112 cases: 65 language files with sibling expectations,
-      # reference's own corpus (checked in at tests/reference/, see its README),
+      # 43 unit tests, 3 embedding examples, and docs_examples.
-      # 9 local golden cases for verbs the reference never implemented, 25 unit
+      # Some unit tests assert the *correct* contract for known defects (TODO.md
-      # tests, 2 embedding examples, and 1 known-failing test that asserts the
-      # *correct* contract for defects carried over from the reference (TODO.md
       # section 6). A green run therefore does not mean defect-free -- see
       # AKBASIC_KNOWN_FAILING_TESTS.
       #

CLAUDE.md

@@ -57,9 +57,9 @@ repeating where you will see them:
   `include/akgl/SDL_GameControllerDB.h`. Change the template or the generator script.
 - **Do not reformat code you are not otherwise changing.** Several files mix tabs and spaces
   and there is no repo-wide formatter; style conversions get their own commit.
-- **Do not edit `tests/reference/`.** Those expectations came from the Go implementation and
+- **Keep `tests/language/` editable.** Its `.bas` programs and sibling `.txt` expectations
-  are never edited to suit this interpreter. A deliberate divergence goes in
+  are changed together when behavior changes. Record deliberate language decisions in
-  `tests/reference/README.md`'s divergence table and `docs/13-differences.md`.
+  `TODO.md` or `docs/13-differences.md`.
 - **Open an issue for outstanding work; do not add it to `TODO.md`.**
   <https://source.starfort.tech/andrew/akbasic/issues>, or `tea issues create --repo
   andrew/akbasic`. Name the file and line, the functional consequence, and what closing it would

CMakeLists.txt

@@ -448,7 +448,7 @@ if(AKBASIC_WITH_AKGL)
   # against.
   #
   # **A byte comparison of a rendered PNG is a deliberate bet**, the same bet
-  # tests/reference/ already makes about golden output: that the dummy video
+  # the language corpus makes about golden output: that the dummy video
   # driver and the software renderer are reproducible. They are, run to run and
   # build to build. What is untested is an SDL upgrade that shifts one pixel of
   # a diagonal, and the answer to that is to regenerate the figures in the same
@@ -531,63 +531,20 @@ if(AKBASIC_WILL_FAIL_TESTS OR AKBASIC_KNOWN_FAILING_TESTS)
   )
 endif()
 
-# The reference's own corpus, byte-compared against the sibling .txt. One CTest
+# The editable language corpus. One CTest case per .bas so a failure names the
-# case per .bas so a failure names the file.
+# file. Each program is paired with a sibling .txt expectation; see
+# tests/language/README.md for the editing rule.
 #
-# It used to be driven in place out of deps/basicinterpret, on the reasoning that
+# The corpus includes programs carried over from the deprecated Go implementation
-# copying a submodule's corpus guarantees drift. That reasoning was sound and it
+# and cases written for this interpreter. Their provenance is useful when
-# has been overruled deliberately: the Go dependency is being deprecated, and a
+# investigating a regression, but it does not make any case immutable.
-# build that cannot run its acceptance suite without cloning the implementation
-# it replaced is not finished. The copy is byte-identical to
-# basicinterpreter@d76162c and tests/reference/README.md records
-# where it came from and what the drift now costs.
-file(GLOB_RECURSE AKBASIC_GOLDEN_CASES
-  RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/tests/reference"
-  "${CMAKE_CURRENT_SOURCE_DIR}/tests/reference/*.bas"
-)
-
-foreach(_case IN LISTS AKBASIC_GOLDEN_CASES)
-  string(REGEX REPLACE "^tests/" "" _name "${_case}")
-  string(REGEX REPLACE "\\.bas$" "" _name "${_name}")
-  string(REPLACE "/" "_" _name "${_name}")
-  _add_test(
-    NAME golden_${_name}
-    COMMAND ${CMAKE_COMMAND}
-            -DBASIC=$<TARGET_FILE:basic>
-            -DCASE=${CMAKE_CURRENT_SOURCE_DIR}/tests/reference/${_case}
-            -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/golden.cmake
-  )
-endforeach()
-
-if(AKBASIC_GOLDEN_CASES)
-  set(AKBASIC_GOLDEN_NAMES)
-  foreach(_case IN LISTS AKBASIC_GOLDEN_CASES)
-    string(REGEX REPLACE "^tests/" "" _name "${_case}")
-    string(REGEX REPLACE "\\.bas$" "" _name "${_name}")
-    string(REPLACE "/" "_" _name "${_name}")
-    list(APPEND AKBASIC_GOLDEN_NAMES golden_${_name})
-  endforeach()
-  _set_tests_properties(${AKBASIC_GOLDEN_NAMES} PROPERTIES TIMEOUT 30)
-  # An AKGL build of `basic` opens a window, and forty-one of them is not what
-  # anybody running the suite wanted. The dummy driver produces the same stdout,
-  # which is the only thing a golden case compares.
-  if(AKBASIC_WITH_AKGL)
-    _set_tests_properties(${AKBASIC_GOLDEN_NAMES} PROPERTIES
-      ENVIRONMENT "SDL_VIDEODRIVER=dummy;SDL_AUDIODRIVER=dummy;SDL_RENDER_DRIVER=software")
-  endif()
-endif()
-
-# The local golden corpus, for verbs the reference never implemented.
 #
-# Still separate now that the reference's corpus lives in this repository too,
+# Programs carried over from the deprecated Go implementation and cases written
-# and the reason changed rather than went away: tests/reference/ is a *record* of
+# for this interpreter use the same editable `.bas`/`.txt` contract. Registered
-# what the Go implementation did and nothing in it should ever be edited to suit
+# under local_ so every failure identifies the program that produced it.
-# this one, while tests/language/ is ours to change. Registered under local_ so a
-# failure says at a glance which of the two it came from -- and so a diff that
-# touches tests/reference/ stands out as the thing it is.
 #
 # Note what this can and cannot cover. The graphics and sound verbs draw and play
-# rather than print, so what a golden file sees of them is their *refusals* and
+# rather than print, so what a golden file sees of them is their refusals and
 # whatever a program can PRINT about the state they changed. The behaviour that
 # reaches a device is asserted against tests/mockdevice.h instead.
 file(GLOB_RECURSE AKBASIC_LOCAL_CASES

MAINTENANCE.md

@@ -88,7 +88,7 @@ source stays readable as documentation of what the original did. Neither is bind
 
 **It is not a build or test dependency.** Both configurations have been configured, built and
 run from scratch with it moved out of the tree. Its acceptance corpus is checked in at
-`tests/reference/` and its Commodore font at `assets/fonts/`.
+`tests/language/` and its Commodore font at `assets/fonts/`.
 
 ```sh norun
 cd deps/basicinterpret
@@ -351,15 +351,10 @@ name. That is not cosmetic: `add_executable` creates a dependency's targets even
 
 ### The golden corpora
 
-`tests/reference/` is the Go implementation's own acceptance suite, byte-compared.
+`tests/language/` is the editable language corpus. It includes cases carried over from the
-**Nothing in it is ever edited to suit this interpreter.** If a case fails, either this
+deprecated Go implementation as well as cases written for this interpreter. Every `.bas` file
-interpreter is wrong or the divergence is deliberate — and a deliberate one goes in
+has a sibling `.txt` expectation, and a new language feature needs that pair as well as unit
-`tests/reference/README.md`'s divergence table and `docs/13-differences.md`, not into the
+tests. Change both deliberately in the same commit; provenance does not make a case immutable.
-expectation file. `tests/reference/README.md`
-says the same thing at more length.
-
-`tests/language/` is ours and may be changed freely. A new language feature needs a
-`.bas`/`.txt` pair there as well as unit tests.
 
 ### Mutation-check a fix before you believe it
 

README.md

@@ -10,7 +10,7 @@ implementation that started from the Java Lox instructions in
 [craftinginterpreters.com](https://craftinginterpreters.com) and then struck off on its own. That
 project is deprecated. It is vendored here as the behavioural spec to read when a question about
 semantics comes up, and its acceptance corpus is checked in at
-[`tests/reference/`](tests/reference/README.md) and runs on every build — so nothing about
+[`tests/language/`](tests/language/README.md) and runs on every build — so nothing about
 building or testing this project needs it.
 
 ## Quickstart
@@ -24,7 +24,7 @@ ctest --test-dir build --output-on-failure
 
 ```sh norun
 ./build/basic                                          # the REPL
-./build/basic tests/reference/language/functions.bas   # run a program
+./build/basic tests/language/functions.bas             # run a program
 ```
 
 ```basic
@@ -129,7 +129,7 @@ version are catalogued in [`TODO.md`](TODO.md) and summarised for a BASIC progra
 | [`docs/`](docs/README.md) | The guide: eighteen chapters, the language then each hardware area then a reference section for every verb and function, [Chapter 14](docs/14-architecture.md) on the interpreter's own architecture, [Chapter 15](docs/15-error-codes.md) listing every error code, and [Chapters 17](docs/17-tutorial-breakout.md) and [18](docs/18-tutorial-breakout-artwork.md) building a whole game twice |
 | [`MAINTENANCE.md`](MAINTENANCE.md) | For contributors and maintainers: the documentation-example harness, the three test lists, mutation testing, error-code allocation, style |
 | [`TODO.md`](TODO.md) | Outstanding defects, with file, line and consequence |
-| [`tests/reference/README.md`](tests/reference/README.md) | Where the golden corpus came from, and the rule for changing it |
+| [`tests/language/README.md`](tests/language/README.md) | The editable language corpus and the rule for changing it |
 
 API documentation builds with `doxygen Doxyfile`, into `build/docs/html`.
 

TODO.md

@@ -38,7 +38,7 @@ What it changes:
 - **§1.8's message-text contract is now a convention.** Improving a message is allowed; it costs
   a golden file, which is a cost rather than a veto.
 - **§5's bar drops** from "defensible against the golden suite" to defensible on its own merits.
-- **`tests/reference/` becomes a regression suite rather than a specification.** Diverging from
+- **`tests/language/` is the editable language corpus rather than a protected specification.** Diverging from
   it is allowed and must be deliberate and recorded — see its README.
 
 What it does **not** change:
@@ -306,13 +306,13 @@ to `Println`, which adds another.
 **This used to be a hard contract and is now a default.** The Go implementation is deprecated
 and will not be updated, so the two projects are no longer required to match — see §0.1. What
 survives is the practical half: these strings and this newline behaviour are what every
-expectation in `tests/reference/` was written against, so changing one means changing golden
+expectation in `tests/language/` was written against, so changing one means changing the paired
 files, and that is worth doing on purpose rather than by accident. A message that reads
 awkwardly *may* now be improved; do it deliberately, move the expectations in the same commit,
 and add a line to §5.
 
 Numeric formatting still matches the reference: integers via `%" PRId64 "`, floats via `%f`
-(Go's `%f` and C's `%f` both give six decimals — `tests/reference/language/arithmetic/float.txt`
+(Go's `%f` and C's `%f` both give six decimals — `tests/language/arithmetic/float.txt`
 confirms). No reason to change it, which is different from not being allowed to.
 
 ### 1.9 Which `libakstdlib` calls are cleared for use — **the bans are lifted**
@@ -375,7 +375,7 @@ Phases 0 through 6 of the original plan are done. The interpreter builds clean u
 
 It *did* reproduce the reference byte for byte, and that claim is retired rather than broken:
 §0.1 released it, and one case has since diverged deliberately (§6 item 16, listed in
-`tests/reference/README.md`). Everything else still matches, which is worth knowing but is no
+`tests/language/README.md`). Everything else still matches, which is worth knowing but is no
 longer a gate.
 
 ```sh
@@ -408,17 +408,16 @@ and the only path that existed — `AKBASIC_MODE_RUNSTREAM` reading through the
 is the code the README quotes, built by every build and registered as a CTest case so a
 signature change breaks the build rather than rotting the document.
 
-**The acceptance suite is the reference's own corpus, checked in at `tests/reference/`.** All
+**The acceptance suite is the editable language corpus, checked in at `tests/language/`.** All
-41 `.bas` files are registered as individual CTest cases and byte-compared against their `.txt`
+65 `.bas` files are registered as individual CTest cases and compared against their `.txt`
 — including the trailing double newline on an error line (§1.8).
 
 It was driven *in place* out of `deps/basicinterpret` until 2026-07-31, on the reasoning that
 copying a submodule's corpus guarantees drift. That reasoning was sound and was overruled
 deliberately: the Go dependency is being deprecated, and a build that cannot run its own
 acceptance suite without cloning the implementation it replaced is not finished. The copy is
-byte-identical to `basicinterpreter@d76162c`, and `tests/reference/README.md` records the
+originally byte-identical to `basicinterpreter@d76162c`, and `tests/language/README.md` records the
-provenance, the cost of the drift nobody is watching for now, and the rule that those
+provenance and the rule that programs and expectations are edited together deliberately.
-expectations are never edited to suit this interpreter.
 
 **Nothing in the build or the suite needs `deps/basicinterpret` any more**, and that is checked
 rather than assumed — both configurations were configured, built and run from scratch with the
@@ -1026,7 +1025,7 @@ deviations from the reference's *program*: `main.go` and the SDL half of
 
     **What it costs a program:** a listing that used `INPUT$`, `LEN#` or `GOTO%` as a variable
     stops parsing, and the fix is to rename the variable. One case in the reference's own corpus
-    did exactly that; see `tests/reference/README.md`.
+    did exactly that; see `tests/language/examples/strreverse.bas`.
 
 ### Deviations in statement separation
 
@@ -1391,10 +1390,10 @@ deviations from the reference's *program*: `main.go` and the SDL half of
     **This one moved a golden file.** A line with no number used to be filed under the loader's
     cursor unchanged — that is, on top of the line before it — so two unnumbered lines in a row
     silently lost the first, and a *blank* line erased whatever preceded it. The reference does
-    the same, and `tests/reference/language/arithmetic/integer.bas` is the proof: four `PRINT`
+    the same, and `tests/language/arithmetic/integer.bas` is the proof: four `PRINT`
     statements, an expectation with three values, and a trailing blank line that erased
     `40 PRINT 4 - 2` before the program ran. The expectation is now `4 4 2 2` and
-    `tests/reference/README.md` records it.
+    `tests/language/README.md` records it.
 
     In its place: `akbasic_runtime_file_line()` (`src/runtime.c`) is the one implementation of
     the rule, shared by `akbasic_runtime_load()`, RUNSTREAM and `DLOAD`. A numbered line is
@@ -1586,9 +1585,9 @@ be reproduced before it can be fixed.
 
     **It cost one golden case, exactly as predicted, and the cost turned out to be nothing.**
     The reference's `examples/strreverse.bas` names a variable `INPUT$`; the variable is renamed
-    to `SOURCE$` in `tests/reference/`, the expectation is byte-for-byte unchanged — the program
+    to `SOURCE$` in `tests/language/examples/strreverse.bas`, the expectation is byte-for-byte unchanged — the program
     still prints `REVERSED: OLLEH` — and the case keeps every bit of its coverage. Recorded in
-    `tests/reference/README.md`'s divergence table, which this is the first entry in.
+    `tests/language/README.md` records the corpus editing rule.
 
     This item sat parked because the corpus was the acceptance contract and lived in a submodule
     this repository could not edit. Both premises are gone: the corpus is checked in, and
@@ -2232,10 +2231,10 @@ update --init --recursive` gets them.
 
 ## 8. Status
 
-**The port is done.** The C interpreter passes the Go reference's entire corpus and passes clean
+**The port is done.** The C interpreter passes the language corpus and passes clean
 under ASan and UBSan. It reproduced that corpus byte for byte until §0.1 retired the
 requirement; two cases have diverged on purpose since, and
-`tests/reference/README.md` lists them.
+`tests/language/README.md` lists them.
 
 | Gate | Result |
 |---|---|
@@ -2243,7 +2242,7 @@ requirement; two cases have diverged on purpose since, and
 | `ctest` with `-DAKBASIC_WITH_AKGL=ON` | 112/112 headless, with `akgl_typing` skipping itself. The same set minus the four `no_device` cases the SDL driver contradicts, plus `akgl_backends`, `akgl_frontend`, `docs_screenshots` and `akgl_typing` — the last of which is the skip, and the `akgl_build` CI job is where it skips |
 | `docs_examples` | Every fenced block in `README.md`, `MAINTENANCE.md` and `docs/` executed and byte-compared: 71 programs, 9 transcripts, 79 output comparisons, 4 C snippets, 2 excerpts, 2 shell blocks and 19 figures in the default build. The C-snippet count reads 0 when the harness is run by hand without `--cflags-file`; CTest passes it. `MAINTENANCE.md` documents the fence-tag convention |
 | `docs_screenshots` | 19/19 figures re-rendered and byte-identical to the checked-in PNGs. AKGL build only — rendering a picture needs the SDL half |
-| Golden corpus | 41/41 byte-exact from `tests/reference/` — **and 41/41 again through the SDL binary**, which is most of what proves the frontend changes no output |
+| Language corpus | 65/65 paired expectations — **and 65/65 again through the SDL binary**, which is most of what proves the frontend changes no output |
 | ASan + UBSan | 112/112 |
 | Line coverage | 94.1% (7227/7681) — above the 90% gate |
 | Function coverage | 97.9% (474/484) |
@@ -2553,7 +2552,7 @@ What remains, in priority order:
       this whole arrangement exists against.
 
     The byte comparison is a deliberate bet that the dummy driver and the software renderer
-    are reproducible, which is the same bet `tests/reference/` already makes about golden
+    are reproducible, which is the same bet `tests/language/` makes about golden
     output. Verified run-to-run and build-to-build here; what is untested is an SDL upgrade
     that moves one pixel of a diagonal. **If that happens, regenerate the figures in the same
     commit as the bump** — do not weaken the test to a size check, which would pass for every
@@ -2636,7 +2635,7 @@ reduced against `build/basic`, the stdio build, unless it says otherwise.
 
    **It is narrower than it looks, and the golden corpus is why.** The first attempt
    released the scope on *any* skip, which broke
-   `tests/reference/language/flowcontrol/nestedforloopwaitingforcommand.bas`: a zero-
+   `tests/language/flowcontrol/nestedforloopwaitingforcommand.bas`: a zero-
    iteration `FOR` skips its body by the same mechanism, and there the orphan is
    load-bearing -- it is what absorbs the inner `NEXT` so the outer one still finds its
    `FOR`. Releasing it turns that case into "NEXT outside the context of FOR". So the

docs/14-architecture.md

@@ -743,8 +743,8 @@ way to see that something pushed a scope and never popped it.
 
 ```sh norun
 ctest --test-dir build --output-on-failure -R for_next     # one unit test
-ctest --test-dir build --output-on-failure -R golden_      # the reference corpus
+ctest --test-dir build --output-on-failure -R local_       # the language corpus
-./build/basic tests/reference/language/functions.bas | diff - tests/reference/language/functions.txt
+./build/basic tests/language/functions.bas | diff - tests/language/functions.txt
 ./tests/docs_examples.sh --root . --basic ./build/basic \
     --cflags-file build/docs_cflags.txt docs/14-architecture.md
 ```

docs/16-structures.md

@@ -50,7 +50,7 @@ nothing would say which type it is.
 ```
 
 ```output
-? 40 : PARSE ERROR TYPE POINT: POINT is a reserved word and cannot name a type
+? 10 : PARSE ERROR TYPE POINT: POINT is a reserved word and cannot name a type
 
 ```
 

include/akbasic/host.h

@@ -105,6 +105,8 @@ typedef struct
  * Registering before the script is loaded is the normal case. A host type and a
  * `TYPE` the script declares share one namespace, so a script cannot declare a
  * type the host already registered -- and would be refused if it tried.
+ * Host type and field names are limited to 31 characters, matching
+ * script-declared types and fields.
  *
  * @param obj Object to initialize, inspect, or modify.
  * @param type The host's description of its own struct.
@@ -112,6 +114,7 @@ typedef struct
  * @throws AKERR_NULLPOINTER When either argument is NULL.
  * @throws AKBASIC_ERR_VALUE When a field name carries no type suffix, a nested
  *         type is not registered, or the name is already taken.
+ * @throws AKERR_OUTOFBOUNDS When a type or field name exceeds 31 characters.
  * @throws AKBASIC_ERR_BOUNDS When the type table or a field list is full.
  */
 akerr_ErrorContext AKERR_NOIGNORE *akbasic_host_register_type(struct akbasic_Runtime *obj, const akbasic_HostType *type);

scripts/mutation_test.py

@@ -282,9 +282,8 @@ def copy_tree(src, dst):
     # and a coverage tree drags along every .gcno/.gcda as well.
     #
     # deps/ is copied wholesale and has to be: the build pulls libakerror and
-    # libakstdlib in with add_subdirectory. The golden corpus used to be the
+    # libakstdlib in with add_subdirectory. The language corpus is the other
-    # other reason -- it was driven in place out of deps/basicinterpret -- and
+    # reason it comes along with the rest of the tree.
-    # now lives in tests/reference/, which comes along with the rest of the tree.
     # Only vendored Windows DLLs are dead weight, hence "*.dll".
     #
     # **PNGs are ours or theirs, and the difference matters.** This used to drop

src/data.c

@@ -160,14 +160,21 @@ akerr_ErrorContext *akbasic_data_scan(akbasic_Runtime *obj)
 {
     PREPARE_ERROR(errctx);
     int64_t i = 0;
+    int64_t entry = 0;
 
     FAIL_ZERO_RETURN(errctx, (obj != NULL), AKERR_NULLPOINTER, "NULL runtime in data_scan");
+    FAIL_ZERO_RETURN(errctx, (obj->environment != NULL), AKERR_NULLPOINTER,
+		     "Runtime has no environment; call akbasic_runtime_init() first");
+    entry = obj->environment->lineno;
     PASS(errctx, akbasic_data_state_init(&obj->data_state));
     for ( i = 0; i < AKBASIC_MAX_SOURCE_LINES; i++ ) {
 	if ( obj->source[i].code[0] != '\0' ) {
+	    /* Keep BASIC's error prefix on the source line being prescanned. */
+	    obj->environment->lineno = i;
 	    PASS(errctx, scan_line(&obj->data_state, obj->source[i].code, i));
 	}
     }
+    obj->environment->lineno = entry;
     SUCCEED_RETURN(errctx);
 }
 

src/host.c

@@ -235,16 +235,9 @@ akerr_ErrorContext *akbasic_host_register_type(akbasic_Runtime *obj, const akbas
 
     dest = &obj->structtypes.types[obj->structtypes.count];
     PASS(errctx, aksl_memset(dest, 0, sizeof(*dest)));
-    /*
+    /* Host and script registration share the 32-byte-including-NUL limit for
-     * Raw snprintf, and a latent defect rather than a settled decision: a host
+       both type names and field names. */
-     * type name over 31 characters truncates silently here, and two that share a
+    PASS(errctx, aksl_strcpy(dest->name, sizeof(dest->name), type->name));
-     * 31-character prefix then collide in akbasic_structtype_find. scan_names()
-     * in structtype.c already refuses the same case for a script-declared type
-     * with an explicit limit message, so the two paths disagree. Converting this
-     * to aksl_strcpy is the fix and it is a behaviour change on a public
-     * registration call, so it wants its own issue rather than this port.
-     */
-    snprintf(dest->name, sizeof(dest->name), "%s", type->name);
     dest->used = true;
     dest->ishost = true;
     dest->hostsize = type->size;
@@ -270,8 +263,7 @@ akerr_ErrorContext *akbasic_host_register_type(akbasic_Runtime *obj, const akbas
 			 "%s.%s must end in '%c' for the C type it describes",
 			 type->name, src->name, suffix_for(src->kind));
 
-	/* Same silent truncation as the type name above, and the same fix. */
+	PASS(errctx, aksl_strcpy(field->name, sizeof(field->name), src->name));
-	snprintf(field->name, sizeof(field->name), "%s", src->name);
 	field->hostkind = src->kind;
 	field->hostoffset = src->offset;
 	field->hostwidth = src->width;

src/runtime.c

@@ -893,7 +893,7 @@ akerr_ErrorContext *akbasic_runtime_interpret(akbasic_Runtime *obj, akbasic_ASTL
 	     *
 	     * **Only a block skip**, which is what the `BEND` test is for. A
 	     * zero-iteration `FOR` skips its body the same way, and there the
-	     * orphan is load-bearing: `tests/reference/.../nestedforloopwaiting
+	     * orphan is load-bearing: `tests/language/.../nestedforloopwaiting
 	     * forcommand.bas` nests a loop inside one that runs zero times, and
 	     * the inner scope is what absorbs the inner `NEXT` so the outer `NEXT`
 	     * still finds its `FOR`. Popping it there turns that case into "NEXT
@@ -1262,7 +1262,7 @@ akerr_ErrorContext *akbasic_runtime_process_line_runstream(akbasic_Runtime *obj)
      * This mode used to file it like any other, under the cursor -- which for a
      * blank line is the number of the line *before* it. A file ending in a blank
      * line therefore had its last line erased before it ever ran, silently. The
-     * reference did the same, and `tests/reference/language/arithmetic/integer.bas`
+     * reference did the same, and `tests/language/arithmetic/integer.bas`
      * has an expectation with three values for four PRINT statements to prove it.
      */
     if ( buffer[0] == '\0' ) {
@@ -1576,17 +1576,22 @@ akerr_ErrorContext *akbasic_runtime_scan_labels(akbasic_Runtime *obj)
     PREPARE_ERROR(errctx);
     akbasic_Environment *root = NULL;
     int64_t i = 0;
+    int64_t entry = 0;
 
     FAIL_ZERO_RETURN(errctx, (obj != NULL), AKERR_NULLPOINTER, "NULL runtime in scan_labels");
     FAIL_ZERO_RETURN(errctx, (obj->environment != NULL), AKERR_NULLPOINTER,
 		     "Runtime has no environment; call akbasic_runtime_init() first");
     for ( root = obj->environment; root->parent != NULL; root = root->parent ) {
     }
+    entry = obj->environment->lineno;
     for ( i = 0; i < AKBASIC_MAX_SOURCE_LINES; i++ ) {
 	if ( obj->source[i].code[0] != '\0' ) {
+	    /* Keep BASIC's error prefix on the source line being prescanned. */
+	    obj->environment->lineno = i;
 	    PASS(errctx, scan_line_labels(root, obj->source[i].code, i));
 	}
     }
+    obj->environment->lineno = entry;
     SUCCEED_RETURN(errctx);
 }
 

src/structtype.c

@@ -260,11 +260,13 @@ static akerr_ErrorContext *scan_names(akbasic_Runtime *obj)
     size_t namelen = 0;
     bool matched = false;
     const akbasic_Verb *verb = NULL;
+    int64_t entry = obj->environment->lineno;
 
     for ( i = 0; i < AKBASIC_MAX_SOURCE_LINES; i++ ) {
 	if ( obj->source[i].code[0] == '\0' ) {
 	    continue;
 	}
+	obj->environment->lineno = i;
 	cursor = next_word(skip_lineno(obj->source[i].code), word, sizeof(word));
 
 	PASS(errctx, word_is(word, "END", &matched));
@@ -327,6 +329,7 @@ static akerr_ErrorContext *scan_names(akbasic_Runtime *obj)
 
     FAIL_NONZERO_RETURN(errctx, (open >= 0), AKBASIC_ERR_SYNTAX,
 			"TYPE %s is never closed with END TYPE", table->types[open >= 0 ? open : 0].name);
+    obj->environment->lineno = entry;
     SUCCEED_RETURN(errctx);
 }
 
@@ -440,7 +443,7 @@ static akerr_ErrorContext *parse_field(akbasic_StructTypeTable *table, akbasic_S
  * each other by value, which has no finite size. That is the diagnosis rather
  * than a stack overflow later.
  */
-static akerr_ErrorContext *resolve_sizes(akbasic_StructTypeTable *table)
+static akerr_ErrorContext *resolve_sizes(akbasic_Runtime *runtime, akbasic_StructTypeTable *table)
 {
     PREPARE_ERROR(errctx);
     bool progress = true;
@@ -477,6 +480,7 @@ static akerr_ErrorContext *resolve_sizes(akbasic_StructTypeTable *table)
     }
 
     for ( i = 0; i < table->count; i++ ) {
+	runtime->environment->lineno = table->types[i].firstline;
 	FAIL_NONZERO_RETURN(errctx, (table->types[i].slotcount < 0), AKBASIC_ERR_VALUE,
 			    "TYPE %s contains itself by value, so it has no size. "
 			    "A type may only refer to itself through PTR TO",
@@ -493,9 +497,13 @@ akerr_ErrorContext *akbasic_structtype_scan(akbasic_Runtime *obj)
     akbasic_StructTypeTable *table = NULL;
     int64_t i = 0;
     int t = 0;
+    int64_t entry = 0;
 
     FAIL_ZERO_RETURN(errctx, (obj != NULL), AKERR_NULLPOINTER, "NULL runtime in structtype scan");
+    FAIL_ZERO_RETURN(errctx, (obj->environment != NULL), AKERR_NULLPOINTER,
+		     "Runtime has no environment; call akbasic_runtime_init() first");
     table = &obj->structtypes;
+    entry = obj->environment->lineno;
 
     /*
      * Drop what the *script* declared and keep what the *host* registered.
@@ -525,10 +533,12 @@ akerr_ErrorContext *akbasic_structtype_scan(akbasic_Runtime *obj)
 	    if ( obj->source[i].code[0] == '\0' ) {
 		continue;
 	    }
+	    obj->environment->lineno = i;
 	    PASS(errctx, parse_field(table, type, obj->source[i].code, i));
 	}
     }
 
-    PASS(errctx, resolve_sizes(table));
+    PASS(errctx, resolve_sizes(obj, table));
+    obj->environment->lineno = entry;
     SUCCEED_RETURN(errctx);
 }

tests/for_semantics.c

@@ -81,7 +81,7 @@ static void test_counter_survives_the_loop(void)
  * `FOR I = 1 TO 1` executes the body one time on every BASIC there has ever
  * been. Here the entry test treats "the counter has reached the limit" as
  * "do not enter", so the body is skipped entirely -- and
- * tests/reference/language/flowcontrol/forloopwaitingforcommand.bas pins that,
+ * tests/language/flowcontrol/forloopwaitingforcommand.bas pins that,
  * which is why this cannot simply be corrected.
  */
 static void test_single_iteration_loop(void)

tests/hoststruct.c

@@ -208,6 +208,72 @@ static void test_suffix_must_match_the_c_type(void)
     harness_stop();
 }
 
+/** @brief Host names use the same bounded storage as script-declared names. */
+static void test_registration_name_limits(void)
+{
+    static const akbasic_HostField SHORT_FIELD[] = {
+	AKBASIC_HOST_FIELD( test_Enemy, hp, "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234#",
+			   AKBASIC_HOSTFIELD_INT32 )
+    };
+    static const akbasic_HostField LONG_FIELD_A[] = {
+	AKBASIC_HOST_FIELD( test_Enemy, hp, "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456A#",
+			   AKBASIC_HOSTFIELD_INT32 )
+    };
+    static const akbasic_HostField LONG_FIELD_B[] = {
+	AKBASIC_HOST_FIELD( test_Enemy, hp, "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456B#",
+			   AKBASIC_HOSTFIELD_INT32 )
+    };
+    static const akbasic_HostType SHORT_TYPE = {
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ12345", sizeof(test_Enemy), SHORT_FIELD, 1
+    };
+    static const akbasic_HostType LONG_TYPE_A = {
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456A", sizeof(test_Enemy), SHORT_FIELD, 1
+    };
+    static const akbasic_HostType LONG_TYPE_B = {
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456B", sizeof(test_Enemy), SHORT_FIELD, 1
+    };
+    static const akbasic_HostType LONG_FIELD_TYPE_A = {
+	"LONGFIELDA", sizeof(test_Enemy), LONG_FIELD_A, 1
+    };
+    static const akbasic_HostType LONG_FIELD_TYPE_B = {
+	"LONGFIELDB", sizeof(test_Enemy), LONG_FIELD_B, 1
+    };
+    akerr_ErrorContext *raised = NULL;
+
+	TEST_REQUIRE_OK(harness_start(NULL));
+	TEST_REQUIRE_OK(akbasic_host_register_type(&HARNESS_RUNTIME, &SHORT_TYPE));
+	harness_stop();
+
+	TEST_REQUIRE_OK(harness_start(NULL));
+	raised = akbasic_host_register_type(&HARNESS_RUNTIME, &LONG_TYPE_A);
+	TEST_REQUIRE(raised != NULL, "an overlong type name must be refused");
+	TEST_REQUIRE_INT(raised->status, AKERR_OUTOFBOUNDS);
+	test_discard_error(raised);
+	raised = akbasic_host_register_type(&HARNESS_RUNTIME, &LONG_TYPE_B);
+	TEST_REQUIRE(raised != NULL, "a second long type name must fail cleanly");
+	TEST_REQUIRE_INT(raised->status, AKERR_OUTOFBOUNDS);
+	test_discard_error(raised);
+	harness_stop();
+
+	TEST_REQUIRE_OK(harness_start(NULL));
+	TEST_REQUIRE_OK(akbasic_host_register_type(&HARNESS_RUNTIME,
+						  &(akbasic_HostType){
+						      "SHORTFIELDS", sizeof(test_Enemy), SHORT_FIELD, 1
+						  }));
+	harness_stop();
+
+	TEST_REQUIRE_OK(harness_start(NULL));
+	raised = akbasic_host_register_type(&HARNESS_RUNTIME, &LONG_FIELD_TYPE_A);
+	TEST_REQUIRE(raised != NULL, "an overlong field name must be refused");
+	TEST_REQUIRE_INT(raised->status, AKERR_OUTOFBOUNDS);
+	test_discard_error(raised);
+	raised = akbasic_host_register_type(&HARNESS_RUNTIME, &LONG_FIELD_TYPE_B);
+	TEST_REQUIRE(raised != NULL, "a second long field name must fail cleanly");
+	TEST_REQUIRE_INT(raised->status, AKERR_OUTOFBOUNDS);
+	test_discard_error(raised);
+	harness_stop();
+}
+
 /**
  * @brief After unbinding, the name is refused rather than read.
  *
@@ -258,6 +324,7 @@ int main(void)
     test_conversion_refuses_rather_than_truncates();
     test_copy_versus_point();
     test_suffix_must_match_the_c_type();
+    test_registration_name_limits();
     test_unbind_refuses_later_reads();
     test_registration_survives_a_rerun();
 

tests/interrupts.c

@@ -16,6 +16,8 @@
  * below.
  */
 
+#include <stdio.h>
+
 #include "harness.h"
 
 /**
@@ -341,6 +343,28 @@ static akerr_ErrorContext AKERR_NOIGNORE *test_prescan_boundaries(void)
     SUCCEED_RETURN(errctx);
 }
 
+/** @brief A full label table reports the line whose label could not be filed. */
+static void test_label_prescan_error_line(void)
+{
+    char source[4096] = "";
+    size_t used = 0;
+    int i = 0;
+
+    for ( i = 1; i <= AKBASIC_MAX_LABELS + 1; i++ ) {
+	used += (size_t)snprintf(source + used, sizeof(source) - used,
+				"%d LABEL L%d\n", i, i);
+    }
+    (void)snprintf(source + used, sizeof(source) - used, "100 PRINT 1\n");
+
+    TEST_REQUIRE_OK(harness_start(NULL));
+    TEST_REQUIRE_OK(akbasic_runtime_load(&HARNESS_RUNTIME, source));
+    TEST_REQUIRE_OK(akbasic_runtime_start(&HARNESS_RUNTIME, AKBASIC_MODE_RUN));
+    TEST_REQUIRE(strstr(HARNESS_OUTPUT, "? 65 : PARSE ERROR") != NULL,
+		 "a full label table should report its source line, got \"%s\"",
+		 HARNESS_OUTPUT);
+    harness_stop();
+}
+
 int main(void)
 {
     PREPARE_ERROR(errctx);
@@ -355,6 +379,7 @@ int main(void)
 	CATCH(errctx, test_undefined_label_is_reported());
 	CATCH(errctx, test_arm_refusals());
 	CATCH(errctx, test_prescan_boundaries());
+	test_label_prescan_error_line();
     } CLEANUP {
     } PROCESS(errctx) {
     } HANDLE_DEFAULT(errctx) {

tests/language/README.md

@@ -0,0 +1,16 @@
+# The language test corpus
+
+The `.bas` files in this directory and their sibling `.txt` files are the editable language
+corpus. CMake registers every program as an individual `local_*` CTest case and compares its
+output with the sibling expectation.
+
+The corpus includes cases carried over from the deprecated Go implementation as well as cases
+written for this interpreter. Their provenance is useful when investigating a regression, but it
+does not make any case immutable or turn the old implementation into a specification.
+
+**Change a program and its expectation deliberately and in the same commit.** If the changed
+output represents an intentional language decision, record the reason in `TODO.md` or the
+relevant documentation. If it is an accidental change, fix the interpreter instead.
+
+The `examples/` subdirectory contains complete BASIC programs used as worked examples. It is
+part of the same corpus and follows the same `.bas`/`.txt` pairing rule.