TRS-80 DOS - PerCom MicroDOS Version 2.20 for the Model I - Resident OS Disassembled

Resident OS Image (4400H-55FFH)

Other Navigation

PerCom MicroDOS 2.20 Resident OS Disassembly (Model I)

The PerCom MicroDOS resident operating system is the 4,608-byte image that the boot sector loads from the chain T0/S1 -> T0/S9 -> T1/S0 -> T1/S9 into RAM starting at 4400H. After the final sector is read, the boot sector at 42BAH executes a JP NZ,4400H, and the three bytes at 4400H (C3 27 47 = JP 4727H) hand control to the resident's initialization routine.

MicroDOS sits between Level II BASIC and the user. It does not replace BASIC; it intercepts BASIC. The initialization routine at 4727H performs five jobs in sequence: (1) it copies 39 bytes of the BASIC ROM error-message table from 18F7H to 4080H (creating an editable copy that MicroDOS can extend with its own error messages); (2) it sets up a comma-separator parsing template at 41E5H; (3) it copies the 147-byte JP-table at 4694H down to 4152H, where the empty entries land on top of the Level II BASIC RST 28H hook addresses (400CH, 4015H) and convert them into MicroDOS DOS-call entries; (4) it initializes the string-storage and byte-storage pointers at 5A00H and 5A64H respectively; and (5) it relocates the stack to 41F8H, prints the PerCom MicroDOS banner via the Level II BASIC ROM 28A7H string-output routine, hooks the keyboard input vector at 4016H to 478FH, and finally jumps to 00B5H to enter Level II BASIC.

From that point on, every keypress comes through 4016H to MicroDOS' keyboard-driver hook at 478FH, which feeds either a stored AUTO-LOAD command sequence (initially "LOAD 30,R" from 44A5H) or a normal keyboard scan into BASIC. Every disk-related BASIC keyword (CMD, CALL, GET, PUT, GETVAL, AND, etc.) is dispatched through the relocated jump table at 4152H, which arranges the entries so that BASIC's reserved-word table indices land on either MicroDOS's own handlers (CMD, F, I, H, K, M, etc.) or on the original Level II BASIC handlers via JP 0043H (a stub that returns "FC Error" for unsupported keywords).

The disk I/O subsystem at 4BCDH (read sector) and 4C44H (verify sector) drives the WD1771 FDC at 37ECH-37EFH using the same alternate-register trick as the boot sector: BC' holds 4300H (the sector buffer), DE' holds 37ECH (FDC command/status), and HL' holds 37EFH (FDC data). The FDC routines re-execute EXX whenever they need to access the FDC, and again to switch back. The sector address is held in 448DH-448EH (a 16-bit logical sector number), and the drive is selected from a one-hot mask at 448CH (01H, 02H, 04H, or 08H).

The custom error message table starting at 52F1H extends the Level II BASIC error list with twelve MicroDOS-specific errors: BAD FILE DATA, FEATURE NOT IMPLEMENTED, INVALID DRIVE NUMBER, INVALID SECTOR NUMBER, DISK READ/WRITE ERROR, DISK WRITE PROTECTED, DISK OVERFLOW, DISK MISSING OR DOOR OPEN, FIELD OVERFLOW, FUNCTION DEFINITION ERROR, INVALID FIELD BUFFER NUMBER, DISK DRIVE NOT AVAILABLE, DISK SEEK ERROR, and CAN'T FORMAT DISK. These messages are reached via JP 19A2H with the error code in Register E.

The 4,608-byte image is laid out as four functional regions. The first region (4400H-4593H) is mostly data: the JP entry at 4400H, the MICRODOS startup banner at 4401H, an internal symbol table at 4459H listing five Level II BASIC variable addresses (CRLNUM, PRGEND, ARREND, ACCUM, and a fifth at 4506H), the AUTO-LOAD command string at 44A5H, three small data tables at 4490H-44A4H used by the FCB system, and the PerCom copyright banner at 4527H. The second region (4594H-4670H) is an embedded copy of the boot sector code, present so that a SYSTEM call or external reload can invoke the loader without re-reading T0/S0. The third region (4671H-46FFH) contains the boot-sector-style data block (TRACK, SECTOR, DISK ERROR, NO MICRODOS, $STEPL) followed by the 147-byte dispatch table that gets relocated to 4152H. The fourth region (4727H-55FFH) is the actual MicroDOS code: the entry routine, the keyboard hook, the BASIC token interceptor, the file directory walker, the disk I/O subsystem, the FCB management routines, and the BASIC error message table extension.

From the user's perspective, MicroDOS appears as an extended BASIC. After the banner prints, the system displays the standard "MEMORY SIZE?" prompt (because 00B5H is the Level II BASIC cold-start entry that ran after MEMORY SIZE prompts), then the BASIC READY prompt. Typing a BASIC command works as it did under cassette Level II BASIC. Typing CMD"D" or CALL DIR (or whichever keyword Stutsman implemented for directory listing) routes through the dispatch table at 4152H and produces a MicroDOS-specific behavior. Disk file operations use MicroDOS's own FCB at 448CH-449FH and its own sector-chain file format (the same chained-sector mechanism used by the boot sector to load the OS itself).

The resident occupies the entire RAM region 4400H-55FFH. After initialization, MicroDOS additionally uses 4080H-40A6H (relocated BASIC error table), 4152H-41E4H (relocated DOS supervisor / dispatch jump table), 41E5H-41E7H (comma-separator template), 41F8H (stack), 5A00H+ (string storage), and 5A64H+ (byte storage).

Address Range	Label / Contents
4400H-4402H (3 bytes)	ENTRY JP 4727H. The first three bytes of the resident image, executed by the boot sector's final JP NZ,4400H. Hands control to the initialization routine.
4403H-4458H (86 bytes)	BANNER1 The startup banner string, decoded as bytes: "MICRODOSA SIMPLE, POWERFUL DOS\rWRITTEN BY JAMES W. STUTSMAN\rFOR PERCOM DATA COMPANY\r\r\0". The leading byte at 4403H is M (4DH), used by the FCB system as a default signature byte. The string is never displayed; it is a build-time signature embedded by Stutsman to identify the OS image.
4459H-4505H (173 bytes)	SYMTAB Built-in symbol table holding five label/address pairs in source-listing format: "CRLNUM EQU 40ECH ;CURRENT LINE NUMBER", "&PRGEND EQU 40FBH ;END OF SIMPLE VARIABLES", "ARREND EQU 40FDH ;END OF ARRAYS", "ACCUM EQU 4121H ;NUMBER ACCUMULATOR", and a fifth entry "NUMBER ACCUMULATOR" at 4506H. Used by the SYM/CALL command (4E55H dispatch entry) to convert symbolic names to addresses.
4488H-448BH (4 bytes)	FCBHDR FCB header bytes 01 00 01 FF. Marks an unallocated FCB slot.
448CH (1 byte)	DRVSEL Drive select mask (one-hot). 01H=Drive 0, 02H=Drive 1, 04H=Drive 2, 08H=Drive 3. Written to 37E1H (drive select latch) by the FDC routines. Initialized to 01H (Drive 0) by 4780H.
448DH-448EH (2 bytes)	SECTOR Current logical sector number (16-bit). Hi byte at 448DH = track number, lo byte at 448EH = sector number within track. Used by the FDC routines at 4D44H to seek the head and select the sector.
448FH (1 byte)	BUFOFF Buffer offset / chain-marker storage. Holds the chain-marker byte read from the first byte of each sector during a sector-chain walk. FFH means continuation, any other value N means end-of-chain with N data bytes.
4490H-4491H (2 bytes)	BUFPTR Pointer into the 256-byte sector buffer at 4300H. Points to the next byte to read from the chain. Initialized to 4301H (skipping the chain-marker byte at offset 0) by 4929H.
4492H-4493H (2 bytes)	RECNO Record number / record byte count. Used by the file allocation and disk-space-checking routines at 4B20H and 4CA1H.
4494H (1 byte)	FDCFLG FDC flags / step-rate. Bits 0-1 hold the WD1771 stepping rate (00=3ms, 01=6ms, 10=10ms, 11=15ms). Bit 7 may be a write-protect flag.
4495H (1 byte)	FDCSTAT Saved FDC status from the last command. Written by 48F7H (Type I error save) and 4BEEH (Type II error save). Read by 490FH to test for write-protect on disk command failure.
4496H (1 byte)	FDCCKSUM Running checksum / accumulator used by FORMAT operations to verify a track's data after writing.
4497H-449AH (4 bytes)	STEPRATE Step-rate selection table. Four bytes selecting the FDC step-rate command for each of the four drives.
449BH-44A4H (10 bytes)	FORMTBL Format-track parameter table. 10 bytes used by the FORMAT routine at 4CA1H to lay down sector ID fields.
44A5H-44ADH (9 bytes)	AUTOCMD The default AUTO-LOAD command string "LOAD 30,R" terminated by a 0DH carriage return. The keyboard input hook at 478FH feeds this string to BASIC one byte at a time on first boot, causing MicroDOS to automatically execute LOAD 30,R after the BASIC READY prompt appears. Once exhausted, the hook switches to live keyboard input.
44AEH-4525H (120 bytes)	SYMTAB2 More entries in the built-in symbol table: "EQU 40FBH ;END OF SIMPLE VARIABLES", "ARREND EQU 40FDH ;END OF ARRAYS", "ACCUM EQU 4121H ;NUMBER ACCUMULATOR", with NEG-encoded source-listing characters interspersed.
4527H-457FH (89 bytes)	BANNER2 The PerCom MicroDOS user banner: "[D]PERCOM MICRODOS VERSION 2.20\rCOPYRIGHT (C) 1979 PERCOM DATA COMPANY\rALL RIGHTS RESERVED\r\0". The leading 'D' at 4527H is a stray byte used by the symbol-table tail; the actual displayed string starts at 4528H. Output by 4761H-4766H via Level II BASIC ROM 28A7H.
4581H-4593H (19 bytes)	LSUMSG The string "LAST SECTOR USED =" terminated by 00H. Used by the format/disk-space routines to display the last allocated sector number.
4594H-4670H (221 bytes)	BOOTCOPY An exact copy of the boot sector code from 4200H-42DCH, embedded in the resident image. Provides a re-entry point for SYSTEM calls or external relocators to re-load the OS without reading T0/S0. The code is identical to the boot sector but executes from 4594H instead of 4200H, so the internal references (e.g., LD HL,42F1H at 45A9H) still point at the original boot sector data area at 42xxH; this means BOOTCOPY only works correctly if the original boot sector is still resident at 4200H, which is the normal case.
4671H (1 byte)	PADBYTE One pad byte (00H) separating the boot copy from the data block.
4672H-4674H (3 bytes)	DEFM_HEAD The bytes 01 17 E8, encoding LD BC,0E817H but used as the lead-in for the DISK ERROR string (17H E8H = HOME and a graphics marker). Same as the boot sector's 42DDH-42DFH region.
4675H-467FH (11 bytes)	DISKERR2 The string "DISK ERROR" terminated by 00H. A second copy of the boot sector's DISK ERROR string. Used by the embedded boot copy at 4636H (which jumps to 4671H, not 42DEH).
4680H-468DH (14 bytes)	NOMDOS2 The string "NO MICRODOS" preceded by 17H E8H and terminated by 00H. Same content as the boot sector's NO MICRODOS message.
468EH-4693H (6 bytes)	STEPL The six bytes "$STEPL" - a residual symbol-table label from the source listing, never read at runtime. Companion to the boot sector's "$STEPH".
4694H-4726H (147 bytes)	JTABLE The 49-entry JP-table relocated to 4152H by the init routine at 4741H-474BH. Each entry is 3 bytes (C3 lo hi). After relocation, the table at 4152H provides the BASIC token dispatch for MicroDOS keywords. Many entries are JP 0043H (the Level II BASIC ROM VDPRT video output trampoline at 0043H, used as a filler for unsupported keywords) and JP 012DH (the Level II BASIC ROM NAVERR routine that displays L3 error 2CH).
4727H-478CH (102 bytes)	INIT The MicroDOS initialization routine. Sets up RAM, hooks the keyboard, prints the banner, and JPs to BASIC.
478FH-47A2H (20 bytes)	KBDHOOK Keyboard input hook. While the auto-command string at 44A5H still has bytes left, returns one byte at a time from the AUTOCMD pointer. When exhausted, re-points the keyboard hook to 47A3H (live keyboard scanner) and falls through.
47A3H-47C8H (38 bytes)	KBDSCAN Live keyboard scanner. Walks the keyboard memory at 3801H, 3802H, 3804H, 3808H, 3810H, 3820H, 3840H, 3880H, computes the row offset, and falls through to the Level II BASIC ROM key-decode routine at 03FBH.
47C9H-485FH (151 bytes)	BASTOK BASIC token dispatcher. Interprets the byte after a CMD/CALL token as a single-letter command (F, I, H, K, M, etc.) and dispatches to the appropriate MicroDOS routine. Implements F (FETCH), I (INPUT), H (HEX), K (KILL), and M (MERGE) - the AUTO-LOAD-related operations.
4870H-4905H (150 bytes)	FILEIO Sector-chain file load routine. Walks the chained-sector format used by MicroDOS files: each sector starts with a length-or-continuation byte (FFH = continue, else N = final with N data bytes), and the file ends when a non-FFH marker is found.
491BH-499DH (131 bytes)	RAMOPS RAM management: copy regions, allocate file space, walk through memory looking for free zones.
49AEH-4A47H (154 bytes)	FCBOPS FCB allocation, file directory walk, and CMD-line parsing for OPEN/CREATE/READ.
4A4AH-4ABFH (118 bytes)	DIRWALK File directory walker. Reads the chained directory record format and decodes filenames.
4AAEH-4AFAH (77 bytes)	OPENRD Open file for read - locates the file in the directory and prepares the FCB.
4AFBH-4B58H (94 bytes)	NUMPARSE Numeric argument parser. Handles drive-number and record-number arguments to disk commands.
4B59H-4BCCH (116 bytes)	FILESPEC Filespec parser. Accepts either a quoted string ("FILENAME") or a BASIC string variable, and resolves it to a buffer pointer.
4BCDH-4C90H (196 bytes)	SECREAD FDC sector read routine. Issues WD1771 Read Sector (88H), polls for DRQ, and transfers bytes into the buffer.
4C91H-4D43H (179 bytes)	FORMAT Disk format routine. Lays down sector IDs and writes data fields for an entire track.
4D44H-4DE2H (159 bytes)	FDCSEEK FDC seek and drive-select routine. Selects the drive, sets the step-rate, seeks the head to the target track, sets the sector register, and prepares for a read or write command.
4DE3H-4E18H (54 bytes)	FDCCMD FDC command issue routine. Same general structure as the boot sector's 42B9H, but with hooks for write commands and error reporting.
4E19H-4E5DH (69 bytes)	ERREXIT Error exit jump table. 16 single-byte error codes loaded into Register E and JPed to 19A2H (the Level II BASIC ROM error handler) to display the corresponding MicroDOS error message from the table at 52F1H.
4E66H-4F11H (172 bytes)	STRMOV String move and assignment. Used by LET-style statements involving disk strings.
4F12H-4FB6H (165 bytes)	BASIC BASIC keyword handlers: WRITE, READ, FIELD, CLOSE - the disk-file-related BASIC statements.
4FB7H-505FH (169 bytes)	NUMIO Numeric I/O: convert numbers to/from disk files, handle field formats.
5060H-52F0H (657 bytes)	UTILS Utility routines: string compare, copy, length, hex digit decode, and miscellaneous BASIC support.
52F1H-5577H (647 bytes)	ERRMSG BASIC error message table. Re-implements the Level II BASIC ROM messages at 18C9H and adds 13 MicroDOS-specific messages. Each message is a NUL-terminated ASCII string, located by index from Register E via JP 19A2H.
5578H-558DH (22 bytes)	ERRJMP Error code jump indirection table. 11 entries of LD E,4AH style instructions, each providing a unique error code via Register E.
558EH-55B3H (38 bytes)	MISCRT Miscellaneous tail routines: string termination, string-to-string move, and an alternative entry to 4977H.
55B4H-55FFH (76 bytes)	CMDTBL The CMD/CALL token name table. NUL-terminated ASCII command names ("AND PROCESSING", "GETVAL", "GETARGUME...") used by the symbol-table parser. The final 0DH-and-NUL-terminated string at 55ECH is "GET ARGUME" (truncated by the end of the image at 55FFH).

MicroDOS uses both internal storage within its image (in the FCB area at 448CH-449FH) and external low-RAM workspace (4080H-40A7H, populated by the init routine). The list below is keyed by address. All entries marked Self-Modifying Code show their initial values from the source disassembly and the runtime values they take after initialization.

Address	Description
4080H-40A6H (39 Bytes)	Relocated BASIC Error Table A copy of the Level II BASIC ROM error message table at 18F7H, written here at 472DH-4731H. MicroDOS extends this in-RAM copy with disk-specific error messages, which is why the error handler at 19A2H sees both ROM and MicroDOS messages.
40A0H (2 Bytes)	Byte Storage Pointer Set to 5A64H by the init routine at 474CH-474EH. Marks the start of MicroDOS's byte-storage area for compiled BASIC variables.
40A4H (2 Bytes)	String Storage Pointer Set to 5A01H by the init routine at 4752H-4759H (loads HL=5A00H, writes 00H, increments HL, stores HL). Marks the start of the string storage area.
40A7H (2 Bytes)	Comma Separator Template Pointer Set to 41E8H by the init routine at 473EH. Points just past the three-byte separator template stored at 41E5H-41E7H, which holds 3AH ":" 00H NUL 2CH ",".
4016H (2 Bytes)	Self-Modifying Code The Level II BASIC ROM keyboard input vector. Init routine at 4767H-476CH writes 478FH here, hooking MicroDOS into BASIC's keyboard input. Once the AUTO-LOAD string is exhausted, 47A0H rewrites this to 47A3H (live keyboard scan).
4152H-41E4H (147 Bytes)	Relocated Dispatch Table A copy of the JP-table at 4694H, written here at 4747H-474BH. After relocation, this table provides the RST 28H-style DOS-call dispatch for every BASIC keyword that MicroDOS overrides.
41E5H-41E7H (3 Bytes)	Comma Separator Template Holds the bytes 3A 00 2C (":" NUL ","), written by the init routine at 4732H-473DH. Used by the argument parser at 4B59H to recognize statement separators in BASIC commands.
41F8H (Stack)	Stack Top Set by the init routine at 475BH (LD SP,41F8H). Stack grows downward into the unused RAM at 41F7H and below. Note this is 4 bytes lower than the boot sector's 41FCH, freeing 4 bytes for an additional level of nested CALL.
4495H (1 Bytes)	Self-Modifying Code FDC saved status. Written by 48F7H whenever a Type-I FDC operation completes (saves the status register before issuing FORCE INTERRUPT D0H), and by 4BEEH whenever a Type-II operation completes. Read by 490FH to test bit 7 (write protect / not ready) when reporting an error.
4496H (1 Bytes)	Self-Modifying Code FORMAT routine running checksum. Written by 487CH (cleared at start of FORMAT), updated by 489CH-48B2H during the format-and-verify pass.
4497H-449AH (4 Bytes)	Self-Modifying Code FORMAT/SEEK step-rate selector. Written by 4775H-4778H during init (LD HL,FFFFH stored to both 4497H and 4499H sets bytes 4497H-449AH all to FFH). Used as a per-drive step-rate selector at 4D44H-4D54H (right-rotated and tested for carry to find the matching drive bit).
448CH (1 Bytes)	Self-Modifying Code Drive-select mask. Init routine at 4780H-4783H writes 01H (drive 0). Modified by drive-selection commands and by the FCB allocation routines.
448DH (1 Bytes)	Self-Modifying Code Track number for next FDC operation. Cleared to 00H by 4926H. Written to 37EFH (FDC data register) by FDCSEEK at 4D6EH-4D6FH.
448EH (1 Bytes)	Self-Modifying Code Sector number for next FDC operation. Initialized to 01H by 4933H (the file-load context init). Written to 37EEH (FDC sector register) by FDCSEEK at 4D77H-4D7AH.
448FH (1 Bytes)	Self-Modifying Code Chain marker / buffer offset. Written by the file load routine at 491DH-4923H whenever a new sector is read (captures the marker byte). Read by 4A6CH-4A70H to drive the chain-walker decisions.
4490H-4491H (2 Bytes)	Self-Modifying Code Buffer pointer (16-bit). Written to (4490H) by 4923H to hold the address of the next byte to read from the buffer. Used in EX DE,HL operations at 4490H-4491H to advance through the buffer.
4492H-4493H (2 Bytes)	Self-Modifying Code Record number / record byte count. Written by 4B20H during file allocation; read by 4CA1H during FORMAT to determine the number of bytes per sector. Used as a 16-bit value at NUMPARSE.
4494H (1 Bytes)	Self-Modifying Code FDC flags. Bit 0 set when a file is being written; bit 6 (tested at 4BFFH and 4C9AH) indicates write-protect on the current drive.
5A00H (1 Bytes)	String storage initial sentinel. Set to 00H by 4755H. Marks the start of the heap that MicroDOS uses for BASIC string variables.
5A01H+ (variable Bytes)	Active string storage. Each entry is a length-prefixed string. The pointer at 40A4H tracks the next free byte.
5A64H+ (variable Bytes)	Byte storage / variable area. Each entry is a 4-byte BASIC variable record (header byte + 3 bytes of value). The pointer at 40A0H tracks the next free record.

Address	Function / Entry-Exit
4727H	Initialization Entry Point (INIT) The first executable code in the resident image. Copies the BASIC error table to 4080H, writes the comma-separator template at 41E5H, copies the dispatch table to 4152H, sets up the string and byte storage pointers at 5A00H/5A64H, relocates the stack to 41F8H, displays the banner via 28A7H, hooks the keyboard at 4016H, and JPs to 00B5H to enter Level II BASIC.
478FH	Keyboard Input Hook (KBDHOOK) Replacement for the BASIC ROM keyboard read at 0049H. Reads from the AUTO-LOAD command string at 44A5H one byte at a time. Returns the byte in Register A. When the string is exhausted (NUL byte read), rewrites the keyboard hook at 4016H to point at 47A3H (the live keyboard scanner) and falls through.
47A3H	Live Keyboard Scanner (KBDSCAN) Scans the keyboard memory rows at 3801H, 3802H, 3804H, 3808H, 3810H, 3820H, 3840H, 3880H. For each row, computes the bit-mask of pressed keys and transitions to the Level II BASIC ROM key-decode routine at 03FBH. Returns Z if no keys are pressed.
47C9H	BASIC Token Dispatcher (BASTOK) Called via the relocated dispatch table for CMD/CALL with a string argument. Reads the first character of the argument, compares against F (4FETCH), I (4INPUT), H (4HEX), K (4KILL), and M (4MERGE), and JPs to the matching handler. Default exit is JP 1E4AH (Illegal Function Call).
4870H	Sector Chain Loader (FILEIO) Reads a sector-chain file. Initializes the FCB header at 4488H-448FH, calls FDCSEEK at 4D44H to position the head, reads the first sector via SECREAD at 4BCDH, and walks the chain marker by marker. Each sector is read into the buffer at 4300H, the marker byte is captured at 448FH, and the data is appended to the destination buffer.
491BH	SYSTEM Re-Init Helper (RAMOPS) Reads a single byte from 4594H (the embedded boot copy entry point), saves it to 448FH, sets up the buffer pointer to 4595H, and calls 4BF6H to write the byte. Used by the SYSTEM-call re-initialization path.
4941H	OPEN File Handler (FCBOPS entry) Routes from the dispatch table at 4152H entry for the OPEN keyword. Calls 4AFBH to extract the filespec (a quoted string or string variable), then performs directory lookup and FCB initialization.
49AEH	OPEN-Existing-File Handler Specifically for the variant that opens an existing file (versus CREATE-new). Reads the FCB number from the BASIC argument list, looks up the file, and prepares the FCB for sequential read.
49F6H	CREATE File Handler Creates a new file in the directory. Sets up an empty FCB, allocates a starting sector via 4977H, writes the directory entry, and prepares the FCB for sequential write.
4AAEH	READ Sector Handler Routes from the GET keyword. Reads a numeric record number, calls FDCSEEK at 4D44H, calls SECREAD at 4BCDH. On success, copies the sector buffer to the BASIC string variable.
4AE4H	WRITE Sector Handler Routes from the PUT keyword. Reads a numeric record number, copies the BASIC string buffer into the 256-byte sector buffer, calls FDCSEEK and the FDC Write command.
4AFBH	Filespec Parser (FILESPEC entry) Calls Level II BASIC ROM 2337H to fetch a parameter, then calls 2819H (typeflag check) and FILESPEC at 4B10H. Returns with HL pointing at the resolved filename buffer.
4B10H	Drive-Number Argument Parser Subtracts 2710H (10000 decimal) from HL repeatedly, counting iterations to extract the drive digit. Result in Register A. Falls through to record-number parser at 4B49H.
4B49H	Record Number Validator Validates that Register E is less than 04H (max drive number 3). If valid, computes the drive-select mask via the (1 << drive) pattern (set A=80H, RLCA repeated drive+1 times) and stores it at 448CH.
4B59H	Filespec Resolver Accepts a quoted string ("#" prefix means a file-buffer reference) or a BASIC string variable. Calls 260DH (VARPTR) and 0AF4H (which at this offset is part of MOVEA / MOVEB) to resolve the variable.
4BCDH	Read Sector via FDC (SECREAD) Issues WD1771 Read Sector command (88H), polls for DRQ, transfers 256 bytes from 37EFH (FDC data register) into the buffer at BC' (4300H). On success, sets BC=4300H and returns; on error (status & 9CH), saves status at 4495H and returns with FDC at FORCE INTERRUPT.
4C44H	Verify Sector (Compare-after-Write) Reads sector and compares against buffer. Returns NC if all bytes match (verify success), C if mismatch.
4C6DH	Read Sector for Compare Issues Read Sector but discards the data, only checking for clean read status. Used by Verify to ensure the sector exists before doing a compare.
4C91H	FORMAT Track (FORMAT) Writes a complete track including sector ID fields and data fields. Used by the FORMAT command. Writes 1771 Format Track command (F4H), then streams the track image with all sector IDs.
4D44H	FDC Seek and Drive-Select (FDCSEEK) Reads the drive-select mask from 448CH, finds which drive is selected (RRA-and-test-carry pattern), retrieves the per-drive step-rate, sets the FDC track and sector registers, and issues the WD1771 Seek command. Equivalent in function to the boot sector's 4275H, but supports four drives and per-drive step rates.
4D89H	Restore-then-Seek (Track 0 Calibration) If a Seek fails, calls Restore (00H) to return the head to Track 0, then re-issues the Seek. Used to recover from misaligned heads.
4DACH	FDC Restore Command Issues WD1771 Restore (00H or 03H based on step-rate). Returns Z if Track 0 reached, NZ if seek error.
4DE3H	Send FDC Command (FDCCMD) Equivalent to the boot sector's 42B9H. Saves the command on the stack, waits for the FDC not-busy, restores the command, writes it via DE' (37ECH), and polls for completion. Re-asserts drive select at 37E1H during the polling loop.
4E19H-4E5DH	Error Code Jump Table (ERREXIT) 16 LD E,nn / JP 19A2H pairs, each providing a unique error code (4AH=BAD FILE DATA, 4EH=FEATURE NOT IMPLEMENTED, etc.). Called from the FDC error paths and the BASIC keyword handlers when an unsupported operation is requested.
4E66H	String Move and Pad (STRMOV) Copies a length-prefixed string from a BASIC string variable into a destination buffer. Pads with spaces if the destination is longer than the source.
4F12H, 4F16H, 4F1AH	WRITE Statement Handlers Three entry points for the BASIC WRITE statement variants: PRINT#, PRINT#USING, PUT. Each loads a different command-code-byte into Register A and then jumps to 4F1CH (the common write dispatcher).
4F2DH, 4F31H, 4F35H	READ Statement Handlers Three entry points for the BASIC READ statement variants: GET, INPUT#, FIELD. Same pattern as WRITE: each loads a command-code byte and jumps to 4F37H.
4F4CH, 4F4FH	OPEN Mode Handlers Two entries differing in whether the file is opened in append mode (FFH) or sequential read/write mode (00H).

Track 0 / Sector 1 (4400H - 44FEH)

4400H - ENTRY - JP to Initialization Routine

When the boot sector at 42BAH executes JP NZ,4400H (the resident is in place because the chain marker on the final sector was non-FFH), the very first three bytes of the resident image take control. This is a forward jump to the initialization routine at 4727H. The 86 bytes immediately following the JP are not executable code; they are the build-time signature banner. The byte at 4403H (4DH = 'M') is also referenced by the FCB system as a default file-record signature, which is why Stutsman placed the M character at this specific offset.

4403H - BANNER1 - Build Signature Banner (DATA)

86-byte build-time signature string. Never displayed at runtime. The string reads "MICRODOS / A SIMPLE, POWERFUL DOS / WRITTEN BY JAMES W. STUTSMAN / FOR PERCOM DATA COMPANY", with carriage returns (0DH) between the lines and a NUL terminator at 4458H. The byte at 4403H (4DH = 'M') doubles as the FCB default-record signature byte, which is why this specific 'M' must remain at this specific address even though the banner is never printed.

4459H - SYMTAB - Built-in Symbol Table (DATA)

A mixed data area containing a source-listing-style symbol table for the SYM command (dispatched via 4E55H), disk configuration parameters, and an auto-load command string. Each symbol entry follows the general format: NAME + TAB + EQU + TAB + ADDRESS + TABs + ;COMMENT + record separator.

Track 0 / Sector 2 (44FFH - 45FDH) - boundary falls within preceding SYMTAB2 row at 44AE-4525

4526H - AUTOPTR - Auto-Load Pointer (DATA)

Two bytes of pointer storage written by the init routine at 476DH-4772H to hold 44A5H (the start of the auto-load command string). The keyboard input hook at 478FH reads from this pointer and increments it.

4527H - BANNER2 - PerCom MicroDOS User Banner (DATA)

The user-visible banner printed by 4761H-4766H during initialization. The leading byte at 4527H is the high byte of the AUTOPTR (44H), but it is also the first byte of a string when read by 28A7H starting at 4527H instead of 4528H. The init routine specifically loads HL=4528H to skip the byte at 4527H, so the actual displayed banner is "PERCOM MICRODOS VERSION 2.20\rCOPYRIGHT (C) 1979 PERCOM DATA COMPANY\rALL RIGHTS RESERVED\r".

4581H - LSUMSG - Last Sector Used Message (DATA)

A 19-byte NUL-terminated string used by the format/disk-space utility commands. Output via 28A7H when the user runs a sector-allocation status command.

4594H - BOOTCOPY - Embedded Copy of Boot Sector Code

An exact 221-byte copy of the boot sector code from 4200H-42DCH. Provided so that a SYSTEM-call re-entry can restart the OS load sequence without reading T0/S0 from disk. The code is byte-for-byte identical to the boot sector, including the FE 00 placeholder at the entry point. Note: the absolute references inside this copy (e.g., LD HL,42F1H at 45A9H, LD HL,42DEH at 45CEH, CALL 424CH at 45A6H) all still point at the original boot sector data area at 42xxH, which means BOOTCOPY only works correctly if the original boot sector is still resident at 4200H. This is the normal case during steady-state operation; the boot sector RAM at 4200H-42FFH is never overwritten by BASIC unless the user explicitly POKEs there.

Track 0 / Sector 3 (45FEH - 46FCH) - boundary falls within preceding BOOTCOPY main loop at 45CEH-45DEH

45E0H - BOOTCOPY Read Sector Subroutine

Internal subroutine of BOOTCOPY equivalent to the boot sector's 424CH-4274H routine. Issues an FDC Read Sector command and transfers data into the buffer. Note: this routine is independent of the boot sector's 424CH; it is invoked only from within BOOTCOPY (via 45A6H) when BOOTCOPY runs.

4609H - BOOTCOPY Seek and Drive-Select Subroutine

Internal subroutine of BOOTCOPY equivalent to the boot sector's 4275H-42A1H. Selects drive 0, sets the FDC track and sector registers, and issues a Seek command. Note this is independent of the boot sector's actual 4275H; it serves the BOOTCOPY data flow only.

4636H - BOOTCOPY Disk Error Handler

Internal disk-error handler for BOOTCOPY. Equivalent to the boot sector's 42A2H, but uses BOOTCOPY's own copies of the DISK ERROR and NO MICRODOS messages at 4675H and 4682H. Displays the message, waits for any keypress, and reboots.

464DH - BOOTCOPY Send FDC Command Subroutine

Internal Send-FDC-Command subroutine of BOOTCOPY, equivalent to the boot sector's 42B9H. Saves the command, waits for FDC not-busy, restores the command, writes it through the alternate DE' (37ECH), and polls bit 0 (busy) until cleared.

465BH - BOOTCOPY Wait for FDC Not Busy Subroutine

Internal wait-for-FDC-not-busy loop, equivalent to the boot sector's 42C7H. Re-asserts drive 0 select on each iteration to defeat the Model I one-shot drive-select latch.

4668H - BOOTCOPY Print NUL-Terminated String Subroutine

Internal NUL-terminated string print routine, equivalent to the boot sector's 42D4H. Walks bytes pointed at by HL, displays each via 0033H, and returns on a zero byte.

4671H - BOOTCOPY Data Block (DATA)

29 bytes of data containing the BOOTCOPY's own copies of the DISK ERROR and NO MICRODOS messages, plus the $STEPL residual symbol. These bytes are reachable by the BOOTCOPY error path (which actually targets 42xxH addresses, so these copies are never read at runtime; they exist as a build-time consequence of copying the entire boot sector).

4694H - JTABLE - BASIC Token Dispatch Table (DATA)

A 147-byte table of 49 JP instructions (3 bytes each = C3 lo hi). The init routine at 4741H-474BH copies this entire table to RAM at 4152H, where it overlaps the BASIC RST 28H hook addresses (400CH, 4015H) and provides MicroDOS keyword dispatch. Each entry corresponds to one BASIC reserved-word index. Entries that point to JP 0043H or JP 012DH are no-op slots reserved for keywords that MicroDOS does not implement (the original Level II BASIC handler handles them). Entries pointing into the 4940H-4ECBH range are MicroDOS handlers.

Track 0 / Sector 4 (46FDH - 47FBH) - boundary falls within preceding JTABLE rows at 46EE-4724

4727H - INIT - MicroDOS Initialization

The first executable code of the resident OS, reached via JP 4727H from the entry trampoline at 4400H. Performs five jobs in sequence: (1) copies 39 bytes of post-error-table data from the Level II BASIC ROM at 18F7H to RAM at 4080H; (2) sets up a 3-byte separator template at 41E5H and points 40A7H at it; (3) copies the 147-byte JTABLE from 4694H down to RAM at 4152H; (4) initializes the byte-storage and string-storage pointers at 5A64H and 5A00H; (5) relocates the stack to 41F8H, prints the user banner via 28A7H, hooks the keyboard input vector at 4016H to KBDHOOK at 478FH, sets the AUTOPTR at 4526H to the auto-load string at 44A5H, initializes FCB defaults, and JPs to BASIC's 00B5H.

478FH - KBDHOOK - Keyboard Input Hook

Replacement for the BASIC keyboard input call at (4016H), installed by the init routine at 4767H-476CH. Reads one byte from the AUTOPTR location at 4526H, increments AUTOPTR, and returns the byte to BASIC as if the user had typed it. When the byte read is NUL, the hook re-points 4016H to point at KBDSCAN at 47A3H.

47A3H - KBDSCAN - Live Keyboard Scanner

The live keyboard scanner, installed at 4016H once the auto-load string has been exhausted. Walks through the 8 keyboard memory rows by left-rotating Register C from 01H through 80H: 3801H, 3802H, 3804H, 3808H, 3810H, 3820H, 3840H, 3880H. For each row, reads the keyboard memory, computes the bit-mask of newly-pressed keys (XORing with the previous-frame state), and either continues scanning (if no keys are newly pressed) or transfers control to the Level II BASIC ROM key-decode routine at 03FBH with the row number in Register D and the keypress mask in Register A.

47C9H - BASTOK - BASIC Token Dispatcher

Reached via JTABLE entry 11 (4152H+33 = 4175H, which is C3 C9 47 = JP 47C9H) when BASIC encounters the CMD/CALL token followed by a string argument. Reads the first character of the string argument, compares it against F (FETCH), I (INPUT), H (HEX), K (KILL), and M (MERGE), and JPs to the matching handler at 47F2H, 4818H, 4802H, 482BH, or 4841H respectively. Default exit is JP 1E4AH (Illegal Function Call).

47F2H - FETCH Command (CMD"F")

Handles CMD"F" (FETCH). Skips a comma, parses an address argument via 4B3FH, validates it via RST 10H, then calls 4870H (the file-load routine) to fetch a file at the parsed address.

Track 0 / Sector 5 (47FCH - 48FAH) - boundary falls within preceding FETCH block at 47FCH (PUSH HL row)

4802H - HEX Command (CMD"H")

Handles CMD"H" (HEX dump or HEX-related operation). Calls 2337H to fetch a parameter, validates with RST 10H, parses additional context via 4851H.

4818H - INPUT Command (CMD"I")

Handles CMD"I" (INPUT-related, file-input). Same general pattern as FETCH but additionally calls 491BH after the file load to perform the BASIC line-pointer relink.

482BH - KILL Command (CMD"K")

Handles CMD"K" (KILL/delete file). Uses the symbol table at 44A5H as a destination buffer (the auto-load string area is reused after init since the auto-load completes before the user issues commands).

4841H - MERGE Command (CMD"M")

Handles CMD"M" (MERGE). Loads a file using FILEIO at 4870H, then performs MERGE-style line-pointer integration via 491BH.

4851H - String-Copy-To-Destination Helper

Copies a BASIC string descriptor's data into a destination buffer at DE. HL points at the BASIC string descriptor (length byte + 2-byte data pointer). Caps the length at 80H (128 bytes). Translates 0AH (line feed) to 0DH (carriage return) during the copy. NUL-terminates the destination.

4870H - FILEIO - File Format/Initialize Routine

Reached from the FETCH and INPUT command handlers at 47FDH and 4823H. The name FILEIO is a misnomer in the original continuation file - this is actually the FORMAT-and-write routine, used to lay down a chain of sectors. Clears the SECTOR variable at 448DH-448EH, fetches a record byte count from RECNO at 4492H, calls FORMAT at 4C91H repeatedly, and uses the verify routine at 48BCH to confirm written data.

48BCH - Verify Track Routine

Reads back all sectors of a track and counts errors. Called from the FORMAT loop after each track is written. Returns Z if all sectors verify clean, NZ with error count in Register A if any failed.

48DAH - ERREXIT2 - Error Code Setup Table (Variant 2)

Eight 4-byte entries. Each entry loads Register E with a unique error code (2EH, 30H, 34H, 32H, 38H, 42H, 44H) and JRs to either 4918H (final-error JP 19A2H) or 48F4H (the FDC FORCE INTERRUPT path that saves status before erroring). These entry points are reached by JP from various FDC error paths in the disk I/O routines.

Track 0 / Sector 6 (48FBH - 49F9H) - boundary falls within preceding ERREXIT2 table at 48F4H

48F4H - FDC FORCE INTERRUPT Pre-Error Path

Common entry from the 48E6H, 48EAH, 48EEH, 48F2H error setups. Saves the current FDC status to 4495H, issues a FORCE INTERRUPT (D0H) to terminate any in-progress operation, marks the offending drive's step-rate entry as FFH, then either tests for write-protect or falls through to the error JP at 4918H.

491BH - SYSTEM Re-Init / Line-Pointer Relink

Reached from the INPUT handler at 4826H, the MERGE handler at 484CH, and from the file-load post-processing path. Loads the byte at 4594H (the embedded boot copy entry, used as a 1-byte signature), saves it to 448FH (the chain marker variable), and sets up the buffer pointer at 4490H to 4595H. Then clears the SECTOR variable, calls 4BF6H (the chain-walker write-back), advances 448EH to 01H (sector 1), and computes the loaded-program length (5600H - 4400H = 1200H) for the BASIC line-pointer relink call at 4968H.

4941H - OPEN/CALL Argument Handler

JTABLE entry 26 routes here for the BASIC OPEN keyword. Calls FILESPEC parser at 4AFBH to fetch a string argument, validates the line ending via RST 10H, then computes the gap between the current string-storage pointer at 40A4H and the string-area top at 40F9H. Calls 4968H to display the gap as a numeric value (probably "FREE BYTES = NN").

4968H - Display Gap as Decimal Number / Allocate Loop

A multipurpose routine reached from 491BH (with HL = image length) and 4954H (with HL = free-byte count). Calls 559EH to display the high byte of HL, then loops calling 497DH and 498FH to walk the chain marker chain.

4977H - Chain Tail Allocation

Final step of a chain allocation: stores BC into HL via the chain-marker-write helper. Reached as a branch target from 55A4H (an alternate entry from the misc-routines tail block).

497DH - Chain Marker Write Helper

Writes Register C (the chain marker byte) to 448FH and Register Pair DE (the buffer pointer) to 4490H, then calls 4BF6H (the actual disk write). After the write, recomputes HL = HL - BC for the caller's gap-tracking.

498FH - Sector Advance Helper

Advances the SECTOR variable at 448DH-448EH to the next track/sector. INC H (track byte), check against record limit at 4492H; if past limit, INC L (the sector wraps), check against limit at 4493H; if both exceeded, raise error 36H ("Disk Overflow").

49AEH - LOAD/RUN Handler (JTABLE entry 18)

Reached via JTABLE entry 18 (4152H+54 = 4188H = JP 49AEH) for the LOAD-and-optionally-RUN keyword. Calls the FILESPEC parser at 4AFBH to fetch the filename argument. Then optionally reads a R suffix (which turns the LOAD into a LOAD-and-RUN), reinitializes the BASIC pointers via 1B4DH, walks through the loaded program updating BASIC line pointers, and finally either returns to the BASIC READY prompt at 1A19H or executes the program via JP 1D1EH.

Track 0 / Sector 7 (49FAH - 4AF8H) - boundary falls within preceding LOAD/RUN handler at 49FAH (DEC HL row)

49F6H - SAVE Handler (JTABLE entry 19)

Reached via JTABLE entry 19 (4152H+57 = 418BH = JP 49F6H) for the SAVE keyword. POPs the stale return address that the BASIC dispatcher pushed (because SAVE handles its own argument processing differently from LOAD). Calls FILESPEC parser at 4AFBH, validates end-of-statement, initializes the buffer with FFH chain markers, and enters a directory-scan loop calling DIRWALK at 4A4AH to find the file's directory entry. When found, allocates new disk space, writes the BASIC program contents using the chained-sector format, and finally re-runs the file allocation routines via 4A45H.

4A4AH - DIRWALK - Directory Walker

Reads the next directory record from the file directory. Each directory record begins with a 4-byte header (loaded into BC=0004H, then read via 4A6CH), followed by a variable-length name field. Returns Z if end-of-directory reached, NZ with DE=line number, A=count if a record was successfully read.

4A6CH - Chain-Byte-Fetch Helper

Fetches one byte from the chained sector buffer. Decrements the byte counter at 448FH; if it reaches zero, calls 4A82H to read the next sector before fetching. Returns the byte in Register A and updates the buffer pointer at 4490H.

4A82H - Read Next Sector and Test Marker

Reads the next sector into the buffer at 4300H, captures the chain-marker byte, and updates the bytes-remaining counter at 448FH and the buffer pointer at 4490H. If the chain marker is FFH (continuation), returns with A holding the byte count. If non-FFH (end-of-chain), takes the special-case path through 4AA6H.

4AAEH - APPEND/Field Handler (JTABLE entry 15)

Reached via JTABLE entry 15 (4152H+45 = 417FH = JP 4AAEH) for the APPEND or FIELD-style keyword. Calls FILESPEC parser at 4B59H, validates a comma, fetches another argument via 4AFBH, validates end-of-statement, then reads a byte from the chain and stores it. If the byte exceeds Register C (the limit), enters the multi-step processing path that calls 55A7H, copies 3 bytes from 40D3H, and updates 4490H from 40D4H.

4AE4H - PUT Handler (JTABLE entry 16)

Reached via JTABLE entry 16 (4152H+48 = 4182H = JP 4AE4H) for the PUT keyword. Calls FILESPEC parser at 4B59H, validates a comma, fetches a numeric argument via 4AFBH, validates end-of-statement, swaps DE and HL, reads a byte from (HL), stores at 448FH, calls the chain-write at 4BF6H.

Track 0 / Sector 8 (4AF9H - 4BF7H) - boundary falls at end of preceding PUT handler row at 4AF9H

4AFBH - FILESPEC Parser (Quoted String or Numeric)

Reached from many keyword handlers including FETCH, INPUT, MERGE, KILL, LOAD/RUN, SAVE, APPEND, PUT. Calls Level II BASIC ROM 2337H to fetch a parameter into the accumulator, sets the type-flag at 40AFH to 02H (single-precision), invokes Level II BASIC ROM 2819H (16-bit compare HL:DE), then calls 4B10H (drive-number argument parser). On exit, HL points just past the parameter and DE points at the resolved buffer.

4B10H - Drive-Number/Record-Number Parser

Splits a 16-bit numeric argument into a drive number (high digit) and record number (low digits). Subtracts 2710H (10000 decimal) from HL repeatedly, counting iterations. When the subtraction goes negative, the iteration count is the drive number and the residue is the record number. Falls through to 4B49H to validate the drive number.

4B1CH - Drive-Number Parser Continuation / Record Validation

Reached when the drive-digit subtraction loop at 4B14H detects HL has gone negative. Restores HL by adding back the over-subtracted DE (=2710H), validates the drive number via 4B49H, then converts the residual record number into a track/sector pair. The records-per-track value is at 4492H and the bytes-per-record value is at 4493H. Computes track = record / records-per-track and sector = record MOD records-per-track. On exit, 448DH = track and 448EH = sector.

4B3FH - Single-Drive-Argument Parser

Used by FETCH (47F4H), HEX (481AH), KILL (4843H) and similar handlers that take only a drive number (no record number). Calls the BASIC ROM general-parameter parser, then validates the value is an integer-type 8-bit, then falls through to 4B49H to validate the drive number.

4B49H - Drive-Number Validator and Drive-Select Mask Builder

Validates that Register A holds a drive number 0-3. If valid, converts the drive number into a one-hot drive-select mask (drive 0 = 01H, drive 1 = 02H, drive 2 = 04H, drive 3 = 08H) and stores at 448CH. If invalid, jumps to the "Invalid Drive Number" error path at 48DAH.

4B59H - FILESPEC Parser (String or Number)

Used by handlers that accept either a string filespec or a numeric record specifier. If the next character is "#" (23H, indicating a previously-OPENed file handle), calls 4E46H to look up the file-handle table at 5600H. Otherwise calls Level II BASIC ROM 260DH (VARPTR) and ROM 0AF4H (MOVEA) to fetch a string variable's address and length, then sets the buffer pointer at 4490H. Returns with C = string length (or FFH for #handle), buffer pointer prepared.

4B7FH - Sector-Read-and-Buffer-Copy Wrapper

Saves the working registers, calls the disk-read routine at 4B8CH, then calls the buffer-to-RAM copy routine at 4BB4H, then restores the registers. Used as a single-shot read-and-copy primitive by handlers that need to fetch a sector and immediately move its contents to a target buffer.

4B8CH - Sector-Read Routine (FDC Read with Retry)

Performs a single sector read from the disk into the buffer at 4300H. Calls 4D44H to seek the requested track and select the drive, then calls 4BC4H to issue the read command (with up to 3 retries). On error, attempts a recalibration sequence (CALL 4DACH at 4BA3H, CALL 4D89H, retry 4BC4H). If the third retry also fails, jumps to the "Disk Read/Write Error" path at 48E6H. After successful read, captures the chain-marker byte from 4300H (offset 0 of the sector) into 448FH.

4BB4H - Buffer-To-RAM Copy Helper

Copies the sector buffer at 4300H+1 to the destination at 4490H. Reads the chain-marker (bytes-remaining count) from 4300H into Register C, sets B=00H, then performs an LDIR (block copy of BC bytes). Returns immediately if the count is zero.

4BC4H - Sector-Read with 3 Retries

Issues the FDC read at 4BCDH; if it returns NC (success), returns immediately. Otherwise retries up to 3 times via DJNZ. Returns with C set if all retries failed.

4BCDH - FDC Sector Read Primitive (with DRQ Polling via EXX)

Issues an FDC READ SECTOR command (88H) via 4DE3H, then polls the FDC status register at (DE) for the DRQ bit (bit 1). When DRQ is set, reads a data byte from (HL) and stores it at (BC=4300H), incrementing BC each iteration. Uses the alternate register set (EXX) to keep BC, DE, HL available for the polling loop while preserving the caller's main registers. On status bits 9CH (record-not-found, CRC error, lost-data, write-protect), saves status at 4495H and writes 0D0H (FORCE INTERRUPT) to terminate. Returns with C FLAG set on error.

Track 0 / Sector 9 (4BF8H - 4CF6H) - boundary falls within following PUT-byte chain-write routine at 4BF8H

4BF6H - PUT-Byte Chain-Write Routine

Writes the byte at 448FH (the chain-marker variable, repurposed as the byte to PUT) to the current sector position on disk. Saves working registers, calls 4D44H to seek and select the drive, tests the FDC step-rate flags at 37ECH for write-protect (bit 6) and aborts to 48E2H if write-protected, copies the buffer count from 448FH into BC, exchanges DE<->HL, writes the byte, optionally LDIRs additional bytes, then calls the actual sector-write at 4C36H, with retry-and-recalibrate logic identical to the read path.

4C36H - Sector-Write with 3 Retries (and verify-via-read)

Issues the FDC write at 4C44H, then verifies via 4C6DH (a re-read). If both succeed, returns NC. Otherwise retries up to 3 times via DJNZ.

4C44H - FDC Sector Write Primitive

Mirror image of the read primitive at 4BCDH but for write. Issues an FDC WRITE SECTOR command (0A8H) via 4DE3H, then polls the FDC status register at (DE) for the DRQ bit and shovels bytes from (BC) to (HL) until the FDC reports busy-cleared. On error bits 0E4H (NOT_READY, WRITE_PROTECT, WRITE_FAULT, LOST_DATA), saves status at 4495H and writes 0D0H FORCE INTERRUPT.

4C6DH - Verify-By-Read Primitive

Issues an FDC READ SECTOR (88H) and reads the data, but discards it (does not store). Used after a write to verify that the sector can be read back without error. If the read succeeds with no status error bits, returns NC. On error bits 9CH (NOT_READY, RECORD_NOT_FOUND, CRC_ERROR, LOST_DATA), saves status at 4495H, writes FORCE INTERRUPT, sets C.

4C91H - FORMAT TRACK Routine

Formats the current track of the disk. Saves working registers, calls 4D44H to seek and select drive, tests for write-protect bit 6 of FDC status (jumps to 48E2H "Disk Write Protected" on error), then issues an FDC WRITE TRACK command (0F4H) and feeds the gap-byte sequence required by the IBM 3740 SD format used by the Model I. Each byte stream is fed via the helper at 4D2BH, which polls DRQ and writes Register C to the FDC data register. The track structure consists of: 0EH bytes of FFH (post-index gap), then 06H bytes of 00H (sync), then F4H/F5H index AM, then 06H bytes of 00H, then F7H/F8H, then ten sector regions each consisting of: 0EH bytes 00H, F5H, F8H, F9H, sector header (FE+T+S+L+CRC1+CRC2), gap, F5H, FB, 256 data bytes, F7, gap. Final 0FFH fills track tail until INDEX detected.

4D25H - Byte-Stream Helper for Format (Status-Polling Sub-Loop)

Used inside the FORMAT TRACK byte-feed loop at 4D2BH. Tests bits 7+5+2+0 (NOT_READY, RECORD_TYPE, LOST_DATA, BUSY) and bit 7+0 only after XOR 01. If FDC has gone NOT_BUSY without error, jumps to 4D34H to compute the post-mortem status. Otherwise falls through to 4D2BH to keep feeding bytes.

4D44H - FDC Seek-and-Select Routine

Selects the drive specified by the one-hot mask at 448CH and seeks the head to the track at 448DH. Uses the per-drive step-rate selector at 4497H-449AH to choose the appropriate FDC step rate (FFH = needs recalibration via 4DACH). Sets up DE=37ECH (FDC status), HL=37EFH (FDC data), then calls 4DF6H for the actual seek. Reads the current track from 37EDH and compares against the desired track; calls 4D89H if seek-and-verify is needed. After successful seek, sets up HL=4300H, DE=(4490H) for any subsequent buffer operations and clears 4495H (saved FDC status).

4D89H - Seek-and-Verify with Recalibrate Retry

Issues an FDC SEEK to the track stored in 448DH and verifies via 4D97H. If the verify fails (NC return from 4D97H), recalibrates via 4DACH and tries again. If the second verify also fails, jumps to "Disk Seek Error" at 48EEH.

4D97H - Single Seek-and-Verify Pass

Stores the desired track from 448DH at the FDC data register 37EFH, builds an FDC SEEK command from the step-rate flags at 4494H low nibble OR'd with 10H (verify-flag for Type I), and issues it via 4DBCH. Tests the resulting status against bits 98H (NOT_READY + RECORD_NOT_FOUND + CRC_ERROR) and returns NC if no error, C set otherwise.

4DACH - FDC RESTORE (Recalibrate to Track 0)

Builds an FDC RESTORE command (Type I) from the step-rate flags at 4494H low nibble (no extra flags - bits 4-7 are zero in the opcode). Issues the command via 4DBCH, tests the result against bits 9CH (NOT_READY + RECORD_NOT_FOUND + CRC_ERROR + LOST_DATA), XOR'd with 04H (LOST_DATA expected from RESTORE). If the result is non-zero (real error), jumps to "Disk Seek Error" at 48EEH.

4DBCH - FDC Command Issuer (Type I, with status return)

Issues a Type I (RESTORE/SEEK/STEP) command to the FDC. Calls 4DE3H to write the command and start polling, then 4DBFH to wait for completion. On exit, Register A contains the final FDC status (with NOT_BUSY).

4DE3H - FDC Command Write Helper

Saves Register A on the stack, calls 4DF6H to refresh the drive-select latch and check the step-rate selector, calls 4DBFH to start the busy-poll, then writes the saved Register A to the FDC command register at 37ECH. After writing, polls bit 0 (BUSY) and waits until BUSY is set, indicating the FDC has accepted the command.

Track 1 / Sector 1 (4DF6H - 4EF4H) - boundary falls at start of following Drive-Select Routine at 4DF6H

4DF6H - Drive-Select-and-Step-Rate-Test Helper

Refreshes the drive-select latch at 37E1H from the mask at 448CH. Tests bit 7 (sign) of the byte at the per-drive step-rate selector pointer in HL: if set, the drive is "fresh" and a debounce delay is applied (decrementing pair from 0xFFFF + 256 DJNZ inner loop totaling about 16ms) before re-asserting drive-select. If bit 7 clear, returns immediately. Validates that the lower nibble is non-zero or jumps to "Invalid Drive Number" 48DAH.

4E19H - ERREXIT Jump Table (BASIC Token Dispatch)

A 17-entry jump table that the JTABLE entries (relocated to 4152H-41E4H) point to. Each entry is a 3-byte JP instruction that vectors to the actual handler for a particular BASIC keyword or token. This indirection lets MicroDOS replace the original BASIC handler addresses with patched ones, while still going through the same 4152H+ dispatch.

4E5BH - File-Handle Table Initializer

Zeros the 4-byte file-handle directory at 5600H, 5700H, 5800H, 5900H (one byte per handle: handle 0 reserved, handles 1-3 user-allocatable). Used by the FILES / OPEN preamble.

4E66H - File-Handle Resolver

Parses a file-handle reference of the form #N or N (where N is 1-3) and returns DE pointing to the handle's table entry at 5600H+N. If the next character is "#" (23H), advances past it via RST 10H. Calls Level II BASIC ROM 2B1CH to fetch the integer handle number, validates it is 1-3, and computes 5600H + N. On invalid handle, jumps to ERROR 3EH ("Invalid File Buffer Number") via 19A2H.

4E7EH - FIELD Keyword Body

Implements the FIELD keyword which assigns string variables to fixed-byte regions of a random-access file's record buffer. Calls 4E66H to resolve the file handle, then iterates: each iteration parses a comma, an integer (field width), the AS keyword (token A0H = AS), and a string variable name; stores the field width and updates the running offset. Loop continues until end-of-statement.

4EC0H - LOAD / SAVE Keyword Handler with #N AS filename$

Implements the MicroDOS extension syntax "LOAD #N AS filename$" and "SAVE #N AS filename$", reached via the ERREXIT table at 4E19H = JP 4EC0H. On entry Register A holds the BASIC keyword token that was peeked by the caller: token 0A7H is the Disk BASIC LOAD keyword, token 0ADH is the SAVE keyword. Anything else falls through to ROM 1997H (Syntax Error). After validating the token, the routine advances the parser, calls 4E66H to resolve a "#N" file-handle reference, requires the next parser byte to be token 0BFH (AS), then takes one of two paths. The LOAD path (token 0A7H) calls GETPAR (2337H) to evaluate the filename string expression, walks its 3-byte descriptor (length + data pointer), and copies the filename into the handle entry. The SAVE path (token 0ADH) calls VARPTR (260DH) for the destination string variable's address and MOVEA (0AF4H) to copy its descriptor to the work area, then optionally calls STRINI / STRSPA to allocate fresh string space if the existing buffer is too small. Both paths converge at the common LDIR-copy-to-handle epilogue at 4F08H.
NOTE: Token assignments confirmed against the canonical Level II / Disk BASIC token table: 0A7H = LOAD, 0ADH = SAVE, 0BFH = AS.

4F12H - Three-Entry Dispatch (Modes 02H / 04H / 08H)

A short three-entry dispatch routine reached via the ERREXIT table at 4E1CH (= JP 4F12H), 4E1FH (= JP 4F16H), and 4E22H (= JP 4F1AH). Each entry loads a different mode byte (02H, 04H, or 08H) into Register A, then falls through into the common body at 4F1CH. The common body saves the mode, calls ROM 2819H (CPHLDE) and 2857H (STRINI), loads HL from 40D4H (DSCTMP, the VARPTR storage area for a string currently being created by BASIC), calls 09FFH, and jumps to 2A2BH. The exact MicroDOS-specific syntax this implements needs confirmation against MicroDOS user documentation.

4F2DH - Three-Entry Dispatch (Modes 01H / 03H / 07H)

A second three-entry dispatch reached via the ERREXIT table at 4E25H (= JP 4F2DH), 4E28H (= JP 4F31H), and 4E2BH (= JP 4F35H). Each entry loads a different mode byte (01H, 03H, or 07H) into Register A, then falls through to the common body at 4F37H. The common body saves the mode, calls ROM 29D7H (READY / string-pointer-to-data resolver), restores the mode, validates that it is less than the count byte at (HL) (otherwise JP 1E4AH = FCERR / Illegal Function Call), then walks two bytes past the count to load Register Pair HL from a 2-byte target address (via LD B,(HL) / INC HL / LD H,(HL) / LD L,B). The mode is then stored at 40AFH (VALTYP = type variable flag) and the routine jumps to ROM 09F7H.

4F4CH - Two-Entry Handler (00H / FFH Flag)

A two-entry handler reached via the ERREXIT table at 4E2EH (= JP 4F4CH = entry with flag 00H) and 4E31H (= JP 4F4FH = entry with flag FFH). The flag is saved on the stack, then VARPTR (260DH) and MOVEA (0AF4H) are called to copy a variable's descriptor into the work area. After a syntax check requiring token 0D5H, GETPAR (2337H) parses an additional integer or expression, and 29D7H is called to obtain a string descriptor. The routine then walks both descriptors (the variable's and the active-string's), computes a length difference, and dispatches to one of two helper subroutines (4F8FH or 4FA6H) based on the saved flag. The body ends with an optional LDIR copy and RET.

4F8FH - Helper Subroutine A (Right-Justify with Leading Spaces)

Helper subroutine called from 4F7FH (the flag-00H path of the 4F4CH handler). On entry Register B holds the count of leading spaces, Register C holds the destination width, and DE points at the destination buffer. The routine returns immediately if B is 0. Otherwise it negates B and adds C to compute the byte count for the upcoming LDIR (writing the source data right-justified), advances the destination pointer past the leading spaces, and fills those leading positions with ASCII space characters (20H). This implements the RSET-style behavior of right-justifying a string within a fixed-width field.

4FA6H - Helper Subroutine B (Left-Justify with Trailing Spaces)

Helper subroutine called from 4F84H (the flag-FFH path of the 4F4CH handler). On entry Register B holds the count of trailing spaces, Register C holds the destination width, and DE points at the destination buffer. The routine returns immediately if B is 0. Otherwise it negates B and adds C to compute the byte count for the upcoming LDIR (writing the source data left-aligned), then writes B trailing spaces at the current destination position. This implements the LSET-style behavior of left-justifying a string within a fixed-width field.

4FB4H - LOC Function Dispatcher

Reached via the ERREXIT table at 4E4FH (= JP 4FB4H). This is the dispatcher for the MicroDOS LOC function, which supplies four kinds of disk-related information depending on its integer argument N: LOC(0) returns the last DSSSS accessed (drive*10000 + sector), LOC(1) returns the largest legal sector number for the current MicroDOS version, LOC(2) returns the WD1771 disk controller status saved after the last I/O error, and LOC(3) returns the count of sectors that could not be verified during the most recent CMD"F" or CMD"I" format operation. After parsing the integer argument with ROM 2B1FH, the dispatcher uses successive DEC A / JR Z to route to one of four handlers; any out-of-range argument falls through to the BASIC ROM "Illegal Function Call" error at 1E4AH.

4FC7H - LOC(0) Handler (Last DSSSS Accessed)

Computes the DSSSS value (drive * 10000 + sector_number) for the most recently accessed sector and returns it as a BASIC integer. The drive number is recovered from the one-hot drive-select mask at 448CH by repeatedly RRCAing until the C FLAG is set, accumulating 10000 in HL on each rotation. The track and sector are then read from 448DH/448EH and combined into the linear sector number using the records-per-track value at 4493H: HL is incremented by (records_per_track * track) plus the within-track sector offset. The composite DSSSS value is returned through ROM 0A9AH (returns HL as a BASIC integer).

4FEEH - LOC(1) Handler (Largest Legal Sector Number)

Returns (records_per_track * tracks) - 1, the largest legal sector number for the current MicroDOS configuration. The records-per-track value at 4493H is multiplied by the tracks-per-disk value at 4492H using a DJNZ-controlled add-loop, then 1 is subtracted to convert from count to maximum index.

Track 1 / Sector 3 (4FF4H - 50F2H) - boundary falls within preceding LOC(1) handler at 4FF4H (the LD E,A row)

5002H - LOC(2) Handler (Disk Controller Status)

Returns the WD1771 floppy disk controller status byte saved at 4495H following the most recent disk I/O error. The byte is loaded into L, H is zeroed, and the result is returned as a BASIC integer. Per the manual: "This call returns the status (in decimal) of the 1771 Disk Controller following any disk I/O which results in an error. It is up to the user to analyze the status to determine the problem."

500BH - LOC(3) Handler (Format-Failure Count)

Returns the count of sectors that could not be verified during the most recent CMD"F" or CMD"I" format operation. The byte at 4496H is the format-fail accumulator; this handler simply loads it and falls through into the LOC(2) tail at 5005H to return it as an integer.

5010H - LOF Function (Field-Buffer Length)

Reached via the ERREXIT table at 4E4CH (= JP 5010H). Returns the total length of all fields defined in the indicated Field Buffer (an integer 0-255), as documented in the manual: "LOF(N) returns the total length of all fields in buffer N." After parsing the buffer number N (1-4) with ROM 2B1FH, the routine calls the file-handle resolver at 4E6EH to obtain a pointer to the per-handle table page, then reads the length byte from that page and returns it.

501DH - LINE INPUT Statement

Reached via the ERREXIT table at 4E37H (= JP 501DH). This is the MicroDOS LINE INPUT statement, a one-line BASIC enhancement documented in Section X of the manual: 'LINE INPUT "PROMPT";A$' prints the prompt without the standard "?" suffix, accepts a single string variable, and treats commas, quotes, colons, and leading blanks as ordinary input characters. The handler first checks for an INPUT token (89H), then optionally parses a prompt-string descriptor and prints it via ROM 21CDH, calls VARPTR (260DH) and MOVEA (0AF4H) to capture the destination string variable, invokes the ROM line-input primitive at 0361H to read the keyboard buffer, and finally builds a BASIC string descriptor from the captured line via ROM 2868H + 1F32H.

503EH - "&H" Hexadecimal Constant Parser

Reached via the ERREXIT table at 4E3AH (= JP 503EH). This is the MicroDOS hexadecimal constant parser, documented in Section IX of the manual: "Any constant preceded by '&H' will be interpreted as a hexadecimal constant. The number may be from 1 to 5 hexadecimal digits. Constants of this type always represent signed integers." The manual also notes that octal (&O) constants are NOT supported by MICRODOS. The handler skips past the leading '&' (already consumed by the trigger), enforces an 'H' character via RST 08H + 48H, then accumulates a 16-bit value in HL by reading hex digits 0-9 and A-F. Each digit is shifted-in via four ADD HL,HL operations with overflow-check (JP NZ,07B2H "Overflow Error").

507AH - LSET/RSET Secondary Entry (Array Element / Recursive FIELD)

Reached via the ERREXIT table at 4E3DH (= JP 507AH). This is a secondary LSET/RSET assignment entry that handles the special cases where the left-hand-side of an assignment refers to either (a) a tokenized expression following byte 0C1H (a Disk-BASIC reserved token used as the array-element-LSET prefix in MicroDOS), in which case it dispatches to 518FH; or (b) a recursive DEF FIELD inline (token 0A3H = FIELD), in which case it dispatches to 4E7EH (the FIELD-body parser). In all other cases, the routine treats the LHS as an ordinary string variable: it calls ROM 2828H (the string-pointer-fixer) and the FIELD-buffer-reference helper at 50E4H, then writes the resolved descriptor pointer back into the variable slot before continuing parsing at ROM 1F05H (string assignment continuation).

5092H - DEF FIELD Statement Body

Reached via the ERREXIT table at 4E43H (= JP 5092H). This is the main body of the DEF FIELD statement, documented in Section VIII of the manual. Syntax: DEF FIELD #N, N1 AS F1$, ..., NI AS FI$ (where N is the buffer number 1-4 and each Ni is a length, optionally parenthesized as an expression, followed by AS and a string variable name to bind to that field). The handler invokes the FIELD-buffer-reference helper at 50E4H, saves VALTYP, walks the field list parsing length expressions and AS-clauses, and at end-of-list collapses the captured field-name+length pairs onto the buffer's directory. After processing, the routine compares the running total against the prior maximum length via 2819H to enforce the FIELD-OVERFLOW limit (255 characters). Note: the FIELD body itself does no allocation; it merely records field names and offsets in the per-handle table page so subsequent variable references resolve into the buffer.

50E4H - FIELD-Buffer-Reference Helper

Helper used by both the FIELD body (5092H) and the LSET-secondary path (5084H). Validates that the parser is positioned at a '#' character (token 0BEH per the Disk-BASIC convention used by MicroDOS for the FIELD-buffer-reference syntactic marker), sets the field-buffer-active flag at 40DCH to 80H, then ORs the existing flag bits with the byte at HL and dispatches to ROM 2612H to resolve the buffer-number expression.

50F0H - DEF FIELD List Parser

Helper called from 50AAH for parenthesized-length DEF FIELD entries. Pops the caller's IX preservation, then enters a recursive parser loop that handles each comma-separated 'length AS name$' clause: it advances past optional ',' separators (RST 08H + 2CH), evaluates a length expression via 1963H, sets the field-buffer-active flag at 40DCH, calls VARPTR (260DH) for the variable name, and tests for a closing ')' to terminate the list. At end-of-list it dispatches via JP IX to the caller's continuation.

Track 1 / Sector 4 (50F3H - 51F1H) - boundary falls within preceding 50F0H helper at 50F3H (the PUSH AF row)

5130H - DEF FIELD List Flush Helper

Helper that walks the temporary field-clause stack pushed during the field-list parser, writing each captured field-name+offset pair into the buffer's directory. Uses the alternate-register set (EXX) to manage the in-flight state without disturbing the BASIC main registers, then performs a series of 3-byte descriptor writes (DEC HL ; LD (HL),C / DEC HL ; LD (HL),B) for each pushed field.

514CH - DEF FIELD Parenthesized-Length Helper

Helper invoked from 50ADH when a field length is given as a parenthesized expression (DEF FIELD #N, (length_expr) AS var$, ...). Loads the saved field-buffer page pointer from 40F3H, requires '(' via RST 08H + 28H, parses the inner expression with VARPTR (260DH) and the type-resolver at 1F2BH, then walks comma-separated additional clauses until ')' is seen. Each clause issues another RST 08H + 2CH (',') and recurses through 515CH-515FH. Final exit issues RST 10H to skip ')', RST 08H + D5H ('=' token), and returns with the resolved buffer pointer in HL.

517BH - String-Descriptor Write Helper

Three-byte descriptor writer used by both 50D8H and 5144H. Saves HL, calls ROM 29F5H to refresh the BASIC string descriptor's data pointer (returning the length byte in A and the data address in HL via 40B3H), then writes the 3-byte descriptor (length, data-low, data-high) at the original HL.

518AH - "Field Overflow" Error Setup

Loads BASIC error code 3CH (60 decimal, MicroDOS error 30 multiplied by 2 per the manual's "ERR/2+1" convention; 30 = "FIELD OVERFLOW") into Register E and dispatches to ROM 19A2H, the BASIC error-message-issuer. Per Section XI of the manual, this error occurs in a DEF FIELD when "either a single field was defined for more than 255 characters, or the total of all defined fields exceeds 255."

518FH - Array-Element LSET/RSET Helper

Reached from the 507AH dispatcher when token 0C1H precedes the LHS variable, signaling that the LHS is an array element rather than a scalar. Calls 51C9H to resolve the array indexing, requires '=' (RST 08H + D5H), evaluates the RHS via ROM 2B02H (numeric-or-string copy), then writes the resulting 2-byte address into the array element slot before returning.

519EH - GET / PUT Through Field Buffer (CVx/MKx Common Path)

Reached via the ERREXIT table at 4E40H (= JP 519EH). Common code path for the CVI/CVS/CVD/MKI$/MKS$/MKD$ family when their argument is a FIELD-buffer slot. Pops the caller's return-address (which encodes the operation: integer, single, or double precision) into a controlled JP HL, calls the array/field-buffer index resolver at 51C9H, rotates Register C right-circular to obtain a per-handle stride mask, and dispatches via JP HL to a target derived from VALTYP. When VALTYP indicates double precision (3 - a coincidence with VALTYP=3 also being string in some contexts but here the test 'CP A,03H' alone gates the call), invokes ROM 29DAH to extend a single-precision FAC to double. Result is left at FAC (4121H) for the caller's convertor.

51C9H - Array/Field Index Resolver

Inner helper used by 518FH (array LSET/RSET) and 519EH (CVx/MKx through field buffer). Advances past the index character with RST 10H, then conditionally reads a single ASCII digit (0-9) from the parser, doubles it (RLA after subtracting '0' converts digit*2 - the offset for a 2-byte ERRJMP table entry), and uses it to index into the ERRJMP table at 5578H to compute a target address. Returns DE pointing at the indexed slot.

51DBH - MID$ Statement (Assignment Form)

Reached via the ERREXIT table at 4E55H (= JP 51DBH). This is the MicroDOS MID$ statement, documented in Section IX of the manual: 'MID$(S1$, N1, N2) = S2$' replaces a portion of S1$ starting at position N1, replacing N2 characters with S2$. N2 is optional; if omitted, either LEN(S2$) or LEN(S1$)-N1+1 is used, whichever is shorter. The handler validates that S1$ exists in writable string storage (re-allocating if necessary), parses N1 with bounds checking (1..LEN(S1$)), optionally parses N2 (capping at the available remaining length), parses '=' and the RHS, then performs the in-place byte-by-byte copy. Per the manual's examples: with A$="ABCDEFG", MID$(A$,3,4)="12345" yields "AB1234G".

Track 1 / Sector 5 (51F2H - 52F0H) - boundary falls within preceding MID$ statement at 51F2H (the CALL 2843H row)

5257H - INSTR Function

Reached via the ERREXIT table at 4E58H (= JP 5257H). This is the MicroDOS INSTR function, documented in Section IX of the manual: 'INSTR(N, S1$, S2$)' searches S1$ for the first occurrence of S2$, optionally starting at position N (default 1). Returns the 1-based position where S2$ was found, or 0 if no match. The handler tests the first argument for whether it's an integer (N) or a string (S1$, with N defaulted to 1), then parses the remaining arguments accordingly. Per the manual: with A$="ABCDEFG", INSTR(A$,"BCD")=2, INSTR(A$,"XY")=0, INSTR(3,"123123123","12")=4.

52DEH - BASIC Error Message Dispatcher

Reached via the ERREXIT table at 4E34H (= JP 52DEH). This is the MicroDOS error-message issuer that walks the inline-string table at 52F1H, indexed by Register E (the error code). Per Section XI of the manual: "All errors are reported by MICRODOS using descriptive error messages. Error code numbers may be derived in 'ON ERROR' routines by using the expression 'ERR/2+1'." The handler converts E to an entry index by RRCA + INC A, then walks the table 00H-terminated entry-by-entry, decrementing B (the index) until the target entry is reached. At the matching entry, control transfers to ROM 1A01H to display the message.