Solid Banner

Solid Banner prints enlarged text banners on a connected printer by reading character bitmaps directly from the ROM. It peeks the ROM character set starting at address 15360 (offset by the ASCII code of each input character multiplied by 8) to extract the 8×8 pixel pattern for each glyph. The bit pattern is unpacked into a string array B$(8,8) using repeated integer division by 2, then the matrix is rotated 90 degrees before being output. Three scaling factors are supported: 1×, 2×, and 4× vertical height, achieved by repeating LPRINT lines and substituting block graphic characters (█) for set pixels.

---

Program Structure

The program is organized into a straightforward linear flow with a retry loop at the end:

1. Lines 10–40: Initialization, dimension the character buffer array, display title screen.
2. Lines 50–110: User prompts — select letter size (S = 1, 2, or 3) and enter message string C$.
3. Lines 120–220: Outer loop over each character in C$; inner loops decode the ROM bitmap into the 8×8 string array B$().
4. Lines 230–430: Rotation loop rebuilds a print line A$ column by column, then LPRINTs scaled output.
5. Lines 440–500: Ask to repeat; branch back to size selection or message input as appropriate.

ROM Character Set Access

The core technique is reading glyph data directly from ROM. Line 130 computes the starting address as:

l = 15359 + (CODE C$(Z) * 8)

The ROM character bitmaps begin at address 15360 for the space character (ASCII 32). Because the formula multiplies the full ASCII code rather than the offset from 32, address 15359 + (32 × 8) = 15615 would be correct for space, but for printable characters the formula works in practice only if the ROM layout matches the assumption — effectively this relies on the character set starting at a base that makes CODE C$(Z) * 8 + 15359 land on the right scan line. The loop at line 170 then advances L by 1 for each of the 8 scan lines.

Bitmap Decoding

Lines 180–210 unpack each byte into individual bits using the classic repeated-halving idiom:

• B$(X, 9-A) = CHR$(CODE "0" + D - 2*INT(D/2)) extracts the least-significant bit and stores it as the character "0" or "1".
• D = INT(D/2) shifts right by one bit position.
• Storing into column 9-A automatically reverses the bit order so that bit 7 (leftmost in the glyph) ends up at column 1.

The result is an 8×8 array of "0"/"1" characters representing the character’s pixel grid.

90-Degree Rotation

Lines 250–350 traverse the array with X going across columns 1–8 and Y going from row 8 down to 1 (STEP -1). This transposition with a reversed secondary index is equivalent to a clockwise 90-degree rotation of the 8×8 bitmap before printing, causing the banner characters to read left-to-right when printed on continuous paper fed vertically.

Scaling and LPRINT Output

Horizontal scaling is achieved by substituting multiple block graphic █ characters (\:: in zmakebas notation) per set pixel, or multiple spaces per clear pixel:

Size (S)	Set pixel	Clear pixel	LPRINT repeats
1 (8×8)	█	1 space	1×
2 (16×16)	██	2 spaces	2×
3 (32×32)	████	4 spaces	4×

Vertical scaling is handled in lines 370–390 by printing A$ once, twice, or four times on successive LPRINT lines using the multi-statement separator ' (which issues a newline in LPRINT context).

Notable Idioms and Techniques

• PRINT AT 12, PI (lines 360 and 400) uses PI (≈3.14159) as a column argument; BASIC truncates it to 3, placing the status message at column 3. This is a compact way to avoid typing the literal digit.
• PRINT PAPER 2,, at line 80 uses two commas to advance the print position without printing text, a spacing trick for formatting.
• The input guard at line 110 silently truncates messages longer than 32 characters rather than rejecting them.
• Line 500 GO TO 50 is unreachable after a “No” answer at line 440 branches to line 470; it appears to be a fallback ensuring the program loops if execution somehow reaches line 500 without having exited via line 470.
• The REM on line 10 serves as a comment crediting the typist — a common convention in type-in listings of the era.

Potential Bugs and Anomalies

• The ROM address formula 15359 + CODE C$(Z) * 8 does not subtract 32 (the ASCII code of space, the first character in the Spectrum ROM font table). For a space character this yields address 15359 + 256 = 15615, which is 256 bytes past the intended start, reading garbage data. For visible ASCII characters (codes 33–127) the addresses are consistently offset by 32 × 8 = 256 bytes too high, landing well outside the 16K ROM — this will PEEK values from RAM rather than the ROM character table. A correct formula would be 15360 + (CODE C$(Z) - 32) * 8.
• Line 130 uses lowercase l as a variable name alongside uppercase L (line 170 uses L); in Spectrum BASIC variable names are case-insensitive for numeric variables, so these are the same variable, but the inconsistency may confuse readers.
• The “32 characters” limit warning in line 60 refers to the display width, not an inherent banner constraint; the actual loop at line 130 processes up to LEN C$ characters regardless.