Graph

This program is an interactive user-defined graphic (UDG) editor that lets the user design a custom character by entering binary pixel data row by row. It first draws a bordered graph grid using PLOT and DRAW commands, then prompts the user to select which UDG letter (a–u) they want to define. For each of the eight rows of the 8×8 character, the user inputs eight bits (0 or 1) one keypress at a time, with a “2” option to restart the current row; the program converts each row’s binary sequence to a decimal value using powers of 2 and writes it directly to UDG memory with POKE USR. After all eight rows are entered, the finished character is displayed on screen, and the user can either send output to a printer with COPY or restart to define another UDG.

---

Program Structure

The program divides into four logical phases:

1. Grid drawing (lines 10–95): Uses PLOT and DRAW to construct a bordered graph grid on the lower portion of the screen, with vertical and horizontal divider lines drawn using nested FOR loops.
2. UDG selection (lines 140–188): Prompts the user — with FLASH 1 — to type the letter (a–u) of the UDG slot to define, then clears the top lines.
3. Pixel entry loop (lines 190–420): The main editor. For each of the 8 rows (FOR a=0 TO 7) and each of the 8 bit columns (FOR b=0 TO 7), the program reads a keypress of 0, 1, or 2, accumulates a binary-to-decimal value, displays the pixel state, then POKEs the result into UDG memory.
4. Output and restart (lines 424–490): Clears the status area, displays the finished UDG character, offers a COPY to printer or RUN to restart.

Key BASIC Idioms

• INKEY$ debounce pair (lines 223–224): IF INKEY$ <>"" THEN GO TO 223 waits for any held key to be released, then IF INKEY$="" THEN GO TO 224 waits for a new keypress — a classic reliable single-keypress capture idiom.
• Binary-to-decimal conversion (lines 240–260): Each bit’s contribution is computed as c * 2↑(7-b) and accumulated in f, correctly building the byte value with the most-significant bit first.
• POKE USR (line 415): POKE USR a$+a,f writes each computed row byte directly to the UDG definition table in RAM, which is the standard method for defining custom characters at runtime.
• Row restart (line 235): Entering “2” branches back to GO TO 210, resetting f=0 and re-running the inner bit loop for that row, allowing corrections.

Variable Usage

Variable	Purpose
a$	UDG letter chosen by user (a–u)
a	Current row index (0–7)
b	Current bit/column index within row (0–7)
c	Current bit value (0 or 1) from keypress
d	Place value: 2↑(7-b)
e	Bit contribution: c*d
f	Accumulated byte value for the current row
g, h	Loop counters for grid drawing and screen clearing
c$	User’s choice at end: copy or new

Notable Techniques

• The grid is drawn entirely with PLOT/DRAW primitives rather than PRINT, giving pixel-precise placement independent of the character grid.
• The pixel preview at line 270–280 uses PRINT AT 7+a,14+b to display a filled block or space in the correct screen position as each bit is entered, giving real-time visual feedback.
• Line 290 additionally prints the numeric bit value (c) at column b, and line 410 prints the running decimal total f at column 27, so the user can verify the conversion.

Bugs and Anomalies

• Variable h reused as loop variable: h is used as the outer loop counter in multiple independent FOR/NEXT blocks (lines 97, 424), and also as the inner loop counter at line 105 while still nominally active at line 97. This works only because the outer h loop at line 97 is effectively replaced, but it is fragile and non-standard.
• Case inconsistency (line 430): The program instructs the user to enter lowercase letters, stores the input in a$, but displays A$ (uppercase variable name) at line 430. In Sinclair BASIC, a$ and A$ are the same variable, so this works correctly but is stylistically inconsistent with the rest of the program.
• INKEY$ race at lines 225–235: The three consecutive IF INKEY$=... tests each independently read the keyboard. If the key is released between tests, only the first matching condition fires; if held, all three are evaluated. For keys “0” and “1” this is harmless, but pressing “2” could theoretically also pass the “0” or “1” tests if the key state changes between lines — in practice the fast sequential execution makes this unlikely.
• No input validation: If the user enters a character outside the 0/1/2 set, the variable c retains its previous value and the row silently accumulates a repeated bit, with no error message.