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

SYS0/SYS

Other Navigation

LDOS 5.3.1 SYS0/SYS Disassembly - Resident System Module (Model I)

SYS0/SYS is the permanently memory-resident core of LDOS. Once the system is booted it stays in low RAM from 4000H upward and is never overlaid, so every other system overlay (SYS1 through SYS13) and every user program reaches the operating system through the fixed entry points this module establishes. Because those entry points must sit at the same addresses under every Model I DOS, the supervisor-call vector table SYS0 publishes at 4420H-4454H is an address-for-address match with the equivalent table in TRSDOS and NEWDOS/80, which is what allows a single binary to run across all of them.

This particular image is the MISOSYS release. The on-screen sign-on identifies it as "LDOS - THE LOGICAL DISK OPERATING SYSTEM - VER 5.3.1" and the load module carries the string "Copyright 1991 MISOSYS, Inc., All rights reserved". The module contains, in load order: a sign-on screen image loaded directly into video RAM, the RST and DOS jump vectors at 400CH, resident system variables and workspace, the supervisor-call vector table, the disk and floppy-disk-controller I/O routines, the directory and file-handling routines, the RST 28H supervisor-call dispatcher, and the transient boot/initialization code and message strings that run once at start-up and are then discarded.

The disassembly begins at 3C00H, which is the base of the Model I video display. That region is not code at all; it is the sign-on banner and block-graphics logo, loaded straight to the screen by the loader. Resident code proper begins at 400CH.

Variable List

The resident-variable and self-modifying-code table for SYS0/SYS is compiled as the disassembly progresses and will be completed once all resident routines have been analyzed.

Major Routine List

The major-routine summary table is compiled as the disassembly progresses and will be completed once all resident routines have been analyzed.

Cross-Reference Notes

SYS0/SYS is called by every other LDOS overlay and by all user programs through the supervisor-call vector table (4420H-4454H) and the RST 28H dispatcher. It calls the Model I Level II BASIC ROM for character and device I/O and for the keyboard, video, and printer drivers. The supervisor-call vector addresses match those documented for TRSDOS 1.3 SYS0 and NEWDOS/80 SYS0.

The symbol names below are the official LDOS 5.3.1 Model I equate labels. Every address was cross-checked against this SYS0/SYS disassembly and against the Model I disk-primitive, math, DCB and clock-workspace routines it had already identified independently; all of them agree. The table also resolves several entries that the earlier pass had left as guesses drawn from the Model III equate file: the supervisor-call vector slots at 444BH-447EH are the Model I set (@CKEOF, @WEOF, @RREAD, @RWRIT, @LOC, @LOF, @SKIP, @DODIR, @TIME, @DATE, @FEXT, @PARAM, @MSG, @LOGOT, @LOGER), and @MULT/@DIV are the resident entries at 44C1H/44C4H. This decodes the RST 28H request codes B3H (@CMNDI), AEH (@DODIR), D3H (@FEXT), E3H (@PARAM), C4H (@CKDRV), A5H (@FNAME) and CDH (@DOKEY). One slot, 4451H, is a two-instruction supervisor-call stub (LD A,0A3H followed by RST 28H) that issues RST 28H request code A3H; because A3H has bit 7 set, the resident dispatcher at 4BCDH routes it through the overlay loader rather than treating it as a resident call, so it is not an integer-divide entry. It carries no @-symbol of its own in this equate set; the named @DIV vector is the separate resident routine at 44C4H.

ROM / low-core vectors

Supervisor-call vector table (4030H-44C4H)

Resident variables, flags, buffers and control blocks

Disk, directory and math primitives

3C00H - Sign-On Screen Image (Video RAM)

The module opens with a block of data that the loader writes directly into the Model I video display, whose RAM begins at 3C00H. This paints the LDOS sign-on screen while the system loads. None of this region is executable; it is character and graphics data. The title text occupies the first display row, the copyright notice the second, and a block-graphics logo spelling "LDOS" with a trademark mark occupies rows five through nine.

400CH - RST and DOS Jump Vectors

The Model I Level II ROM redirects three of its restart and interrupt vectors into this fixed low-RAM window so the resident DOS can service them. Each entry is a three-byte jump into the body of SYS0.

4015H - Device Control Blocks: KIDCB$, DODCB$, PRDCB$ (Keyboard, Video, Printer)

Three eight-byte Device Control Blocks for the standard character devices. Each block is a data structure: byte 0 is the type/attribute byte, bytes 1-2 the driver entry address, bytes 3-5 the driver's working storage, and bytes 6-7 the two-character device name.

402DH - Exit and Abort Vectors

Two short entry points that return control from a running program to the operating system by issuing a supervisor request through the RST 28H dispatcher.

4033H - Device Driver Hook Vector

A single jump vector, labelled @DVRHK, giving a fixed address at which the device-driver linkage routine can be reached.

4036H - Unused Fill

Filler occupying the gap before the next initialized workspace location.

403EH - Clock Counters and Interrupt Workspace

Sparse locations in the resident workspace. The loader writes only the bytes shown; the surrounding cells are cleared or left for runtime use. This area holds the interrupt tick counter, the software real-time-clock counters, the interrupt status/mask bytes, and the interrupt task-vector table.

41DEH - Reserved Workspace

Two initialized bytes standing alone in the workspace.

4300H - Patchable Hook Stubs (@KITSK, @ICNFG)

Two three-byte slots each initialized so that calling them simply returns. A feature that needs to intercept these points overwrites the RET with a jump at runtime.

4308H - Drive State, System Flags, and Stored Addresses

Resident drive and system state. Each cell is identified by the code that reads or writes it. The system flag byte at 430FH is consulted throughout SYS0; 4310H and 4316H hold stored routine addresses rather than loose bytes.

431BH - Prompt and Keyboard Input Routine

Displays a caller-supplied prompt at a caller-supplied screen position, reads a line from the keyboard into the input buffer, and returns with a subroutine ready to convert the typed characters into binary digits. On entry HL holds the screen position and DE points to the prompt string.

4338H - CONFIG/SYS Filespec String

A constant filename string stored in the workspace and used by the boot process to locate the system configuration file.

4349H - Parse Decimal Fields Routine

Converts the typed input into up to three one-byte binary values, as used for a date (month, day, year) or time (hours, minutes, seconds) entry. Each field is one or two decimal digits, separated by a delimiter, and the input ends at a carriage return.

4378H - Display Character Output Driver

The video character driver. It restores the character sitting under the cursor, then routes the new character to the appropriate ROM display routine according to whether it is a control code, a printable character, or a graphics code. On entry Register C holds the character and IX points to the video Device Control Block.

4396H - Supervisor Request and Timed Delay Helper

Issues a supervisor request, then conditionally performs a short timed delay based on two system flags. Used to pace a system operation.

43C0H - Additional Device Control Blocks: JLDCB$, SIDCB$, SODCB$ (Job Log, System Input, System Output)

Before this block the load module leaves a gap: addresses 43B0H-43BFH are not written by the module (sixteen bytes left as uninitialised RAM), so nothing is loaded there. Loaded data resumes at 43C0H with three more eight-byte Device Control Blocks. Each DCB has the same layout as the keyboard/video/printer blocks at 4015H: byte 0 is the device type/attribute byte, bytes 1-2 are the driver entry address (low byte first), bytes 3-5 are the driver's working storage, and bytes 6-7 are the two-character device name. These are data structures, not code.

4400H - Command Supervisor Entries (@CMD, @CMNDI)

A short supervisor-call entry. It loads a DOS request code into Register A and executes RST 28H, the one-byte restart that the ROM vectors through 0028H to 400CH and on to the supervisor-call dispatcher at 4BCDH. The dispatcher reads Register A to decide which function to run. The first is the @CMD vector (4400H, official LDOS Model I equate); the second, @CMNDI, follows at 4405H.

4409H - Error Display and DEBUG Vectors

The error-message display vector (@ERROR) followed by the DEBUG entry vector (@DEBUG).

4410H - Task-Slot Management Vectors

Four jump vectors that install and remove periodic-task handlers in the Task Control Block table at 4500H, the same table the interrupt service routine scans on every timer tick. Each table slot is a two-byte pointer; an empty slot holds the default do-nothing handler at 45B2H. In the Model I LDOS equates these four vectors are @ADTSK (4410H, add a task), @RMTSK (4413H, remove a task by slot), @RPTSK (4416H, replace/install a task at a preset slot) and @KLTSK (4419H, kill the task currently being dispatched); each targets the task-table code at 459DH-45B3H, matching those names exactly.

441CH - Filespec-Syntax Vector and Version Byte

The filespec-syntax supervisor vector (@FSPEC, 441CH) and, at 441FH, the device/DOS flag byte DFLAG$. (The operating-system version byte OSVER$ is at 403EH, not here.)

4420H - Supervisor Call Vector Table

The fixed supervisor-call vector table. This is the contract every program and overlay depends on, so these addresses are identical across the Model I DOSes and must never move. Two forms of entry appear. A file-management call that needs a resident routine or a loadable overlay is coded as a request code loaded into Register A followed by RST 28H, which the dispatcher at 4BCDH decodes. A call handled entirely inside SYS0 is coded as a direct jump to its routine. Single pad bytes fill the one-byte gaps left after the shorter request-code entries so that every vector begins on its fixed three-byte boundary.

4457H - File Access Extension Vectors

Five further file-access vectors continuing the table. The Model I LDOS equates name them @RWRIT (4457H, re-write current record), @LOC (445AH, return current record number), @LOF (445DH, return end-of-file record number), @SKIP (4460H, skip one record) and @DODIR (4463H, directory service, request code AEH). The table then leaves a one-byte pad before the display/print group at 4467H.

4467H - Display, Print, and File-Length Vectors

The display-string vector (@DSPLY, 4467H), the print-string vector (@PRINT, 446AH), the get/display-time vector (@TIME, 446DH) and get/display-date vector (@DATE, 4470H), then @FEXT (4473H, request D3H), @PARAM (4476H, request E3H), @MSG (4479H, display a message), @LOGOT (447BH, display a carriage-return-terminated line) and @LOGER (447EH).

44A0H - Program-Loader Parameter Buffer

Not loose workspace: this is the parameter buffer the program loader uses. The loader stores into 44A1H (at 4C22H) and points Register Pair DE at 44A0H as a buffer base (at 4C3CH). The bytes shown are the buffer's initial contents, overwritten while a program is loaded, followed by fill before the DEBUG handler.

44B4H - DEBUG Launcher, then @CKDRV / @FNAME / @DOKEY / @MULT / @DIV Vectors

The @DEBUG launcher (44B4H-44B7H) is reached from the RST 30H restart vector at 400FH and the @DEBUG vector at 440DH; it saves AF and issues request 87H, which brings in and starts the DEBUG monitor overlay (that call does not return here). Physically following it are five further supervisor-call vectors that the Model I LDOS equates name @CKDRV (44B8H, request C4H), @FNAME (44BBH, request A5H), @DOKEY (44BEH, request CDH), @MULT (44C1H, JP to the multiply routine at 4B8FH) and @DIV (44C4H, JP to the divide routine at 4BA9H). The disassembler had read these as one continuous DEBUG sequence; the equate table shows they are independent entry points.

44C7H - Device Driver Linkage Routine

Reached from the @DVRHK vector at 4033H. Given a Device Control Block, it fetches that block's driver entry address and type/attribute byte, follows any chain link to another block, checks whether the device is enabled, and transfers control to the driver. On entry Register Pair HL points to the DCB and Register B holds the caller's driver-operation code.

44E3H - Display String Routine

The worker behind the @DSPLY vector. It sends a string to the video device one character at a time through the ROM device-output routine, stopping at the 03H terminator (and also stopping after a carriage return). On entry Register Pair HL points to the string.

44F8H - Print String Routine

The worker behind the @PRINT vector. It is the display routine directed at the printer instead of the screen, sharing the same output loop.

4500H - Task Control Block Table (TCB$)

The Task Control Block table, labelled TCB$. Twelve task-handler slots ... holds twelve two-byte handler addresses that the interrupt service routine calls in turn on each timer tick. Every slot is initialised to the do-nothing default handler at 45B2H until a real periodic task is installed in that slot. This is a data table, not code.

4518H - Interrupt Service Routine

Reached on every hardware interrupt through the RST 38H vector at 4012H. It reads the Model I interrupt-status latch, masks it against the enabled sources, runs the task attached to each pending source, performs the per-tick clock housekeeping, and can divert into the DEBUG monitor when a trap is armed. The latch is read at the memory-mapped address 37E0H (a port would be used on a Model III), which fixes this image as the Model I build.

456FH - Clock Periodic Task

One of the periodic tasks the interrupt service routine dispatches on each timer tick. It services four fixed task slots, then advances a rotating sub-second tick counter and services one further slot chosen by that counter.

458AH - Task Handler-Block Dispatcher

Given a slot index in Register A, this runs the task installed in that slot of the Task Control Block table at 4500H. Each slot holds a pointer to a handler block; the first word of the block is the handler entry address, and the block base is passed to the handler in Register Pair IX.

459DH - Task-Slot Management Routines

The routines the 4410H-4419H vectors jump to. They install a task handler-block pointer into a Task Control Block slot, or overwrite a slot with the default do-nothing block to remove a task. Interrupts are disabled while a slot is updated because the interrupt routine reads the same table. Entry at 459DH removes the task currently being dispatched; entry at 45A2H removes the task in the slot named by Register A; entry at 45A5H installs the block pointer in Register Pair DE into the slot named by Register A.

45B4H - Install-At-Preset-Slot Routine

The routine the 4416H vector jumps to. It installs a handler into a slot whose address is held in a pointer that is patched into its own LD instruction at run time.

45BEH - Software Real-Time-Clock Task

A handler-block task that maintains the time of day. Register Pair IX points at its handler block; the block holds a divider count at offset 2. The task runs only once every five ticks, then cascades the seconds, minutes, and hours counters at 4041H-4043H against the rollover limits stored at 45DDH.

45E0H - Select Drive and Wait For Controller

Selects the drive described by the current drive control block (addressed by Register Pair IY) and waits for the WD1771 to be free. The drive-select value is assembled from the control block and written to the memory-mapped drive-select latch at 37E1H.

45FBH - FDC Operation Dispatcher

Selects which floppy-controller operation to perform from the operation code in Register B. Restore, seek, and step share the Type I command path; the read and write operations branch away to their own handlers. The step direction and command base are set up here before falling into the command-issue routine.

461CH - Wait For FDC Not Busy

Polls the WD1771 status register until the controller finishes its current command, re-asserting the drive selection on each pass. The controller is read at the memory-mapped status address 37ECH.

462AH - Issue WD1771 Type I Command

Sets the target track and sector in the WD1771, computes the seek distance, then builds and issues a Type I command (Restore, Seek, or Step) whose stepping rate comes from the drive control block. The command byte is written to the memory-mapped command register at 37ECH.

466BH - FDC Read/Write Sector Engine

The data-transfer core reached from the FDC operation dispatcher for read and write requests. It patches the byte-transfer instruction and error vector for the requested direction, issues the WD1771 Type II command, then moves a sector's worth of bytes through the data register while polling the Data Request status bit. On entry Register B holds the operation code and the caller has supplied, inline after the call, the transfer instruction and its target address.

46FFH - Drive Configuration Table (DCT$)

A single filler byte, then the Drive Configuration Table at 4700H (labelled DCT$), holding one ten-byte control block per drive for up to four drives. Each block begins with a jump to the floppy-controller driver, so the block address is itself callable, and continues with the drive's flags, select mask, current track, and geometry. The active drive's block is the one Register Pair IY points at throughout the FDC code.

4728H - Per-Drive Driver Hook Stubs

Four short stubs, one per drive, each a RET followed by cleared bytes. They are patchable hooks a driver extension can overwrite; as loaded they simply return.

4750H - Disk Primitive Entry Points

The named low-level disk operations. Each loads its operation code into Register A and funnels into the common tail at 4779H, which records the drive, locates its control block, and runs the driver. On entry Register C holds the drive number; the entry at 4750H instead reuses the last drive saved at 4308H.

478FH - Get Drive Control Table Entry (GETDCT)

Sets Register Pair IY to the control block for a drive in the table at 4700H, and provides a helper to fetch a byte from any drive's block. The block address is computed as 4700H plus the drive number times ten.

47B4H - Build FDC Track/Sector Parameter Block

Copies the target sector and following control fields into the FDC parameter block at 44AEH, adjusting the sector number to the one-based value the controller expects. Two short byte-copy helpers follow. On entry Register Pair HL points at the source fields and Register A holds the raw sector value.

47CBH - Position File and Prepare Record

The file record-positioning core behind the write, position, and backspace vectors. It validates the open file control block (IX), computes the buffer offset for the requested logical record, and flags the buffer as holding a record to write. IX offsets: +01 access/status flags (bit5 = buffer holds a record, bit6 = write pending, bit7 = open), +05 current byte offset in the buffer, +09 logical record length, +0A/0B next record number.

4835H - Rewind File (@REW)

The @REW worker (vector 443FH). Repositions the file to its first record.

483CH - Position To End Of File (@PEOF)

The @PEOF worker (vector 4448H). Positions the file to its last record so the next write appends.

484DH - Byte Position To Record Converter

Converts a byte position into a record number and remaining offset by dividing by the logical record length, using the divide routine at 4BA9H. Reached from the random-access vectors and from the write positioner.

4878H - File-Length From End Record

Random-access setup (vector 445DH). Loads the end record number and end-of-file byte offset, then reuses the converter above to compute the file's byte length.

4886H - Flush End-Of-File To Directory Entry

The worker the 444EH vector reaches. Despite the Model III equate naming that vector @MULT, its target is not a multiply: it reads this file's directory entry, writes the current end-of-file offset and end record number into it, and writes the entry back. This keeps the on-disk directory in step with the file's size.

48ADH - Read Logical Record (@READ)

The @READ worker (vector 4436H). Copies one logical record from the file into the caller's buffer, one byte at a time. On entry Register Pair HL points at the caller's buffer.

48CBH - Write Logical Record (@WRITE) and Verify (@VER)

The @WRITE worker (vector 4439H) and the @VER worker (vector 443CH), which share the same loop. The verify flag at 49CFH selects a plain write or a write-and-verify. On entry Register Pair HL points at the caller's buffer.

48E6H - Write With Verify Entry (@VER)

The @VER worker (vector 443CH). Identical to the write path but sets the verify flag so each written sector is read back and checked.

48ECH - File Byte I/O (Device-Driver Entry)

Reached from the device-driver linkage when a file is used as a byte device. Register B selects the operation (a get for values below 2, a put otherwise). This entry fetches the next byte from the file's buffer, refilling the buffer from disk when the current sector is exhausted. On entry Register Pair IX points at the FCB.

4914H - Mark Buffer Holds Record

Sets the FCB flag that records the buffer now holds the current sector.

4919H - Put Byte To File

Stores one byte into the file's buffer, flushing the buffer to disk when it fills and extending the recorded end of file. On entry Register A holds the byte and Register Pair IX the FCB.

494FH - Flush And Load Sector For Position

Ensures the buffer holds the sector for the current record position, writing a modified buffer back first, then reading the required sector. Register A access-level bits in the FCB decide whether writing is allowed.

497EH - Get Next Record Number / Current Byte Address / Access Check

Three short FCB helpers: fetch the next record number, compute the current byte address in the buffer, and test the open/write access flags.

499EH - Flush Modified Buffer To Disk

Writes a modified file buffer back to its sector (with optional verify), updates the position, and, when the file grew, flushes the new size to the directory. Entered directly (vector at 4457H) or from the helpers above.

49F1H - File Operation Prologue (FCB Setup)

The common prologue every file operation calls. It has two overlapping entry points: entry at 49F1H forces the "already open" state, while entry at 49F3H first checks the FCB's open flag. Both save the caller's registers, make Register Pair IX the working FCB, and arrange for a register-restoring return, so the operation body runs with IX pointing at the file control block. On entry Register Pair DE points at the FCB.

4A1AH - End-Of-File Check

The worker the 444BH vector reaches, also called throughout the file engine. It reports whether the current record position has reached the file's end by comparing the next record number and byte offset against the recorded end record number and end-of-file offset. Despite the Model III equate naming its vector @FEXT, its function here is the end-of-file test.

4A41H - Translate File Record To Physical Track And Sector

Converts the file's current record position into the physical track and sector that hold it. The record number is divided by the sectors-per-granule to get a granule index, the file's extent table (starting at FCB offset 0EH) is walked to find which allocated run contains that granule, and the drive geometry is applied to produce the track (Register D) and sector (Register E). When the position is past the last allocated granule, a new granule is requested through the allocate supervisor call. Several instruction operands here are patched at run time.

4B10H - Read Directory Sector (DIRRD)

Reads the directory sector that contains a given entry into the directory buffer and points Register Pair HL at the entry. On entry Register Pair BC holds the directory-entry locator.

4B1FH - Write Directory Sector (DIRWR)

Writes the directory buffer back to disk with verification and maps the controller result to a DOS error code.

4B37H - Compute Directory Buffer Address

Translates a directory-entry number into its address within the directory buffer on page 42H and the sector that holds it.

4B45H - Read Sector Into Directory Buffer (RDSSEC)

Reads the directory track and sector into the directory buffer.

4B65H - Get Directory Track From Drive Block

Fetches the directory track number from the active drive's control block.

4B6CH - Eight-Bit Multiply (MULTEA)

Multiplies Register E by Register A, returning the low byte of the product in Register A. A shift-and-add loop over eight bits.

4B7BH - Eight-Bit Divide (DIVEA)

Divides Register E by Register A, returning the quotient in Register E and the remainder in Register A. A shift-and-subtract loop over eight bits.

4B8FH - Sixteen-Bit Multiply

Multiplies Register Pair DE by Register C, returning the 24-bit product in Register A (high) and Register Pair HL (low sixteen bits). Used to convert a record number times the record length into a byte or sector position.

4BA9H - Sixteen-Bit Divide

Divides Register Pair HL by Register A, returning the quotient in Register Pair HL and the remainder in Register A. A sixteen-step shift-and-subtract loop. Used to convert a byte position into a record number and offset.

4BBCH - Empty

4BCBH - Execute Drive Operation

Transfers control to the active drive's control block, whose leading instruction jumps into the floppy driver. Reached from the disk-primitive tail after Register Pair IY has been set to that block.

4BCDH - RST 28H Supervisor Dispatcher (Overlay Call)

Entered from the RST 28H vector at 400CH with a request code in Register A. A code with its high bit set selects a system overlay: the dispatcher disarms the DEBUG trap, loads the overlay for the code, calls it, then restores the trap. A code with the high bit clear is treated as a no-op return. The call to the loaded overlay is a self-modified CALL whose target is patched by the loader.

4BEFH - Positive-Code Return Path

Handles request codes with the high bit clear. Code 1 simply returns; any other positive code is treated as an error.

4BF5H - Load System Overlay

Ensures the SYS overlay that services the request code is resident at 4E00H. If the requested overlay is already loaded it is reused; otherwise its directory entry is found, its parameters built, and it is read from disk. On return the entry address is planted into the dispatcher's call. On entry Register H (from Register A) holds the request code.

4C4BH - System Error Exit

Displays the fatal system-error message and aborts to DOS. The message string follows.

4C5EH - Run Program (@RUN)

The @RUN worker (vector 4433H). Loads a program file and transfers control to it, honouring the debug and no-execute flags.

4C77H - Load Program (@LOAD)

The @LOAD worker (vector 4430H). Opens the program file and reads its load module into memory, returning the transfer address.

4C8DH - Module Loader Setup

Prepares to parse a load module by pointing the byte-stream pointer at the file buffer and passing the parameter block in Register Pair IX.

4C9DH - Load-Module Record Parser

Reads the module one record at a time and acts on the record-type byte: a data record is copied to its load address and verified, a transfer-address record ends the load, and other record types are handled or skipped. This is the LDOS load-module format reader.

4D1CH - Module Byte And Word Fetch

Reads the next byte of the load module from the sector buffer, refilling the buffer from disk when it is exhausted, and a helper that reads two bytes as a little-endian word.

4D3AH - Clock-Display Task Block

A task handler block installed in the Task Control Block table for the on-screen clock. Its first word is the handler entry; the handler runs once every five ticks to refresh the time on screen.

4D45H - Display Time

Formats the software clock's hours, minutes, and seconds as HH:MM:SS and writes them to the screen. The clock task enters at 4D45H with the fixed screen position; the vector at 446DH enters at 4D48H with the caller's screen position in Register Pair HL. The time counters are read downward from 4043H (hours), 4042H (minutes), 4041H (seconds).

4D63H - Display Date

Displays the date as three slash-separated fields, reusing the field formatter above. The vector at 4470H reaches this with the caller's screen position in Register Pair HL. The date counters are read downward from 4046H.

4D6CH - Display 16-Bit Value As Hex

Takes a two-byte value from the stack frame and writes it as four hexadecimal digits to the screen, using the classic DAA-based binary-to-hex conversion.

4D8FH - File Position Helpers

Adjust the record number in Register Pair HL by the buffer state, so callers get the effective current position. Used by the end-of-file check and the byte-position converter.

4DA6H - Per-Tick Keyboard And BREAK Scan

Called by the interrupt service routine on every tick. It reads the memory-mapped keyboard rows for the SHIFT, ENTER/CLEAR, and BREAK keys and records their state in the key-status flag byte at 4423H, returning to the interrupt whether a BREAK diversion should occur.

4DF0H - End Of Resident Image (USTOR$)

Padding to the end of the resident image, followed by the USTOR$ word that points into the user/system storage area.

4E00H - System Boot Initialization

The transient start-up code and the module's execution entry point. It sets interrupt mode 1 and the stack, sizes installed RAM, records the device-driver vectors, initialises the drive configuration table, enables interrupts, and reads the configuration sector. After it hands off, this 4E00H area is reused as the load address for system overlays.

4E63H - Apply Drive Config, Enable Interrupts, Read Config Sector

Merges the boot-supplied drive flags into drive 0's DCT block, sets the interrupt-enable mask and turns interrupts on, then reads the configuration sector into the file buffer. This region uses an overlapping-code trick: the no-config path (the jump from 4E54H to 4E66H) and the config path (falling in at 4E63H) reach the shared code at 4E68H having set Register L differently.

4E90H - Read Configuration And Select Date/Time Path

Reads the configuration byte, and from the stored date/time configuration decides whether to prompt the operator for the date, prompt for the time, or skip straight to finishing the boot.

4EA9H - Prompt For And Parse Date

Displays the "Date ? " prompt, reads the operator's entry, and validates and stores the month, day, and year. Re-prompts on invalid input.

4EF4H - Compute Date Fields And Day Of Week

Builds the working month, day, and year counters and computes the day of the week by accumulating a day number and dividing by seven.

4F50H - Display Date And Time

Positions the cursor and displays the day-of-week name, the date, and the time using the display helpers.

4F89H - Prompt For And Parse Time

Displays the "Time ? " prompt, reads and validates the hours, minutes, and seconds, and copies them into the software clock counters.

4FBDH - Install Clock Task And Load Drive Configuration

Installs the software real-time-clock task into the task table, copies the configuration for drives 1 to 3 into their DCT blocks, and reads the directory.

4FE3H - Boot Finalization

Applies directory-derived options, paints the sign-on line, patches the dispatcher for the operating mode, checks for a boot-time DEBUG key, copies vector tables into place, and hands off to load the start-up command.

505AH - Boot-Relocated Interrupt-Vector Installer

Copied to 405DH at boot and run there. It applies the operating-mode flags, optionally programs an output port, block-copies the presets carried in the alternate registers, installs the RST 38H interrupt vector, sets the cursor, and returns to start the system.

5084H - Display Three-Character Label

Displays a three-character field from a table, indexed by Register B, via the ROM character-output routine. Used with the separator helper below to show a labelled value such as the day name.

5094H - Display Separator

Writes a comma and a space to the screen, and a shorter entry that writes just a space.

509EH - Display Two-Digit Decimal

Displays the value in Register A as up to two decimal digits, suppressing a leading zero when Register D is zero. Uses the ROM character-output routine.

50B6H - Date And Time Prompt Strings

The two prompt strings used by the boot date/time entry. Each begins with the 1EH control code, holds the label and a question mark, and ends with the 03H string terminator.

50C8H - End Fill

Zero fill from 50C8H to the end of the file image at 50FFH.