Renumber

This program is a BASIC renumbering utility that rewrites line number references (GO TO, GO SUB, ON ERR GO TO, RESTORE, etc.) throughout a BASIC program. The bulk of the work is performed by 383 bytes of Z80 machine code, loaded into RAM at address 64986 via a hex-string DATA loader in lines 9943–9991. The DATA loader decodes pairs of ASCII hex digits from 48 DATA strings into raw bytes using the expression (CODE a$(k)-48-(7 AND a$(k)>"9"))*16+..., a standard technique for embedding machine code in BASIC. At runtime, line 9998 prompts for a starting line number and step value, stores them into memory-mapped variables at addresses 23297–23299, then transfers control to the machine code with RANDOMIZE USR 64986. The utility is designed to be MERGEd into the target program, used once, then removed.

---

Program Analysis

Program Structure

The program divides cleanly into four parts:

1. Lines 10–12: REM documentation describing the utility’s purpose and usage instructions.
2. Line 9943: The DATA loader — reads 48 hex strings and POKEs decoded bytes to address 64986 onward.
3. Lines 9944–9991: 48 DATA statements, each containing 16 hex-encoded bytes (8 bytes per string × 2 chars each = 16 chars, actually 16 hex digits = 8 bytes per line, giving 48 × 8 = 384 bytes, though the header states 383).
4. Lines 9998–9999: The user-facing entry point: prompts for start line and step, stores parameters, invokes machine code, then LISTs the result.

Machine Code Loader (Line 9943)

The loader at line 9943 uses a compact but well-known hex-decode idiom:LET num=(CODE a$(k)-48-(7 AND a$(k)>"9"))*16+(CODE a$(k+1)-48-(7 AND a$(k+1)>"9"))

This converts each pair of ASCII hex characters to a byte value. Subtracting 48 converts digits ‘0’–’9′ to 0–9. The extra -7 adjustment (applied when the character is greater than ‘9’) handles the gap between ‘9’ (57) and ‘A’ (65) in ASCII, correctly converting hex letters A–F to 10–15. The result is POKEd sequentially from address 64986.

The loader iterates with FOR j=1 TO 48 (one iteration per DATA string) and an inner FOR k=1 TO LEN a$ STEP 2 walking character pairs. After loading, a LIST is executed, which is an unusual choice — it may be intended to confirm loading completed, or it is a leftover artifact.

Parameter Passing (Line 9998)

Line 9998 stores the user-supplied renumbering parameters into fixed memory locations before invoking the machine code routine:

Address	Content	How stored
23297	Low byte of starting line number	L-(INT(L/256))*256
23298	High byte of starting line number	INT(L/256)
23299	Step value	Direct POKE of L

Addresses 23297–23299 fall in the system variables area (RAMTOP and surrounding bytes on the standard Spectrum/TS2068 map). The machine code reads these three bytes as its configuration inputs. The low/high byte split uses integer division rather than bitwise operations, which is the idiomatic BASIC approach on this platform.

Note that the step value is stored as a single byte (POKE accepts 0–255), limiting the renumbering step to a maximum of 255.

Machine Code Routine

The 383-byte Z80 routine at 64986 performs the actual renumbering. Based on the DATA content and the described behaviour, it walks the BASIC program area (whose start address is read from system variable PROG at 23635, i.e., 2A 53 5C = LD HL,(5C53h)) and scans each line for keyword tokens that are followed by line number arguments. Tokens handled include GO TO, GO SUB, RESTORE, and ON ERR GO TO. For each such reference it finds, it calculates the new line number and overwrites the relevant bytes in place.

The routine uses ROM calls (visible as CD 4C FF, CD 41 FF, CD EE 0A, CD E2 FE, CD D4 FE, etc.), leveraging existing ROM floating-point and display routines rather than implementing them from scratch. The RANDOMIZE USR 64986 call in line 9998 is the standard method for invoking machine code from BASIC.

Notable Techniques

• Hex DATA loader: Encoding machine code as hex strings in DATA statements avoids the need for a separate binary file or POKE-per-byte listings, and is resilient to line re-ordering.
• MERGE workflow: The utility is designed to be MERGEd into the target program at high line numbers (9943–9999), used, then deleted with DELETE, keeping the utility self-contained and non-destructive to the user’s code below line 9943.
• ROM call reuse: The machine code delegates number parsing and display to existing ROM routines, keeping the routine compact at under 400 bytes.
• RESTORE 9944 at the start of line 9943 ensures the DATA pointer is correctly positioned regardless of prior BASIC execution state.

Potential Issues and Anomalies

• The header claims 383 bytes but 48 DATA strings × 8 bytes = 384 bytes. This is a minor discrepancy; the machine code likely ends one byte short of the full 384, with the last byte unused or the count off by one.
• The step value is limited to a single byte (0–255) due to the direct POKE at address 23299, which may be too restrictive for programs with widely spaced line numbers if a step larger than 255 is desired.
• The LIST at the end of line 9943 causes the screen to scroll through the program after loading, which may be disorienting but is not harmful.
• Line 9999 executes LIST after renumbering completes, providing immediate visual confirmation of the result.