ERRORS

ERRORS prints all 28 ZX81/TS1000 BASIC error messages by invoking machine code POKEd into RAM starting at address 40000. The 25-byte machine code routine is loaded from DATA statements in line 60 and verified with a checksum (2651) before execution. The routine uses ROM calls — specifically the address 0x08A9 (RST or CALL sequences visible in the DATA) — to walk through and display each error message stored in the system ROM. A commented-out alternative DATA line at line 120 shows the same routine expressed as hex string literals, left as an incomplete development artifact.

---

Program Structure

The program is organized into four logical phases:

1. Setup (line 20): Resets the DATA pointer to line 60, sets the load address l=40000, and initializes a checksum accumulator cs=0.
2. Machine code loading (lines 30–50): A FOR loop reads 25 bytes from the DATA statement and POKEs them into memory starting at address 40000, accumulating a byte sum in cs.
3. Checksum verification (line 70): Compares the accumulated sum against the expected value 2651. A mismatch halts with an error message, guarding against corrupt or mistyped DATA.
4. Execution (line 80): RANDOMIZE USR l transfers control to the machine code at address 40000.

Lines 90–120 are development remnants: REMs noting the routine was written on 4/29/86 and marked “incomplete,” followed by line 120 which holds the same machine code expressed as hex string literals in a DATA statement that is never READ. Line 130 is a STOP that prevents line 120’s DATA from being accidentally reached. Line 140 saves the program with LINE 20 to auto-run from line 20.

Machine Code Routine

The 25 bytes POKEd at address 40000 (0x9C40) are a Z80 routine. Disassembling the DATA values from line 60:

Offset	Hex	Z80 Mnemonic	Notes
0	06 1C	LD B, 28	Loop counter: 28 error messages
2	C5	PUSH BC	Preserve counter
3	CD A9 08	CALL 0x08A9	ROM routine to print error message
6	C1	POP BC	Restore counter
7	78	LD A, B	Copy counter to A
8	11 65 0F	LD DE, 0x0F65	Load address (ROM error table or helper)
11	C5	PUSH BC	Preserve counter again
12	CD 3F 07	CALL 0x073F	ROM routine (likely newline/print)
15	06 32	LD B, 50	Inner delay/pause count
17	76	HALT	Wait for interrupt (timing delay)
18	10 FD	DJNZ -3	Repeat HALT 50 times (~1 second pause)
20	C1	POP BC	Restore outer counter
21	10 EB	DJNZ -21	Outer loop: next error message
23	CF	RST 0x08	Return to BASIC (error/restart)
24	1A	LD A, (DE)	(Likely part of RST 0x08 parameter)

The outer loop runs 28 times (LD B, 28 = 0x1C), calling ROM address 0x08A9 each iteration to display an error message, then pausing for approximately 50 interrupt cycles (~1 second at 50 Hz) using a HALT/DJNZ inner loop before advancing to the next message. The RST 0x08 at the end provides a clean return to BASIC.

Checksum Verification

The sum of all 25 DATA bytes is checked against the constant 2651 at line 70. This is a simple but effective integrity check: if any byte in line 60 is mistyped during entry, the program stops rather than executing corrupt machine code that could crash or corrupt the system. The checksum is an arithmetic sum (not CRC), which is typical for this era of hobbyist machine code loading routines.

Notable Techniques

• RESTORE 60 at the start of line 20 ensures the DATA pointer is always reset to line 60, making the program safely re-runnable without manually resetting the pointer.
• The use of RANDOMIZE USR l rather than RAND USR l is the standard idiom for calling machine code; the return value from USR is discarded by RANDOMIZE.
• The HALT instruction inside the timing loop leverages the interrupt mechanism as a delay primitive — each HALT suspends the CPU until the next interrupt (every ~20 ms at 50 Hz), giving a reliable frame-rate-based delay without needing a busy-wait counter.
• Line 120’s DATA of hex strings was an in-development alternative representation of the same machine code, preserved as a reference but intentionally unreachable due to the STOP on line 130.
• VAL is not used for the GO TO/GO SUB targets here; the author uses a simple variable l for the USR address, which is clear and idiomatic.

Bugs and Anomalies

The offset-8 operand in the DATA is 17, 101, 15 (decimal), which decodes as LD DE, 0x0F65. However, the hex comment in line 120 shows "11670f", which would be LD DE, 0x0F67. This two-byte discrepancy between the actual DATA (line 60) and the hex comment (line 120) suggests the hex string version in line 120 was not kept in sync with the final binary — consistent with its “incomplete” status noted in the REMs.

The final two bytes CF 1A (RST 0x08 followed by 1A) follow the convention where RST 8 takes an inline operand byte indicating the error code or action; 0x1A (26 decimal) would correspond to a specific system action.