CRYPTO

This program implements an interactive simple-substitution cipher tool that accepts either a plaintext message or cryptogram and displays it with a visual substitution pad. The message is split into lines of up to 32 characters at word boundaries and printed with blank lines between each segment; below each line of text a substitution row is maintained on screen. The program uses SCREEN$ to read characters directly from the display buffer rather than maintaining a separate data array, effectively using the screen as its working storage for the cipher alphabet. POKE 23609,30 sets the BORDCR system variable, POKE 65535,128 and POKE 23658,8 configure display and caps-lock behavior, while the loop at lines 10–14 zeroes a block of high memory. Input validation at lines 504 and 613 restricts entries to printable ASCII range below the backtick (character 96).

---

Program Analysis

Program Structure

The program divides into four logical phases:

1. Initialization (lines 5–24): Clears high memory, sets system variables, and displays the title and prompt.
2. Message formatting (lines 30–350): Accepts a message via INPUT LINE, then iteratively splits it into word-wrapped segments of up to 32 characters, printing each segment with two blank lines beneath it to leave room for the substitution row.
3. Punctuation seeding (lines 360–396): Scans the on-screen text and copies any non-alphabetic, non-space characters directly to the substitution rows below them.
4. Interactive substitution loop (lines 480–690): Prompts the user to press a letter key, highlights all occurrences on screen using FLASH 1, then asks for a substitute letter and writes it into the substitution rows, updating the cipher alphabet string c$.

Screen-as-Data-Structure Technique

The most distinctive design choice is the use of SCREEN$ (lines 375, 530, 540, 660–666) as the sole working storage for both the ciphertext display and the substitution alphabet. No separate arrays are maintained; the program reads character values directly from the display buffer at runtime. This conserves RAM but ties all logic tightly to screen coordinates and layout.

The layout uses rows in multiples of 3: ciphertext on row r, substitution on row r+1, and a blank row at r+2. The outer loops at lines 365 and 515 step by 3 (STEP 3) to exploit this structure.

Message Word-Wrapping (Lines 100–350)

Word wrapping is implemented by scanning backwards from position 33 for a space character:

• Line 100 starts the loop from position 33 down to 1.
• Line 110 clamps i to LEN a$ if the remaining text is shorter than 32 characters.
• Line 120 breaks on a space, routing to line 200 to split there.
• Line 150 handles the fallback hard split at column 32 if no space was found.
• After printing, lines 330–350 strip leading spaces from the remainder.

The sentinel "\u " appended at line 55 (a UDG character followed by a space) ensures the last word is always terminated by a space, guaranteeing the word-wrap scan always finds a delimiter.

Substitution Alphabet String c$

The string c$ initialized at line 30 holds the 26-letter alphabet. As substitutions are assigned, the corresponding position in c$ is blanked (line 630) to prevent double-assignment. The check at line 618 (IF c$(CODE m$-64)=" ") enforces this constraint. When a substitution is written to the screen (line 668), line 666 restores the letter to c$ if a previously placed substitution is being overwritten — though this restoration logic only fires when the screen row already contains an alphabetic character, so partial edge cases may arise if substitutions are changed repeatedly.

Input Handling and Validation

The keypress wait at lines 500–502 uses the standard flush-then-wait idiom: line 500 waits for the key to be released, line 501 waits for a new press. This prevents key repeat from triggering unwanted actions.

Lines 504 and 613 validate input by checking the character code falls within the printable range below backtick (`, code 96). On this keyboard, codes 65–90 are uppercase letters and codes 32–64 are digits and punctuation — the backtick upper bound neatly excludes control characters above code 96 while accepting the full printable set.

System Variable Configuration

Address	System Variable	Value	Effect
23609	BORDCR	30	Sets border/paper color
65535	High memory byte	128	Program-specific flag
23658	FLAGS2	8	Disables CAPS LOCK
65528–65534	High RAM	0	Zeroed initialization block

Notable Bugs and Anomalies

• Line 390 punctuation placement: Punctuation is printed at row r+1 (the substitution row), but the loop only checks r=1 TO 20 STEP 3. If the message fills more than 7 lines (row 20), trailing punctuation will be missed.
• Line 670 early exit: Inside the substitution-writing loop, encountering a null screen character (CODE SCREEN$(r,c)=0) causes an immediate GO TO 480 rather than continuing to check remaining rows. This can leave occurrences of the target letter on later rows un-substituted if a null cell appears mid-scan.
• UDG sentinel visible: The \u UDG character appended at line 55 may render as a visible (possibly undefined) graphic on the last printed line before being word-wrapped off, depending on whether UDG “u” has been defined.