TRS-80 DOS - TRSDOS v2.3 for the Model I - SYS6/SYS Disassembled

SYS6/SYS

Other Navigation

TRSDOS 2.3 SYS6/SYS Disassembly - Library Command Overlay (Model I)

SYS6/SYS is the library command overlay for TRSDOS 2.3 on the TRS-80 Model I. It contains the implementations for all 19 library commands that are dispatched from the SYS1 overlay command table. When a user types a library command at the DOS READY prompt, SYS1 parses the command name, looks it up in the overlay command name table at 4EBDH, and loads SYS6 into memory at 5200H via RST 28H with SVC code 88H. SYS6 then dispatches to the appropriate command handler based on the command index passed in Register C.

SYS6 is the largest overlay in TRSDOS 2.3, spanning from 5200H to 60D8H (approximately 3.8 KB). Because it shares the overlay slot with other SYS files, SYS6 is loaded on demand and can be cached (indicated by bit 4 of the system flags at 430FH) to avoid redundant disk reads when multiple library commands are issued in sequence.

The overlay uses two FCB work areas: a primary FCB at 5600H (256 bytes) and a secondary FCB at 6F00H (used by APPEND for the destination file). The command buffer and parsed filespec are stored in the SYS1 work area starting at 5551H (primary filespec) and 5571H (secondary filespec, used by COPY, APPEND, and RENAME). Several commands also use the directory sector buffer at 4200H, the overlay/sector buffer at 4D00H, and a large directory image buffer at 6100H (used by DIR for caching the full directory).

The dispatch mechanism uses a simple decrement-and-test chain: Register C holds the 1-based command index, and SYS6 decrements Register A (loaded from C) once for each command until it reaches zero, then jumps to the corresponding handler. Before entering the dispatch chain, the no-error exit address 402DH is pushed onto the stack so that handlers can return to DOS READY via a simple RET instruction after successful completion.

Command Dispatch Table

Key Variables and Work Areas

Self-Modifying Code Locations

Major Routines

Cross-Reference Notes

SYS6 relies heavily on the SYS0 resident module entry points for file I/O operations (441CH Extract Filespec, 4420H Open New/Existing, 4424H Open Existing, 4428H Close, 442CH Kill, 4436H Read, 4439H Write, 4448H Position to EOF, 4467H Display Message, 4473H Insert Default Extension, 4476H Additional Utility). It also calls SYS0 internal routines directly: 4AF0H (Read Directory Sector into 4D00H), 4B03H (Write Sector from 4D00H), 4B35H (Read Sector with Retry), 4B55H (Track Cache Lookup), 4AC1H (Read Directory Sector into Buffer), and 4AD6H (Write Directory and GAT Sectors). ROM routines used include 0033H (Display Character), 003BH (Printer Output), 0040H (Line Input), 0049H (Scan Keyboard), 001BH (Cassette Write Byte), and 0013H (Read Record from File via DOS). SYS1 routines called include 50D1H (Parse Hexadecimal Value), 509BH (Command Table Lookup variant), 50FDH (Drive Validation), 512EH (Write Directory), 5141H (Write to Directory Entry), and 51A0H (Parameter Parser Helper).

5200H - Command Dispatcher

Entry point for all SYS6 library commands. Register C contains the 1-based command index from SYS1's overlay command table at 4EBDH. The no-error exit address 402DH is pushed onto the stack so handlers can return to DOS READY via RET. Register A is then decremented once per command until it reaches zero, at which point execution jumps to the matching handler.

525AH - Error Message: "RESERVED COMMAND"

ASCII string displayed when an invalid command index is passed to SYS6. Terminated by 0DH (carriage return).

526BH - Error Message: "-NOTHING DONE-"

ASCII string displayed when a command has no work to perform (e.g., PROT with no options specified). This entry point is also used as a shared error handler by multiple commands. Terminated by 0DH.

5274H - Data: "-NOTHING DONE-" String

ASCII message string used by the 526BH error handler. Terminated by 0DH.

5283H - AUTO Command Handler

Implements the AUTO command, which writes an auto-boot command string to a reserved area (offset 0E0H) of directory sector 0 on the system disk. When the system boots, the boot code checks this area and executes the command if present. The AUTO command takes no filespec; it writes the current command buffer contents (everything after "AUTO ") to the directory sector. Format: AUTO command-string

529DH - DATE Command Handler

Implements the DATE command, which sets the system date. The user provides the date in MM/DD/YY format on the command line. The Date/Time Parser at 52EAH is called with Register C = 2FH (ASCII '/') as the delimiter character, and the three parsed values are stored to the system date variables at 4044H-4046H (day, month, year). Format: DATE MM/DD/YY

52B1H - TIME Command Handler

Implements the TIME command, which sets the system time. The user provides the time in HH:MM:SS format on the command line. The Date/Time Parser at 52EAH is called with Register C = 3AH (ASCII ':') as the delimiter character, and the three parsed values are stored to the system clock variables at 4041H-4043H (seconds, minutes, hours). Format: TIME HH:MM:SS

52C5H - CLOCK Command Handler

Implements the CLOCK command, which enables or disables the real-time clock display. When enabled, the timer interrupt service routine calls 4CA9H periodically to update the clock display on screen. This is implemented by enqueueing or dequeueing a timer callback entry. Format: CLOCK (ON) or CLOCK (OFF)

52D3H - "BAD FORMAT" Error Display

Shared error handler for DATE and TIME commands when the user provides an improperly formatted value. Displays "BAD FORMAT" and exits to DOS READY via the error-already-displayed exit.

52DCH - Data: Date/Time Parser Work Area and "BAD FORMAT" String

Three-byte work area used by the Date/Time Parser at 52EAH to store parsed values, followed by the "BAD FORMAT" error message string.

52EAH - Date/Time Parser

Parses three 2-digit decimal values separated by a delimiter character (in Register C) from the command line pointed to by HL. Results are stored at 52DCH-52DEH in reverse order: the first value parsed goes to 52DEH, the second to 52DDH, and the third to 52DCH. Used by both the DATE command (delimiter = '/') and the TIME command (delimiter = ':'). Returns with Z flag set on success, NZ on parse error.

52FFH - Two-Digit Decimal Parser

Parses a 2-digit decimal number from the command line at (HL). Combines the tens digit and units digit into a single binary value in Register A. Returns Z on success, NZ (via CARRY set) on invalid input. Used by the Date/Time Parser at 52EAH.

5314H - Digit Parse Error Return

Error return point for the Two-Digit Decimal Parser. Sets NZ flag to indicate parse failure.

5316H - Single Digit Parser

Extracts one ASCII digit character from (HL), advances HL, and converts the digit to binary (0-9). Returns with CARRY set if valid digit, CARRY clear if not.

531DH - DEVICE Command Handler

Implements the DEVICE command, which displays the logical device routing table stored at 43C0H in the SYS0 work area. Each device entry is 5 bytes: 2 bytes for the device name character pair (e.g., "KI" for keyboard input), followed by 3 bytes of padding/routing data. The routine walks the table printing each device name pair with a carriage return until it encounters a zero byte marking the end of the table. Format: DEVICE (no parameters)

533AH - LIB Command Handler

Implements the LIB command, which displays all available library command names from the overlay command name table at 4EBDH in SYS1 memory. The table contains 19 entries of 8 bytes each (6-character command name + 2 bytes of dispatch data). The display formats 4 commands per line, each preceded by character C2H (inverse video bracket) and followed by C8H (inverse video closing bracket) for visual emphasis. Format: LIB (no parameters)

536AH - PROT Command Handler

Implements the PROT command, which manages master password protection for the system disk. PROT supports three subcommands: PW (change master password), LOCK (assign master password to all user files), and UNLOCK (remove passwords from all user files). The master password hash is stored in directory sector 0 at offset 0CEH. An optional drive specifier can precede the subcommand keyword. Format: PROT [:n] PW, PROT [:n] LOCK, or PROT [:n] UNLOCK

540CH - PROT Directory Scan (LOCK/UNLOCK)

Iterates through all directory sectors (2 through 9) on the target drive, examining each directory entry. For LOCK, it writes the master password hash to each user file's password field. For UNLOCK, it writes the blank password hash (4296H). Only entries with the active file type marker (10H in the flags byte) are modified. Register Pair HL holds the password hash to assign; for LOCK this is the master password, for UNLOCK this is 4296H.

5454H - Password Input Routine

Prompts the user to enter a password at the keyboard. Accepts up to 8 characters of input using the ROM line input routine at 0040H, pads the result with spaces to 8 characters, then calls the SYS1 hexadecimal parser at 50D1H to compute the 16-bit password hash. Returns with the hash in Register Pair HL.

546EH - "INVALID COMMAND DURING PROGRAM CHAINING" Error

Error handler displayed when PROT is attempted while program chaining is active (bit 5 of system flags at 430FH is set).

5477H - Data: PROT Message Strings

ASCII message strings used by the PROT command handler. Includes error messages and prompts. Each string is terminated by 0DH (carriage return) or 03H (ETX, end of text used by the display routine to stop output without adding a newline).

54EBH - Data: PROT Subcommand Keyword Table

Keyword table for the PROT command's option parser. Contains three 8-byte entries, each consisting of a 6-character keyword (space-padded) followed by a 2-byte target address where the option parser stores the result when the keyword is matched. The table is terminated by a 2-byte entry (54H, 00H) that the parser recognizes as end-of-table.

5504H - VERIFY Command Handler

Implements the VERIFY command, which enables or disables write verification. When VERIFY is ON, every disk write is followed by a read-back comparison to ensure data integrity. The verification state is stored in the self-modifying flag byte at 485EH in SYS0. Format: VERIFY (ON) or VERIFY (OFF)

5515H - BREAK Key Check Utility

Checks whether the BREAK key has been pressed. Used by LIST, PRINT, and other commands that display or output data in loops, allowing the user to abort the operation. Returns NZ if BREAK was pressed (operation should stop), Z if no BREAK detected (operation should continue). Also implements the SHIFT-@ pause mechanism: if SHIFT-@ is held, the routine waits for any key before continuing.

553AH - "FILE SPEC REQUIRED" Error Handler

Shared error handler displayed when a command that requires a filespec is invoked without one. Used by APPEND, COPY, DUMP, KILL, LIST, LOAD, PRINT, RENAME, and other file-oriented commands.

5543H - "DEVICE SPEC REQUIRED" Error Handler

Error handler displayed when a device-oriented command lacks the required device specifier.

554CH - Disk Error Handler

Shared disk error handler used by all commands that perform disk I/O. ORs the error code in Register A with 40H (setting bit 6 to indicate the error occurred during an overlay operation) and exits via the SYS0 error exit at 4409H.

5591H - Data: Error and Work Area Strings

ASCII message strings for file and device specification errors, plus FCB work areas used by file-oriented commands.

5700H - APPEND Command Handler

Implements the APPEND command, which appends the contents of one file to the end of another. Two filespecs are required: the source file and the destination file. The source file is opened for reading, the destination file is opened for reading (to get its existing FCB), then the destination FCB is positioned to EOF before the read/write copy loop begins. The APPEND command uses two FCB work areas: 5600H for the source and 6F00H for the destination. Format: APPEND source TO destination

573DH - NOP Padding (APPEND Continuation)

A block of 15 NOP instructions (573DH-574BH) followed by a jump to the APPEND copy loop. This padding suggests the area was reserved for additional APPEND logic that was either removed or never implemented.

574FH - COPY Command Handler

Implements the COPY command, which copies a file to a new name and/or drive. Two filespecs are required: the source file and the destination. The source is opened as an existing file, the destination is opened as new-or-existing (created if it does not exist). Data is copied record-by-record in a read/write loop. The copy terminates when an EOF condition (error 1CH) or past-EOF condition (error 1DH) is returned by the read operation. Format: COPY source TO destination

57B6H - APPEND Read/Write Copy Loop

The APPEND copy loop reads one record at a time from the source file (via the primary filespec at 5551H) and writes each byte to the destination file (via the secondary filespec at 5571H) using the cassette write routine at 001BH. This routine is entered from the NOP block at 574CH after the APPEND setup at 5700H. It also includes BREAK key checking to allow the user to abort the append operation.

57D7H - DUMP Command Handler

Implements the DUMP command, which saves a file or memory range to cassette tape. The DUMP command accepts a filespec and optional parameters: START=X'nnnn' (start address), END=X'nnnn' (end address), and TRA=X'nnnn' (transfer/entry address). Default values are START=7000H, END=7000H, and TRA=402DH (no-error exit). The output is written in system tape format using the cassette write byte routine at 001BH. Format: DUMP filespec (START=X'nnnn',END=X'nnnn',TRA=X'nnnn')

58BEH - DUMP Error Display Subroutine

Displays an error message pointed to by HL and exits via the error-already-displayed path. Used by the DUMP command for address validation errors.

58C4H - Data: DUMP Message Strings and Option Table

Error messages, default extension, and option keyword table used by the DUMP command.

58F5H - Data: DUMP Option Keyword Table

Keyword table for the DUMP command's option parser. Contains START, END, and TRA keywords, each 6 characters (space-padded) followed by a 2-byte target address where the option parser stores the parsed hexadecimal value. The table is prefixed by a byte count or flags byte.

5914H - KILL Command Handler

Implements the KILL command, which deletes a file from disk. The filespec is extracted, the file is opened (to verify it exists and get the directory entry info), then the file is killed (directory entry cleared and granules freed). Format: KILL filespec

592CH - LIST Command Handler

Implements the LIST command, which reads a text file and displays its contents on the video display. The file is opened, then records are read one at a time using 0013H and displayed character by character using 0033H. A LINE option can be specified to skip a number of lines before displaying. Carriage returns (0DH) in the file produce line breaks on the display. The BREAK key check at 5515H allows the user to abort the listing. Error codes 1CH/1DH (EOF conditions) cause a normal exit. Format: LIST filespec [(LINE=nnnn)]

598BH - Data: LIST Option Keyword Table

Keyword table for the LIST command's option parser. Contains a single keyword "LINE" with its target address.

5994H - LOAD Command Handler

Implements the LOAD command, which loads a program file into memory for execution. The filespec is extracted, validated (no wildcards), and then the file is loaded via the SYS0 load-and-execute routine at 4430H. Format: LOAD filespec

59ACH - PRINT Command Handler

Implements the PRINT command, which reads a text file and sends its contents to the printer. Functionally identical to LIST except that output goes to the printer via ROM routine 003BH instead of the video display via 0033H. After each record, a CR is sent to the printer to advance the paper. The BREAK key check allows aborting the print job. Format: PRINT filespec

5B00H - ATTRIB Command Handler

Implements the ATTRIB command, which sets file attributes including the access password (ACC), update password (UPD), protection level (PROT), and invisibility flag (INV). The file is first opened to verify it exists, then the command line is parsed for a parenthesized option list. Options are applied to the file's directory entry and written back to disk. Format: ATTRIB filespec (PROT=level, ACC=password, UPD=password, INV=ON)

5B69H - Protection Level Match Verifier

Called when the first byte of a protection level table entry matches. Checks the second byte. If both match, removes the CALL return address from the stack and falls through to the level assignment code at 5B6DH. If the second byte does not match, returns to the caller to continue searching.

5B97H - INV Option Parser

Parses the INV (invisible) option. Sets bit 3 of the visibility flag at 5C0DH. The INV option does not take a value; its mere presence makes the file invisible in directory listings.

5BA7H - ACC Option Parser

Parses the ACC (access password) option. The value after '=' is an 8-character password string that is hashed and stored to 516AH-516BH for later application to the directory entry. Sets bit 1 in the options bitmask.

5BBCH - UPD Option Parser

Parses the UPD (update password) option. Identical in structure to the ACC parser but stores the hash to 5168H-5169H and sets bit 2 in the options bitmask.

5BD1H - Scan to Equals Sign and Parse Value

Scans the command line from (HL) looking for an '=' sign, skipping over the keyword characters. If '=' is found, reads the value text into the SYS1 work area at 5155H (space-padded to 8 characters) and returns NZ. If no '=' is found (delimiter is CR, ')' or ','), returns Z indicating no value was provided. Used by the PROT, INV, ACC, and UPD option parsers.

5BF7H - ATTRIB: Apply Options to Directory Entry

Reached after the closing parenthesis ')' is parsed. Reads the file's directory sector, applies the parsed options (protection level, access password, update password, visibility) to the directory entry, and writes it back to disk.

5C39H - "ATTRIBUTE SPECIFICATION ERROR" Handler

Error handler displayed when the ATTRIB option list contains an unrecognized keyword or malformed syntax.

5C42H - Data: ATTRIB Error Message and Protection Level Table

ASCII error message string and the 2-byte-per-entry protection level lookup table used by the PROT option parser.

5C61H - Data: Protection Level Lookup Table

Table of 7 two-byte entries representing the first two characters of each recognized protection level name. The entries are searched in reverse order: entry 0 (index 6) = EXEC, entry 1 (index 5) = READ, entry 2 (index 4) = WRITE, entry 3 (index 3), entry 4 (index 2) = RENAME, entry 5 (index 1) = KILL, entry 6 (index 0) = FULL. The loop counter B starts at 7 and decrements; the protection level value is derived as B-1 after a match.

5C6FH - DIR Command Handler

Implements the DIR command, which displays the directory listing for a specified drive. The command reads all 8 directory sectors (sectors 0-7, loaded into a 2048-byte buffer at 6100H-68FFH), then iterates through each 32-byte directory entry displaying the filename, extension, attribute flags (S=system, I=invisible, P=password protected), and optionally the file size metrics (LRL, EOF offset, sector count). An optional drive specifier can be provided; the default is drive 0. Options A (show all including system/invisible), I (show invisible), and S (show system) can be specified in parentheses. The directory header and disk label are read from sector 0 offset 0D0H and displayed. Format: DIR [:n] [(S,I)]

5DE1H - Clear Directory Image Buffer

Zero-fills the 2048-byte directory image buffer from 6100H to 68FFH. Called before exiting the DIR command to clean up memory.

5DF1H - DIR: Display File Metrics

Displays the file size metrics for a directory entry: the EOF byte offset (from offset +03H), the Logical Record Length (from offset +04H), the sector count (from offset +10H/+11H converted via 24-bit division at 60A7H), and the total granule count (computed by walking the extent chain at 5E3EH). All numeric values are converted to decimal ASCII by the 606CH routine and inserted into the format string at 5EB7H before display. Returns with B=01H to indicate only 1 entry per line when file metrics are shown.

5E3EH - DIR: Count File Sectors (Extent Chain Walker)

Walks the extent chain for a file and accumulates the total number of granules allocated to the file. Each extent entry is a 2-byte pair at offset +16H within the directory entry: byte 1 has extent info, byte 2's lower 5 bits (AND 1FH) hold the granule count minus 1 for that extent. Special values FEH (chain continues in another entry) and FFH (end of chain) terminate the walk. For chain continuations (FEH), the next byte provides the directory entry info byte for locating the continuation entry.

5E6AH - Data: DIR Format Strings and Option Table

Data area containing the DIR option keyword table, directory header format string, disk label format template, and file metrics format template. The option table at 5E6AH has entries for "A" (show all), "I" (show invisible), and "S" (show system) options. The header at 5E83H includes screen-clear codes (1CH, 1FH) followed by the "FILE DIRECTORY --- DRIVE X" banner. The disk label template at 5EA1H has placeholders filled at runtime with the actual disk name and date. The metrics template at 5EB7H has placeholders for LRL, EOF, and SIZE values.

5EE0H - FREE Command Handler

Implements the FREE command, which displays the amount of free space on all 4 drives. For each drive 0-3, the command reads directory sector 0, extracts the disk name and date, reads the GAT (Granule Allocation Table) from sector 0, counts the number of free granules, counts the number of free directory entries, and displays the results. The GAT at 4D00H is scanned byte by byte: each byte represents allocation for one track, with individual bits representing granules. A bit shifted out as 0 indicates a free granule. The free directory entry count is computed by scanning each 32-byte entry in the 4D00H buffer sector for zero bytes at specific positions. Format: FREE (no parameters)

5F62H - Data: FREE Format String

Output format template for the FREE command, displayed once per valid drive.

5F9CH - RENAME Command Handler

Implements the RENAME command, which changes a file's name on disk. Two filespecs are required: the current name and the new name. The file is opened to verify it exists and check access permissions (protection level must be < 3 to allow renaming). The new name is then written into the directory entry, replacing the old name. If the new filespec does not include a drive specifier, the original file's drive is used. Format: RENAME old-name TO new-name

6028H - "DRIVE SPECIFICATION ILLEGAL" Error

Displayed when the RENAME command's new filespec includes a drive specifier (renaming across drives is not supported).

6031H - Data: RENAME Error Messages

Error message strings for the RENAME command.

604EH - "DUPLICATE FILE NAME" Error

Displayed when the RENAME command's new filename already exists on the disk.

6057H - Data: "DUPLICATE FILE NAME" String

606CH - Decimal Output Routine

Converts a 16-bit value in Register Pair HL to a 5-digit decimal ASCII string stored at (DE). Uses successive division by 10000, 1000, 100, and 10 via the division subroutine at 608CH. Leading zeros are suppressed by replacing them with spaces. The final units digit is always stored.

608CH - Division Subroutine (HL / BC with Leading Zero Suppression)

Divides HL by BC using repeated subtraction. The quotient digit is stored at (DE) as an ASCII character. Leading zeros are suppressed: if no significant digit has been output yet (indicated by Register A = space on entry), a zero quotient stores a space instead of '0'. Once a nonzero digit is output, subsequent zeros are stored as '0'. On entry: HL = dividend, BC = divisor, A = leading-zero character (space or '0'). On exit: HL = remainder, DE incremented past the stored digit, A = leading-zero character for next call.

60A7H - 24-Bit Division Routine

Divides a 3-byte big-endian value at (HL) by the divisor in Register C, returning the quotient in Register Pair DE. If C=0, the routine instead loads a 2-byte value from (HL) directly into DE (big-endian: first byte = high, second byte = low). Uses a shift-and-subtract algorithm processing 8 bits per byte across 3 bytes.

60CDH - VERIFY Flag Setup Routine

Sets or clears the write-verify flag at 485EH based on the Z flag state. Called by the VERIFY command at 5504H. On entry: Z flag indicates the desired state (Z = OFF, NZ = ON from the parameter parser). Loads HL with 478BH (write-without-verify address). If Z is set (VERIFY OFF), stores 00H to 485EH. If NZ (VERIFY ON), stores 01H to 485EH. Returns with HL=478BH and Z/NZ indicating the state.