Model I TRSDOS v2.3 SYS1/SYS Disassembly

SYS1/SYS is TRSDOS 2.3's Command Line Interpreter overlay for the TRS-80 Model I. It loads into the overlay area at 4E00H-51C8H and is invoked by the SYS0 resident module whenever the system needs to accept and process a user command. SYS1 is a mandatory system file that must be present on every bootable TRSDOS 2.3 disk.

SYS1 is entered via a request code passed in Register A, masked to bits 4-6, which selects one of several operational modes. These modes range from full system initialization (enabling interrupts, resetting the stack, and displaying the "DOS READY" prompt) to targeted sub-functions like filespec parsing and option/keyword processing.

The module's primary responsibilities include:

Command Input and Dispatch (Request Code 10H/20H): Initializes the stack and interrupt state, displays the "DOS READY" prompt, and reads a command line from the keyboard into the 63-character buffer at 4318H. After parsing the input into a filespec at 4480H, SYS1 searches two command name tables. The first table (at 4EA4H) contains three resident commands handled within SYS1 itself: BASIC2, DEBUG, and TRACE. The second table (at 4EBDH) contains nineteen overlay commands (APPEND, ATTRIB, AUTO, CLOCK, COPY, DATE, DEVICE, DIR, DUMP, FREE, KILL, LIB, LIST, LOAD, PRINT, PROT, RENAME, TIME, VERIFY) that are dispatched to SYS6 via the overlay loader at 4E90H. If the command is not found in either table, SYS1 assumes it is a program filename and attempts to load and execute it via the SYS0 program loader at 4433H, using "CMD" as the default file extension.

Filespec Parsing (Request Code 50H): The filespec parser at 4F56H extracts a structured filename from the command line into the system DCB buffer at 4480H. It handles up to 8 characters for the name, a "/" separator followed by up to 3 characters for the extension, a "." separator followed by up to 8 characters for the password, and a ":" separator followed by a 1-character drive specifier. The parser also strips TRSDOS "noise words" (TO, ON, OVER) from the command line by checking parsed names against a keyword table at 4FA7H.

Default Extension Insertion: When loading an unrecognized command as a program file, the routine at 4FC0H inserts the default extension "/CMD" (or whatever extension is passed in HL) if the user did not specify one. This is the main purpose of the routine often misdescribed as a "drive specifier extractor".

Option/Keyword Processing (Request Code 60H): The routine at 507DH parses parenthesized option lists from the command line, supporting keyword=value syntax with decimal, hexadecimal (X'nn'), and boolean (YES/NO/ON/OFF) value formats. This allows TRSDOS commands to accept parameters like (DRIVE=1,PROT=ON).

Resident Commands: BASIC2 (at 514CH) starts non-DOS BASIC by performing a warm restart into Level II BASIC, copying the first 36H bytes of ROM vectors back to 4000H, clearing the DOS work area, and jumping to the ROM BASIC entry point at 0075H. Unlike Disk BASIC, non-DOS BASIC has no access to disk files or DOS commands. DEBUG (at 5162H) toggles the DEBUG flag in the system flags byte at 430FH and patches the RST 30H vector and BREAK key handler accordingly. TRACE (at 5191H) toggles the interrupt-driven TRACE callback by enqueueing or dequeueing the trace handler address (4CD9H) via the SYS0 timer callback system.

Address Range	Purpose
430FH-430FH (1 byte)	System flags byte. Bit 4: overlay loaded flag (SYS6 resident). Bit 5: BREAK key context flag. Bit 7: DEBUG active flag.
4315H-4315H (1 byte)	BREAK key handler opcode. C3H (JP) when BREAK is enabled; 00H or other value when disabled.
4316H-4317H (2 bytes)	BREAK key handler target address.
4318H-4356H (63 bytes)	DOS command input buffer. Keyboard input is read here (max 63 characters).
4359H-4359H (1 byte)	System condition flags. Bit 5: tested during DOS READY initialization.
4030H-4032H (3 bytes)	Error-already-displayed exit vector. Patched by DEBUG toggle to either LD A,A3H or CALL 400FH.
4031H-4032H (2 bytes)	Address portion of patched instruction at 4030H. Set to 400FH (RST 30H vector) when DEBUG is active.
4480H-4494H (21 bytes)	Parsed filespec buffer: NAMENAME/EXT.PASSWORD:D format. Populated by the filespec parser at 4F56H.
5026H-5026H (1 byte)	Filespec parser remaining-character counter. Self-modified by the character extraction routine at 4FF4H.
51AFH-51B4H (6 bytes)	Option keyword matching buffer. Used by the option parser at 508EH as the destination for parsed keyword names.
51B5H-51B7H (3 bytes)	Default extension string: "CMD" (43H 4DH 44H). Used when loading unrecognized commands as program files.
51B8H-51C2H (11 bytes)	DOS READY prompt string: 0AH + "DOS READY" + 0DH.
51C3H-51C8H (6 bytes)	Error message string: "WHAT?" + 0DH. Displayed when command parsing fails.

Address	Purpose
4E00H	Request Code Dispatcher Entry point. Masks bits 4-6 of Register A and dispatches to the appropriate handler based on the request code (10H/20H/30H/40H/50H/60H).
4E1FH	DOS READY and Command Input Request codes 10H and 20H. Enables interrupts, resets stack to 41FCH, checks system flags, displays "DOS READY" prompt, reads command line, parses and dispatches commands.
4E4EH	Command Line Parser and Dispatcher Request code 30H. Parses the command buffer into a filespec, searches the resident and overlay command tables, and either dispatches to the matching handler or loads the command as a program file.
4E90H	Overlay Command Dispatch Loads SYS6 via RST 28H with SVC code 88H to handle overlay-based library commands. Sets bit 4 of system flags to track overlay presence.
4EA4H	Resident Command Table Data table. Three 8-byte entries for BASIC (514CH), DEBUG (5162H), and TRACE (5191H), terminated by 00H.
4EBDH	Overlay Command Table Data table. Nineteen 8-byte entries for APPEND through VERIFY, all dispatching to 4E90H (SYS6 loader), terminated by 00H.
4F56H	Filespec Parser Request code 50H. Extracts a structured filespec (name/ext.pass:drive) from the command line at (HL) into the buffer at (DE). Strips noise words (TO, ON, OVER).
4FA7H	Noise Word Keyword Table Data table. Three entries: "TO", "ON", "OVER". Used by the filespec parser to strip noise words from command lines.
4FC0H	Default Extension Insertion Routine Called internally (e.g. from 4E7DH) to add the default extension (typically "/CMD") when the parsed filename has no extension. Uses LDDR block moves to shift the string and insert the extension passed in HL. Drive separator checks are secondary to this purpose.
4FF4H	Character Extraction Subroutine Reads up to B characters from (HL), storing valid filename characters (0-9, A-Z) into (DE). Terminates on 03H, 0DH, or non-alphanumeric characters. Self-modifies the remaining count at 5026H.
502AH	Command Table Lookup Searches an 8-byte-per-entry command table at (BC) for a match against the filespec at (DE). Returns Z flag set and dispatch address in DE on match, with entry index in C.
507DH	Option/Keyword Parser Request code 60H. Parses parenthesized option lists with keyword=value syntax, supporting decimal, hexadecimal, and boolean values.
50DFH	Boolean Value Parser Parses YES/Y, NO/N, OFF, ON from the command line and returns FFFFH (true) or 0000H (false) in BC.
5104H	Decimal Number Parser Converts ASCII decimal digits to a 16-bit binary value in BC using multiply-by-10 accumulation.
511FH	Hexadecimal Number Parser Parses X'nn' format hexadecimal values into a 16-bit binary value in BC.
514CH	BASIC2 Command Handler Starts non-DOS BASIC. Copies ROM vectors (36H bytes from 06D2H) back to 4000H, clears 27H bytes of DOS work area, and jumps to ROM BASIC at 0075H.
5162H	DEBUG Command Handler Toggles the DEBUG flag (bit 7 of byte pointed to by 430FH), patches the BREAK key handler and RST 30H vector accordingly.
5191H	TRACE Command Handler Toggles the TRACE timer interrupt callback (address 4CD9H) by enqueueing or dequeueing it via SYS0 routines at 4410H/4413H.

Writer	Target	Purpose
4FF5H	5026H	Remaining character count stored into the operand of LD A,00H at 5025H. Used by the filespec parser to track how many characters remain in the current field.
5018H	5026H	Same target. Cleared to 00H after a valid character is stored, resetting the first-character flag.

SYS1/SYS is loaded by the SYS0 overlay loader (RST 28H handler at 4BA2H) whenever the system dispatches an SVC code that maps to overlay file 1. SYS0 entry points referenced by SYS1 include: 402DH (no-error exit), 4030H (error-already-displayed exit), 4410H (enqueue timer callback), 4413H (dequeue timer callback), 4433H (load and execute program file), and 4467H (display message to screen). SYS1 dispatches overlay commands to SYS6 via RST 28H with SVC code 88H. The BASIC2 command handler references ROM entry point 0075H (BASIC warm start) and ROM data at 06D2H (vector initialization block). The DEBUG handler patches the RST 30H vector at 400FH and the BREAK handler at 4315H. The TRACE handler uses the timer display routine at 4CD9H as the callback address.

4E00H - Request Code Dispatcher

Entry point for SYS1/SYS. Register A contains the full SVC code from the RST 28H overlay call. This routine masks out the function bits (bits 4-6) and dispatches to the appropriate handler based on the request code. Request code 10H and 20H both go to the DOS READY prompt and command input handler. Request code 30H goes to the command line parser. Request code 40H goes to the filespec parser. Request code 50H goes to the default extension insertion routine (indirectly). Request code 60H goes to the option/keyword parser. Any other request code returns immediately.

4E1FH - DOS READY and Command Input Handler

This is the main DOS READY handler, entered for request codes 10H and 20H. It enables interrupts, resets the stack pointer to 41FCH, checks system condition flags to determine if DEBUG is active and if the BREAK key should be tested, displays the "DOS READY" prompt, reads a command line from the keyboard, and falls through to the command parser at 4E4EH. The stack reset to 41FCH ensures a clean stack regardless of how deeply nested the previous operation was.

4E4EH - Command Line Parser and Dispatcher

This section parses the command line from the buffer at 4318H, extracts the command name into the filespec buffer at 4480H, and searches two command tables to determine how to handle the command. The first table at 4EA4H contains resident commands (BASIC, DEBUG, TRACE) handled within SYS1 itself. The second table at 4EBDH contains overlay commands dispatched to SYS6. If the command is not found in either table, it is assumed to be a program filename and is loaded and executed via the SYS0 program loader.

4E84H - Command Table Match Dispatch

This short routine is reached when either the resident or overlay command table contains a match for the entered command. Register Pair DE holds the dispatch address from the matching table entry, and the saved HL (command line position) is on the stack. The routine pops HL, pushes the dispatch address, and uses RET to jump to the handler.

4E87H - Command Parse Error Handler

Reached when the filespec parser returned an error, the first character was a wildcard, or any other invalid command condition. Displays the "WHAT?" error message and exits to the error-already-displayed handler to return to the DOS READY prompt.

4E90H - Overlay Command Dispatch (Load SYS6)

This routine handles all nineteen overlay commands by loading SYS6/SYS via the RST 28H overlay mechanism. It first checks if SYS6 is already loaded in the overlay area (bit 4 of system flags at 430FH). If so, it jumps directly to 5200H where SYS6's entry point resides. If not, it sets the overlay-loaded flag and invokes RST 28H with SVC code 88H to load SYS6 from disk. The RST 28H handler does not return to 4EA4H; instead, the loaded overlay takes control and processes the command, eventually returning to the DOS READY prompt via the no-error exit at 402DH.

4EA4H - Resident Command Name Table

Data table containing three 8-byte entries for commands handled directly within SYS1/SYS. Each entry consists of a 6-character command name (padded with spaces or version characters) followed by a 2-byte little-endian dispatch address. The table is terminated by a 00H byte. The command table lookup routine at 502AH searches this table by comparing the parsed command name character-by-character against each entry. The disassembler has misinterpreted these data bytes as Z80 instructions.

4EBDH - Overlay Command Name Table

Data table containing nineteen 8-byte entries for library commands handled by SYS6/SYS. Each entry consists of a 6-character command name (padded with trailing spaces for names shorter than 6 characters) followed by the 2-byte little-endian dispatch address 4E90H. All entries share the same dispatch address because they all route through the SYS6 overlay loader at 4E90H. The specific command within SYS6 is identified by the entry index returned in Register C by the lookup routine at 502AH. The table is terminated by a 00H byte at 4F55H. The disassembler has misinterpreted these data bytes as Z80 instructions.

4F56H - Filespec Parser

This routine extracts a structured filespec from the command line at (HL) into the buffer at (DE). The filespec format is: NAME/EXT.PASSWORD:DRIVE, where NAME is up to 8 characters, EXT is up to 3 characters, PASSWORD is up to 8 characters, and DRIVE is a single character. Each field separator ("/", ".", ":") is stored in the output buffer. After parsing, the routine checks the result against the noise word keyword table at 4FA7H (containing "TO", "ON", and "OVER") and, if a match is found, restarts parsing at 4F56H to skip the noise word and extract the next word. TRSDOS supports noise words like "COPY file1 TO file2" where "TO" is silently consumed. On return, Z flag set indicates successful parsing; NZ indicates the input was exhausted or contained no valid characters.

4F98H - Wildcard Check During Filespec Parse

Reached when the character extraction routine returned NZ (valid characters found, but stopped on a non-separator). This checks if the stopping character was an asterisk wildcard, and if so, continues extracting characters after it.

4FA7H - Noise Word Keyword Table

Data table containing three 8-byte entries for TRSDOS "noise words" that are silently consumed during filespec parsing. Noise words are common English prepositions and conjunctions used in TRSDOS command syntax for readability (e.g., "COPY FILE1 TO FILE2"). When the filespec parser encounters one of these words, it discards it and parses the next word instead. Each entry uses the same 8-byte format as the command tables: 6 characters of name (padded with spaces) followed by a 2-byte value (set to 0000H since noise words have no dispatch address). The table is terminated by a 00H byte.

4FC0H - Default Extension Insertion Routine

This routine inserts the default file extension (typically "/CMD") when the user did not specify one. It is called from the command dispatcher (at 4E7DH) when an unrecognized command is to be loaded as a program file. HL points to the default extension string (e.g. "CMD" at 51B5H). The routine scans the filespec buffer looking for the end of the name field. If no extension separator ("/") is present, it uses LDDR block moves to shift the existing string and insert the extension, producing e.g. "MYPROG/CMD". Checks for the drive separator (":") help determine name boundaries but are not the primary purpose of this routine.

4FDBH - Insert Default Extension Into Filespec

Reached when the drive specifier extractor finds a position in the filespec where the default extension should be inserted. HL points to the current position in the filespec (where the name ends), and the default extension string address is saved on the stack. This routine uses LDDR (block move decrementing) to shift the existing filespec characters to make room, then copies the default extension into the gap.

4FF4H - Character Extraction Subroutine

Reads up to B characters from the command line at (HL), storing valid filename characters (digits 0-9 and uppercase letters A-Z) into the output buffer at (DE). Skips over excess characters when the maximum count is reached. Terminates when it encounters a 03H end-of-buffer marker, 0DH carriage return, or any character outside the valid range (below 30H or between 3AH-40H or above 5AH). On return: A = the character that caused termination, Z flag set = no valid characters were stored (first-character flag still set), NZ = at least one character was stored. Self-modifies the byte at 5026H to track whether a character has been stored in the current field.

502AH - Command Table Lookup

This routine searches an 8-byte-entry command/keyword table for a match against the parsed name in the buffer at (DE). Each table entry contains a 6-character name followed by a 2-byte dispatch address or value. The table is terminated by a 00H byte. On entry: BC = table start address, DE = parsed name buffer. On return: Z flag set = match found (DE = dispatch address from the table entry, C = 1-based entry index, HL restored from stack); NZ flag = no match found. The routine compares up to 5 characters of the parsed name against each entry, and also checks for padding matches where the table entry has spaces and the input has a 03H or 0DH terminator.

5042H - Command Table Entry Comparison

Reached when the first character of the parsed name matches a table entry. This code performs a detailed character-by-character comparison of the next 5 characters (the remaining bytes of the 6-character name field). The comparison accounts for the parsed name being shorter than the table entry by treating 03H and 0DH terminators as matching any space (20H) padding in the table entry.

5064H - Mismatch Character Validation

Reached when a character in the parsed name does not match the corresponding table entry character. This code checks whether the mismatched character is a valid filename character (digit or letter). If it is, the mismatch might just be because the command name is a prefix of a longer filename, so the search continues with the next table entry. If the character is not a valid filename character (it is a separator, terminator, or invalid), the code checks if the table entry has space padding where the input terminates.

507DH - Option/Keyword Parser

This routine parses parenthesized option lists from the command line. TRSDOS commands can include options in the format "(KEYWORD=VALUE,KEYWORD=VALUE)". Entry: HL points to the current position in the command line. The routine first scans past any spaces to find an opening parenthesis "(" (28H). If found, it enters a loop that extracts keyword names (up to 6 characters) and their associated values. Values can be decimal numbers, hexadecimal numbers (prefixed with "X'"), or boolean keywords (YES/NO/ON/OFF). On return: Z flag set = options parsed successfully (closing ")" found), NZ = no parenthesized options found or the input terminated before ")". Register Pair DE points to the keyword lookup buffer at 51AFH.

508EH - Parse Single Option Keyword and Value

Parses one keyword=value pair from within the parenthesized option list. First extracts the keyword name (up to 6 characters) into the buffer at 51AFH using the character extraction routine at 4FF4H, then looks up the keyword in a caller-provided command table. If the keyword is found and is followed by "=" then the value is parsed according to its format. On return: Z flag set = option pair parsed successfully and the caller should look for more options; NZ = option list ended or error.

50A8H - Parse Option Value After Keyword Match

Reached after a keyword has been found in the option table. The dispatch address from the table entry is in DE, pointing to a 2-byte storage location for the value. This code checks for an "=" sign; if present, it parses the value in one of three formats: hexadecimal (X'nn'), boolean (YES/NO/ON/OFF), or decimal. If no "=" is present, the keyword is treated as a boolean flag and assigned the value FFFFH (true). The parsed value is stored at the address in DE.

50C1H - Parse Value After Equals Sign

Reached when "=" was found after a keyword. Advances past the "=" and examines the first character of the value to determine its format: "X" indicates hexadecimal (X'nn' format), a letter A-Z indicates a boolean keyword (YES/NO/ON/OFF), and a digit 0-9 indicates a decimal number.

50DFH - Boolean Value Parser (YES/NO/ON/OFF)

Parses boolean option values. Recognizes "Y" (YES), "N" (NO), "ON" (two characters: "O" then "N"), and "OF" (OFF, checked as "O" then "F"). For true values (Y, ON), BC is set to FFFFH. For false values (N, OFF), BC is set to 0000H. On return: Z flag set = valid boolean parsed, NZ = not a recognized boolean keyword.

5104H - Decimal Number Parser

Parses a decimal number from the command line into a 16-bit value in Register Pair BC. Uses the multiply-by-10-and-add algorithm: for each digit, BC = BC x 10 + digit. The multiply-by-10 is implemented as (BC x 4 + BC) x 2, using ADD HL,HL and ADD HL,BC instructions. On return: BC = the parsed 16-bit value. Returns when a non-digit character is encountered.

511FH - Hexadecimal Value Parser (X'nnnn' Format)

Parses a hexadecimal value enclosed in single quotes after an "X" prefix. The "X" has already been consumed by the caller. This routine expects the next character to be a single quote (27H), followed by hex digits (0-9, A-F), and a closing single quote. Each hex digit is accumulated into BC by shifting BC left 4 bits and adding the digit. On return: Z flag set = valid hex parsed (BC = value), NZ = parse error.

514CH - BASIC2 Command Handler

The BASIC2 resident command handler. BASIC2 starts non-DOS BASIC (Level II BASIC without disk support). This routine performs a warm restart into Level II BASIC by copying the first 36H (54) bytes from ROM address 06D2H to RAM address 4000H, which restores the original BASIC RST vector table and system hooks that were overwritten when TRSDOS loaded. It then clears the next 27H (39) bytes of the work area (4036H-405CH) to zero and jumps to the ROM BASIC initialization entry point at 0075H. This effectively exits TRSDOS and returns full control to Level II BASIC, permanently abandoning all DOS state. Unlike Disk BASIC, non-DOS BASIC has no access to disk files or DOS commands.

5162H - DEBUG Command Handler

The DEBUG resident command handler. Toggles the DEBUG mode on or off based on a boolean parameter. When DEBUG is enabled, the system flags byte at 430FH has bit 7 set, the BREAK key handler is patched to jump to the RST 30H vector (400FH for the debug entry point), and the error exit vector at 4030H is patched to CALL 400FH instead of LD A,A3H. When DEBUG is disabled, these patches are reversed. Entry: HL points to the command line after "DEBUG". The routine calls 51A0H to parse an optional boolean parameter (ON/OFF/YES/NO).

5191H - TRACE Command Handler

The TRACE resident command handler. Toggles the interrupt-driven trace display by enqueueing or dequeueing the trace callback handler at 4CD9H through the SYS0 timer callback system. When TRACE is enabled, the timer interrupt service routine calls 4CD9H on each tick, which displays register contents on the screen in real time. Entry: HL points to the command line after "TRACE".

519FH - Parameter Parser Helper

Helper routine that skips spaces, then parses a parenthesized boolean value. Used by the DEBUG and TRACE command handlers. Entry: HL points into the command line. First calls 51A0H (which skips spaces), then if "(" is found, parses the boolean value. On return: Z = false or no parameter, NZ = true. Register A reflects the boolean result (0 = false/absent, non-zero = true).

51AFH - Data Area: Buffers and Message Strings

This area contains keyword buffers, the default extension string, and system message strings used by SYS1. These are not executable code; the disassembler has misinterpreted the bytes as Z80 instructions.