Baby Syntext

This program implements a full-screen text editor for the ZX81/TS1000, storing up to 2,880 characters of text in the string array A$(2880) and displaying a 22×32 window into that buffer on screen. The editor supports cursor movement in four directions (including word-wrap logic), insert, delete, carriage return, and tab-like jumps of 8 positions, all driven by Sinclair shifted-key codes detected via INKEY$. A blinking cursor is simulated in the GOSUB 5000 subroutine by printing a block graphic and immediately overprinting with the actual buffer character at the current position. The buffer is paged: variable A tracks the index of the first character in the current display window, advancing or retreating in steps of 32 (one screen row) as the cursor moves off screen. An auxiliary 32-character string D$ is used for the “clear to end of line” function, and a HELP menu at line 3000 documents all key bindings.

---

Program Analysis

Program Structure

The program is organised into a set of clearly separated functional blocks:

1. Lines 10–70: Initialisation — allocates A$(2880) as the text buffer, sets cursor position variables, and allocates D$(32) as a scratch line buffer.
2. Line 300: Display refresh — PRINT AT 0,0;A$(A TO A+703) renders the current 22-row window (22 × 32 = 704 characters).
3. Lines 100–999: Main dispatch loop — calls the keyboard subroutine at 5000 and uses a chain of IF CODE B$=… THEN GOTO tests to route each keypress to its handler.
4. Lines 1000–1900: Individual key handlers (carriage return, backspace, cursor movement, insert, delete, tab-right, end-of-screen, end-of-line).
5. Lines 3000–3099: Help menu display.
6. Lines 3500–3570: Tape save routine.
7. Lines 5000–5040: Keyboard input / cursor blink subroutine.
8. Lines 6000–6060: Line-wrap subroutine called when Y exceeds 31.
9. Lines 7000–7040: Standalone screen dump subroutine (not called from the main loop; likely a debugging aid).
10. Line 9998–9999: Program self-save and restart.

Buffer and Window Model

The text buffer is the 2,880-character string A$. The display window always shows 704 characters (22 rows × 32 columns) starting at index A. The absolute buffer index of the cursor is B. Screen row and column are tracked in X and Y respectively. Scrolling is achieved by incrementing or decrementing A by 32 (one row), keeping X clamped to 0–21. This means the editor can hold 2880 ÷ 32 = 90 screen-rows of text, far exceeding what can be displayed at once.

The boundary guard at line 5020 warns the user when B exceeds 2816 (i.e., within the last 64 characters of the buffer), printing an inverse-video “NO MORE TEXT CAN BE ENTERED” message.

Key Dispatch Table

Code	Key	Handler	Action
19	SHIFT+B	1800	Jump to beginning (A, last position in window)
115	SHIFT+5 / cursor left	1000	Overtype with buffer char / cursor left
221	SHIFT+T	1900	Clear to end of line
114	SHIFT+6 / cursor right-ish	1100	Backspace / cursor left
216	SHIFT+H	3000	Help menu
16	SHIFT+I	1200	Insert blank at cursor
225	SHIFT+S	3500	Save to tape
228	SHIFT+D	1300	Delete character at cursor
23	SHIFT+?	20	Restart (go to beginning)
113	SHIFT+7 / cursor down	1400	Move cursor down one row
112	SHIFT+8 / cursor up	1500	Move cursor up one row
118	ENTER	1600	Carriage return (move to start of next line)
220	SHIFT+N	1700	Move right 8 positions (tab)
218	SHIFT+?	191	Replace with space graphic "\ '"

Cursor Blink Technique

The subroutine at line 5000 implements a software cursor blink without machine code. Line 5010 uses two consecutive PRINT AT clauses in a single statement: first it prints the block graphic "\. " (▖, a lower-left quarter block) at position (X,Y) to act as a visible cursor marker, then immediately overprints the actual buffer character A$(B) at the same position, creating a flicker effect as the display refreshes. The INKEY$ poll at line 5000 is non-blocking, looping back until a key is held down.

Insert and Delete

Insert (line 1200) uses ZX81 string slicing to open a gap: LET A$=A$( TO B-1)+" "+A$(B TO 2879). This concatenates everything before the cursor with a space and everything from the cursor onward, dropping the last character to keep the total length at 2880. Delete (line 1300) does the reverse: LET A$=A$( TO B-1)+A$(B+1 TO 2880)+" ", removing the character at B and appending a trailing space. Both operations are O(n) in buffer size and will be noticeably slow on real hardware as the buffer fills.

Clear to End of Line

Line 1900 uses LET A$(B TO B+31-Y)=D$(Y+1 TO 32), where D$ is a 32-character string (initialised by DIM D$(32) which fills it with spaces). This overwrites from the cursor position to the end of the current 32-character row with spaces in a single slice assignment — an efficient use of string array slicing.

Carriage Return Behaviour

The ENTER key handler (line 1600) does not insert a newline character into the buffer. Instead it simply advances B to the start of the next row by computing B=B+32-Y, then calls the line 1420 column-overflow handler. This means the editor is a fixed-width, grid-based word processor rather than a stream-oriented text editor — lines are always exactly 32 characters wide.