TRS-80 DOS - LDOS 5.3.1 for the Model I - SYS6/SYS Disassembled

SYS6/SYS

Overlays in SYS6

Other Navigation

LDOS 5.3.1 SYS6/SYS Disassembly - Library A Command Overlay Set (Model I)

SYS6/SYS is the Library A transient command file of LDOS 5.3.1 for the TRS-80 Model I. It is not a single program: it is a partitioned overlay file holding fifteen independent command overlays. Every overlay is assembled to load and run at 5200H, directly above the resident operating system (SYS0/SYS occupies 4000H-4DFFH and the RST 28H dispatcher/overlay loader live inside it). Only one overlay is resident at any moment; the resident overlay loader reads the requested overlay into 5200H, transfers control to it, and the overlay runs to completion and returns to the caller.

SYS6 is reached through the resident supervisor call RST 28H with the request code 88H in register A and the command number in register B. The resident dispatcher at 4BCDH (see the SYS0 disassembly) recognises code 88H as "Library A", calls the overlay loader at 4BF5H to bring the B-th overlay of SYS6 into memory at 5200H, and enters it at its first byte. The companion file SYS7/SYS is Library B (request code 89H) and holds the remaining transient commands. The command-name to (library, number) mapping is performed earlier by the command interpreter SYS1/SYS, which classifies the typed command word and issues the appropriate RST 28H request.

Because all fifteen overlays share the load address 5200H, the addresses in this disassembly repeat from overlay to overlay. Each overlay is documented as its own numbered section below, in the order it appears in the SYS6 file (which is the order of its command number). The entire memory image of every overlay in this page has been verified byte-for-byte against the raw SYS6.SYS load module (the LDOS load records were parsed and each overlay's loaded bytes compared against the listing; 0 mismatches across all fifteen overlays).

SYS6 Overlay Structure Map

The fifteen overlays and their SYS6.SYS file offsets, load range, and function. Each overlay begins with a stack-pointer save (LD (nnnnH),SP) so that it can restore the caller's stack and return, then validates its command line through the resident parameter services before performing its work.

Resident SYS0 Services Used By SYS6

Every overlay reaches back into the resident SYS0 core for its parameter parsing, display, math and directory primitives. These are external references; each is linked to the SYS0 disassembly at its resident address.

Cross-Reference Notes

SYS6 is entered from the resident RST 28H dispatcher at 4BCDH in SYS0/SYS in response to request code 88H, and returns to it (or to @EXIT 402DH / @ABORT 4030H). The command interpreter SYS1/SYS decides which SYS6 command number to request. SYS6 itself calls only into the resident SYS0 core (4000H-4DFFH); it does not call SYS7 or any other overlay. Companion command file SYS7/SYS is Library B (request code 89H).

5200H - Overlay Entry and Command Parameter Parse

Entry point of the MEMORY command overlay. It saves the caller's stack pointer for a clean return, then hands its command tail to the resident @PARAM service to decode the CLEAR, ADD, WORD, BYTE, GO, PRINT and HIGH keywords. Each recognised keyword deposits its value directly into the operand field of an instruction inside this overlay, so the tests that follow read those self-modified operands.

5224H - CLEAR Routine Template (Relocated to 4200H)

This 23-byte block is not executed in place. The setup above copies it to the resident scratch buffer at 4200H and returns into it. Running there, it zero-fills memory from 5201H up to the current HIGH$ ceiling and exits to DOS, wiping the reserved high-memory region requested by the CLEAR keyword.

523BH - ADD Keyword: Hexadecimal and Decimal Value Display

Reached when CLEAR was not given. If the ADD keyword supplied a value it is echoed back to the operator both ways - as a 4-digit hexadecimal address and as a decimal number - in the form X'dddd' = ddddd ('dddd' => X'dddd'), using the resident hex-format and the local decimal-format helpers.

5294H - HIGH Keyword: Reserve or Release High Memory

If the HIGH keyword supplied a new HIGH$ value this section validates it against the overlay's own load address and the top of memory, plants a relocatable reserve stub just below the new ceiling, and rewrites the resident HIGH$ word (4049H). If HIGH was not given, control falls through to the high-memory directory display.

52CFH - Confirm HIGH$ and Prepare Directory Display

Compares the resident HIGH$ ceiling (4049H) against the top-of-memory word (4403H). When they are equal (no high memory reserved) it shows the current High = X'xxxx' line; otherwise it proceeds to walk the reserved high-memory module chain.

52E7H - High-Memory Directory: Header and Module Loop

Prints the High Memory Directory heading and then iterates over the resident high-memory module chain. For each linked module it copies the module's name and computes and formats its start address, end address and length into the display line.

5357H - Build the Directory Column-Header Line

Assembles the column-header line (Module / Start Address / End Address / Length) and the HIGH$ = value into the overlay's work area at 5200H, then emits it above the per-module rows.

53A4H - Scan the Resident High-Memory Module Chain

Walks the chain of resident high-memory module headers. Each header is found by its 18H marker byte; the routine reads the forward link and the module name, validates the name characters, and formats each module's extent for display, looping until the chain reaches the top of memory.

53FFH - Helper: Format Register Pair as Hex Address Field

Utility used throughout the directory display. It converts the value in HL to four hexadecimal ASCII digits (via the resident 4D76H formatter) and drops them, wrapped in X'____', into the caller-supplied field.

5411H - Helper: Format Value as Right-Justified Decimal

Utility that converts the binary value in HL to a right-justified, space-padded decimal string of up to five digits at the buffer addressed by DE, using the resident divide-by-ten helper (44C4H).

542AH - Helper: Emit the Work Line and Blank It

Displays the assembled work line at 5200H to the video device (and to the printer when the PRINT keyword was given), then refills the 57-byte work area with spaces ready for the next line.

543FH - Helper: Optional Pause / Wait for a Key

Provides the paged-display pause. It tests a self-modified counter; when a screen is full it waits at the ROM keyboard scan for a key, honouring the BREAK key as an abort back to DOS.

545FH - Overlay Exit and Caller Stack Restore

The common exit. It optionally jumps through a saved vector, restores the caller's stack pointer that was saved at entry, and returns to the LDOS command level, or aborts to DOS if the system flag demands it.

547AH - Command-Level and System-State Check

Verifies that the command was issued from the LDOS command level and not from within another running program or a background task, refusing the operation and displaying the Can't message otherwise.

54A0H - Parameter Error Handler

Entered when @PARAM rejected the command line. It raises the resident error service with the syntax-error code and returns to DOS.

54A9H - MEMORY Data: Reserved-Block Module-Header Template

The 10-byte resident-module header that the ADD keyword copies to the top of memory to mark the block it has just reserved. Its link and name fields are patched in code before the copy.

54B3H - MEMORY Data: Error Messages

The two error strings displayed by the MEMORY overlay: the command-level restriction and the range-error report. Both are carriage-return terminated.

54E9H - MEMORY Data: @PARAM Keyword Descriptor Table

The parameter table handed to the resident @PARAM service at 5204H. Each 8-byte entry is a 6-character keyword name followed by the two-byte address of the instruction operand that @PARAM overwrites when that keyword appears. Every keyword is listed twice: spelled in full and as its one-letter abbreviation.

555AH - MEMORY Data: Value-Display Templates

The two templates the HIGH and ADD keywords use to echo an address in both hexadecimal and decimal. The lower-case placeholder characters are overwritten in code with the formatted digits.

558FH - MEMORY Data: Directory Headings and Summary Labels

The title, summary-line labels and column headings the directory display copies into its 5200H work buffer before printing the high-memory module table.

55F4H - MEMORY Data: Fallback Name and Hex-Address Template

The placeholder name used for anonymous modules and the X'____' template used to print a 16-bit address. These occupy the final bytes of the MEMORY overlay (through 5603H).

5200H - DIR Overlay Entry: Filespec, Drive and Option Parse

Entry of the DIR command overlay, which displays a disk directory. It first saves the caller's stack pointer for a clean return, then parses the command tail: an optional filespec mask (name and extension held in the 5B6AH/5B72H match buffers), an optional drive number, and the option keywords (A, I/INV, S/SYS, P, N, DATE, MOD, SORT) through the resident @PARAM service. Register HL points at the command tail on entry, set up by the resident overlay loader.

5252H - DIR Setup: Busy-State Check, Sort-Buffer Ceiling and Date Filter

Prepares the global state for the listing. It notes whether the system is busy (which suppresses the in-memory sort buffer), computes the ceiling below HIGH$ into which sorted entries may be gathered, forces non-stop output when the printer option is active, and parses the optional DATE range into the start and end compare values, before falling into the per-drive scan loop.

52B4H - Per-Drive Loop: Drive Check, GAT Read, Free-Granule Count and Drive-Type Field

Top of the per-drive scan loop. For the current drive it verifies the drive is ready, loads that drive's Drive Control Table (DCT) into IY, determines whether extended date stamping is enabled for it, reads the Granule Allocation Table (GAT) into the shared buffer, counts the free granules, and builds the drive-type descriptor (floppy single/double density and sides, or hard-disk head count) for the header line. Register C holds the drive number on entry.

533DH - Disk Capacity, Directory Capacity, Disk Name and Header Display

Completes the header line for this drive. It computes the granules-per-cylinder and the total granule capacity, formats it as a kilobyte figure, works out the directory-entry capacity, counts the directory slots in the Hash Index Table (HIT), copies the disk name and creation date out of the GAT sector, then displays the assembled header line and the column-heading separator before dropping into the directory read loop.

53DEH - Record Advance, Drive-Loop Exit and Drive-Not-Ready Skip

Advances to the next directory record and, when a directory sector is exhausted, either sorts and flushes the collected entries or moves on. When the last record of the drive is done it either exits (single drive requested) or steps to the next drive. It also holds the common overlay exit and the path taken when a drive is not ready.

542DH - Directory Record Read Loop: Attribute, Name and Date Filters

The heart of the listing. For each directory slot it reads the record, rejects empty, secondary-extent, system, invisible and undated records according to the options in force, matches the file name and extension against the mask, applies the date range filter, and then either collects the record in the sort buffer or displays it immediately. Register B holds the record index and register C the drive number throughout.

5509H - Format One Directory Line: File Name, Extension and Attribute Letters

Helper that formats and prints one directory entry. This first part emits the file name and extension (padded to a fixed column), then the attribute letters S (system), I (invisible), P (protected/access), the modified marker and the plus marker, each shown as its letter when the attribute is set or a hyphen when it is not. Register pair HL addresses the directory record on entry.

55C5H - Detail Columns: Access, LRL, Records, EOF, Granules, Size and Modification Date/Time

Fills the detail portion of the line buffer for the A (all) and SORT listings: the access code, the logical record length, the record count, the end-of-file byte, the granule/extent count, the file size in kilobytes, and the modification date and time. It then displays the assembled line. Register pair HL addresses the directory record on entry.

5709H - File-Size Helpers: Stored Key and Extent Walk

Returns a file's granule/extent count in register pair DE and its size measure in register pair BC. When sorting, the value was pre-computed and stored in the record; otherwise it is computed here by walking the file's extents, following the secondary-extent (FXDE) chain and reading further directory sectors as needed.

577CH - Output Helpers: Line, Character, Space and Printer

The low-level output primitives. 577CH displays a whole message and echoes it to the printer under the P option; 5787H emits a space; 5789H sends one character to the video and then, via 578EH, to the printer when the P option is active.

5796H - Granules-to-Kilobytes Formatter

Converts a granule count in register pair DE to a kilobyte figure written as decimal at the buffer addressed by register pair HL, returning the tenths digit in register A. It multiplies granules by sectors-per-granule to get sectors, divides by four (256 bytes per sector over 1024 bytes per kilobyte), and maps the fractional sectors to a tenths character.

57C2H - Copy File-Name Field with Upper-Case Folding

Copies up to register B characters of a file name or extension from the command line (register pair HL) into the match buffer (register pair DE), folding lower case to upper case, passing the dollar wildcard through unchanged, and stopping at a delimiter. It returns the terminating character in register A.

57DDH - Decode a Directory Date to a Comparable Value

Reads the packed modification date from a directory record (register pair HL at the flags/month byte) and returns a single comparable year/day value in register pair DE, drawing the year either from the record's short field or, when extended dating is enabled for the drive, from the extended-date word.

5806H - Parse a Date Argument and Validate It

Parses an MM/DD/YY date field from the command line (register pair HL), validates the month against 12 and the day against the days-in-month table (allowing for a leap year), packs it into the comparable year/day form in register pair BC, and jumps to the parameter-error handler on any bad value. Helpers 5856H, 586BH and 5881H parse the individual fields.

5856H - Date-Field and Number Parsers

Supporting parsers for the date argument: 5856H reads three separator-delimited numeric fields into consecutive scratch cells; 586BH reads a one- or two-digit decimal number; and 5881H converts a single ASCII digit to binary and reports whether it was a valid digit.

5888H - Decimal Formatters

Right-justified decimal output into a buffer (register pair DE) from a 16-bit value (register pair HL). Entry points select the field width: 5888H and 588CH format up to five digits, 589AH three, and 58A0H two. Leading zeros are shown as the pad character in register A. 58ACH extracts one decimal digit for a given power of ten.

58C7H - Pause/BREAK Check and Keyboard-Flag Reset

Honours a keyboard pause and detects BREAK between listing lines, using the resident keyboard flag KFLAG$ (4423H) and the ROM keyboard scan. 58E8H resets the keyboard flag at the start of the command. The check is skipped unless the command is running at the LDOS command level.

58F2H - Paged-Display Line Counter and Separator

Counts displayed lines and, when a screen is full and pausing is enabled, waits for a key (honouring BREAK to abort and C/space to run non-stop) and reprints the column headings. 5921H prints the column-heading line and a 64-character rule beneath the drive header.

5944H - Name-Sort Engine (Shell Sort of Collected Entries)

When the SORT option is active, the matching records were gathered in the high-memory buffer from 5E00H. This routine builds a table of pointers to those records, sorts the pointers by file name and extension using a diminishing-gap (Shell) sort, and then displays the records in sorted order through the line formatter at 5509H.