Big Message

This program renders text entered by the user as large bitmap characters on screen, using the ZX81’s character ROM data. It reads each character’s 8-byte font pattern from memory starting at address 7680 plus the character code multiplied by 8, then extracts individual bits by repeatedly checking whether the value is 128 or greater and doubling the remainder. Each bit is printed as either a space or an inverse-video character (CHR$ 128) at a calculated screen position, effectively scaling the font up column by column. The loop structure iterates over characters in the input string, then over each row byte, then over each of 3 bit-planes to build the magnified display.

---

Program Analysis

Program Overview

The program accepts a string input from the user and renders it enlarged on screen by reading font bitmap data directly from ROM. Each character’s 8×8 pixel pattern is extracted bit by bit and displayed as a magnified block character grid using AT-positioned PRINT statements.

Program Structure

Lines	Purpose
10–20	Prompt and accept user input string M$
30	Store string length in variable LEN
50–60	Outer loop over each character; compute ROM address base
63–67	Initialise row (A) and column (B) print positions
70–240	Nested loops: scan font rows, extract bits, print magnified pixels
260	Advance to next character in string
270–300	Stop, housekeeping, and save/run stubs

Font ROM Access

The character font data is accessed via PEEK at address 7680 + (CH * 8), where CH is the character code obtained from CODE M$(L). On the ZX81, the character ROM begins at address 7680 (0x1E00), with each character occupying 8 consecutive bytes representing its 8-pixel-tall bitmap rows. The inner FOR R loop walks these 8 bytes in descending order (with a fractional step of -0.25, discussed below).

Bit Extraction Technique

Individual bits are extracted from each font byte using the classic shift-and-test method. At line 140, if RC < 128 the most-significant bit is 0 (print a space, CNTR=0); otherwise the bit is 1 (CNTR=128, which is CHR$ 128, the filled inverse-video block on the ZX81). Line 160 subtracts 128 if set, and line 170 doubles RC to shift the next bit into the MSB position. CHR$ 128 is the checkerboard/inverse-space character used here as a solid block.

Notable Techniques and Anomalies

• Fractional STEP value: The loop at line 70 uses STEP (-0.25) to iterate from R+7 down to R. Because the loop variable is also named R (shadowing the address variable set at line 60), this actually traverses 33 iterations (from R+7 to R in steps of −0.25), which is far more than the 8 font rows needed. This is almost certainly a bug — the intended step was likely -1.
• Variable name collision: R is used both for the ROM base address (line 60) and as the FOR loop variable (line 70), which overwrites the base address value on entry to the loop.
• Redundant reset in G loop: Line 120 reads IF G=2 OR 3 THEN LET RC=D. Due to ZX81 BASIC evaluation rules, OR 3 is always true (3 is non-zero), so RC is reset to D on every iteration of the G loop. This means each pass of the inner G loop reprints the same bit three times in consecutive rows, creating a 3× vertical magnification per bit. The intent was likely IF G=2 OR G=3.
• LEN as a variable name: Line 30 uses LET LEN=LEN M$, storing the string length in a user variable also named LEN. This works because ZX81 BASIC allows multi-character variable names for numeric variables, and the keyword LEN is tokenised — the context distinguishes function call from variable reference.
• Column advance without row reset: After each font byte (line 220–230), the screen column B is incremented and A reset to 1, building the character left-to-right on screen with each font byte’s bits printed vertically.
• Lines 280–300: CLEAR, SAVE, and RUN after STOP are never executed during normal program flow and appear to be development/save artefacts.

Screen Layout Logic

Each bit within a font row is printed at screen position AT A,B where A is the row (reset to 1 per font-byte column) and B advances once per font byte processed. The G loop (1 to 3) causes A to increment three times per bit, so each pixel row of the font is rendered as 3 character rows tall on screen, giving a magnified appearance. The horizontal expansion depends on how many font bytes are printed per character (controlled by the R loop).