TRS-80 DOS - TRSDOS v2.3 for the Model I - SYS0/SYS Disassembled

SYS0/SYS

Other Navigation

TRSDOS v2.3 SYS0/SYS Disassembly - The Resident DOS (Model I)

SYS0/SYS is the part of TRSDOS 2.3 that stays in memory. BOOT/SYS reads it from the system diskette and jumps to its transfer address, 4E00H. The file holds 2,647 bytes in 72 load records between 400CH and 4F28H; the records skip the areas the ROM and the other modules own, and one record (4768H-476AH) loads over bytes an earlier record put there. The start-up code at 4E00H-4F28H runs once and is then overwritten, because 4E00H-51FFH is where the system overlays SYS1/SYS-SYS5/SYS are loaded.

The resident part gives TRSDOS 2.3 its fixed entry points at 4400H-4478H and 402DH-4033H, the RST 28H overlay call, the RST 30H DEBUG entry, the interrupt handler with its twelve timer task slots and the clock, the keyboard scan with debounce, and all of the file input and output: read, write, position, the conversion of a record number into a track and sector, the search of a file's extents in the directory and the allocation of new granules. Opening, closing, killing, the error messages and DEBUG live in the overlays and are reached through RST 28H.

Every byte of the file is shown once on this page, in address order, checked against S:\1\SYS0.SYS and its listing. The areas between the load records, from 4000H to 4DFFH, are shown as DEFS rows without bytes, with what TRSDOS 2.3 keeps there.

Memory Map

RST 28H and the System Overlays

RST 28H with bit 7 of Register A set loads a system overlay and calls it (4BA2H). Bits 0-3 are the overlay number, which is also the position of its directory entry on drive 0: overlay n uses entry 0 of directory sector n plus 2, and overlays 8-15 use entry 1 of sectors 2-9. Bits 4-6 choose the function inside the overlay; SYS1/SYS and SYS2/SYS test them (AND 70H), SYS3/SYS likewise. Codes with bit 7 clear go to the hook at 4312H. The RST's own return address is dropped, so an overlay function returns to the caller of the entry point that executed the RST.

DOS Entry Points

The File Control Block

An open FCB is 32 bytes. SYS2/SYS fills it in when the file is opened (its 4FA7H); these are the bytes SYS0/SYS uses.

Diskette Layout Used by SYS0/SYS

A track holds ten 256-byte sectors (0-9) and two granules of five sectors; a diskette has 35 tracks (00H-22H). The directory track is 11H (17) unless the diskette's boot sector says otherwise in its byte 2 (4B3EH). Its sector 0 is the granule allocation table, one byte per track at offsets 00H-22H (bit 0 = granule 0, bit 1 = granule 1, FFH = no free granule), with the AUTO command at offsets E0H-FFH. Sectors 2-9 hold the directory entries, eight of 32 bytes in each sector; an entry's bytes 16H-1FH are five extents of two bytes (track, granule byte), with FEH followed by a locator continuing the list in another entry and FFH ending it. The directory and the allocation table are written with the FAH data mark, which a read reports as error 06H; 4B35H accepts only sectors with that mark.

Error Numbers

Error numbers are bits 0-5 of Register A; the texts are SYS4/SYS's own messages. Bit 6 set asks SYS4/SYS for the message text only, without the ERRCOD number and the FILE and REFERENCED AT lines; bit 7 set makes it return to the caller instead of exiting through 4030H. The disk errors 01H-0FH are built by 46D1H from the base 01H (read) or 09H (write) plus the position of the lowest error bit in the controller status.

Interrupts and Timer Tasks

The RST 38H vector at 4012H is set to JP 4518H at start-up. The handler reads the interrupt latch at 37E0H, keeps the bits enabled in 404CH and calls the routine whose address is in the vector for each bit (404DH for bit 0 up to 405BH for bit 7). Bit 7 is serviced by the clock tick routine at 4560H and bit 6 by 4669H, which waits for the disk controller and reads its status. The clock tick routine runs timer slots 8-11 on every tick and one of slots 0-7 per tick by the low three bits of the counter at 4040H. A slot holds the address of a task control block whose first word is the task's routine; Index Register IX points to the block while the task runs. Slot 7 holds the clock (45AFH), which counts five of its runs as one second; SYS6/SYS puts the time display 4CA9H into slot 6 and SYS1/SYS's TRACE puts the address display 4CD9H into slot 11. When BREAK is down and 4315H holds C3H, the handler leaves through the address in 4316H-4317H.

Notes from the Code

• A later load record replaces LD A,(IX+08H) at 4768H with CALL 43D1H, so positioning to the end of a file whose last sector is only partly used goes to that sector at its end byte.
• Back up one record (4737H) takes the next record number as the sector the current byte is in. That holds while bit 5 of FCB+01H is set; after a read that ends inside a sector the next record number is one past the buffered sector, and the position set is one sector further on.
• Granule allocation (4A00H) adds the granule wanted minus the granules the file has, plus two: one granule more than the file needs.
• The program loader (4C81H) returns error 24H (ATTEMPTED TO LOAD READ ONLY MEMORY) when the failing location does take its complement, and 23H (MEMORY FAULT) when it does not, as ROM does.
• The start-up loops at 4E53H and 4E74H end in JR NZ with a displacement of 00H, so only 43CCH is cleared and only the keyboard control block is copied to 4358H.
• 4661H-4668H (issue a command and wait) is not called by any TRSDOS 2.3 module; 4B9FH is a loaded byte nothing executes.
• The overlays are read through the FCB at 44A0H using only its first extent; the two bytes after it (44B0H-44B1H) are code and serve as that extent's running granule total.

Resident Variables

Self-Modifying Code

Addresses Outside SYS0/SYS

4000H - Restart Vectors Kept by the ROM

The Model I ROM sends RST 08H, RST 10H, RST 18H and RST 20H to the three-byte vectors at 4000H, 4003H, 4006H and 4009H. SYS0/SYS does not load these twelve bytes and none of its code reads or changes them; they are listed so that the whole of 4000H-4DFFH can be followed on this page.

400CH - RST 28H and RST 30H Vectors

The ROM's 0028H does JP 400CH and its 0030H does JP 400FH. SYS0/SYS loads a JP into each: RST 28H becomes the TRSDOS 2.3 overlay call (Register A = function code) and RST 30H becomes the DEBUG entry. The RST 38H vector at 4012H-4014H is written at run time by the start-up code at 4E81H-4E8AH.

402DH - DOS Exit Vectors

Three fixed entries that programs and the overlays jump to when they finish. 402DH returns to DOS READY, 4030H is the exit after an error message has already been shown, and 4033H is the device dispatch the ROM's driver entry jumps to when a device control block's type does not match the request.

403EH - Version Byte and Clock Counters

Three bytes loaded at 403EH-4040H. 4041H-404AH (the time, the date and two memory limits) are not in the file; the start-up code sets 4047H-404AH and the time and date start at whatever the RAM held.

404BH - Interrupt Status, Enable Mask and Interrupt Task Vectors

The interrupt handler at 4518H reads the Model I interrupt latch at 37E0H, keeps the value in 404BH, masks it with the enable bits in 404CH and calls the routine whose address is in the two-byte slot for each set bit: bit 0 uses 404DH, bit 1 404FH and so on up to bit 7 at 405BH. Every slot starts as 4537H, a RET.

405DH - RAM Not Loaded by SYS0/SYS

405DH-42FFH is outside the SYS0/SYS file. Two parts of it matter to the resident DOS: the stack, which every TRSDOS 2.3 entry point (4E03H here, 4E20H in SYS1/SYS) sets to 41FCH, and the sector buffer at 4200H-42FFH that SYS0/SYS uses for directory and allocation table sectors.

4300H - Drive Tables and System Variables

Eighteen bytes loaded at 4300H-4311H: the last head position and the directory track of each of the four drives, the drive that is selected now, the last file call, the overlay that is in memory and the system flags.

4398H - Wait Until the Disk Controller Is Not Busy

Called with nothing in particular in the registers. Polls bit 0 (BUSY) of the WD1771 status register at 37ECH until it is clear. Unlike 4669H it does not write the drive select latch first. Changes Register A.

43ACH - Select the Drive and Read the Disk Status

Called by 4669H, which loops on it until the controller is not busy. Writes the saved select latch value to 37E1H, which also restarts the drive motor timer, then returns the WD1771 status in Register A.

43D1H - Last Record Adjustment (Patch for 4768H)

A separate load record whose CALL replaces the LD A,(IX+08H) that SYS0/SYS first loads at 4768H. Entered from the position-to-end routine with Register Pair BC = the file's ending record number (ERN). When the last sector is only partly used it steps back to that sector, so the next write goes into it at the end byte.

43D8H - Keyboard Scan (TRSDOS 2.3 Driver)

4F23H installs this as the keyboard driver address at 4016H. It is the ROM's row scan from 03E3H with an added debounce: a newly pressed key must still be down after a short delay, otherwise the scan reports no key. Returns Register A = 00H when no new key is down.

4400H - DOS Entry Point Table

Fixed addresses that SYS1/SYS-SYS6/SYS, BASIC/CMD and the utilities call. Each entry is either a JP into SYS0/SYS or LD A,code / RST 28H, which loads the overlay named by bits 0-3 of the code into 4E00H-51FFH and runs the function named by bits 4-6 (SYS1/SYS is overlay 3, SYS2/SYS 4, SYS3/SYS 5, SYS4/SYS 6, SYS5/SYS 7). The bytes between the entries are not part of the file.

4480H - Command FCB and the Overlay FCB

4480H-449FH is the 32-byte FCB that SYS1/SYS fills with the filespec of a typed command (4E52H); SYS0/SYS loads it with a placeholder text. 44A0H-44AFH is the FCB that the overlay loader at 4BA2H uses to read SYS1/SYS-SYS6/SYS into memory; its fields are filled in at 4BC1H-4BDCH.

44B0H - Error Message and DEBUG Entries

44B0H saves the error number and loads SYS4/SYS, which displays the message and then returns to the caller or exits through 4030H. 44B4H saves Register Pair AF and loads SYS5/SYS, the DEBUG monitor.

44B8H - Device Dispatch (4033H)

Entered through 4033H when the ROM's driver entry at 03C2H finds that the type byte of the device control block in Index Register IX does not match the request in Register B (01H input, 02H output, 04H control) and Register C holds the character. A type of 10H links to another control block, a type above 10H (an open FCB) sends the request to the file routines, and anything else calls the driver.

44CFH - Display a Message (4467H)

Register Pair HL points to the text. Each character goes to the display through the ROM's 0033H; the text ends after a 0DH (displayed) or at a 03H (not displayed). Register Pair HL is returned unchanged.

44DFH - Print a Message (446AH)

The same as 44CFH, but each character goes to the printer through the ROM's 003BH. The text ends after a 0DH (printed) or at a 03H (not printed). Register Pair HL is returned unchanged.

4500H - Timer Task Slots

Twelve two-byte slots, 4500H-4517H. Each holds the address of a task control block: a word with the task's routine address, followed by whatever the task keeps for itself (Index Register IX points to the block while the task runs). The clock routine at 4560H runs slots 8-11 on every clock tick and one of slots 0-7 per tick in turn. Every slot starts with 45A3H, the empty task.

4518H - Interrupt Handler (RST 38H)

The RST 38H vector at 4012H jumps here (set at 4E81H-4E8AH). Reads the Model I interrupt latch at 37E0H, keeps only the sources enabled in 404CH and calls the routine in the vector for each set bit (bit 0 at 404DH up to bit 7 at 405BH). Then, if BREAK is held and the BREAK vector at 4315H is armed, leaves through that vector instead of returning.

4560H - Clock Tick Routine

The vector for interrupt bit 7 (405BH) points here (set at 4E8DH-4E90H). Runs the tasks in slots 8-11 on every tick, adds 1 to the tick counter at 4040H and runs one of slots 0-7, chosen by the counter's low three bits. Called from 4538H with Register Pair HL, Register Pair DE, Register Pair BC, Register Pair AF and Index Register IX already saved.

457BH - Run the Task in a Timer Slot

Register A = the slot number (00H-0BH). The address of the slot is remembered in the operand at 45A6H for 4416H and 4419H, Index Register IX is pointed to the task control block and the task's routine is jumped to; the task's RET returns to whoever called 457BH.

458EH - Timer Slot Maintenance (4410H-4419H)

Four entries share the code that stores a task control block address into a slot with interrupts off. 4596H stores Register Pair DE into slot Register A (4410H); 4593H stores the empty task 45A3H (4413H); 458EH does that for the slot that is running, dropping the caller's return address (4419H); 45A5H makes the running task continue after its CALL next time (4416H).

45AFH - Clock Task (Timer Slot 7)

The task control block 45AFH-45B1H is put into slot 7 by the start-up code (4EA4H-4EA9H). Slot 7 runs once every eight ticks; the counter at IX+02H lets five of those runs pass, so the routine at 45B6H runs once for every 40 ticks and adds one second to the time at 4041H-4043H, carrying into the date at 4044H-4046H.

4600H - Select a Drive

Register C = the drive number (00H-03H). When the drive differs from the one in 4308H, the controller's track register is saved for the old drive at 4300H plus its number and loaded from the new drive's byte, and the new select latch value is built. The drive is then selected through 37E1H; if the controller showed NOT READY, a delay lets the motor come up to speed. Register Pair HL is preserved.

4639H - Bit Number to Bit Mask

Register A = a bit number (only bits 0-2 are used). Builds the second byte of SET n,A in the operand at 4645H and executes it on a cleared Register A, returning Register A = 1 shifted left n times. 461EH uses it for the drive select latch value and 4A9DH for the granule bit in the allocation table.

4647H - Select the Drive and Seek to the Track

Register C = drive, Register D = track, Register E = sector. Selects the drive (4600H), waits until the controller is free, loads the sector register with Register E and the data register with Register D, and issues a SEEK (1FH) only when the head is not already on track Register D. 4686H calls it before every try of a sector read or write; 4732H calls it to move the head after positioning a file.

4669H - Wait Until the Controller Is Not Busy

Selects the drive again through 43ACH and polls BUSY (bit 0) of the status register until it clears. Also the routine of interrupt bit 6 (vector 4059H, set at 4E96H): reading the status register clears the disk controller's interrupt request.

4671H - Sector Read and Write Core

Called from the four entries at 46DDH-46F3H with Register A = the WD1771 command and four inline bytes after the CALL: the number of tries, the error number for status bit 0 (the error is that number plus the position of the lowest status error bit), and the two instructions that move a data byte. The CALL's return address is used only to find those bytes, so the routine returns to whoever called the entry. Register C = drive, Register D = track, Register E = sector, Register Pair HL = the 256-byte buffer. Returns Register A = 00H and the Z FLAG, or the error number and the NZ FLAG.

46DDH - Sector Read and Write Entries

Each entry loads the WD1771 command into Register A and calls 4671H, followed by its four inline bytes. Register C = drive, Register D = track, Register E = sector, Register Pair HL = buffer. 46DDH reads a sector into the buffer, 46E6H writes the buffer with the normal FBH data mark, 46EFH writes it with an FAH data mark (directory and allocation table sectors), and 46F3H reads a sector without storing it, to check that it can be read.

4700H - Position (4442H)

Register Pair DE = an open FCB, Register Pair BC = the record number. With logical records (bit 7 of FCB+01H set) the record number is multiplied by the record length to find the sector and the byte offset in it; otherwise Register Pair BC is the sector. The changed buffer is written first, the sector becomes the next record number with bit 5 of FCB+01H set (load the buffer before the next byte), and the sector's address is worked out (allocating space when needed) and the head moved there. Bit 6 of FCB+01H is set, so later writes inside the file do not move its end.

4737H - Back Up One Record (4445H)

Register Pair DE = an open FCB. Without logical records the next record number is reduced by one sector. With logical records the byte offset is reduced by the record length, and the record number by one when the offset goes below zero. The routine takes the next record number as the sector the current byte is in, which holds while bit 5 of FCB+01H is set (the buffer is used up); with bit 5 clear the next record number is one past the buffered sector, so the position set is one sector further on.

4756H - Rewind (443FH)

Register Pair DE = an open FCB. Sets the next record number to 0 and the byte offset to 0 through 4717H.

475FH - Position to the End of the File (4448H)

Register Pair DE = an open FCB. Takes the ending record number from FCB+0CH and the end-of-file byte from FCB+08H; the CALL 43D1H (a later load record over the original LD A,(IX+08H)) steps back to the last sector when it is only partly used. The result is set through 4717H, so a following write adds to the file.

476DH - Read (4436H)

Register Pair DE = an open FCB. Without logical records the next sector is read into the FCB's buffer (480EH). With logical records, one record of FCB+09H bytes is read byte by byte (47BBH) into the memory at Register Pair HL.

478BH - Write (4439H) and Write with Verify (443CH)

Register Pair DE = an open FCB. The operand at 485EH is set to 00H (no check) or 01H (read the sector back after writing). Without logical records the FCB's buffer is written as the next sector (483EH). With logical records, one record of FCB+09H bytes is taken from Register Pair HL and written byte by byte (47DAH).

47AEH - One Byte to or from a File Used as a Device (44C8H)

Reached from the device dispatch at 44C8H when the control block in Index Register IX is an open FCB. Register B = the ROM's request (01H input, 02H output) and Register C = the character. Input reads the next byte of the file (47BBH); output writes Register C (47DAH). Bit 7 of FCB+01H is set, so the buffer is handled as a stream of bytes.

47BBH - Read the Next Byte

Index Register IX = an open FCB (after 4892H). Checks the position against the end of the file, reads the next sector into the buffer when bit 5 of FCB+01H says the buffer is used up, takes the byte at the buffer plus the byte offset and adds 1 to the offset, setting bit 5 again when the offset wraps to 00H. Returns Register A = the byte and the Z FLAG, or the error number and the NZ FLAG.

47DAH - Write the Next Byte

Register A = the byte, Index Register IX = an open FCB. When bit 5 of FCB+01H is set the sector at the next record number is read into the buffer first, so the rest of it is kept. The byte is stored at the buffer plus the byte offset, the buffer is marked as changed and the offset moved on; the end-of-file byte follows the offset when the write is at or past the end (or when the file has not been positioned). When the offset wraps to 00H the full buffer is written (483EH).

480EH - Read and Write a Sector of a File

480EH reads the sector at the next record number into the FCB's buffer and adds 1 to the next record number (481BH is the same without the access check); 482DH only reads the sector; 483EH writes the buffer as the sector at the next record number (484BH without the access check), moves the ending record number when the write is at the end, and adds 1 to the next record number. Index Register IX = the open FCB throughout.

4878H - Write the Buffer if It Holds Changed Records

Index Register IX = an open FCB. When the file has logical records (bit 7 of FCB+01H) and the buffer has been changed (bit 4), the buffer is written as the sector at the next record number through 483EH; otherwise Register A = 00H. SYS3/SYS also calls it at 4E71H before closing a file.

4883H - Address of the Current Byte in the Buffer

Index Register IX = an open FCB. Returns Register C = the byte offset (FCB+05H) and Register Pair DE = the buffer address (FCB+03H) plus that offset.

4892H - File Call Set-Up

Called as the first instruction of every file routine (4700H, 4737H, 4756H, 475FH, 476DH, 478BH, 47A8H, 47AEH and SYS3/SYS's close and kill) with Register Pair DE = the FCB. Refuses an FCB without bit 7 of byte 0 set (error 26H, FILE NOT OPEN). Otherwise it records the FCB and the caller's return address in 430AH and 430CH, points Index Register IX at the FCB, saves the caller's Register Pair BC, Register Pair DE, Register Pair HL and Index Register IX and pushes 48B3H, so the file routine's final RET restores them. SYS2/SYS enters at 4896H to set up an FCB that is not open yet.

48B9H - Compare the Position with the End of the File

Index Register IX = an open FCB. Compares the next record number (FCB+0AH) with the ending record number (FCB+0CH); when they are equal, compares the byte offset (FCB+05H) with the end-of-file byte (FCB+08H). Returns Register A = 00H and the Z FLAG before the end, Register A = 1CH (END OF FILE ENCOUNTERED) at the end, or 1DH (RECORD NUMBER OUT OF RANGE) past it, with the NZ FLAG. Also returns Register Pair HL = the next record number and Register C = the byte offset.

48DCH - Disk Address of the Next Record Number

Index Register IX = an open FCB. A granule is five sectors and a track holds two granules (sectors 0-4 and 5-9). The next record number (FCB+0AH) is divided by 5: the quotient is the granule counted from the start of the file and the remainder the sector inside it. The FCB keeps up to five extents of the file at FCB+0EH, four bytes each: the track, the granule byte (bits 5-7 = first granule on that track, bits 0-4 = number of granules minus 1) and the granule number at which the next extent of the FCB begins. Extent 1 always begins at granule 0. When no extent in the FCB covers the granule, the directory is searched (49B5H), extending the file when needed, and the extent found is put into the second extent of the FCB. Returns Register C = drive, Register D = track, Register E = sector and the Z FLAG, or an error number and the NZ FLAG.

49B5H - Find a Granule in the Directory Extents

Register Pair BC = the granule of the file that is wanted, Index Register IX = the open FCB. Reads the file's directory entry (locator FCB+07H) and walks its extent list (entry bytes 16H-1FH, two bytes each: track, then granule byte). A track byte of FEH means the list goes on in another directory entry whose locator follows; FFH ends the list. When the list ends before the granule wanted, granules are allocated (4A00H) and the search starts again. Returns Register H = the extent's granule byte, Register L = its track and Register Pair DE = the granule of the file at which the extent begins.

4A00H - Allocate Granules to a File

Register Pair BC = the granule of the file that is wanted, Register Pair DE = the granules the file has, Register Pair HL = the FFH end mark in its directory entry (in the sector at 4200H), Index Register IX = the open FCB. Reads the allocation table of the drive into 4D00H-4DFFH (one byte per track, bit 0 = granule 0, bit 1 = granule 1; FFH = no granule free) and allocates the granule wanted minus the granules the file has, plus two. Each granule extends the last extent when the next granule on the disk is free and the extent has fewer than 32 granules; otherwise a new extent is started at the first free granule found from a track chosen by the entry's directory sector. The allocation table and the directory sector are written back at the end (4AB6H).

4AC1H - Read a Directory Sector

Register B = a directory entry locator (bits 5-7 = the entry's offset in the sector in steps of 20H, bits 0-4 = the directory sector minus 2, 0-7), Register C = drive. Reads the directory sector holding the entry into 4200H-42FFH and returns Register Pair HL = the entry. Registers B, C, D and E are kept. Returns Register A = 00H and the Z FLAG, or 11H (DIRECTORY READ ERROR) and the NZ FLAG. Used by SYS2/SYS, SYS3/SYS, SYS4/SYS and SYS6/SYS.

4AD6H - Write a Directory Sector

Register B = a directory entry locator, Register C = drive; the sector is in 4200H-42FFH. Writes it with the FAH data mark and reads it back, expecting the read to report that mark (error 06H). Returns the Z FLAG, or Register A = 12H (DIRECTORY WRITE ERROR) or 10H and the NZ FLAG. Used by SYS2/SYS, SYS3/SYS and SYS6/SYS.

4AF0H - Read the Allocation Table

Register C = drive. Reads sector 0 of the drive's directory track (the granule allocation table) into 4D00H-4DFFH, accepting it only with the FAH mark. Registers D, E, H and L are kept. Returns the Z FLAG, or Register A = 14H (GAT READ ERROR) and the NZ FLAG. Used by SYS3/SYS and SYS6/SYS.

4B03H - Write the Allocation Table

Register C = drive; the allocation table is in 4D00H-4DFFH. Writes it to sector 0 of the directory track with the FAH mark and reads it back. Returns the Z FLAG, or Register A = 15H (GAT WRITE ERROR) and the NZ FLAG. Used by SYS3/SYS and SYS6/SYS.

4B1EH - Directory Entry Locator to Track, Sector and Address

Register B = an entry locator, Register C = drive. Returns Register D = the drive's directory track, Register E = the sector (locator bits 0-4 plus 2), Register Pair HL = 4200H plus the entry offset (locator bits 5-7 times 20H) and the Z FLAG, or Register A = 10H (ILLEGAL LOGICAL FILE NUMBER) and the NZ FLAG when bits 0-4 are 8 or more.

4B35H - Read a System Sector

Register C = drive, Register D = track, Register E = sector, Register Pair HL = buffer. Directory and allocation table sectors are written with the FAH data mark, which a read reports as error 06H; this routine turns 06H into success. When the read succeeds with a normal mark instead, the diskette's directory is not on track Register D: the boot sector (track 0, sector 0) is read and its byte 2 becomes the drive's directory track at 4304H plus the drive, and the read is repeated. Used by SYS2/SYS, SYS3/SYS, SYS6/SYS and the start-up code (4ECBH).

4B55H - Directory Track of a Drive

Register C = drive. Returns Register D = the directory track from 4304H plus the drive, and Register Pair HL = that address. Used by SYS2/SYS, SYS3/SYS and SYS6/SYS.

4B5DH - Test a Bit Chosen at Run Time

Register A = a bit number (0-7), Register B = the byte to test. Builds BIT n,B in the operand at 4B68H and executes it, returning the Z FLAG when bit n of Register B is clear. 4A4FH and 4A90H use it to find a free granule in an allocation table byte.

4B6AH - Multiply a Record Number by the Record Length

Register Pair HL = the record number, Register A = the logical record length (00H stands for 256). Returns Register Pair HL = the product divided by 256 (the sector) and Register A = the product's low byte (the byte offset). Register Pair BC is kept; Register Pair DE returns the record number.

4B84H - Divide by a Byte

Register Pair HL = the dividend, Register A = the divisor. Returns Register Pair HL = the quotient and Register A = the remainder; Register Pair DE is kept. 48E4H uses it with 5 (sectors per granule); SYS3/SYS calls it at 4EE2H.

4B97H - End-of-File Byte Compare

Called by 48CFH when the next record number equals the ending record number, with Register C = the byte offset minus 1 and Index Register IX = the FCB. Returns Register A = (end-of-file byte minus 1) minus Register C, the Z FLAG when the offset is exactly the end, the CARRY FLAG when it is before the end, and Register C put back to the byte offset.

4BA0H - Default Hook for RST 28H Codes Below 80H

The JP at 4312H points here until a program (BASIC/CMD) changes it. Returns Register A = 00H, so the ROM's keyboard routine (which executes RST 28H with Register A = 01H for BREAK at 0456H) reports no key.

4BA2H - RST 28H: Load and Call a System Overlay

Register A = the function code. Bits 0-3 name the overlay: its directory entry is in sector (bits 0-3) plus 2 of the directory track, entry 0, or for overlay numbers 8-15 in sector (bits 0-3) minus 6, entry 1 (offset 20H). Bits 4-6 select the function inside the overlay. The overlay is read through the FCB at 44A0H into 4E00H-51FFH or wherever its load records say, unless 430EH shows it is already there, and its transfer address is called with Register A = the code and the caller's Register Pair BC, Register Pair DE and Register Pair HL. The BREAK vector at 4315H is disarmed while the overlay runs. The RST's own return address is dropped, so the overlay returns to the caller of the routine that executed the RST.

4C06H - Load and Run a Program (4433H)

Register Pair DE = an FCB holding a program's filespec. The program is loaded through 4430H; on an error the message is displayed (4409H). Otherwise its transfer address is jumped to, or, when the DEBUG flag (bit 7 of 430FH) is set, DEBUG is entered first with the transfer address as the address to continue at.

4C16H - Load a Program (4430H)

Register Pair DE = an FCB holding a program's filespec. Opens it with the buffer at 4D00H and whole sectors, refuses a file of access level 6 or 7 while DEBUG is on (error 25H), and loads its records (4C39H). Errors from the open come back with bit 6 set; 18H (not in the directory) becomes 5FH, PROGRAM NOT FOUND with bit 6. Returns Register Pair HL = the transfer address and the Z FLAG.

4C39H - Load Module Loader

Register Pair DE = an open FCB whose buffer is 4D00H. Reads the file a byte at a time (4C8CH) as records: a type byte, a length byte (00H = 256), then that many bytes. Type 01H is a load block (two-byte address, then data, each byte checked after storing); type 02H is the transfer address and ends the load; other types below 20H are skipped; 20H and above give error 22H. Returns Register Pair HL = the transfer address and the Z FLAG. 4BE2H uses it for overlays.

4C8CH - Fetch the Next Byte for the Loader

Register C = the byte offset in the buffer at 4D00H, Register Pair DE = the open FCB. Moves Register C on by one; when it wraps to 00H the next sector of the file is read into the FCB's buffer through 481BH. Returns Register A = the byte at 4D00H plus Register C. On a read error it drops the loader's return address and returns to the loader's caller with the error number plus bit 6.

4CA9H - Time Display Task

A task control block for timer slot 6, where SYS6/SYS puts it (52C8H-52D0H). Slot 6 runs once every eight ticks and the counter at 4CABH lets five runs pass, so once a second the time is written as HH:MM:SS into the top line of the screen at 3C35H-3C3CH.

4CB7H - Time and Date as Text (446DH and 4470H)

4CB7H writes the time as HH:MM:SS and 4CD2H the date as MM/DD/YY, eight characters at Register Pair HL. Each of the three values (00-99, binary) is turned into two decimal digits; the separator is in Register C. Register Pair HL returns just past the text.

4CD9H - Program Address Display Task (TRACE)

A task control block for timer slot 11, where SYS1/SYS's TRACE command puts it (5191H-519CH). Slot 11 runs on every clock tick, called from 4571H, so the address the interrupted program was executing is the word 12H bytes up the stack; it is shown as four hexadecimal digits at the top of the screen at 3C2EH-3C31H.

4CEAH - Show a Byte as Two Hexadecimal Digits

Register A = the byte, Register Pair HL = the screen address. Writes the high digit and then the low digit and returns with Register Pair HL past them.

4D00H - Overlay and Allocation Table Buffer

Not part of the file. 4D00H-4DFFH is the 256-byte buffer the program loader (4C16H) and the overlay loader (FCB at 44A0H) read sectors into, and where 4AF0H and 4B03H keep the allocation table while granules are allocated.

4E00H - Start-Up

BOOT/SYS loads SYS0/SYS and jumps to its transfer address 4E00H. This code runs once and is then overwritten by the overlays, which load at 4E00H. It finds the top of memory, installs the keyboard driver, copies the device control blocks, sets up the interrupt handler, the clock and the disk interrupt routine, shows the sign-on message and then runs the AUTO command stored in the allocation table sector, unless ENTER is down or no AUTO command is set. The start-up code does not enable interrupts itself; SYS1/SYS's DOS READY code does (EI at 4E1FH).

4F20H - Install the Keyboard Driver

A separate load record reached by the JP at 4E20H. It puts the keyboard scan with debounce at 43D8H into the ROM's keyboard control block and goes back to the start-up code with Register Pair HL = 43D8H.