TRS-80 DOS - NEWDOS/80 v2.0 for the Model III - SYS18/SYS Disassembled

SYS18/SYS

Other Navigation

SYS18/SYS is the NEWDOS/80 v2.0 overlay responsible for executing BASIC direct-mode statements that manipulate program text. It is loaded into the overlay area at 5200H–56E7H when the user enters a direct command that requires it. The overlay handles the following BASIC direct commands: LIST (display program lines), EDIT (enter the line editor for a specified line), DELETE (remove a range of program lines), DI (delete a line and insert it at a new line number), DU (duplicate a line at a new line number), AUTO (automatic line numbering during program entry), and RENEW (recover a program after NEW). It also provides the dispatch mechanism for invoking the RENUM (SYS11) and REF (SYS12) overlays when those commands are entered.

The overlay's entry point is at 5200H, which is a stub consisting of CP A / RET that simply returns with Z flag set. The real entry point for direct statement execution is at 5202H, which is reached from the ROM BASIC command execution loop. The code first sends a control character to initialize the display, checks the DOS intercept flag at 63FAH, and then classifies the input character to determine which path to follow: colon (execute stored line), line-feed/left-bracket/period/comma (LIST variants), semicolon/cursor-right (EDIT entry), cursor-up/slash (specific line operations), or an unrecognized character (fall through to the keyword parser at 53C5H for EDIT, LIST, DELETE, DI, DU, AUTO, RENEW, RENUM, and REF).

The BASIC program text is stored as a linked list of lines. Each line consists of a 2-byte forward link pointer (address of the next line), a 2-byte line number, followed by the tokenized BASIC text terminated by a 00H byte. The end of the program is marked by a line whose link pointer is 0000H. SYS18 walks this linked list to locate target lines for LIST, EDIT, DELETE, DI, and DU operations.

The following memory locations are used as variables, self-modifying code targets, and data areas by SYS18/SYS.

Ram Variables (External)

Data Tables

The following routines have been identified within SYS18/SYS.

5200H – Overlay Stub and Return

The first two bytes of SYS18/SYS form a minimal stub routine. When another part of NEWDOS/80 needs to test whether SYS18 is loaded into the overlay area, it performs a CALL to 5200H. If the overlay is present, CP A compares Register A against itself (always producing Z flag set and clearing the CARRY flag), then RET returns to the caller. If the overlay is NOT loaded, the memory at 5200H contains whatever was previously there (or 00H = NOP), and the behavior differs — allowing the caller to detect the overlay's absence.

5202H – Main Entry Point: Direct Statement Executor

This is the primary entry point for SYS18, called from the ROM BASIC command execution loop when a direct-mode statement needs to be processed. The code first sends a control character to initialize the cursor, then checks the DOS state flags to determine the input method. If the extended input mode is active (bit 5 of 4289H set), it invokes the full line input routine at 05D9H which provides line editing capabilities. Otherwise, it uses the simple keyboard scan at 0049H which returns a single keypress. After obtaining the input character, the code checks the keyboard intercept flag at 63FAH — if set, input is redirected to ROM routine 2831H for special processing. Otherwise, the key value is classified through a series of comparisons to determine which command handler to invoke.

5271H – Colon Handler: Direct Statement Execution

When the user presses the colon key (3AH) in direct mode, this handler is invoked. A colon at the READY prompt means "execute the text on the current screen line as a BASIC direct statement." The handler examines Register L (which was cleared to 00H at 5226H) to determine the context. If L is 00H (colon pressed at the top level), DE is set to 0000H (line number zero = direct statement). If L is 40H (colon pressed after an at-sign), the code checks whether the stored key was an at-sign and branches accordingly. Otherwise, the current line number is loaded from 40ECH.

5280H – BASIC Line Search Routine

This routine walks the BASIC program linked list starting at the address stored in 40A4H, searching for a line whose line number matches or exceeds the target value in DE. Each line in the BASIC program consists of a 2-byte link pointer (address of the next line), a 2-byte line number, and the tokenized BASIC text terminated by 00H. The end of the program is indicated by a link pointer of 0000H. The routine counts lines in BC as it walks the list. On exit: HL points to the line that matched or exceeded the target (or the last line if the target was not found), BC holds the count of lines preceding the target, and the flags reflect the comparison result.

52ADH – Line Found: Key-Dependent Offset Selection

Execution reaches here when the line search at 5280H found a line whose number is greater than or equal to the target. The saved key value (from the stack, originally pushed at 522EH) is now analyzed to determine the screen offset — how many lines before or after the found line should be displayed. Different keys produce different offsets: down-arrow (0AH) sets DE = 0001H (display starting one line after), left-bracket (5BH) sets DE = FFFFH (display starting at the very beginning of the screen page), at-sign (40H) sets DE = 0000H (display starting at the found line), and colon (3AH) sets DE = FFF3H (display starting 13 lines before, to center the line on screen). Any other key is an error and jumps to 5379H.

52CEH – Line Offset Calculator and Line Walk

This routine takes the line count (BC = number of lines before the target) and the display offset (DE = signed value from the key handler above), combines them to calculate the absolute line index to start displaying from, then walks the BASIC program linked list from the beginning to reach that line. The calculation is: absolute_index = BC + DE. If the result is negative (underflow), it is clamped to 0 (start of program). The routine then walks forward through the linked list, counting down from the calculated index, to reach the target display line.

52FCH – Screen Clear and Line Display Loop

This routine clears the screen by sending control codes 1CH (clear screen) and 1FH (home cursor), then enters the main line display loop. The loop iterates through BASIC program lines starting from HL, calling ROM routine 2B7EH to detoken and display each line, and ROM routine 5D0BH to display the line number. The code tracks screen row usage to stop when the screen is full (15 rows on the Model III) or the end of the program is reached. Register D counts screen rows consumed, Register E counts columns within the current row, and Register C holds the maximum number of lines to display per page.

5354H – Screen Not Full: Continue to Next Line

When the screen is not yet full (fewer than 15 rows consumed), this code stores the current line address for later use, follows the link pointer to the next line, checks for end-of-program, and either loops back to display the next line or exits if the program has ended or the line limit is reached.

5367H – End of Listing: Extract Line Number and Prepare READY

This code extracts the line number from the last displayed line and stores it into the self-modifying operand at 5272H (which is the operand of LD DE at 5271H). This allows the colon handler to recall the last displayed line number. It then sets up the stack for the READY prompt display by pushing 0000H as a sentinel and jumping to 53B8H which enters the BASIC warm restart.

5379H – READY Prompt Display and BASIC Warm Restart

This routine displays the READY prompt on the bottom line of the screen with appropriate cursor positioning. It first sends cursor-home (1DH) to position the cursor. Then it checks whether the current bottom line of the screen already contains the "READY" text — if so, it sends a cursor-right (1BH) to skip past it rather than reprinting. Finally, it sends cursor-down (1EH) and jumps to the BASIC warm restart at 2B33H. The entry at 5379H is the error/fallthrough path that pushes AF first; the entry at 537AH is the direct path from end-of-program detection.

53BBH – "READY" Text String (Data)

This is a 10-byte read-only data area containing the ASCII text "READY" followed by five space characters (20H). It is used by the screen comparison routine at 53A0H–53ACH to detect whether the previous screen row already displays the READY prompt. The disassembler misinterprets these bytes as Z80 instructions, but they are pure ASCII data.

53C5H – Keyword Dispatcher Entry Point

This is the main keyword dispatcher, reached after the line input routine returns a complete command line. The code first checks whether BREAK was pressed during input (CARRY flag set from 05D9H/05E3H), exiting to the BASIC command executor at 0375H if so. Otherwise, it saves the registers, backs up the text pointer, and calls RST 10H to fetch the first non-space character. If the character is a digit, the input is parsed as a bare line number (which is a syntax error if not followed by a statement). If the character is not a digit, control falls through to the keyword table lookup at 53DAH.

53DAH – Keyword Table Lookup

This routine looks up the input text against the keyword table at 54B2H. It compares the input characters (after uppercasing via CALL 57BAH) against each keyword entry in the table. Each table entry consists of the keyword's ASCII characters (with the byte AFTER the last character having bit 7 set as a terminator/flag), followed by a 2-byte handler address. If a keyword match is found, the handler address is loaded into BC and the flag byte determines the dispatch path. If no keyword matches, control falls through to the syntax error path at 544DH.

53F5H – Keyword Match: Character Advance and Completion Check

When a character matches during the keyword lookup, this code advances to the next table byte and checks whether the keyword is fully matched (bit 7 set on the next byte). If not fully matched, it loops back to compare the next character. When fully matched, it extracts the 2-byte handler address into BC and the flag byte into A, then dispatches based on the flag bits: bit 6 controls whether this is an EDIT-style command (bit 6 set) or a DI/DU/other command (bit 6 clear), and bit 5 distinguishes DI/DU (bit 5 set) from LIST/EDIT/DELETE/AUTO (bit 5 clear).

5413H – Line Command Dispatcher: EDIT, LIST, DELETE, DI, DU, AUTO

This handler processes the line-manipulation commands. The flag byte in Register A (bit 5) distinguishes between DI/DU commands (bit 5 set → jump to 5453H for parameter parsing) and EDIT/LIST/DELETE/AUTO commands (bit 5 clear → parse a line number or period parameter, then scan for the end of the line). For EDIT/LIST/DELETE/AUTO, the code fetches the next character: if it is a digit, it is parsed as a line number; if it is a period, the current line number from 40ECH is used as the default; otherwise it is an error. The code then scans forward to find the end of the logical statement (looking for '=' which signals a different syntax, or CR which terminates the command).

5453H – DI/DU Parameter Parser

This handler parses the parameters for the DI (Delete and Insert) and DU (Duplicate) commands. The syntax is: DI aaaaa,bbbbb or DU aaaaa,bbbbb (or DI .,bbbbb / DU .,bbbbb where period means "current line"). The code parses the source line number (aaaaa), the comma separator, and the destination line number (bbbbb), validates both, then performs the line move/copy operation. The flag byte's low bits distinguish DI (delete original) from DU (keep original).

54B2H – Keyword Lookup Table (Data)

This is the keyword lookup table used by the keyword dispatcher at 53DAH. Each entry consists of the ASCII characters of the keyword, followed by a flag/terminator byte with bit 7 set, followed by a 2-byte handler address (low byte first). The flag byte's lower bits encode additional information: bit 6 set indicates an overlay-style command (RENEW, RENUM, REF) that stores the handler address and fills the buffer; bit 6 clear indicates a line-manipulation command. Bit 5 set indicates DI/DU mode. The table is terminated by a 00H byte. The disassembler misinterprets all bytes in this table as Z80 instructions, but they are pure data.

54FAH – AUTO Command Handler

This routine implements the AUTO command for automatic line numbering during program entry. It retrieves the saved BC from 57B6H (containing any prior handler context), clears the LOAD/SAVE flag at 57B7H, then uses RST 10H to check for parameters. If no parameters are present (indicated by the INC A / JR Z sequence at 5504H–5505H producing a zero), the handler enters a loop via DJNZ to clean up and return. Otherwise, it processes the AUTO parameters (start line, increment) and initiates the auto-numbering loop through ROM routines.

5537H – NOP Padding

The remainder of the SYS18/SYS overlay from 5537H through 56E7H is filled with NOP instructions (00H bytes). This is unused reserved space that pads the overlay to its full allocated size within the SYS file structure. The overlay's executable code ends at 5536H (the RST 28H inline parameter).