TRS-80 DOS - NEWDOS/80 v2.0 for the Model I - SUPERZAP/CMD Disassembled

SUPERZAP/CMD

Other Navigation

SUPERZAP is a powerful disk utility program for NEWDOS/80 v2.0 on the TRS-80 Model I. Created by APPARAT, it provides low-level disk access capabilities for viewing, editing, and manipulating disk sectors directly. SUPERZAP is an essential tool for disk recovery, system maintenance, and understanding disk structure.

Primary Functions:

• 'DD - Disk Dump to Disk: Copy entire disks sector by sector
• 'DM - Dump Memory: Display memory contents in hex and ASCII format
• 'DFS - Disk File Sector: Display sectors belonging to a specific file
• 'DTS - Disk Track Sector: Display sectors by track and sector number
• 'DMDB - Dump Memory Data Block: View memory in block format
• 'VDS - Verify Disk Sector: Verify disk sector integrity
• 'ZDS - Zap Disk Sector: Write/modify disk sectors directly
• 'CDS - Copy Disk Sector: Copy sectors between locations
• 'CDD - Copy Disk to Disk: Full disk copy operation
• 'DPWE - Disk Password Write Enable: Enable write access with password
• 'DNTH - Disk N-th Sector: Display the N-th absolute sector

Key Features:

• Compressed String System: Messages are stored using a sophisticated compression scheme where common words (AT, BE, DO, IF, IS, OF, OK, OR, TO, ALL, AND, BAD, END, EOF, FEW, FOR, MAY, NOT, OUT, THE, TOO, YOU, etc.) are replaced with single-byte codes (80H-FFH). This saves significant memory while providing extensive user messages.
• Multi-Mode Display: Supports different display modes (DFS, DTS, DD) with appropriate status labels (DRV, TRK, TRS, DRS, FRS).
• Comprehensive Error Handling: Robust error detection with retry/skip/exit options for disk errors.
• Input Validation: Thorough validation of all user input including drive numbers, track numbers, sector numbers, addresses, and hex values.
• Mathematical Routines: Built-in 8×8, 8×16 multiply and 16÷8 divide routines for address calculations.
• Flexible Number Parsing: Accepts both decimal and hexadecimal input with automatic detection.

Memory Layout:

SUPERZAP loads at 5400H and extends through 6FFFH. The program entry point is at 54C5H. The code is organized into several major sections:

• 5400H-54FFH: FCB area, variables, and working storage
• 54C5H-6689H: Main program code (initialization, menu, commands)
• 668AH-68F6H: Utility routines (memory copy, comparisons, validation, math)
• 68FEH-6BECH: Status labels, menu data, and compressed word tables
• 6BEDH-6EFFH: Error message table and compressed message strings
• 6F00H-6FFDH: Work buffer (254 bytes of zeros)

Address	Bytes	Purpose
5400H-5405H	6	FCB (File Control Block) area - start of file control structure
5406H	1	FCB drive byte - contains current drive number (0-3)
5487H-548BH	5	Decimal conversion buffer - 5-digit ASCII output for number display
5491H	1	Primary mode flags - controls display and operation modes
5492H	1	Secondary mode flags - additional state information
5493H	1	Tertiary mode flags - bit 6: special mode, bit 1: alternate handling
5494H	1	Error code storage - holds current error code for display
5499H	1	Working drive variable - current drive being accessed
549BH	1	Tracks per disk - total track count for current drive
549CH	1	Tracks per disk (copy) - duplicate for calculations
549EH	1	Sector within track - relative sector number (1-based)
54A0H	1	Current track number - track being accessed
54A2H	2	Current absolute sector number - 16-bit sector address
54A8H	2	Maximum sector count - total sectors on disk (tracks × sectors/track)
54ACH	2	Address value variable - 16-bit address for memory operations
54AEH	1	Granule number variable - current granule for file operations
54C5H	-	Program entry point / abort handler address
6F00H-6FFDH	254	Work buffer - temporary storage for disk and memory operations
430DH	1	DOS workspace - sectors per track (typically 10)
430EH	1	DOS workspace - tracks per disk
430FH	1	DOS workspace - tracks (alternate location)

Address	Purpose
445EH	NEWDOS/80 PDRIVE lookup - select drive and retrieve parameters
4409H	DOS error handler - display error message via SVC
6245H	Display compressed string with newline
6248H	Display newline only
6255H	Display compressed string (no newline)
62BAH	Display B bytes from buffer at HL
6345H	Display prompt (alternate entry)
634EH	Display prompt and collect user input
6578H	Disk error handler
6598H	Special exit - empty input (returns with carry and Z set)
65A0H	Syntax error handler
65A5H	Special exit - comma handling
668AH	Block memory copy - copy B bytes from HL to DE
6691H	16-bit equality comparison - compare HL vs DE
6697H	Range check - check if HL is within BC:DE range
66A2H	Range check - check if BC is within DE range
66ADH	16-bit equality comparison - compare BC vs DE
66B3H	Memory block comparison - compare B bytes at DE vs HL
66BBH	Uppercase letter check - test if A contains A-Z
66CBH	Hex digit validation - test if A contains A-F
66D5H	Decimal digit check - test if A contains 0-9
66DCH	Prompt for TO address
66E1H	Prompt for FROM address
66EFH	Prompt for granule number
670FH	Parse/validate drive number (0-3)
6732H	Parse/validate sector-within-track
6751H	Parse/validate track number
6770H	Parse hex value with error check
677BH	Parse/store 16-bit address at 54ACH
678FH	Prompt for disk parameters
67B5H	Select drive and get disk parameters
67E5H	Parse hex value with terminator validation
67EDH	Parse hex input with special character handling
6822H	Parse decimal number into DE
684FH	Parse hexadecimal number into DE
686DH	Convert ASCII character to hex digit value (0-15)
687BH	8×8-bit multiply entry (sets H=0)
687DH	8×16-bit multiply - HL = HL × A
6896H	16÷8-bit divide - HL = HL ÷ A, remainder in A
68A6H	Convert 8-bit value to decimal string
68ABH	Convert 16-bit value from memory to decimal
68C5H	Convert and display 16-bit value
68D1H	Core decimal conversion - DE to 5-digit ASCII at 5487H

SUPERZAP uses a dual-table compression system to reduce memory usage for displayed messages:

Table 1: Short Words (Codes 80H-9FH) at 69BDH

Code	Word	Code	Word	Code	Word
80H	(space)	8BH	OR	96H	NOT
81H	-	8CH	TO	97H	YOU
82H	AT	8DH	TO?	98H	MAY
83H	BE	8EH	-	99H	BAD
84H	DO	8FH	OR	9AH	-
85H	-	90H	AND	9BH	END
86H	DO	91H	NOT	9CH	EOF
87H	IF	92H	THE	9DH	FEW
88H	IS	93H	ALL	9EH	-
89H	OK	94H	FOR	9FH	-
8AH	OF	95H	TOO

Table 2: Long Words (Codes A0H-FFH) at 69F6H

Code	Word	Code	Word	Code	Word
A0H	(space)	B8H	READ	D0H	RECORD
A1H	BASE	B9H	SEEK	D1H	RETURN
A2H	BASE	BAH	SKIP	D2H	RETURN
A3H	BYTE	BBH	WRITE	D3H	-
A4H	CODE	BCH	DEVICE	D4H	-
A5H	COPY	BDH	PROTECT	D5H	-
A6H	DATA	BEH	SECTOR	D6H	-
A7H	DUMP	BFH	ZERO	D7H	WITHIN
A8H	DISK	C0H	-	D8H	SYSTEM
A9H	EXIT	C1H	VERIFY	D9H	DISKETTE
AAH	-	C2H	VERIFY	DAH	INVALID
ABH	-	C3H	CONTAIN	DBH	DESTINATION
ACH	-	C4H	ILLEGAL	DCH	-
ADH	-	C5H	MEMORY	DDH	DESTINATION
AEH	INPUT	C6H	MEMORY	DEH	-
AFH	PAUSE	C7H	-	DFH	-
B0H	BEYOND	C8H	OFFSET	...	...
B1H	EXTRA	C9H	-
B2H	FOUND	CAH	-
B3H	SOURCE	CBH	PARITY
B4H	-	CCH	-
B5H	SOURCE	CDH	-
B6H	BUFFER	CEH	PARITY
B7H	BUFFER	CFH	OFFSET

Note: Words are terminated with the high bit (bit 7) set on the final character.

Address	String/Message
6D50H	"DRIVE,SECTOR?" prompt
6D6DH	"TO?" prompt
6D71H	"FR?" (FROM?) prompt
6D75H	"GR?" (Granule?) prompt
6DEBH	"INVALID DRIVE" error
6DEFH	"INVALID SECTOR" error
6DF3H	"INVALID TRACK" error
6DF7H	"INVALID SECTOR" (absolute) error
6DFCH	"INVALID ADDRESS" error
6DFFH	General input error
6E04H	Value out of range error
6E38H	"ERROR CODE" prefix
6E3FH	"PREVIOUSLY SUCCESSFULLY" message
6E59H	"INTERNAL PROGRAMMING ERROR"
6E71H	"'R'ETRY, 'S'KIP, E'X'IT" prompt
6EBCH	"SHALL I WRITE?" confirmation
6ECBH	"PARTIAL DATA DUE" message
6EDBH	"NO MATCH" search result
6EE6H	"UNDER DOS-CALL" message

Located at 68F6H, this table contains negated powers of 10 used by the decimal conversion routine (68D1H):

Address	Value (Hex)	Value (Decimal)	Purpose
68F6H	D8F0H	-10000	Ten-thousands place
68F8H	FC18H	-1000	Thousands place
68FAH	FF9CH	-100	Hundreds place
68FCH	FFF6H	-10	Tens place

The units place (1) is handled separately by directly adding 30H to the remainder.

5200H - Conditional Copy of Relative Sector to Current Display Position

This routine checks bit 3 of the mode flags at 5491H (the "memory mode" flag indicating whether we're working with memory rather than disk). If bit 3 is set, the routine exits early without doing anything. Otherwise, it copies the relative sector value from 54B4H to the current display position variable at 5495H. This allows SUPERZAP to track which relative sector is currently being displayed.

520DH - Initialize HL and C from E, Store to 54C3H

This short routine sets Register L, Register H, and Register C all to the value in Register E, then stores HL to address 54C3H. This appears to be used for initializing position or offset values. The address 54C3H holds a 16-bit position value used in various SUPERZAP operations.

5214H - Load H from 54B3H and Store HL to 54C3H

This routine loads a byte from 54B3H into Register H (the high byte of the track/sector indicator), then jumps to 5210H to store HL into 54C3H. This is used to set up position tracking with a specific high byte value.

521AH - Reserved Space (NOP Padding)

This area from 521AH to 52FFH contains NOP instructions (00H bytes). This is reserved space, possibly for future expansion or patch area. The NOPs serve no functional purpose in normal execution.

54C5H - SUPERZAP Main Entry Point and Initialization

This is the main entry point for SUPERZAP (as indicated by "PROGRAM ENTRY = 54C5H" in the disassembly). This routine initializes the stack pointer, clears mode flags, sets up buffer pointers, copies default values from ROM to RAM, and then proceeds to display the main menu and parse command line arguments. The initialization sets up the operating environment for all SUPERZAP functions.

550BH - Process Matched Command or Handle Options

This routine is called when a command keyword has been matched (or when handling the command line after the keyword). It checks for the ",P" option (printer mode), validates command flags, and ultimately dispatches to the appropriate command handler. The routine reads the command flags byte and the handler address from the keyword table entry.

5545H - "J" Command Handler (Jump to Disk/Track/Sector)

This routine handles the "J" (Jump) command when in disk mode with the jump pending flag set. It prompts for disk/track/sector parameters, validates input, and positions SUPERZAP to display the specified location.

5554H - "K" Command Handler (Track/Sector Jump) Entry

This entry point handles the "K" command when the jump pending flag (bit 4) is set. It prompts for track number input.

5563H - Sector Number Prompt

Prompts for sector number input after disk and track have been specified.

5584H - "J" Command - Physical Disk/Sector Jump

This routine handles the physical disk jump when no special mode flags are set.

5593H - Absolute Sector Prompt

Prompts for absolute sector number in physical disk mode.

55C5H - File Zap Command Handler Entry

This routine handles file-based zap operations. It prompts for a filespec, opens the file, and sets up for file sector editing. The routine validates the file exists and is accessible before proceeding.

5641H - File Relative Sector Prompt

Prompts for relative sector number when in file mode (not memory mode).

564FH - Alternate Relative Sector Prompt

Alternative entry for relative sector prompting with different initial conditions.

5668H - Printer Output Setup

Sets up for printer output mode, calculating how many sectors to print.

56A9H - Display Error Message (Sector Out of Range)

Displays an error message when the user attempts to access a sector that is out of the valid range.

56BAH - Main Display/Edit Loop Initialization

This is the main entry point for the sector display and editing loop. It initializes the stack pointer and display position, then enters the command processing loop where users can view and modify sector data.

5734H - "K" Command Handler (Sector Navigation)

Handles the K command which is used for sector navigation. The behavior varies based on current mode: in alternate mode it prompts for relative sector, in file mode it prompts for file sector, in memory mode it prompts for memory address, and in disk mode it prompts for track/sector.

574FH - Navigation Key Handler (+, -, R)

Handles the navigation keys: + advances to the next sector, - goes to the previous sector, and R re-reads/refreshes the current sector. The behavior varies based on whether we're in alternate mode (bit 5) or memory mode (bit 3), which changes whether we navigate by absolute sector or relative sector.

5774H - Relative Sector Navigation (Alternate/Memory Mode)

Handles navigation when in alternate display mode or memory mode. Instead of navigating by absolute sector number, this uses the relative sector value stored at 54B4H. The high byte of the relative sector (D register) is incremented or decremented.

5795H - "S" Command Handler (Search)

Handles the S (Search) command. This command searches for a byte pattern across sectors. It validates that the command is appropriate for the current mode, then uses inline parameter data to configure the search. The pattern "COPY" at 579EH-57A1H appears to be placeholder data that gets overwritten with the actual search pattern.

5803H - Inline Parameter Processor

This utility routine processes inline parameter data that follows a CALL instruction. It reads bytes from the return address, comparing them against user input character by character. When a zero byte (terminator) is found, the routine adjusts the return address to point past the inline data and returns. This allows commands to embed their parameter signatures directly after the CALL instruction.

5814H - "E" Command Handler (Exit to DOS)

This routine handles the E (Exit) command. It uses the inline parameter processor at 5803H to verify the user typed "EXIT", then clears the command line area and jumps to the DOS warm start entry point at 402DH to return to NEWDOS/80 Ready prompt.

5821H - "L" Command Handler (List File Sectors)

This routine handles the L (List) command when a file is open (bit 6 of mode flags is set). It saves the current key code, calls the file sector read routine, and determines whether to continue listing or return to the display loop.

582CH - "F" Command Handler (Find/File Operations)

This routine handles the F (Find) command. It initializes the search parameters and calls the file sector read routine to begin searching. If no match is found immediately, it continues to the search setup at 5834H.

5834H - Find Command Parameter Setup

This section sets up the search parameters for the Find command. It saves various state variables including the search position, mode flags, and relative sector information. The routine handles both memory mode and disk mode searches differently based on the mode flags.

586AH - Alternate Search Mode Entry

This section handles the alternate search mode when the carry flag was set on entry. It processes hex input for the search pattern.

5872H - Search Position Calculation

This section calculates and stores the search position within the current sector. It handles the byte offset calculation and adjusts for memory mode if needed.

58A0H - Multi-Byte Search Pattern Input

This section collects multiple bytes for the search pattern. It allows up to 4 bytes to be entered for the search string.

58BEH - Search Initialization Complete

This section finalizes the search setup by storing the starting position and initiating the search loop. It checks for the BREAK key and handles both disk sector and memory mode searches.

5902H - Update Search State and Continue

This section updates the search state variables and determines whether to continue searching or if a match was found. It handles incrementing through sectors and checking for sector boundaries.

5919H - Search Pattern Matching Loop

This is the core pattern matching loop. It compares bytes from the search pattern buffer against the current position in the data being searched. When all pattern bytes match, the search is successful.

5931H - Search Match Found

This section executes when a search pattern match is found. It cleans up the stack, sets the "sector modified" flag to indicate a match was found at this location, and returns to the command loop with the 'R' command to re-read and display the found sector.

593CH - Get Next Byte for Search

This routine retrieves the next byte from the data being searched. It handles both alternate display mode (reading from a buffer) and normal mode (reading from disk sectors). The routine advances the position counters and handles sector boundaries.

5951H - Normal Mode Sector Read for Search

This routine reads the next sector from disk during a search operation. It calls the DOS sector read routine and handles various conditions including end-of-file, sector boundaries, and file mode operations. The routine manages the search offset counter and handles multi-sector spanning searches.

596CH - Handle File Sector Boundary

This routine handles crossing sector boundaries during file searches. It reads the next sector and determines whether to continue the search, skip sectors, or reset based on the file structure.

5982H - Handle Data Address Mark

This routine handles a Data Address Mark (DAM) encountered during file search. It calculates the proper offset for continuing the search past the header bytes.

5989H - Skip Sectors Loop

This routine skips a specified number of sectors during file search. It repeatedly calls the DOS sector read until the counter in D reaches zero.

5990H - DOS Sector Read for Search

This routine performs the actual DOS sector read operation. It calls the NEWDOS/80 file read routine at 444EH with the FCB at 5400H. The routine handles various return conditions including successful read, end of file (error 06H), and break key detection.

59B4H - Reset Search State

This routine resets all search state variables to their initial values. It clears the position counters, offset variables, and prepares for a new search or returning to normal display mode. This is called when the search is aborted or reaches the end of searchable data.

59E0H - Copy Command Setup (Source Specification)

This routine handles the setup for the Copy command. It displays prompts for the source disk/sector and collects the parameters needed for the copy operation. The routine saves the source parameters for later use when specifying the destination.

5A09H - Copy Command Setup (Destination Specification)

This section prompts for the destination disk and sector for the copy operation. It validates the input and prepares the parameters for the actual copy.

5A57H - Copy Operation Main Loop Setup

This section sets up the buffer addresses and begins the main copy loop. It calculates the source and destination buffer addresses and initiates the byte-by-byte copy process.

5A72H - Copy Operation Byte Transfer Loop

This is the main byte-by-byte copy loop. It transfers data from the source buffer to the destination buffer, handling sector boundaries and direction control.

5A9AH - Reverse Copy Pointer Adjustment

This section handles pointer adjustment for reverse direction copying. It decrements the buffer pointers instead of incrementing them.

5AACH - Read Source Sector for Copy

This routine reads the source sector for the copy operation into the buffer at 4200H. It saves and restores all working registers, handles the sector position update, and accounts for forward or reverse direction.

5AD2H - Write Destination Sector for Copy

This routine writes the destination sector to disk during copy operations. It saves all working registers, clears the search type flag at 5494H, calls the sector write routine, updates the destination sector number based on the copy direction (forward or reverse), and restores the registers before returning. The routine at 5AD6H contains self-modifying code where the search type flag value is stored.

5AEFH - Write and Read Next Destination Sector

This routine handles destination sector boundary crossing during copy operations. It first writes the current destination sector to disk, then reads the next destination sector into the buffer. This is called when the destination byte offset wraps around (crosses a 256-byte sector boundary).

5AF2H - Read Destination Sector for Copy

This routine reads the destination sector into the buffer at 5300H. It sets up the FCB parameters (sector number, buffer address, disk number), performs the read via 5B42H and 6457H, checks for sector overflow beyond the disk's maximum sector, and handles self-modifying code to track the operation type.

5B16H - Read Sector with Overflow Check

This routine reads a sector from disk after setting up the FCB parameters. It checks for sector overflow (attempting to read beyond the disk's maximum sector) but only in standard disk mode (not in memory or file mode). Used by the copy operation to read source sectors.

5B29H - Write Sector with Overflow Check

This routine writes a sector to disk after setting up the FCB parameters. It loads the current sector number, maximum sector, buffer address, and disk number, then checks for overflow before calling the disk write routine at 6474H.

5B42H - Setup FCB Parameters

This utility routine stores the sector number, buffer address, and disk number into the File Control Block (FCB) at 5400H. The FCB is used by NEWDOS/80 for all disk I/O operations. On entry: HL=sector number, BC=buffer address, A=disk number.

5B4DH - Move Command Setup (Source Specification)

This routine handles the setup for the Move command. It displays prompts for specifying the source disk and sector parameters. The Move command differs from Copy in that it operates on sectors within the same file or disk structure. The routine saves the source parameters for later use when specifying the destination.

5B6DH - Move Command Setup (Destination Specification)

This section prompts for the destination disk for the move operation. After validating the input, it calculates the transfer parameters and handles reverse direction if specified.

5B9EH - Zeroize/Fill Command Setup

This routine handles the Zeroize (or Fill) command setup. It displays the appropriate prompt and collects input for specifying the range of sectors to fill with zeros or a specified byte value.

5BA6H - Purge Command Setup

This routine handles the Purge command which securely erases sectors by overwriting them. It checks for a special option flag and sets the purge mode if specified.

5BB3H - Sector Range Input Loop

This routine collects the sector range input for zeroize/purge operations. It loops until valid input is received, then processes the disk parameters.

5BBBH - Zeroize/Purge/Move Main Loop Setup

This is the main setup and dispatch point for the zeroize, purge, and move operations. It determines which disk and sector to operate on based on the mode flags, then reads the sector into the buffer.

5BECH - Check Operation Mode and Execute

This section determines what operation to perform based on the mode flags. It handles verify mode, purge mode, and zeroize mode differently.

5C1AH - Zeroize/Purge Sector Execution

This section performs the actual zeroize or purge operation on the current sector. For purge mode, it sets bit 5 indicating multiple passes. It fills the sector buffer with zeros and writes it to disk.

5C30H - Advance to Next Sector

This routine advances to the next sector in the sequence (forward or reverse based on mode flags), decrements the remaining count, and loops back until all sectors are processed.

5C5AH - "MOD" Command Handler (Sector Modification)

This routine handles the MOD (Modify) command which allows direct editing of sector data at the byte/nibble level. It uses inline parameter verification to confirm "OD" was typed after "M", then enters an interactive editing mode where the user can modify individual bytes using hex input. The cursor position tracks location within the sector buffer.

5C69H - Modify Mode Main Loop

This is the main loop for the Modify mode. It stores the current edit position, reads a hex nibble from the user, and processes the input to update the sector buffer. The loop continues until the user presses ENTER to confirm or another key to exit.

5CAEH - Process Non-Hex Key Input

This section handles keypresses that are not valid hex digits. It checks for control keys like ENTER (confirm changes), SPACE/TAB (advance position), BACKSPACE (move back), and arrow keys (navigation).

5CC7H - Check Backspace and Arrow Keys

This section handles the BACKSPACE key (move cursor backward) and arrow keys for navigation within the sector buffer.

5CD6H - Check Down Arrow Key

This section handles the DOWN ARROW key to move the cursor down by one line (2 bytes in hex display).

5CE7H - Check Up Arrow and Other Navigation Keys

This section handles UP ARROW, LINE FEED (down by 16 bytes), and begins checking for special command keys.

5D01H - Confirm and Save Sector Changes

This routine handles the ENTER key press during Modify mode. It prompts the user to confirm whether to write the changes to disk. If in alternate display mode (bit 5 set), it skips the confirmation. Otherwise, it displays "WRITE CHANGES (Y/N)?" and waits for user response. If 'Y' is pressed, the sector is written to disk.

5D23H - Display Modification Complete Message

This routine displays a completion message after modifications have been made (or skipped). It shows "MODIFICATION COMPLETE" and waits for user acknowledgment before returning to the main display loop with a Re-read command.

5D34H - Check for Quit Command

This section checks if the user pressed Q to quit the Modify mode without saving. It also handles alternate mode differently, showing an "ABORTED" message.

5D45H - Check for Zap Byte Command

This section checks for Z (zap/zero a byte) or A (set to alternate value) commands. These allow quickly setting a byte to 00H or another preset value.

5D51H - Zap/Repeat Fill Command Processing

This routine processes the Zap (Z) or Repeat fill (R) command. It echoes the command character, gets additional parameters (end address and optionally fill value), validates the range, and fills the specified bytes. For Zap, it fills with 00H. For Repeat fill, it prompts for a fill value. The syntax is "ZT<end>" for Zap or "RT<end>,<value>" for Repeat fill.

5D9AH - Fill Bytes Loop

This is the main fill loop that writes the fill value to consecutive bytes in the sector buffer. It continues until the byte count in C reaches zero, then returns to the modify mode.

5DA6H - Error Handler and Recovery

This routine handles errors and boundary conditions during Modify mode. It displays an error message, waits for the user to press * to acknowledge, then returns to the edit loop. This is called when the user tries to edit beyond sector boundaries or when an invalid operation is attempted.

5DBCH - Display Cursor and Wait for Keypress

This routine displays a cursor character at the current screen position, waits for a keypress (with cursor blinking), and returns the key code. It calculates the screen address from the buffer position and handles cursor blinking by alternating the character display. Entry: A=cursor character, B=mode flags, C=buffer position. Exit: A=key code pressed.

5DECH - Wait for Keypress with Timeout

This routine waits for a keypress with a timeout counter. If no key is pressed before the timeout expires, it returns with Z flag set (for cursor blinking). If a key is pressed, it returns with NZ and the key code in A.

5DF7H - Get Character from Input

This routine gets a character from user input. It waits for a keypress, checks if it's a printable character (ASCII 20H or higher), and optionally echoes it to a buffer. If the key is below 20H (control character), it returns with carry set.

5DFDH - Echo Character to Command Buffer

This routine stores a character into the command line echo buffer area. It calculates the buffer position, checks for overflow, and stores the character. The buffer is located in video memory at 4000H.

5E19H - Get Hex Address Input

This routine gets a hexadecimal address value from user input. It first gets a character, then parses up to 4 hex digits into a 16-bit value in Register pair DE. If the input is invalid or the user presses a control key, carry is set on return. Used by the MOD command to get the starting edit position.

5E1CH - Parse Hex Digits into DE

This routine parses hexadecimal digits from user input into a 16-bit value. It accumulates digits into Register pair DE, shifting previous digits left by 4 bits for each new digit entered. Entry: Called after first character is in A. Exit: DE=parsed value, carry set on error.

5E2EH - Get Hex Byte with Validation

This routine gets a hex byte value from input with additional validation. It calls the parse routine and then checks for proper termination. Used for getting search patterns and other byte values.

5E33H - Get Hex Value with Full Parsing

This routine gets a complete hex value from input, handling up to 4 digits. It's the main entry point for hex input when a full address or value is expected.

5E37H - Check Input Termination

This routine checks if the input was properly terminated with ENTER (0DH) or a comma (2CH). It's called after parsing to validate that the user completed the input correctly. Returns: Z flag if terminated with ENTER, carry clear if comma (more input follows), carry set if invalid terminator.

5E49H - Password Entry and Checksum Calculation

This routine handles password entry for protected operations. It displays a password prompt, collects up to 8 characters of input, clears the entry area on screen with spaces, and then calculates a 16-bit checksum of the entered password combined with stored data. The checksum algorithm uses a complex series of rotations and XOR operations to create a hash value. This is used for disk copy protection verification.

5E64H - Checksum Calculation Loop

This is the main checksum calculation loop. It processes each byte of the password buffer through a complex series of rotations and XOR operations to generate a pseudo-random hash. The algorithm is designed to make it difficult to reverse-engineer the expected password from the stored checksum.

5E8CH - Display Checksum Result

After calculating the checksum, this section converts the 16-bit hash value in DE to hexadecimal ASCII and displays it. The checksum is shown as a 4-digit hex number.

5EA0H - Filespec Entry and Validation

This routine handles filename input with validation. It displays a prompt for the filespec, collects up to 8 characters for the filename, pads with spaces if needed, then collects up to 3 characters for the extension. It calculates a checksum of the entered filespec for validation purposes.

5ECCH - Filespec Checksum Calculation

This section calculates a checksum of the entered filespec for validation. It XORs all 11 characters (8 filename + 3 extension) together with rotation to create a hash value.

5EDFH - Raw Track Read Command Setup

This routine sets up and initiates a raw track read operation for disk analysis. It prompts for track/sector parameters, sets the file mode flag in the secondary mode flags at 5493H, configures the FCB (File Control Block) at 5400H with the maximum sector count and starting sector, then calls NEWDOS/80's directory search routine. This allows SUPERZAP to read raw track data directly from the floppy disk controller for analyzing disk format and copy protection.

5F05H - Raw Track Read Initialization

This routine initializes the WD1771 floppy disk controller for a raw track read operation. It saves the current disk select byte from the DOS workspace at 4309H, disables interrupts for precise timing, calls the drive select routine, then restores the select byte. Raw track reads require uninterrupted execution to capture every byte as it streams off the disk.

5F26H - Wait for FDC Busy

This short loop waits for the FDC to transition from "just busy" (status=01H) to "busy with data ready" (status has DRQ bit set). This synchronizes the capture loop with the actual data stream from the disk.

5F2BH - Raw Track Data Capture Loop

This is the critical high-speed data capture loop. It reads raw bytes from the FDC data register at 37EFH as fast as possible and stores them into the buffer at 7000H. The loop must complete each iteration within the byte time of the disk (32 microseconds for single density) or data will be lost. Multiple DRQ checks handle timing variations.

5F46H - Track Read Completion and Error Check

This section handles completion of the raw track read. It checks for CRC errors in the captured data, marks error locations in the buffer, sends a Force Interrupt command to reset the FDC, re-enables interrupts, and saves the final buffer position for later analysis.

5F54H - Save Buffer Position and Check Errors

This section saves the final buffer position, extracts error bits from the FDC status, and determines whether to display results or an error message. The buffer position indicates how many bytes were captured from the raw track read.

5F63H - Display Disk Error

This routine displays a disk error message based on the error code in Register A, then returns to the error handler to allow the user to retry or abort.

5F69H - Display Track Read Results

This routine displays the results of a successful raw track read operation. It shows the buffer start address (7000H), the buffer end address (from 5F7CH), allowing the user to see how much data was captured.

5F85H - FDC Status Check with Retry

This routine checks the FDC status and handles busy/not ready conditions with automatic retry. It's used during drive initialization to wait for the drive to become ready.

5F8DH - Handle FDC Busy Condition

This section handles the case where the FDC is busy. It checks if the controller is simply completing an operation or if it needs to be reset with a Force Interrupt command.

5F9DH - Check FDC Not Ready

This short routine checks if the FDC is reporting "not ready" status, which indicates the drive door is open or no disk is inserted.

5FA2H - Output Drive Select Byte

This routine outputs the current drive select byte to the disk controller hardware. It reads the select byte from the DOS workspace at 4309H and writes it to the drive select latch at 37E1H.

5FA9H - Timing Delay and Read FDC Status

This routine provides a short timing delay (approximately 30 microseconds) then reads the FDC status register. The delay allows the FDC time to update its status after a command or operation.

5FB2H - Initialize Sector Display Screen

This routine initializes the screen for displaying sector contents. It sets up the cursor position pointer at 54B0H, clears the command line area, and prepares the video memory starting at 3C00H for the hex/ASCII dump display. The display shows 16 rows of 16 bytes each (256 bytes total per sector).

5FC6H - Format Display Row Address

This section calculates and displays the address prefix for each row of the hex dump. It shows the offset within the sector at the left margin.

5FE8H - Format Hex Bytes and ASCII Display

This is the main formatting loop that displays each row of the hex dump. For each row, it shows 8 pairs of hex bytes in the left portion of the screen, and the corresponding ASCII characters in the right portion. Non-printable characters are displayed as periods.

601AH - Check Display Mode and Show Status

After displaying the 16 rows of hex/ASCII dump, this section checks the display mode flags and adds status information at the bottom of the screen. It shows disk number, track, sector, and granule information depending on the active mode (file mode, memory mode, or standard disk mode).

6032H - Display Disk Number Status

This section displays the disk drive number on the status line at the top of the screen. It sets up the display parameters and calls the status formatting routine.

6041H - Check for File Mode Status

This section loads the current sector number and checks if file mode is active. In file mode, additional information about granules and file position is displayed. Otherwise, track and sector information is shown.

604CH - Calculate File Position for Status

When in file mode, this section calculates the current position within the file by traversing the granule allocation chain. It determines which granule contains the current sector and calculates the offset within the file.

605DH - Traverse Granule Chain

This loop traverses the granule allocation chain in the FCB to calculate the file position. It checks each granule entry to see if the current sector falls within that granule, accumulating the byte offset as it goes.

6089H - Complete File Position Calculation

This section completes the file position calculation and proceeds to display the track/sector status line.

608DH - Calculate Exact File Offset

When the correct granule is found, this section calculates the exact byte offset within the file based on the granule position and sector offset.

60B5H - Display Track Number Status

This section displays the track number on the status line. It retrieves the sector number from the stack, checks if file mode is active, and calculates the track number based on sectors per track.

60DEH - Display Track Number and Search Type

This section displays the track number at screen position 3F00H (bottom status row), then displays the current search/operation type indicator at position 3FC1H.

60EAH - Restore Registers and Return

This is the common exit point for the sector display routine. It restores the BC register pair that was saved at the beginning and returns to the caller.

60ECH - Format and Display Status Value

This is a general-purpose routine for formatting and displaying numeric status values on the screen. It takes a 16-bit value in HL, a screen position in DE, and a format string address in BC. It calculates three screen positions (base, +64, +128 for multi-line display), copies a 3-character label from the format string to the base position, then displays the value in three formats: as a formatted string, in decimal, and in hexadecimal with an "H" suffix.

6111H - Boundary Range Check

This routine checks if the current position falls within a specified boundary range. It compares values at 5499H and 549AH, then checks if the current sector (54A2H) is within range of the target sector (54A4H). If within range, it sets bit 7 of the secondary mode flags at 5493H. This is used during search operations to determine if a match has been found within the current sector.

612DH - Reverse Range Check

This section handles the reverse search case where the target sector is before the current sector. It recalculates the range to determine if the current position is within the search boundary.

6134H - Set Boundary Flag

This section sets bit 7 of the secondary mode flags to indicate that the boundary condition has been met. This flag signals to the calling code that the search target has been found.

613AH - Print Sector Display to Printer

This routine prints the current sector display to the printer. It first refreshes the screen display, then outputs each character of the first row (64 characters) to the printer, converting TRS-80 graphics characters to printable ASCII. The user can press H to halt, P to pause, or let it continue for multiple pages.

6147H - Print Row Character Loop

This loop reads each character from video memory and outputs it to the printer. TRS-80 graphics characters (codes 00H-1FH and 80H-BFH) are converted to printable ASCII by adding 40H to codes below 20H.

6157H - Check for User Interrupt

After printing each row, this section checks if the user has pressed a key to halt or pause the printing. H halts completely, P pauses until Enter is pressed.

6168H - Pause and Wait for Enter

When the user presses P, this loop waits for them to press Enter before resuming the print operation.

616FH - Continue Printing or Finish

This section decrements the page counter and either continues printing the next row or finishes the print job with extra newlines.

617BH - Initialize Edit Buffers

This routine initializes the edit buffers for sector operations. It calculates the buffer size based on the value at 54B4H, sets up the source buffer at 4200H and destination buffer at 5300H, stores the buffer address in the FCB, and fills the destination buffer with FFH bytes while reading keyboard input. This allows the user to enter data while the buffer is being initialized.

6191H - Fill Buffer with FFH

This loop fills the destination buffer at 5300H with FFH bytes. The FFH value represents "empty" or "uninitialized" data in the TRS-80 disk format.

6197H - Keyboard Input During Fill

After filling the buffer, this section reads keyboard input using the ROM routine at 0013H. Characters are stored into the buffer, allowing the user to enter data. Special keys (BREAK, CLEAR) are handled separately.

61A2H - Handle Special Keys

This section handles special keys returned by the ROM keyboard routine. Key code 1CH indicates BREAK was pressed (fill remaining buffer with FFH and show error), while 1DH indicates CLEAR was pressed (return to a specific menu).

61BFH - Calculate Buffer Parameters from Input Value

This routine calculates sector and offset values from an input address in HL. It compares HL against the limit value at 54B2H, computes the sector number and byte offset within sector, and sets up the FCB fields for file positioning. On entry: HL = input address value. On exit: FCB at 540AH contains sector number, 5405H contains byte offset, bit 5 of 5401H is set to indicate special buffer mode.

61EAH - Convert DE to Hex ASCII at (HL)

This routine converts the 16-bit value in DE to 4 hex ASCII characters, storing them at the address in HL. It calls the byte conversion routine twice - once for D (high byte) and once for E (low byte). On entry: DE = 16-bit value to convert, HL = destination buffer address. On exit: HL points past the 4 stored characters.

61EFH - Convert Byte A to 2 Hex ASCII Characters at (HL)

This routine converts the byte in A to two hex ASCII characters, storing them at the address in HL. It converts the high nibble first, then the low nibble. On entry: A = byte to convert, HL = destination address. On exit: HL points past the 2 stored characters (HL = HL + 2).

61F8H - Convert Low Nibble of A to Hex ASCII and Store at (HL)

This routine converts the low nibble (bits 0-3) of A to a hex ASCII character ('0'-'9' or 'A'-'F') and stores it at the address in HL, then increments HL. On entry: A = value with nibble to convert in bits 0-3, HL = destination address. On exit: Character stored at (HL), HL = HL + 1.

6205H - Non-Blocking Keyboard Scan

This routine performs a non-blocking keyboard scan by calling ROM routine 002BH. It preserves DE and converts any lowercase letters to uppercase. On entry: None. On exit: A = key code if key pressed (converted to uppercase), A = 0 if no key, DE preserved.

620BH - Blocking Keyboard Wait

This routine waits for a keypress by calling ROM routine 0049H. It preserves DE and converts any lowercase letters to uppercase. This is a blocking call - execution pauses until a key is pressed. On entry: None. On exit: A = key code (converted to uppercase), DE preserved.

620FH - Restore DE and Convert Lowercase to Uppercase

This is the common exit point for keyboard routines. It restores DE from the stack and converts any lowercase letter in A to uppercase. On entry: A = key code from keyboard. On exit: A = key code (uppercase if was lowercase letter), DE restored.

6210H - Convert Lowercase to Uppercase

This routine converts a lowercase letter (a-z) in A to uppercase (A-Z). If A is not a lowercase letter, it is returned unchanged. On entry: A = character to convert. On exit: A = uppercase character (if was lowercase) or original character.

6219H - Clear Command Line and Display String with Newlines

This routine clears the command line area on screen, then displays the string pointed to by HL, followed by 3 carriage returns (newlines) to the printer. It's used to prepare the display for new prompts or messages.

6224H - Display String and Prompt for Y/N Confirmation

This routine displays a string at (HL), then displays the standard Y/N prompt from 6D11H and calls the confirmation input routine. On exit: Z flag set if user entered Y, NZ if N. If Z flag is set, execution jumps to 54C5H (main command handler).

6231H - Y/N Confirmation Input Loop

This routine repeatedly displays the prompt string at (HL), collects keyboard input, and loops until the user enters either Y (59H) or N (4EH). The routine gives the user 3 attempts, re-displaying the prompt each time. On entry: HL = prompt string address. On exit: A = key pressed (59H for Y or 4EH for N), Z flag set if Y, NZ if N.

6242H - Flush Printer and Display String with Newline

This routine flushes the printer buffer, then displays the string at (HL) followed by a newline. Used when printer output needs to be synchronized before displaying new content.

6245H - Display String with Single Newline

This routine displays the string pointed to by HL, then outputs one carriage return (0DH) to the printer. On entry: HL = string address. The string display routine at 6255H is called first.

6252H - Flush Printer and Display Compressed String

This routine flushes the printer buffer before displaying a compressed string. It's an entry point that ensures printer synchronization before string output.

6255H - Display Compressed String

This is the main compressed string display routine. SUPERZAP uses a sophisticated string compression system where common words are stored in tables at 696BH (short words) and 6A23H (longer words). Strings contain special control codes (60H and above) that index into these word tables. The high bit of each character in the tables marks the end of a word. On entry: HL points to the compressed string. Register C tracks state: bit 0 indicates if a space should precede the next word.

629FH - Character Output Filter

This routine filters character output. If the character is 08H (backspace control code), it resets the space flag in C and returns without output. Otherwise, it outputs the character via the main character output routine at 62C8H. On entry: A = character to output, C = flags (bit 0 = space flag). On exit: Character output to display/printer (unless A was 08H).

62A7H - Clear Command Line Area

This routine clears the command line area on the screen by first outputting a "home to command line" code (1CH) followed by a "clear to end of line" code (1FH). Used to prepare the screen for new prompts or messages.

62AEH - Output "Turn On Expanded Print" Control

Outputs control code 0EH to enable expanded (double-width) printing on compatible printers.

62B2H - Output "Turn Off Expanded Print" Control

Outputs control code 0FH to disable expanded (double-width) printing on compatible printers.

62B6H - Output "Home to Command Line" Control

Outputs control code 1CH to position the cursor at the command line area (bottom of screen).

62BAH - Output Buffer Contents (B bytes from HL)

Outputs B bytes from the buffer at (HL) to the character output routine. On entry: HL = buffer address, B = byte count. On exit: HL points past the last byte output, B = 0.

62C2H - Output Single Character from (HL) and Advance

Outputs one character from (HL) and advances HL. Used for inline string output where HL tracks position.

62C6H - Output Space Character

Outputs a space character (20H). Called by the compressed string routine to insert spaces between words.

62C8H - Main Character Output Routine

This is the central character output routine for SUPERZAP. It handles both screen and printer output, managing column tracking, line wrapping, and special control codes. The routine uses several workspace variables: 5483H (current column position), 5484H (line width), 5480H (output mode flags where bit 6 = printer output enabled), 5481H (lines per page), 5482H (current line count). On entry: A = character to output. All registers are preserved.

6327H - Output Padding Spaces

This routine outputs padding spaces to align output. It calculates how many spaces are needed based on the difference between line width and current position, then outputs that many spaces. On entry: B = alignment parameter. On exit: Spaces output to current position, or returns immediately if already past alignment point.

6339H - Display Prompt and Get Filename

This routine displays a prompt string at (HL), then collects filename input from the user into the buffer at 5440H. The input is limited by the value in B (maximum characters). On entry: HL = prompt string address, B = maximum input length. On exit: HL = 5440H (input buffer address).

6345H - Display String and Wait for Keypress

This routine displays the string at (HL), then waits for the user to press ENTER. It loops until ENTER is pressed. Used for "Press ENTER to continue" prompts.

634EH - Display Prompt and Collect Input

This routine displays a prompt string at (HL), then collects keyboard input into the buffer at 5440H. Maximum input length is 64 characters (40H). On entry: HL = prompt string address. On exit: A = first character of input, Z flag set if first char is ENTER (0DH), HL = 5440H.

636AH - Disable Printer Output Mode

This routine flushes the printer buffer, then clears the output mode flags at 5480H to disable printer output. Printer output is controlled by bit 6 of 5480H.

6374H - Flush Printer Buffer

This routine flushes any pending output and prepares for new output. It sets the output device to printer mode (22H stored at self-modifying location 63ECH) and initializes column position. If the current column is not at line start, a newline is output first.

6379H - Output Carriage Return to Printer

This routine initializes for screen output mode (00H) and ensures the cursor is at the start of a line.

639FH - Enable Printer Output Mode

This routine enables printer output by setting bit 6 of the output mode flags at 5480H. When bit 6 is set, characters are sent to both screen and printer.

63A8H - Disable Printer Output Mode

This routine disables printer output by clearing bit 6 of the output mode flags at 5480H. Output will go to screen only.

63AFH - Check if Line Counter at Page Boundary

This routine checks if the current line counter (at 5482H) equals 60 (3CH), which indicates a page boundary for printer pagination. On exit: Z flag set if at page boundary (line counter = 3CH).

63B5H - Handle End of Line for Printer

This routine handles end-of-line processing for the printer. It checks the output mode, manages page breaks (outputting extra carriage returns at page boundaries), and resets the column position. The self-modifying location at 63ECH determines the current output mode (22H = printer, 00H = screen).

63DDH - Output Multiple Newlines Until Page Boundary

This routine outputs newlines until the line counter reaches a page boundary (60 lines). Register C specifies the maximum number of newlines to output. Used to advance to a new page or create vertical spacing. On entry: C = maximum newline count.

63E8H - Device Output Dispatcher

This routine outputs a character to the current output device(s). It uses a clever self-modifying dispatch mechanism to handle the return path. The routine at 6427H captures the return address and patches it into jump targets at 6434H and 6442H, allowing different return paths depending on how the output completes. On entry: A = character to output.

63EDH - Screen Output with Character Filtering

This routine outputs a character to the screen with filtering for non-printable characters. Characters above a configurable threshold (stored at 4370H) are replaced with a period (2EH). Control characters are handled specially. On entry: A = character to output.

6427H - Output Setup with Self-Modifying Return Path

This routine implements a sophisticated dispatch mechanism using self-modifying code. It captures the return address from the stack and patches it into two jump targets (6434H and 6442H), allowing the output routines to return to different points depending on the execution path. This technique avoids multiple returns and simplifies control flow.

6436H - Alternate Return Path Setup

This routine provides an alternate entry for setting up return path. It patches the address into 6442H instead of 6434H, creating a different return destination.

6444H - Common Exit - Restore Registers and Return

This is the common exit point for the output routines. It restores all saved registers (IY, IX, BC, DE, HL) and returns to the caller.

644CH - Read File with Raw Mode Flag Set

This routine sets the raw/track mode flag (bit 6 of 5493H), calls the main file read routine at 6457H, then clears the flag. This wraps the file read operation with raw mode enabled for track-level access.

6457H - Main File Read Setup

This routine prepares for and executes a DOS file operation. It sets up the FCB flags, calls the DOS @FSPEC routine at 4436H, and handles any errors. On entry: None (uses FCB at 5400H). On exit: Carry set on error, Z flag set if operation succeeded without error code.

6474H - Write Sector to Disk

This routine writes a sector to disk. It sets up the FCB for a write operation (80H flag), checks the operation type, and calls the DOS write routine. On exit: Carry set on error.

6497H - FCB Setup with Self-Modifying Return Path

This routine sets up the FCB (File Control Block) for a disk operation and configures the self-modifying return address. It captures the return address from the stack, patches it into 64BAH, and initializes FCB fields. On entry: A = operation flag (00H = read, 80H = write). On exit: FCB prepared, self-modifying jump target set.

64BCH - Check DOS Error Status

This routine checks the result of a DOS operation. It examines flags and the error code in A, returning appropriate status or jumping to error display. On entry: Flags from DOS call, A = error code. On exit: Z set if no error, Carry set for critical errors, NZ for warnings.

64C5H - Display DOS Error Message

This routine displays a DOS error message based on the error code. It saves registers, clears the command line, displays drive/sector status, looks up the error message in the error table at 6BEDH, and prompts for user response. On entry: A = DOS error code, flags from error check. On exit: May jump to retry, skip, or exit based on user input.

6573H - Display Error from DE

Entry point that exchanges DE and HL, then displays an error message. Used when the message address is in DE instead of HL.

6576H - Display Unknown Key Error

Entry point for handling unknown/invalid key presses. Displays DOS error code 01 (with C0H prefix) and waits for user acknowledgment.

657FH - Display Message and Wait for Any Key

Displays a message from (HL) with printer flush, then waits for any keypress before returning to the main command loop.

658EH - Display "INVALID" Error

Entry point for displaying "INVALID" error message from 6E20H.

6593H - Display "BEYOND" Error

Entry point for displaying "BEYOND" (out of range) error message from 6E26H.

6598H - Display Message and Return with Carry Set

Displays error message from 6E0AH, then returns with Carry flag set to indicate error to caller.

65A0H - Display Error Message from 6E0FH

Entry point for displaying error message from 6E0FH, returns with Carry set.

65A5H - Display Error Message from 6E14H

Entry point for displaying error message from 6E14H, returns with Carry set.

65AAH - Display "ILLEGAL OPERATION" Error

Entry point for displaying "ILLEGAL OPERATION" (or similar) error from 6E3DH. Used when an invalid operation is attempted.

65AFH - Display Error Message from 6E59H

Entry point for displaying error message from 6E59H.

65B4H - Display "ABORTED" Message

Entry point for displaying "ABORTED" message from 6E85H. Used when user chooses to exit/abort an operation.

65B9H - Display Error Message from 6DE7H

Entry point for displaying error message from 6DE7H.

65BEH - Display Error Message from 6EE9H

Entry point for displaying error message from 6EE9H.

65C3H - Main Return to Command Loop

Entry point that outputs a newline, displays a message from 6C2DH, and returns to command loop.

65CBH - Add A to HL (HL = HL + A)

This utility routine adds the value in A to the 16-bit value in HL. Used for table indexing and address calculations. On entry: A = offset to add, HL = base address. On exit: HL = HL + A.

65D0H - Display Drive and Sector Status

This routine displays the current drive number, sector number, track, and sector-within-track for error messages and status displays. It retrieves values from the FCB and mode flags, formats them, and outputs to the display. Uses label strings from 6E8DH (drive), 6E90H (track), 6E93H (sector), 6E96H (absolute sector), and 6E9BH.

660AH - Display Label with 8-bit Value

Entry point that expands an 8-bit value in A to 16-bit in DE, then displays it with a label. On entry: A = 8-bit value, HL = label string address.

660DH - Display Label with Numeric Value and Decimal Conversion

This routine displays a label string, converts a value to decimal, and outputs it with leading zero suppression. It also shows the value in hex format. On entry: DE = value to display, HL = label string address. Uses buffer at 5487H for conversion.

6649H - Convert Byte to Hex and Display

Converts a byte in A to two hex ASCII characters in the buffer at 5487H, then displays them. On entry: A = byte to convert. On exit: Two hex characters displayed.

665BH - Convert DE to Hex and Display with Suffix

Converts the 16-bit value in DE to 4 hex ASCII characters and displays them, followed by the "H" suffix. On entry: DE = 16-bit value to display.

6665H - Convert DE to Hex ASCII at (HL)

Converts the 16-bit value in DE to hex ASCII characters stored at (HL). Handles leading zeros by only outputting significant digits. On entry: DE = value to convert, HL = buffer address. On exit: HL points past the stored characters.

6674H - Convert Byte to Two Hex ASCII Characters

Converts a byte in A to two hex ASCII characters (high nibble first, then low nibble) and stores them at (HL), advancing HL by 2. On entry: A = byte to convert, HL = destination buffer. On exit: HL = HL + 2.

667DH - Convert Nibble to Hex ASCII and Store

Converts the low nibble (bits 0-3) of A to a hex ASCII character ('0'-'9' or 'A'-'F') and stores it at (HL), then increments HL. On entry: A = value with nibble in bits 0-3, HL = destination. On exit: Character stored, HL incremented.

668AH - Block Memory Copy Routine

This routine copies a block of B bytes from the address pointed to by HL (source) to the address pointed to by DE (destination). It is a standard memory block move operation used throughout SUPERZAP for buffer transfers. On entry: HL = source address, DE = destination address, B = number of bytes to copy. On exit: HL and DE point past the copied data, B = 0.

6691H - Compare HL to DE (16-bit Equality)

This routine compares the 16-bit value in HL with the 16-bit value in DE, setting the Z flag if they are equal. This is used to test if two pointers or addresses are identical. On entry: HL = first value, DE = second value. On exit: Z flag set if HL equals DE, NZ flag set if they differ.

6697H - Compare HL Against BC:DE Range (Lower Bound Check)

This routine checks if the pointer HL is at or below a range boundary. It compares HL against BC and sets carry if HL is below the range start. This is used for boundary validation in buffer operations. On entry: HL = value to test, BC = first boundary, DE = second boundary. On exit: NZ if out of range, Carry set if HL is below L boundary.

66A2H - Compare BC Against DE Range

This routine compares BC against DE and HL as range boundaries. It performs a three-way comparison to determine if BC falls within a valid range. On entry: BC = value to test, DE = one boundary, HL = other boundary. On exit: Flags set based on comparison results.

66ADH - Compare BC to DE (16-bit Equality)

This routine performs a simple 16-bit comparison between BC and DE, setting the Z flag if they are equal. This is a utility function for comparing two register pairs. On entry: BC = first value, DE = second value. On exit: Z flag set if BC equals DE.

66B3H - Compare Memory Blocks

This routine compares B bytes starting at (DE) against B bytes starting at (HL). It returns with Z flag set if all bytes match, or NZ flag set at the first mismatch. This is used for search operations and data validation. On entry: DE = first block address, HL = second block address, B = number of bytes to compare. On exit: Z flag set if all bytes match, NZ flag set on first mismatch. HL and DE point past the last compared byte.

66BBH - Check If Character Is Uppercase Letter (A-Z)

This routine checks if the character at (HL) is an uppercase letter (ASCII 41H-5AH, 'A'-'Z'). It uses the carry flag to indicate the result. On entry: HL = pointer to character to test. On exit: NC (No Carry) if character is uppercase letter A-Z, C (Carry) if character is outside this range.

66C3H - Check If Character Is Uppercase Letter (A-Z) - Alternate Entry

This routine is an alternate entry point that checks if the character at (HL) is an uppercase letter, with slightly different flag behavior. On entry: HL = pointer to character. On exit: Carry flag indicates range validity.

66CBH - Check If Character Is Valid Hex Digit (A-F)

This routine checks if Register A contains a valid hexadecimal letter digit (A-F, ASCII 41H-46H). On entry: A = character to test. On exit: NC if character is G or above (invalid hex letter), C if character is A-F (valid hex letter), or falls through to digit check.

66D4H - Load Character and Check If Digit

This is an alternate entry point that loads a character from (HL) and checks if it's a digit 0-9. On entry: HL = pointer to character. On exit: C if digit 0-9, NC if not a digit.

66D5H - Check If Character Is Digit (0-9)

This routine checks if Register A contains a decimal digit character (ASCII 30H-39H, '0'-'9'). It sets the carry flag if the character is a valid digit. On entry: A = character to test. On exit: C (Carry set) if character is a digit 0-9, NC (No Carry) if not a digit.

66DCH - Prompt for TO Address Input

This routine displays the "TO?" prompt and collects a 16-bit address value from the user. It is used when SUPERZAP needs a destination address, such as for copy operations. The routine loops until valid input is provided. On entry: None. On exit: DE = validated address value, HL points past the input.

66E1H - Prompt for FROM Address Input

This routine displays the "FR?" (FROM?) prompt and collects a 16-bit address value from the user. It is used when SUPERZAP needs a source address. On entry: None. On exit: DE = validated address value, HL points past the input.

66E4H - Common Address Input Loop

This is the common code for prompting and collecting a 16-bit address value. It displays the prompt at (HL), collects user input, and validates it via the 677BH routine. If validation fails (carry set), it loops back to re-prompt. On entry: HL = address of prompt string. On exit: DE = validated address value, NC (No Carry) on success.

66EFH - Prompt for Granule Number Input

This routine displays the "GR?" (Granule?) prompt and collects a granule number from the user. Granules are allocation units on the disk (typically 5 sectors each). The routine validates that the value is within the valid granule range. On entry: None. On exit: Granule number stored at 54AEH, NC on success, C on error.

66FBH - Validate and Store Granule Number

This routine validates a granule number input. It parses the hex value, checks that it fits in a single byte (high byte must be zero), and stores it at 54AEH. On entry: HL = pointer to input buffer. On exit: NC and value at 54AEH on success, C on error with error message displayed.

670FH - Parse and Validate Drive Number

This routine parses a drive number from the input buffer and validates it. Valid drive numbers are 0-3 (single byte values). If valid, the drive number is stored at both 5406H (FCB drive byte) and 5499H (working drive variable), and the drive is selected via 67B5H. On entry: HL = pointer to input. On exit: NC on success, C on error with message displayed.

6725H - Input Validation Success Exit

This is the common success exit point for input validation routines. It restores saved registers and returns with NC (No Carry) indicating the input was valid. On entry: AF and HL saved on stack. On exit: NC (success), registers restored.

6728H - Display "Invalid Drive" Error

This entry point is used when a drive number validation fails. It loads the "INVALID DRIVE" error message address and falls through to the common error display routine. On entry: AF and HL on stack. On exit: C (Carry set) indicating error.

672BH - Display Error Message and Return with Carry

This is the common error exit routine. It displays the error message pointed to by HL, restores saved registers, sets the carry flag, and returns. All input validation routines use this to report errors. On entry: HL = error message address, AF and original HL on stack. On exit: C (Carry set) indicating error.

6732H - Parse and Validate Sector-Within-Track Number

This routine parses a sector number (within the current track) from the input buffer and validates it against the disk's sectors-per-track value. Valid sector numbers range from 0 to (sectors_per_track - 1). If valid, the sector number is stored at 549EH. On entry: HL = pointer to input. On exit: NC on success, C on error with message displayed.

6751H - Parse and Validate Track Number

This routine parses a track number from the input buffer and validates it against the disk's track count. Valid track numbers range from 0 to (tracks - 1). The track count is stored at 549BH after drive selection. If valid, the track number is stored at 54A0H. On entry: HL = pointer to input. On exit: NC on success, C on error with message displayed.

6770H - Parse Hex Value with Error Check

This routine parses a hex value and returns with carry set on any error. Unlike other routines, it returns immediately on success (NC) without storing the value. Used as a validation-only check. On entry: HL = pointer to input. On exit: DE = parsed value, NC on success, C on error with message displayed.

677BH - Parse and Store 16-bit Address Value

This routine parses a 16-bit hex address from the input and stores it at 54ACH. It validates that the value is non-zero (zero is typically an invalid address for SUPERZAP operations). On entry: HL = pointer to input. On exit: DE = parsed value, value at 54ACH, NC on success, C on error.

678FH - Prompt for Disk Parameters (Drive, Sector)

This routine displays a prefix message from (HL), then prompts for drive number and absolute sector number. It combines multiple input prompts into a single operation for disk access setup. The prompt at 6D50H asks for "DRIVE,SECTOR". On entry: HL = prefix message address. On exit: Drive at 5406H/5499H, sector at 54A2H, NC on success.

6792H - Get Sector Parameters from User

This routine prompts the user for drive and absolute sector number using the combined prompt "DRIVE,SECTOR?" at 6D50H. It validates each input and stores the results. The routine handles ENTER-only input (returning carry set with Z flag) as a special case for "use current values". On entry: None. On exit: Drive at 5406H/5499H, sector at 54A2H, NC on success, C+Z if ENTER pressed without input.

67B5H - Select Drive and Get Disk Parameters

This routine selects the current drive (from 5406H) and retrieves the disk's format parameters from NEWDOS/80's PDRIVE table. It stores the tracks-per-disk at 549BH and 549CH, and calculates the maximum sector number (tracks × sectors_per_track) at 54A8H. This is called whenever drive parameters are needed for validation. On entry: 5406H contains drive number (0-3). On exit: 549BH = tracks per disk, 549CH = tracks per disk (copy), 54A8H = maximum sector count. All registers preserved.

67E5H - Parse Hex Value with Terminator Validation

This routine parses a hex value from the input buffer at (HL) and validates the terminator. It calls 67EDH to do the actual parsing, then checks that the input was properly terminated (ENTER or comma). If the input ends with something unexpected, it jumps to 65A0H for error handling. On entry: HL = pointer to input buffer. On exit: DE = parsed value, HL points past the value, NC on success with proper terminator, C on error.

67EDH - Parse Hex Input with Special Character Handling

This routine parses a hexadecimal value from the input buffer. It handles special terminators: ENTER (0DH) returns via 6598H with carry, comma (2CH) advances HL and returns via 65A5H. It also supports optional drive letter prefix (A-H) for extended addressing and 'H' suffix for explicit hex notation. On entry: HL = pointer to input buffer. On exit: DE = parsed 16-bit value, HL points to terminator or past it, Z flag set if valid terminator, C flag set on parse error or empty input.

6822H - Parse Decimal Number from Input

This routine parses a decimal (base 10) number from the input buffer at (HL) into DE. It accumulates digits by multiplying the running total by 10 and adding each new digit. The routine stops when it encounters a non-digit character. On entry: HL = pointer to input buffer. On exit: DE = parsed decimal value, HL points to first non-digit character, NC on success, C if no digits found or overflow.

682CH - Process One Decimal Digit

This routine processes a single decimal digit from the input. It validates the character at (HL) is a digit 0-9, then multiplies the current value in DE by 10 and adds the new digit. The multiplication is done as DE = DE × 2 × 2 + DE × 2 = DE × 10. On entry: HL = pointer to character, DE = current accumulated value. On exit: DE = new accumulated value (DE × 10 + digit), NC if valid digit processed, C if not a digit or overflow.

684FH - Parse Hexadecimal Number from Input

This routine parses a hexadecimal (base 16) number from the input buffer at (HL) into DE. It accumulates digits by shifting the running total left by 4 bits (×16) and adding each new hex digit (0-9, A-F). On entry: HL = pointer to input buffer. On exit: DE = parsed hex value, HL points to first non-hex character, NC on success, C if no digits found or overflow.

6859H - Process One Hexadecimal Digit

This routine processes a single hexadecimal digit from the input. It validates the character at (HL) as a hex digit (0-9 or A-F), then shifts the current value in DE left by 4 bits and adds the new digit. On entry: HL = pointer to character, DE = current accumulated value. On exit: DE = new accumulated value (DE × 16 + digit), NC if valid digit processed, C if not a hex digit or overflow.

686DH - Convert ASCII Character to Hex Digit Value

This routine converts an ASCII character to its hexadecimal digit value (0-15). It handles both decimal digits (0-9) and uppercase hex letters (A-F). On entry: A = ASCII character to convert. On exit: A = hex value (0-15), C (Carry set) if valid hex digit, NC if not a valid hex digit.

687BH - 8-bit by 8-bit Multiply (Entry Point)

This is an alternate entry point for the multiply routine when the multiplicand is only 8 bits. It sets H to zero and falls through to the main 8×16 multiply routine. On entry: A = multiplier (8-bit), L = multiplicand (8-bit). On exit: HL = product (A × L).

687DH - 8-bit by 16-bit Multiply (HL = HL × A)

This routine multiplies a 16-bit value in HL by an 8-bit value in A, returning the 16-bit result in HL. It uses the shift-and-add algorithm, shifting the multiplier right and conditionally adding the multiplicand. The result is shifted right to position it correctly. On entry: HL = multiplicand (16-bit), A = multiplier (8-bit). On exit: HL = product (HL × A), DE and BC preserved.

6896H - 16-bit by 8-bit Divide (HL = HL ÷ A)

This routine divides a 16-bit value in HL by an 8-bit value in A, returning the quotient in HL and the remainder in A. It uses the standard shift-and-subtract division algorithm. On entry: HL = dividend (16-bit), A = divisor (8-bit). On exit: HL = quotient, A = remainder.

68A6H - Convert 8-bit Value to Decimal String (Entry Point)

This is an alternate entry point for decimal conversion when the value is only 8 bits. It extends A to 16 bits in DE and falls through to the main conversion routine. On entry: A = 8-bit value to convert. On exit: 5487H-548BH contains 5-digit ASCII decimal string, B = count of significant digits, DE = original HL pointer.

68ABH - Convert 16-bit Value from Memory to Decimal String

This entry point reads a 16-bit value from memory at (HL) and converts it to a decimal ASCII string. It also advances HL past the 2-byte value. On entry: HL = pointer to 16-bit value (low byte first). On exit: 5487H-548BH contains 5-digit ASCII decimal string, B = count of significant digits, DE = original HL + 2.

68AFH - Convert 16-bit Value to Decimal String with Leading Zero Suppression

This routine converts a 16-bit value in DE to a 5-digit ASCII decimal string at 5487H, then replaces leading zeros with spaces. On entry: DE = value to convert, HL = pointer (saved). On exit: 5487H-548BH contains decimal string with leading spaces, B = count of significant digits + 1, DE = original HL.

68C5H - Convert and Display 16-bit Value as Decimal

This routine converts a 16-bit value in DE to decimal and displays it. It combines the conversion with buffer display. On entry: DE = value to convert and display. On exit: Value displayed on screen.

68D0H - Convert HL to Decimal (Entry Point)

This entry point converts HL to decimal by first moving it to DE. On entry: HL = value to convert. On exit: 5487H-548BH contains 5-digit decimal string.

68D1H - Convert DE to 5-Digit Decimal ASCII String

This is the core decimal conversion routine. It converts a 16-bit value in DE to a 5-character ASCII decimal string stored at 5487H. The algorithm repeatedly subtracts powers of 10 (10000, 1000, 100, 10) to extract each digit. On entry: DE = 16-bit value to convert (0-65535). On exit: 5487H-548BH contains 5-digit ASCII decimal string (with leading zeros).

68F6H - Powers of 10 Table (Negated)

This is a data table containing the negative values of powers of 10, used by the decimal conversion routine. The values are stored as 16-bit little-endian integers: -10000 (D8F0H), -1000 (FC18H), -100 (FF9CH), -10 (FFF6H). Using negative values allows the conversion to use ADD instead of SBC.

68FEH - Status Display Label Table

This area contains 3-character ASCII label strings used for the status display in various SUPERZAP modes. These labels appear on screen to identify the drive number, track number, sector numbers, etc. The labels are referenced by display routines to show disk operation status.

690FH - Menu Command Definition Table

This area contains structured menu command definitions. Each entry consists of a command code byte (with bit 7 often set), followed by a 16-bit address or data, and additional parameters. These define the commands available in SUPERZAP's various menus and their associated handlers or data.

6934H - Command Keyword Table (Continued)

Continuation of the command keyword parsing table that begins at 690FH. This table is used by the command parser at 54E6H to match user input against valid SUPERZAP commands. Each entry consists of a keyword (ASCII characters), a terminator byte (80H), flag bytes, and handler address data. The complex interleaving of keywords and data bytes reflects the table's optimized structure for the parsing algorithm.

6951H - Command Keyword Table (Final Entries)

Final entries in the command keyword table, containing remaining SUPERZAP commands with their flag and handler data.

6968H - Escape Sequence and Table Marker

Short control sequence followed by a marker byte that may indicate the start of the compressed string lookup tables.

696CH - Display Prompt Strings

Compressed display strings used for prompts, confirmations, and status messages. These strings use the compressed word format where bytes 80H-FFH represent common words, and 08H serves as a formatting control (often interpreted as "don't add trailing space").

69A1H - Additional Format Strings

More display formatting strings for prompts, separators, and input field labels. These continue the compressed string format used throughout SUPERZAP's user interface.

69BDH - Compressed String Table 1 (Short Words, Codes 80H-9FH)

This is the first compressed string table containing common 2-4 letter words. Each word has its final character with the high bit (bit 7) set to mark the end of the string. When SUPERZAP displays messages, codes 80H-9FH in the message data are replaced with these short words. This compression saves memory by replacing frequently-used words with single-byte codes.

6BECH - Error Message Lookup Table

This is the error message lookup table used by the error handler at 64FAH. Each entry consists of: (1) an error code byte, (2) the message content using compressed string codes (where codes 80H-FFH reference the compressed word tables at 69BDH and 6A24H), (3) a 00H terminator. Entries are separated by 03H bytes. The error handler searches this table for a matching error code and then displays the associated message. When a byte in the message has bit 7 set, it references a word from the compressed string tables.

6C1DH - Error Message Table (Continued)

Continuation of the error message lookup table. Each entry consists of compressed message bytes using codes from the 80H-FFH range, terminated by 03H separators. Error codes appear as bytes before 00H markers. The messages use the compressed word system where bytes 80H-9FH represent short words (AT, BE, DO, IF, IS, etc.) and bytes A0H-FFH represent longer words (BUFFER, DISK, MEMORY, SECTOR, etc.).

6C30H - APPARAT Copyright Message

This section contains the APPARAT company name as part of a copyright or identification message displayed by SUPERZAP. APPARAT was the company that created NEWDOS/80. The message uses format control codes (bytes 60H-7FH) for cursor positioning around the text.

6C3EH - Menu Header Text

Header text displayed above the SUPERZAP command menu. Uses compressed strings and formatting codes to display introductory text before the list of available commands.

6C53H - Menu Command Entry: 'DD - Disk Dump

Menu entry for the 'DD (Disk Dump to Disk) command. Each menu entry consists of a quote prefix (27H), the command letters, a format control code (6CH), and compressed text describing the command function, ending with a carriage return (0DH). Format control bytes in the 60H-7FH range control cursor positioning for the menu display.

6C62H - Menu Command Entry: 'DM - Dump Memory

Menu entry for the 'DM (Dump Memory) command, which displays memory contents in hex and ASCII format.

6C6AH - Menu Command Entry: 'DFS - Disk File Sector

Menu entry for the 'DFS (Disk File Sector) command, which displays sectors belonging to a specific file.

6C74H - Menu Command Entry: 'DTS - Disk Track Sector

Menu entry for the 'DTS (Disk Track Sector) command, which displays sectors by track and sector number.

6C7EH - Menu Command Entry: 'DMDB - Dump Memory Data Block

Menu entry for the 'DMDB (Dump Memory Data Block) command for viewing memory in block format.

6C89H - Menu Command Entry: 'VDS - Verify Disk Sector

Menu entry for the 'VDS (Verify Disk Sector) command for verifying disk sector integrity.

6C93H - Menu Command Entry: 'ZDS - Zap Disk Sector

Menu entry for the 'ZDS (Zap Disk Sector) command for writing/modifying disk sectors.

6C9DH - Menu Command Entry: 'CDS - Copy Disk Sector

Menu entry for the 'CDS (Copy Disk Sector) command for copying sectors between locations.

6CA7H - Menu Command Entry: 'CDD - Copy Disk to Disk

Menu entry for the 'CDD (Copy Disk to Disk) command for full disk copying.

6CB0H - Menu Command Entry: 'DPWE - Disk Password Write Enable

Menu entry for the 'DPWE (Disk Password Write Enable) command for enabling write access with password.

6CBEH - Menu Command Entry: 'DNTH - Disk N-th Sector

Menu entry for the 'DNTH command for displaying the N-th absolute sector of a disk.

6CCFH - Menu Help Text: Printer Option

Help text explaining the ",P" printer option that can be appended to certain commands. This section describes which commands support printer output.

6D04H - Menu Help Text: DMDB Command

Continuation of menu help text mentioning the DMDB command.

6D0BH - Compressed Message Strings

Compressed message strings used for various prompts and status displays. These use compressed word codes (80H-FFH), format control bytes (60H-7FH), and 03H as entry separators.

6D1AH - Sector Operation Messages

Compressed messages related to sector operations including "COPY THE SECTORS" and similar descriptions. Format control bytes (60H-7FH) provide cursor positioning.

6D2DH - Comparison and Search Messages

Compressed messages for comparison operations and search features. Format control bytes (60H-7FH) provide cursor positioning, compressed word codes (80H-FFH) reference the word tables, and 03H marks entry separators.

6D4BH - Destination and Address Messages

Compressed messages for destination disk/sector and memory address operations.

6D6DH - Input Prompt Messages

Short compressed messages for input prompts.

6D81H - Status and Error Messages

Various status messages and error indicators for disk operations.

6D90H - Retry/Skip/Exit Prompt Message

Compressed message for the retry/skip/exit prompt displayed after disk errors.

6D9BH - File and Modification Messages

Compressed messages related to file operations and sector modifications.

6DB7H - Copy Operation Messages

Compressed messages displayed during copy operations.

6DC4H - Cancelled/Aborted Messages

Messages displayed when operations are cancelled or aborted by the user.

6DD5H - Password and System Messages

Compressed messages related to password operations and system functions.

6DE7H - Invalid Parameter Error Messages

Error messages displayed when invalid parameters are entered by the user. These use compressed codes with format controls and 03H separators between entries.

6E0AH - Too Many/Too Few Error Messages

Error messages for parameter count errors using compressed word codes.

6E14H - Embedded/Imbedded Command Message

Message related to embedded commands and special operations.

6E20H - Sector Read/Write Error Messages

Error messages for sector read and write failures.

6E2CH - Sector Error Messages

Prefix messages used with sector error codes for read, write, and verify errors.

6E38H - Error Code and Previous Operation Messages

Messages for displaying error codes and referencing previous operations.

6E59H - Internal Programming Error Message

Error message displayed for internal programming errors - this indicates a bug in SUPERZAP itself rather than a user error.

6E71H - Retry/Skip/Exit Option Prompt

The standard error recovery prompt showing available options after an error occurs. Uses compressed codes and format control bytes to display "'R'ETRY, 'S'KIP, E'X'IT".

6E81H - Record/Byte Display Messages

Messages used when displaying records and bytes.

6E8DH - Display Label Messages

Short label messages used in the status display area for disk, source, sector, DRS, FRS, and other labels.

6EABH - Enable/Disable Status Messages

Messages for feature availability and enable/disable status.

6EBCH - Shall I Write Confirmation Prompt

Confirmation prompt asking the user if SUPERZAP should write changes to disk.

6ECBH - Partial Data Due Message

Message indicating partial data was read or written.

6EDBH - No Match Message

Message displayed when a search operation finds no matches.

6EE6H - Under DOS-Call Message

Technical message about DOS call status.

6EFBH - Final Message Entry

Last message entry in the string table.

6F00H - Buffer/Work Area (Zeros)

This area from 6F00H to 6FFDH is initialized to zeros and serves as a work buffer or reserved space for SUPERZAP operations. The 254 bytes of zeros provide scratch space for various disk and memory operations.

Program Entry Point

SUPERZAP's program entry point is at address 54C5H. When SUPERZAP is loaded and executed, control transfers to this address to begin the main initialization and menu display sequence.