ColorCopy

This program is a menu-driven front-end for printing screen captures on an Okidata OKI 20 dot-matrix printer using a machine code driver loaded from tape. It lets the user choose between black-and-white or color output, small or large size, and left/center/right/variable horizontal position, then loops for a specified number of copies. The machine code routines are stored at addresses starting around 64440 and are called via RANDOMIZE USR; different entry points handle header display, screen setup, and the four copy-mode combinations (B/W small, B/W large, color small, color large). Position values are patched directly into the machine code at runtime using POKE statements targeting four separate addresses (poka, pokb, pokc, pokd), one for each copy-mode routine. The program loads a SCREEN$ file by name from tape and supports reusing the last loaded screen for subsequent copy runs without reloading.

---

Program Analysis

Program Structure

The program is split across two BASIC line-10 entries (a loader and the main program), suggesting the listing represents two separately saved programs or program segments. The first line 10 bootstraps the system: it clears memory to 54711, loads a machine code block, and executes it. The second line 10 begins the interactive session after the machine code is resident. The main program then flows through parameter collection, screen loading, and the print loop.

1. Lines 10–20: Initialization — stop-recorder prompt, variable setup mapping friendly names to machine code entry points.
2. Lines 30–40: Wait for keypress release, then call the header-display routine at hdld (64440) and set caps-lock off via POKE 23658,8.
3. Lines 50–330: Full parameter menu — mode, size, position, number of copies, confirmation.
4. Lines 340–410: Screen$ load logic, with option to reuse the previously loaded screen.
5. Lines 420–510: Printer-ready prompt, copy execution loop calling RANDOMIZE USR copy for each copy.
6. Line 520: Loops back to line 30 for another run.

Machine Code Entry Points

All machine code interaction is via RANDOMIZE USR. Ten named entry points are stored in variables at initialization:

Variable	Address	Purpose
hdld	64440	Header/title display routine
scld	64460	Screen load/preparation routine
scst	64468	Post-load screen setup routine
poka	64485	Position byte for B/W small copy
bwca	64505	B/W small copy routine
pokb	64586	Position byte for B/W large copy
bwcb	64610	B/W large copy routine
pokc	64759	Position byte for color small copy
clcc	64782	Color small copy routine
pokd	65002	Position byte for color large copy
clcd	65029	Color large copy routine

The poka–pokd addresses are not entry points but operand bytes within the machine code. The program patches all four simultaneously with POKE regardless of which copy mode is selected, keeping all routines consistent.

Key BASIC Idioms

• Boolean arithmetic for positions: Line 220 uses 9+(16 AND s$="S") and line 230 uses 16+(32 AND s$="S") to compute center and right positions differently for small vs. large output — a compact alternative to nested IF statements.
• INPUT #0: Used throughout for all user prompts, which directs input through stream 0 (keyboard) and allows AT positioning of the prompt text on screen without disturbing the parameter display area.
• Debounce pattern: Lines 30 and 480 wait for INKEY$ to clear before proceeding, preventing spurious keypresses from carrying over.
• POKE 23658,8: Enables extended mode / caps-lock suppression by writing to the FLAGS2 system variable, ensuring clean keyboard behavior during INPUT prompts.

Position Validation

When variable positioning is selected (line 240–270), the program computes a max value of 16 (large) or 48 (small) using the same boolean arithmetic idiom, then validates the entered position with IF pos>max THEN GO TO 250. Note that line 270 always branches back to line 250 on out-of-range input even when the large-size prompt was at line 260 — this is a minor anomaly but functionally acceptable since both prompts accept the same variable pos.

Screen Reuse Logic

A flag variable scr is set to 1 at startup and on the first pass forces the screen-load path (line 340). Once a screen has been loaded, scr is cleared to 0 (line 470), and on subsequent copy runs the user is offered the choice to reuse the loaded screen or load a fresh one (lines 350–370). The screen filename is entered with caps-lock disabled and validated to a maximum of 10 characters (line 390).

Copy Loop

Lines 500–510 implement a simple counted loop: RANDOMIZE USR copy calls the selected machine code print routine, decrements num, and repeats until the count reaches zero. The screen-setup call at line 490 (RANDOMIZE USR scld) is made once before the loop begins, preparing the screen data for repeated printing without reloading it each pass.

Notable Techniques

• All four position-patch POKEs (line 280) are executed unconditionally, keeping all copy routines synchronized to the same position value regardless of which will be called.
• The use of named numeric variables (hdld, bwca, etc.) instead of literal addresses throughout the copy loop and POKEs makes the code significantly more readable and maintainable than embedding raw numbers.
• The BEEP triplet on line 10 provides an audible stop-recorder signal after the machine code loads, followed by PAUSE 150 to give the user time to react.