ZX Typer

This program renders user-input text as large block-graphic characters, three display rows tall, using the ZX Spectrum’s block graphics (chars 128–143). After accepting a string via INPUT, it iterates through each character, dispatches to a subroutine via the computed GOSUB formula (CODE A$(A)-25)*100, and draws the corresponding block-graphic glyph at position (X,Y) on screen. Characters are laid out in a grid of 3-row-high cells, advancing Y by 3 each step and wrapping to the next row (incrementing X by 3) after every 10 characters. The program covers letters and digits, with each glyph defined by three PRINT AT statements using block graphics to approximate each character’s shape.

---

Program Analysis

Program Structure

The program is organised into three logical areas:

1. Initialisation and input (lines 10–93): REMs serve as a title banner (displaying “ZX-TYPER” in inverse video). Lines 20–24 initialise cursor positions and accept a string, capping its length at 70 characters.
2. Main loop (lines 30–93): Iterates over each character of the input string, skips spaces and low punctuation, computes a subroutine address, draws the glyph, and advances the layout cursor.
3. Glyph subroutines (lines 200–3803): Each subroutine draws a single block-graphic character using three PRINT AT statements, then RETURNs. Subroutine numbers are multiples of 100, and the dispatch formula maps ASCII codes directly to them.

Dispatch Mechanism

The key idiom is at line 60:

GOSUB (CODE A$(A)-25)*100

This translates a character’s ASCII code into a subroutine line number. For example, the space character (ASCII 32) gives (32−25)×100 = 700, which is the subroutine for the letter corresponding to that slot. The mapping is:

Character	ASCII	Formula result	Subroutine
!	33	800	line 800
“	34	900	line 900
0–9	48–57	2300–3200	lines 2300–3200
A–Z	65–90	4000–6500	(not all present)

In practice, examining the subroutines present (200 through 3803), the covered range maps to punctuation and digits. The letter subroutines starting at line 200 correspond to the . character (ASCII 46, giving (46−25)×100 = 2100), and so on. The actual character set rendered covers roughly . through Z in ASCII order, one subroutine per character.

Layout and Cursor Management

Two variables, X and Y, track the current glyph position on screen. Each glyph occupies a 3×3 block-graphics cell. After drawing each character, Y is incremented by 3 (line 70). When Y reaches 30 — the right edge of the 32-column display at this granularity — it wraps to 0 and X advances by 3 (lines 80–83), moving down to the next row of glyphs. This allows up to 10 glyphs per row and multiple rows.

Input Filtering

Lines 40 and 50 handle character filtering:

• Line 40 skips space characters entirely (GOTO 70 advances Y without drawing).
• Line 50 skips any character with ASCII code below . (46) but above space (32) — i.e., punctuation characters ! through - — by executing NEXT A directly, skipping both the GOSUB and the Y-advance. This means those characters are silently ignored rather than advancing the cursor.

Note that line 50’s skip via NEXT A bypasses the Y-increment at line 70, so ignored characters do not consume layout space, which may or may not be the intended behaviour.

Glyph Rendering with Block Graphics

Each glyph subroutine uses two or three PRINT AT X+row, Y+col; "..." statements. The strings contain ZX Spectrum block graphic characters (codes 128–143), which each encode a 2×2 pixel pattern within a single character cell. By combining these, each glyph is rendered at approximately 6×6 pixel resolution across a 3-row, 3-column region of the text screen.

Some glyphs use offset column positions (e.g., PRINT AT X+2,Y+1) to handle narrower characters such as 1, I, and !.

Notable Techniques

• Computed GOSUB: Using an arithmetic expression as the GOSUB target is an efficient alternative to a long IF-THEN chain for character dispatch.
• Input loop: After rendering, lines 91–93 wait for another INPUT, clear the screen with CLS, then RUN restarts the program, resetting X and Y to zero for a fresh display.
• Title in REMs: Lines 10–12 display a bordered title “ZX-TYPER” using inverse-video characters purely as documentation/display in the program listing.
• String length cap: Line 24 clamps input to 70 characters, preventing the layout loop from overrunning screen bounds.

Anomalies and Notes

• Line 1400 skips from statement 1400 to 1402 — line 1401 is absent. This is harmless as subroutine execution falls through sequentially, but the missing line number is unusual.
• The Y=30 wrap condition (line 80) allows 10 three-column glyphs per row (columns 0, 3, 6, …, 27), but with the 3-column glyph width the last glyph starts at column 27 and prints up to column 29, fitting within the 32-column display.
• Lines 3810–3820 (SAVE "1010%3" followed by RUN) appear at the end of the glyph table and are not part of the normal execution flow; they are used to save the program.
• The author credit appears as an inverse-video REM at line 9999: “RYAN GRAY”.