Variable A

This program is a TS2068 variable area inspector that decodes and displays the contents of the system variable area starting at STKBOT (addresses 23627–23628). It walks through each variable record, identifying type by examining the high three bits of the first byte (dividing by 32), and dispatches to subroutines that handle single-letter numeric variables, multi-character numeric variable names, numeric arrays, FOR–NEXT loop control variables, strings, and string arrays. Numeric values are decoded from the Spectrum’s five-byte floating-point format in subroutine 800, correctly handling both the integer shortcut (byte 1 = 0) and full floating-point mantissa/exponent reconstruction. The array subroutine at line 900 reads dimension counts and element sizes, computing total element count as a product of all dimensions.

---

Program Analysis

Program Structure

The program is organized as a dispatcher loop anchored at line 20. It reads successive bytes from the variable area (whose start address is obtained via the system variables at addresses 23627–23628, pointing to VARS), then branches to one of six type-handling blocks based on the upper three bits of the first byte of each variable record.

Lines	Role
1–5	Setup: screen colors, dimension working array b(5)
10–70	Main dispatch loop: read type byte, branch on p2=INT(p1/32)
100–120	Type 3 — single-letter numeric variable
200–270	Type 5 — multi-character numeric variable name
300–330	Type 4 — numeric array
400–465	Type 6 (bits 110) — FOR–NEXT loop control variable
500–550	Type 2 — string variable
600–650	Type 6 (bits 110, lower) — string array (dispatched as p2=6)
800–875	Subroutine: decode five-byte float/integer into n
900–945	Subroutine: parse array header (dimensions, total element count t)
9998	SAVE with auto-run

Variable Area Traversal

The pointer p is initialized from the two-byte system variable VARS (23627 low byte, 23628 high byte). The main loop at line 20 peeks p into p1, checks for the sentinel value 128 (end-of-variables marker), and otherwise dispatches. Each type handler is responsible for advancing p past the record before looping back to line 20 via GO TO 20. The subroutine at line 800 always advances p by 5 bytes as a side effect, which is relied upon by all numeric decoding callers.

Type Detection

The Spectrum encodes variable type in the upper three bits of the first byte of each record. The program recovers this with LET p2=INT(p1/32), equivalent to a right-shift by 5 bits. The mapping is:

• p2=3 (bits 011x xxxx) — single-letter number, name in low 5 bits
• p2=5 (bits 101x xxxx) — multi-character number name
• p2=4 (bits 100x xxxx) — numeric array
• p2=7 (bits 111x xxxx) — FOR loop variable
• p2=2 (bits 010x xxxx) — string
• p2=6 (bits 110x xxxx) — string array

Five-Byte Floating-Point Decoder (Lines 800–875)

The Spectrum stores numbers in a five-byte format: byte 1 is the exponent (biased by 128), bytes 2–5 are the mantissa with the sign in bit 7 of byte 2. The integer shortcut uses byte 1 = 0, with byte 2 acting as a sign byte (0 = positive, 255 = negative) and bytes 3–4 holding a 16-bit value.

1. If b(1)=0, use integer path: n=b(3)+256*b(4); if b(2)=255, subtract 65536 for negative values.
2. Otherwise, record the sign from b(2) >= 128, force bit 7 of b(2) to 1 (the implicit leading 1 of the mantissa), accumulate mantissa as b(2)/1 + b(3)/256 + b(4)/65536 + b(5)/16777216 (loop from j=2 to 5, dividing by 256^(j-1)), then apply the exponent: n=n*2^(b(1)-128).
3. Negate if the sign flag m was set.

Note a subtle issue: the mantissa loop at line 855 uses b(j)/256^(j-1) starting at j=2, which gives b(2)/256 + b(3)/65536 + ... — this is off by a factor of 256 compared to the canonical reconstruction (which starts dividing from j=1 with b(2) as the most significant byte). This is compensated by the exponent term in line 865: the effective result is still mathematically correct because the exponent is adjusted implicitly by the off-by-one scaling. However, the reconstruction is non-standard and could accumulate floating-point rounding errors for large mantissa values.

Array Header Parser (Lines 900–945)

Called for both numeric and string arrays, this subroutine reads the two-byte length field at p+1, advances past it and the dimension count byte, then loops over each dimension, reading its two-byte element count. It multiplies all dimensions together into t (total elements) and prints each dimension size. The closing LET p=p-1 at line 940 backs up one byte so the caller’s subsequent increment keeps p aligned correctly to the first element.

String Array Handler (Lines 600–650)

The string array handler at line 600 is notably simplified: it prints only a single character per element (line 630: CHR$ PEEK p), suggesting it only handles arrays of single characters or is incomplete for multi-character string arrays. Full Spectrum string arrays store each element as a fixed-length string whose length equals the last dimension; this nuance is not reflected in the display logic.

Notable Bugs and Anomalies

• Line 550: LET p=p+j uses the final value of j after the NEXT j loop exits. In Spectrum BASIC, j after the loop equals l+1, so the pointer advances by l+1 instead of the intended l. This is a classic off-by-one error that will misalign p for subsequent variables.
• Line 60: Comment says “string aray” (typo for “array”).
• Line 450: FOR loop variable includes line number (2 bytes) and statement number (1 byte) stored after the three five-byte numeric fields; the pointer is advanced by 4 here but the three prior GO SUB 800 calls already moved it by 15, so the total per-record advance is correct.
• Line 1: INK 9 selects “transparent ink” on the Spectrum, meaning character ink color inherits from the existing screen attribute — an unusual choice that relies on the display state at startup.

Key BASIC Idioms

• Using PEEK 23627+256*PEEK 23628 to read a two-byte little-endian system variable address is standard Spectrum BASIC practice.
• TAB is used throughout for columnar alignment of output without needing a separate formatting routine.
• The subroutine at line 800 advances the global pointer p as a side effect, making it a stateful iterator rather than a pure function — a common pattern in memory-walking BASIC utilities.