Variable Area

This program dumps and decodes the entire variable area in human-readable form, walking through memory starting at the address stored in system variables VARS (23627–23628). It identifies all seven variable types — single-letter numerics, multi-character named numerics, numeric arrays, FOR-NEXT loop control blocks, strings, and string arrays — by inspecting the high three bits of each entry’s first byte. Numeric values are decoded from the Spectrum’s five-byte floating-point format, including the sign bit, biased exponent (offset 128), and mantissa reconstruction across bytes 2–5. The FOR-NEXT loop handler extracts the current value, limit, step, line number, and statement counter from the control block, displaying them with labeled column alignment using TAB.

---

Program Structure

The program is organized as a dispatcher with a main loop and a set of subroutines. Lines 10–70 form the main loop: they read the current byte at pointer p, determine the variable type from the upper three bits, and branch to one of six handlers. Line 25 detects the end-of-variable-area sentinel byte (128). Lines 100–650 are the six type handlers, and lines 800–940 are shared utility subroutines.

Lines	Role
1–5	Initialization: screen colors, dimension work array
10–70	Main dispatch loop
100–120	Handler: single-letter numeric variable (type 3)
200–270	Handler: multi-character numeric variable (type 5)
300–330	Handler: numeric array (type 4)
400–465	Handler: FOR-NEXT loop control block (type 7)
500–550	Handler: string variable (type 2)
600–650	Handler: string array (type 6)
800–875	Subroutine: read and decode 5-byte float/integer
900–945	Subroutine: read array header (dimensions and total element count)

Variable Area Navigation

The starting address is fetched via PEEK 23627+256*PEEK 23628, which reads the two-byte system variable VARS. The pointer p is advanced manually after each field is consumed. This byte-by-byte traversal mirrors what the Spectrum ROM itself does when searching for variables.

Type Dispatch Mechanism

At line 30, p2 = INT(p1/32) extracts the top three bits of the first byte (equivalent to a right-shift by 5). The resulting value identifies the variable type:

• p2=3 — single-letter numeric (bits 011)
• p2=5 — multi-character numeric name (bits 101)
• p2=4 — numeric array (bits 100)
• p2=7 — FOR-NEXT loop control (bits 111)
• p2=2 — string variable (bits 010)
• p2=6 — string array (bits 110)

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

The Spectrum stores all numeric variables in a five-byte format. Subroutine 800 first reads five bytes into array b(). If b(1) is zero, the value is a short integer stored in b(3) and b(4), with b(2)=255 signaling a negative value (two’s complement adjusted by subtracting 65536).

For true floating-point values, b(1) holds the biased exponent (bias 128), b(2) holds the sign in its high bit plus the implicit leading mantissa bit, and bytes 3–5 hold the remaining mantissa. The reconstruction at line 855 iterates j=2 TO 5, accumulating b(j)/256^(j-1). After restoring the implicit bit and adjusting the exponent at line 860, the result is scaled by 2^b(1). The sign flag m is applied last.

Multi-Character Variable Name Decoding (Lines 200–260)

In the Spectrum variable area, multi-character names encode the first letter with bit 6 set (adding 64) and the last letter with bit 7 set (adding 128), while intermediate letters are stored as plain ASCII. The handler subtracts 64 from the first byte and 128 from the last byte to recover the original characters, printing them in sequence.

FOR-NEXT Loop Block Handler (Lines 400–465)

A FOR-NEXT control block stores five values in sequence: the current loop value, the limit (TO value), the step, the line number (two bytes), and the statement number within that line. The handler calls subroutine 800 three times to decode the floating-point current, limit, and step values, then reads the two-byte line number and one-byte statement index directly with PEEK.

Array Header Subroutine (Lines 900–940)

Subroutine 900 reads the two-byte total byte-length field, then the dimension count d, then iterates over each dimension’s two-byte element count. It computes the total number of elements t as a running product (line 920), and prints the dimension sizes separated by commas before the closing parenthesis. The pointer is left one byte before the first element so that subsequent loops calling subroutine 800 (which pre-increments p) land correctly.

Notable Techniques

• The array b(5) (line 5) is reused on every call to subroutine 800, avoiding repeated variable declarations.
• TAB columns are used consistently for value alignment: column 16 for numeric values, column 22 for labels, giving the output a structured columnar appearance.
• The main loop uses GO TO 20 rather than a FOR loop, since the step between entries is variable-length and depends on the type just processed.

Bugs and Anomalies

• String array elements (lines 610–640): The handler reads only one byte per element (CHR$ PEEK p), which is incorrect for multi-character string array elements. Each element in a string array occupies a fixed number of characters defined by the last array dimension, so only the first character of each element is shown.
• Typo at line 60: The REM comment reads “string aray” (missing ‘r’), which is cosmetic only.
• Floating-point sign bit handling (line 850): When b(2) is less than 128 the sign flag m is set to 0 (positive) and 128 is added back to b(2) to restore the implicit leading mantissa bit. This logic is inverted from what the comment might suggest but is arithmetically correct for the Spectrum’s format.