Zed Text

This program implements a full-featured text editor for the ZX81/TS1000, storing document text in a single string variable T$ and operating through a macro-command interpreter. Commands are entered as letter-prefixed macro strings where the letter selects a GOSUB target via a dispatch table array F(26) indexed by character code, allowing one-letter command codes (A=Append, C=Cursor, D=Delete, J=Justify, M=Memory, P=Print, R=Reset, S=Save, T=Test, X=Execute, Z=Stop) to route to the appropriate subroutine. The editor supports multi-page documents (640 characters per page), cursor movement with blinking via inverse-video toggling, word-wrap justification, and repeat-execution of macros via the X command. Text is stored and manipulated entirely as substring operations on T$, with memory usage reported by PEEKing the ZX81 system variables for RAMTOP and the display file pointer.

---

Program Analysis

Program Structure

The program is organized into an initialization block, a central macro-decode loop, and a suite of command subroutines. Initialization (lines 10–235) populates the dispatch table, then jumps to the title-screen/menu renderer at line 3670 before entering the macro interpreter at line 1000.

Line range	Purpose
10–150	Build dispatch table F(26)
200–235	Initialize editor state variables, jump to splash screen
1000–1230	Macro decode loop
2000–2140	A – Append text
2200–2390	C – Cursor movement and display
2500–2590	D – Delete
2800–2960	J – Justify (word-wrap)
3000–3025	K – LIST (mapped but labelled K & L in menu)
3100–3150	M – Memory test
3300–3390	P – Print page
3500–3520	R – Reset (RUN)
3600–3665	S – Save to tape
3670–3710	Splash screen / menu, then enter decode loop
3800–3820	T – Test (load sample text)
3900–3970	X – Multiple/repeat execution
4000–4040	Z – Stop

Dispatch Table via F(26)

Lines 10–150 initialize the array F(26) with line numbers corresponding to each command subroutine. The macro decoder (line 1200) calls GOSUB F(CODE K$-37), where K$ is the command letter. Since CODE "A" on the ZX81 is 38, subtracting 37 gives index 1 for A, 3 for C, 4 for D, and so on up to 26 for Z. Any letter without an entry in F has a default value of 0, causing a harmless GOSUB 0 to a non-existent line — a known ZX81 no-op technique.

Note that line 80 reads RAND F(12)=3000 rather than LET F(12)=3000. This is a typo or corruption; RANDOMIZE with a conditional expression will silently evaluate as a numeric statement and set the random seed, so F(12) (the L command) is never actually assigned 3000 and remains 0.

Macro Decode Loop

The loop at lines 1000–1230 accepts a line of input in M$, then scans for characters whose CODE falls in the range 38–63 (the letters A–Z on the ZX81 character set). The letter found becomes the command key K$; the digits before it become the numeric repeat count N; the characters between the letter and the next quote become the string argument W$. After the GOSUB dispatch, the parser resumes scanning for the next command in the same input string, allowing multiple commands per input line.

Text Storage and Editing

The entire document is held in the string T$. The current insert/cursor position is tracked by the integer CI. Pages are 640 characters wide (20 lines × 32 columns). Substring slicing with T$(x TO y) handles all insertions, deletions, and page extractions.

• Append (A): Inserts N repetitions of W$ at position CI, at the start, or at the end of T$ depending on whether CI is 0, equal to LEN T$, or in between.
• Cursor (C): Moves CI by N characters; special arguments "0" and "1" jump to page start or end of text. Cursor blinking at lines 2310–2340 loops 10 times printing the normal then inverse character.
• Delete (D): Removes N characters from position CI using four conditional substring cases; then calls the cursor routine with N=-1 to refresh display.
• Justify (J): Scans 32-character blocks looking for a space near position 32 to use as a word-wrap break, padding into a fixed-length DIM H$(32) to normalize the line.

Memory Reporting

The M command (lines 3100–3150) reports free space for text by reading ZX81 system variables directly: PEEK 16386 + 256*PEEK 16387 gives RAMTOP, and PEEK 16412 + 256*PEEK 16413 gives the current stack/string area pointer, with the difference being available bytes.

Notable Techniques

• FAST / SLOW mode switching around INPUT and PRINT operations to balance display stability with execution speed.
• GOSUB F(CODE K$-37) — a compact computed GOSUB that replaces a long IF/THEN chain for 26 possible commands.
• The splash screen at lines 3680–3685 uses ZX81 block-graphic escape sequences to draw a decorative banner.
• Line 55 places F(9)=3670, pointing the I command (index 9: letter I = CODE 46, 46−37=9) back to the splash/menu screen, implementing a “show menu” function.
• The X (multiple execution) command at lines 3900–3970 re-enters the decode loop at line 1040, bypassing the INPUT, to replay the current macro N times by resetting D and I.
• Line 4030 contains SAVE "1024" — the inverse-digit escape in the filename acts as an auto-run marker for the ZX81 tape loader.

Bugs and Anomalies

• Line 80: RAND F(12)=3000 should be LET F(12)=3000. The L command (index 12) is therefore never registered, so the K/L listing command is inaccessible via the dispatch table despite having its subroutine at line 3000.
• The Justify routine (lines 2820–2960) references variable V$ as both a 32-character slice of T$ and later re-DIMs H$; however, V$(I2) at line 2860 treats the previously assigned string V$ as an array, which will work on a ZX81 only if V$ is exactly 32 characters — the logic is fragile for short documents.
• The cursor blink loop (lines 2310–2340) uses J=CODE T$(CI)+128 to compute the inverse character, relying on the ZX81 inverse-video bit (bit 7). If CI points beyond the end of T$, this will cause an error.