Wordfix

This program is a full-screen text editor for the ZX81/TS1000, written entirely in BASIC and copyrighted N. Godwin 1982. It maintains a single string variable Z$ as the document buffer, with an integer cursor position A tracking the insertion point within that string. The editor supports cursor movement, character insertion and deletion, word-wrap printing with configurable left and right margins, and file load/save operations using PEEK and POKE to manipulate system variables directly. Key presses are read via a PAUSE/INKEY$ polling loop, and characters are identified by their CHR$ codes; control functions are dispatched through computed GOSUB targets of the form X*30+1000. The program also includes a 704-byte block copy routine that transfers text to and from a fixed RAM area at address 32000.

---

Program Analysis

Program Structure

The program is organised as a set of loosely coupled subroutines grouped by function, with a main edit loop beginning at line 130. The initial GOTO 130 at line 1 skips past short utility stubs at lines 2–7 that are called by number from elsewhere. The high-level flow is:

1. Lines 100–169: Initialisation and main insert-mode loop. Z$ is the document buffer; A is the cursor position (0 = before first character).
2. Lines 200–329: Secondary input loop used in certain modes; dispatches keyword/symbol lookup against a packed string at line 250.
3. Lines 400–499: Display refresh — clears screen, prints prompt and buffer, then falls through to the keypress routine at 1000.
4. Lines 500–609: Control-key dispatcher for non-printable key codes.
5. Lines 1000–1099: Core keypress engine: highlights the character under the cursor by OR-ing 128 into its display code via POKE, then waits for a key with PAUSE 40000 / INKEY$.
6. Lines 1100–1519: Word-wrap printer with configurable left (L) and right (R) margins.
7. Lines 1600–1889: File management (load/save with variable-name indirection) and block-selection/cut routines.
8. Lines 4360–4630: Cursor-movement primitives (page up/down, character left/right, etc.), each terminated with RETURN.
9. Lines 7540–7899: High-level menu actions: go to load (7540), clear and load 704-byte block from address 32000 (7570–7609), enter block-select mode (7660), go to save (7750), program-name input (7780), and a tape-based block load (7870).
10. Line 9000: Copyright notice: N. Godwin 1982.

Document Buffer Management

The entire document is held in the single string Z$. The cursor position is the integer A, meaning the insertion point is between characters A and A+1. Three cases are handled explicitly at lines 450–470:

• A=0: prepend — Z$=X$+Z$
• 0 < A < LEN Z$: insert — Z$=Z$(1 TO A)+X$+Z$(A+1 TO )
• A=LEN Z$: append — Z$=Z$+X$

Deletion at line 4570–4589 mirrors this three-way split, removing the character at position A and decrementing A. Because BASIC string slicing allocates new strings on every operation, heavy editing will fragment the string area and may trigger garbage collection pauses.

Computed GOSUB Dispatch

Control characters are dispatched using the idiom GOSUB X*30+1000 (lines 230, 520, 772). The key code X is multiplied by 30 to produce a line-number target. The cursor-movement stubs at lines 4360, 4390, 4420, 4450, 4510, 4540, 4570, 4630 correspond to specific computed targets. For example:

X (key code)	X*30+1000	Routine
112	4360	Cursor page-up (A−32)
113	4390	Cursor page-down (A+32)
114	4420	Cursor left (A−1)
115	4450	Cursor right (A+1)
117	4510	Go to print/margin routine
118	4540	Set X=0 (newline/clear flag)
119	4570	Delete character
121	4630	Set X=12 (form-feed/CLS flag)

Cursor Highlighting via PEEK/POKE

The character under the cursor is highlighted by directly poking the display file. Routine at lines 1000–1050 computes the display-file address of the cursor character using the system variable at 16396/16397 (D-FILE pointer), accounting for the newline byte at the end of each 32-character row with INT((A-1)/32). The character code is read with PEEK Q, converted via GOSUB 1080 (which maps code 192 to 11, i.e. treats the cursor-block graphic as a space), and if it is a printable ASCII character, OR-ed with 128 via POKE Q, X+128 to display it in inverse video as the cursor. This avoids any flicker from re-printing and works directly on the hardware display file.

System Variable Manipulation for File I/O

Rather than using a high-level LOAD/SAVE with a fixed name, the file routines at lines 1670–1682 patch system variables in RAM to redirect the tape filename at runtime. POKE 16559 sets the filename character, POKE 16562/16563 sets associated length or type bytes, allowing the editor to load or save named string variables (e.g. A$ through W$) by writing their letter code directly into the system area before falling through to line 4 (LET Z$="") or line 5 (RETURN).

Word-Wrap Printer

The print routine (lines 1220–1519) implements a simple word-wrap algorithm. Starting from position J in Z$, it attempts to advance 32−R characters (where R is the right margin). If that position is not a space, it walks backwards to find the nearest preceding space and breaks there. Left-margin padding is handled by subroutine 1370, which prints L spaces before each line. The routine checks PEEK 16442 (the display scroll counter) to detect a full screen, then pauses for a keypress (lines 1490–1519) before continuing or scrolling/clearing. A CHR$ 67 (the letter C) embedded in Z$ acts as a hard line-break sentinel (lines 1430, 7690).

Fixed RAM Buffer at Address 32000

Lines 7570–7609 implement a 704-byte (22 rows × 32 columns) snapshot of the display file, stored at the fixed address 32000. Loading reads the buffer back through PEEK and rebuilds Z$; saving copies the D-FILE contents (again compensating for end-of-line newline bytes with INT((J-1)/32)) into the block. This provides a crude fast-save to a fixed RAM location, presumably in a RAM pack, bypassing tape entirely.

Keyword Lookup Table

Line 250 defines a 43-character lookup string X$ containing block-graphic symbols and BASIC keywords. The loop at lines 260–280 searches this string for a character matching the current key code; if found, the corresponding single character at offset J-21 is used as the inserted text. This allows the editor to insert printable representations of ZX81 block graphics and keywords into the document buffer.

Notable Anomalies and Dead Code

• Lines 1045 and 1820 are REM-commented-out conditionals that would have prevented re-highlighting a character already under the cursor (code 67). They appear to have been disabled during development.
• Line 1231 is referenced by GOTO 1231 at line 1519 but does not exist as a distinct line; execution will fall to line 1235, which is the correct continuation — a deliberate jump-to-next-line technique.
• Line 1246 is referenced at line 1449 but does not exist; execution continues at 1250. Similarly a known ZX81 BASIC technique.
• Lines 4520, 7689, and 7899 are bare RETURN statements that appear unreachable given the preceding GOTOs at lines 4510, 7660, and 7870 respectively. They may be defensive stubs.
• The SAVE X$ at line 530 saves the filename string itself to tape when key code 226 is received and X$ is non-empty — an unconventional use that saves the variable name as a tape file.