RAMPager

RAMPAGE-R is a machine-code-driven RAM text editor that loads and runs a substantial Z80 routine embedded in the REM statement at line 1. The program displays a title screen rendered in block graphics alongside a command reference listing read/write operations such as address jump, page navigation, copy, insert, and kill. After the user presses ENTER, control is transferred to the machine code via RAND USR 30720 (line 250). A separate save routine at line 1000 uses RAND USR 16526 to invoke the system’s SAVE entry point, preserving the program including its embedded binary payload. The REM block at line 1 contains several hundred bytes of Z80 machine code that implements the full editor logic, including keyboard scanning, screen memory manipulation, and cursor movement.

---

Program Analysis

Program Structure

The listing divides into two functional blocks:

1. Lines 1–260: Title/splash screen, command reference, and launch sequence.
2. Lines 1000–1030: A self-save utility that preserves the program (including machine code) back to tape.

Line 1 is a REM statement whose body is not human-readable text but rather a dense stream of Z80 opcodes. The BASIC portion is purely a loader/UI shell; every meaningful operation of the editor is performed by the machine code.

Machine Code Payload

The REM at line 1 contains several hundred bytes of Z80 machine code. The entry point is reached by RAND USR 30720 at line 250. The hex address 30720 (0x7800) places the entry inside the REM body, which in a 16 KB RAM machine sits in a predictable location given a freshly loaded program.

Significant Z80 patterns visible in the payload include:

• ED B0 — LDIR block-copy instructions, used for moving screen data and initialising memory regions.
• ED 42 / ED 52 — SBC HL,BC / SBC HL,DE, used for 16-bit comparisons to determine cursor position boundaries and direction.
• CD BB 02 — repeated CALL 0x02BB, the ROM keyboard-scan routine that returns a key row/column result; used throughout the main edit loop for polled input.
• CD BD 07 — CALL 0x07BD, the ROM routine that converts a character address to a display-file address.
• CD 1C 7A — an internal subroutine (within the REM body) called repeatedly; likely the routine that writes nibble-encoded characters to the display file.
• Structured CALL cc / JP cc chains implementing a multi-key dispatch table for the editor commands (A, 6, 7, Z, W, L, S6, S7, I, K).
• CB 44, CB 5D, CB 65 — BIT tests on B and E registers, used to decode the two-byte keyboard port result into individual key states.

Title Screen Rendering

Lines 20–40 use zmakebas block-graphic escape sequences to draw a decorative logo in the BASIC PRINT statements. The logo is composed entirely of the eight 2×2 block characters (codes 128–135), requiring no UDG definitions or machine code for the title art.

Line 100 uses inverse-video characters (percent-encoded as %R%A%M%P%A%G%E%R etc.) to render the heading “RAMPAGE-R COMMAND LIST” with alternating highlighted letters, a common Sinclair BASIC display technique.

Lines 120 uses repeated \~~ sequences (inverse tilde / pound-sign characters) to draw separator lines, producing a ruled appearance.

Command Reference Table

The on-screen command list documents the following editor operations:

Mode	Key	Function
Read	A	Address (jump to address)
Read	6	Next page
Read	7	Last page
Read	Z	Copy
Read	W	Write (enter write mode)
Write	L	Last (go to last)
Write	S6	Scroll down
Write	S7	Scroll up
Write	I	Insert
Write	K	Kill (delete)
Both	ENTER	Return to Read mode
Both	BREAK	Return to BASIC

Input Handling (BASIC side)

Line 230 implements a busy-wait on INKEY$ comparing against CHR$ 118 (the ENTER key, character code 0x76 in the Sinclair character set) before launching the machine code. This is the standard BASIC polling idiom for waiting on a specific keypress without halting execution.

Save Routine

Lines 1000–1030 constitute a self-contained save block. RAND USR 16526 at line 1020 calls the ROM SAVE entry point (address 0x408E / 16526), causing the entire BASIC program — including the REM-embedded machine code — to be saved to tape under the name RAMPAGE-R (rendered with inverse R via %R). After saving, RUN at line 1030 restarts the program from line 1, returning to the splash screen.

Memory Map Observations

Several 16-bit addresses appear repeatedly in the machine code as operands to LD HL,(nn), LD (nn),HL, and LD DE,(nn):

• 0x400C — likely the PROG/E-LINE system variable area, used to locate the start of the BASIC program in RAM.
• 0x407B — an internal workspace variable storing the current editor cursor or buffer pointer.
• 0x403C / 0x403E / 0x4036 — additional editor state variables (page start, write position, etc.).
• 0x400E — a further pointer, possibly the current line pointer within the editor buffer.

The machine code performs arithmetic on these pointers (adding fixed offsets like +5, +0x10, +0x13, +0x17, +0x18) consistent with navigating a fixed-width screen of 24 lines × 33 columns, matching the ZX81/TS1000 32-column display with a one-byte attribute or end marker.

Notable Techniques

• The entire editor binary is self-contained in a REM line, requiring no separate code loading; the BASIC program is the binary.
• The use of RAND USR (rather than GO TO or GOTO) to invoke machine code is idiomatic: it discards the USR return value silently and avoids needing a variable assignment.
• Keyboard scanning via direct CALL 0x02BB (ROM KEYBOARD) is more responsive than BASIC INKEY$ and allows multi-key combinations (e.g. SHIFT+6 for S6, SHIFT+7 for S7).
• The LDIR instruction is used for both bulk memory initialisation and text scrolling, avoiding slow byte-by-byte BASIC loops.
• The copyright notice (line 70) credits Dan Tandberg, MD of Calliope Software, Albuquerque, New Mexico, 1983.