LDOS 5.3.1 for the Model III - SYS0/SYS Disassembled

SYS0/SYS

Other Navigation

LDOS 5.3.1 SYS0/SYS Disassembly - The Resident System (Model III)

SYS0/SYS is the resident part of LDOS 5.3.1 for the Model III: the file the boot sector loads and jumps to. It is a load module of 4184 bytes on the diskette: a name record, a copyright record and 34 load blocks (3985 bytes) and the transfer record for 4E00H. Four blocks go into video memory (the sign-on lines and the logo, 3C00H-3E7FH), the rest into 400CH-50FFH. 4000H-4DFFH stays resident while LDOS runs; 4E00H-50FFH is the reset, which runs once at boot and is then overwritten, because 4E00H-51FFH is the area the other system files (SYS1/SYS-SYS12/SYS) are loaded into.

The Model III ROM keeps its own RAM at 4000H-42FFH, and LDOS fits its cells around it: the restart vectors and the ROM's three device control blocks (4000H-402CH) are loaded with the ROM's own values, the ROM's clock vector (4046H) becomes @KLTSK, the ROM's two RS-232 device control blocks (41E5H-41F4H) hold SYS0/SYS's keyboard and printer drivers, and TIME$ and DATE$ are the ROM's own clock bytes (4217H-421CH), which the ROM's real time clock routine keeps up to date: SYS0/SYS calls that routine after its tasks on every clock interrupt.

The resident part holds the supervisor call vectors (4400H-4470H, with more request stubs at 4203H-420BH and 4285H-42B7H), the interrupt service routine and the task table (44A5H-456AH), the floppy disk driver for the controller at ports F0H-F4H (456BH-46FFH), the drive code tables (4700H), the disk primitives (4750H), the file system (47CBH-4A40H), the space finder (4A41H-4B0FH), the directory routines (4B10H-4B6AH), the arithmetic (4B6BH-4BBAH), the supervisor dispatcher and overlay loader (4BCCH-4C5CH), @RUN, @LOAD and the module loader (4C5DH-4D38H) and the text output, the device hook and the keyboard scan (4D39H-4DEFH).

Request Codes

A program calls the system through RST 28H with a request code in Register A (the stubs of the vector table do this for it). Codes 80H and up name a system file in bits 3-0 (the file number plus 2: 3 for SYS1/SYS up to 0EH for SYS12/SYS; 88H and 89H are the libraries SYS6/SYS and SYS7/SYS, whose member is given in Register B) and a function of that file in bits 6-4. The dispatcher (4BCCH) loads the file into 4E00H when it is not already there (OVRLY$, 4414H, names the file in place), reading its directory record (3-7 for SYS1/SYS-SYS5/SYS, 20H-26H for SYS6/SYS-SYS12/SYS) on drive 0 through SFCB$ (42A1H), and calls it with the request code in Register A. Codes below 80H are refused with SYS Error, except 01H while the reset's change at 4BEFH is in force.

How the Floppy Disk Driver Reads and Writes

The driver (4583H) selects the drive through port F4H (the select bit, the side, double density and, on a double density cylinder above the directory, write precompensation), seeks with the cylinder in the data register and the sector of the track side in the sector register, and then runs a transfer loop with wait states (bit 6 of port F4H): the read loop takes 256 bytes with INI and ends by its count, the write loop has no end of its own and is left through the NMI that the controller's interrupt request causes at the end of the command (port E4H bits 7-6, the NMI routine at 46F9H). A read that finds no record changes the drive's density in its drive code table and tries again, up to six tries; the error number is the operation's first number plus the position of the lowest status error bit.

The Reset

At 4E00H the reset saves the ROM's clock routine and installs @KLTSK, its NMI routine, interrupt mode 1 and its stack, clears the spare device control blocks, sets port ECH (38H), the interrupt mask (only the real time clock) and port FEH, finds the top of memory, puts its drivers into the keyboard, video and printer blocks (the video driver only when RIGHT ARROW is not held), takes the step rate and the directory cylinder of drive 0 from the boot sector, enables interrupts and reads the system information sector (BOOT/SYS sector 2) into 4300H. It asks for the date and the time unless the sector says not to (or a date is kept over a reset), copies the drive code tables of drives 1-7, reads the allocation table of drive 0, shows the diskette's name and date, and decides on the AUTO command and CONFIG/SYS. Its last part runs as a copy at 405DH, because loading CONFIG/SYS loads system files over the reset.

Cells of SYS0/SYS

Address Size	Contents
4015H-402CH 24 bytes	KIDCB$, DODCB$, PRDCB$ The ROM's keyboard, video and printer device control blocks, eight bytes each, as the ROM's power-up copy loads them; the reset changes their driver addresses.
402DH-4032H 6 bytes	@EXIT and @ABORT LD A,93H and RST 28H twice: request 93H, LDOS Ready.
4046H-4048H 3 bytes	@KLTSK The ROM's clock vector; the reset stores 454AH at 4047H.
4049H-404BH 3 bytes	NMI Vector The reset stores 46F9H at 404AH, the floppy disk driver's NMI routine.
405DH-408AH 46 bytes	The End of the Reset A copy of 5054H-5081H run at boot (DBGSV$ afterwards).
4203H-4205H 3 bytes	BREAK Vector JP 44FAH: cassette off and @ABORT. Interrupt bits 0-1 go here as well.
4210H 1 byte	Port ECH Copy 38H from the reset, OR 78H with FAST.
4213H 1 byte	Interrupt Mask Copy 04H, the real time clock only.
4217H-4219H 3 bytes	TIME$ Seconds, minutes, hours, set by the Time prompt.
421AH-421CH 3 bytes	DATE$ Year (0-99), day, month.
421DH-421FH 3 bytes	@ICNFG A RET and two spare bytes, called after CONFIG/SYS (5072H).
4220H-4221H 2 bytes	JDCB$ The control block of the current file call (49F9H).
4225H-4264H 64 bytes	INBUF$ The command line; the boot prompts and the AUTO command use it.
4245H-4255H 17 bytes	CONFIG/SYS.CCC:0 The file specification the reset loads.
4265H-4284H 32 bytes	JFCB$ The JCL file's control block (the date parser is there at boot).
4285H-4287H 3 bytes	@KITSK A RET hook the keyboard driver calls on every key request.
4288H 1 byte	TIMER$ The clock tick counter (4533H).
4289H 1 byte	DFLAG$ The device flags, 00H at boot.
428AH 4 bytes	@LOGOT, @LOGER Display and log a text; @LOGER at 428DH is a RET.
429FH 1 byte	KFLAG$ Bit 0 BREAK, bit 1 SHIFT @ (pause), bit 2 ENTER (4DBEH).
42A0H 1 byte	Port FEH Byte 00H, sent to port FEH by the reset.
42A1H-42B4H 20 bytes	SFCB$ The control block for system files; its buffer is 4300H.
42B8H-42BFH 8 bytes	KISV$, DOSV$, PRSV$, KIJCL$ The driver addresses the reset installs (41EDH, 4DB2H or 0473H, 41E5H), and SYS11/SYS's keyboard driver word.
42C2H-42D3H 18 bytes	JLDCB$, SIDCB$, SODCB$ Six byte device control blocks of type 08H with the driver 497CH.
42D4H-42EBH 24 bytes	Spare Device Control Blocks Cleared by the reset (4E1BH).
42ECH-42FFH 20 bytes	Device Names KI, DO, PR, JL, SI, SO and four empty names.
4300H-43FFH 256 bytes	SBUFF$ The system buffer: the system information sector, the allocation table, directory sectors and system files pass through it.
4400H-4401H 2 bytes	DEBUG Hook 4876H, OR A and RET, for a command SYS5/SYS does not know.
4405H-4407H 3 bytes	BREAK Trap C9H (off) or C3H (on) and the address 440DH.
4411H-4412H 2 bytes	HIGH$ The highest address free for programs.
4413H 1 byte	Year Offset The years since 1980 (0-31).
4414H 1 byte	OVRLY$ The request code of the system file at 4E00H.
4415H-4416H 2 bytes	Top of Memory As found by the reset.
4417H-4418H 2 bytes	Day of the Year and Date Flags Day of the year (9 bits), day of the week (bits 3-1 of 4418H), leap year (bit 7).
441FH 1 byte	OSVER$ 53H, version 5.3.
4423H 1 byte	PDRV$ The last drive select value sent to port F4H.
4427H 1 byte	LDRV$ The drive of the last disk primitive call.
442BH 1 byte	SFLAG$ System flags: bit 2 @RUN, bit 3 FAST, bit 4 BREAK disabled.
442FH 1 byte	Kept Month The month OR 50H once a date is set; 50H skips the date and the time.
4457H 1 byte	Kept Day The day of the system date.
4473H-4484H 18 bytes	INTIM$, INTMSK$, INTVC$ The latch image, the mask 7FH and eight vectors (4203H, 4203H, 4518H, then 44C2H).
4485H-44A4H 32 bytes	CFCB$ The control block of the command being run.
4500H-4517H 24 bytes	TCB$ Twelve task slots, each the address of a task block (455FH when empty).
4562H-4563H 2 bytes	Running Task Entry The operand of LD HL at 4561H, stored at 453BH.
4666H-4667H, 468BH 3 bytes	Transfer Loop and First Error Number Stored by 464CH from the bytes after each CALL 464CH.
4700H-474FH 80 bytes	DCT$ Eight drive code tables of 10 bytes.
4758H, 475DH, 4762H, 4767H 4 bytes	Spare Bytes of the Primitives 4758H a status byte of SYS1/SYS, 475DH flags of SYS2/SYS and SYS3/SYS, 4762H the tick pattern FFH, 4767H 01H for SYS8/SYS.
4BBCH-4BBDH 2 bytes	ROM Clock Routine The operand of LD DE at 4BBBH: 3529H from 4047H.
4BC8H-4BC9H 2 bytes	Overlay Length Loaded by every system file.
4BCAH-4BCBH 2 bytes	JRET$ The return address of the current file call (49F6H).
4BE4H-4BE5H, 4BE8H 3 bytes	Dispatcher Operands The entry of the system file and the saved BREAK trap switch.
4DB7H-4DB8H 2 bytes	ROM Video Driver The operand of CALL 0474H at 4DB6H.
4DF0H-4DFDH 14 bytes	Base Cells Used by members of SYS6/SYS and SYS7/SYS.

Ports

Address Size	Contents
F0H-F3H 4 ports	Floppy Disk Controller F0H command and status, F1H track, F2H sector, F3H data.
F4H 1 port	Drive Select Bits 3-0 the drive, bit 4 side 1, bit 5 write precompensation, bit 6 wait states, bit 7 double density.
E4H 1 port	NMI Mask C0H during a write (46A5H), 00H otherwise.
E0H 1 port	Interrupt Latch and Mask Read: a 0 bit for each pending interrupt; written: 04H, the real time clock only.
ECH 1 port	Miscellaneous Control 38H at boot, bit 6 added by FAST; reading it clears the clock interrupt (4BC4H).
FEH 1 port	Port FEH The byte at 42A0H, sent at boot.

Outside Routines

Address Where	Use
001BH ROM	@PUT Sends Register A to the device whose control block is at Register Pair DE (4D43H).
0033H ROM	Display a Character Used by the reset's display helpers.
0040H ROM	Line Input Used by the boot prompts (4233H).
0060H ROM	Delay Counts Register Pair BC down; the motor wait (45D9H).
01F8H ROM	Cassette Off 44FAH.
03C2H, 044BH ROM	Printer Driver and Printer Status Reached through SYS0/SYS's printer driver at 41E5H.
0474H ROM	Video Driver after its DI Called by 4DB6H.
3024H ROM	Keyboard Driver Reached through 41F0H.
3529H ROM	Real Time Clock Routine Pushed by the clock interrupt so that it runs after the tasks (451BH).

3C00H - Sign-On Screen (Video Memory, Data)

Four load blocks of SYS0/SYS go straight into video memory (3C00H-3FFFH, 64 characters by 16 rows): while the boot sector loads the file, the sign-on lines and the LDOS logo appear on the screen. They are data, not code. SYS0/SYS's reset later adds the diskette name and date (3CD1H, 3CE5H), the date and time prompts (3F17H, 3F57H) and the day and date line it builds from them.

400CH - Restart Vectors

The Model III ROM sends its RST 28H, RST 30H and RST 38H restarts through these three bytes each (ROM 0028H, 0030H and 0038H jump to 400CH, 400FH and 4012H). SYS0/SYS loads a JP into each: the supervisor call dispatcher, the DEBUG entry and the interrupt service routine. RST 28H with a request code in Register A is how every overlay of the system is called.

4015H - Device Control Blocks of the Keyboard, Video and Printer

The ROM's three device control blocks, eight bytes each, loaded with exactly the bytes of the ROM's power-up copy at 36BFH-36D6H: +00H the type of device, +01H-+02H the address of its driver, +03H-+07H the driver's own bytes. SYS0/SYS's reset then points the keyboard block at 41EDH, the video block at 4DB2H (unless RIGHT ARROW is held) and the printer block at 41E5H, and saves the addresses it installs at 42B8H, 42BAH and 42BCH.

402DH - @EXIT and @ABORT

The two ways a program ends. Both issue request 93H, which runs the LDOS Ready command loop of SYS1/SYS. Programs JP to 402DH (@EXIT) when they finish and to 4030H (@ABORT) when they stop on an error; SYS1/SYS pushes 402DH as the return address of a command it runs (its 4E58H).

41E3H - The Reset's Return Word

Two bytes at the top of the stack SYS0/SYS's reset sets (Stack Pointer 41E3H at 4E15H). Then the printer and keyboard drivers SYS0/SYS puts over the ROM's two RS-232 device control blocks (41E5H-41F4H), which LDOS does not use.

4203H - The BREAK Vector, @CKDRV and the Date

4203H is the vector the ROM jumps to when BREAK is pressed while it waits on the cassette or the RS-232 port (3362H, 3677H, 3699H). Then the ROM's interrupt vector at 4206H, the @CKDRV request stub and the date.

4228H - Boot Prompt: Display, Input, Parse

Used only by the reset (4EBDH for the date, 4FADH for the time); once the reset has finished, 4228H-4264H is part of INBUF$ and the AUTO command is copied over it (502BH-5031H). Register Pair HL gives the screen address of the prompt, Register Pair DE the prompt text, Register B the most characters to accept and Register C the limit for a separator. Returns with the CARRY FLAG set when three fields of two digits were read.

4245H - The CONFIG/SYS Filespec

The name the reset passes to @LOAD (4430H) to load the configuration that SYSTEM (SYSGEN) saved (504BH-5050H). After the reset these bytes are part of INBUF$; SYS1/SYS addresses 424EH (its 4EE1H).

4256H - Parse Three Two Digit Fields

Reads the line at Register Pair HL as three fields of two digits each, separated by any one character below the limit in Register C, and stores them at 4227H, 4226H and 4225H (the first field typed at 4227H). Returns with the CARRY FLAG set when all three were read. A field that is not two digits, a separator not below Register C, or ENTER before the third field returns with the CARRY FLAG clear. 4265H-427FH is reused as JFCB$ after the reset.

4285H - @KITSK, the Flags, @LOGOT and Request Stubs

A hook for the keyboard, TIMER$ and DFLAG$, the job log entries, five request stubs, KFLAG$, the port FEH byte and SFCB$.

42A1H - SFCB$, the Control Block for System Files

A 20 byte file control block the overlay loader uses to read a system file: it stores the directory record number at 42A8H, the flags at 42A2H and a record number of 0 at 42ABH-42ACH, and 47B4H copies the first two extents of the file to 42AFH-42B4H; then the file is loaded through it. Its buffer is SBUFF$, 4300H.

42C2H - Device Control Blocks of JL, SI and SO

Three more device control blocks, six bytes each: the job log (JL), the standard input (SI) and the standard output (SO). Type 08H with the driver 497CH (XOR A and RET): a request to them returns 00H at once until a device is assigned to them. The four spare blocks after them (42D4H-42EBH) are cleared by the reset, and the table of device names follows.

4400H - The Supervisor Call Vectors

The fixed entry points of the system, the same address for every program: each is either a JP to a routine of SYS0/SYS or a request stub, LD A with a request code and RST 28H. A request code names a system file in its low four bits (the file number plus 2: 3 for SYS1/SYS up to 0EH for SYS12/SYS) and a function of that file in bits 6-4. Programs CALL these addresses; the supervisor dispatcher (4BCCH) drops the return address the RST pushes, so the overlay's RET goes straight back to the program. That is why a stub needs no RET, and why the byte after some stubs is free: SYS0/SYS keeps variables there (441FH, 4423H, 4427H, 442BH).

4473H - The Interrupt Latch Image, Mask and Vectors

The interrupt service routine (44A5H) reads the interrupt latch (port E0H, whose bits read 0 for a pending interrupt), keeps its complement at 4473H, masks it with 4474H and calls the vector of every bit that is set, bit 0 first.

44A5H - The Interrupt Service Routine

ROM 0038H (RST 38H in interrupt mode 1) jumps to 4012H and so here. It reads the interrupt latch at port E0H (a bit reads 0 while its interrupt is pending), keeps the complement at 4473H, and for every bit that is also set in the mask at 4474H calls the routine whose address is in that bit's vector at 4475H-4484H, bit 0 first. Then it scans the keyboard for BREAK, SHIFT @ and ENTER (4DBEH): SHIFT BREAK selects the drive of the last disk call again, BREAK alone springs the BREAK trap at 4405H. Registers are kept.

4500H - TCB$, the Task Table

Twelve words, one for each task slot 0-11: the address of the task's block, whose first word is the address of the task's routine (the routine finds its block in Index Register IX and may keep its own bytes after that word). The clock interrupt runs slots 8-11 on every tick and one of slots 0-7 in turn (4518H-4549H). @ADTSK, @RMTSK, @RPTSK and @KLTSK (403DH-4046H) change the entries. In the file every slot holds 455FH, the empty block.

4518H - The Clock Interrupt: Run the Tasks

The vector of interrupt bit 2 (4479H), the real time clock. 4BBBH decides whether this tick runs the tasks; when it does, the address of the ROM's real time clock routine (3529H, saved at 4BBCH by the reset) is pushed as the return address, the tasks of slots 8, 9, 10 and 11 run, TIMER$ (4288H) counts the tick and the task of the slot 0-7 its bits 2-0 select runs last; its RET goes to the ROM's routine, which blinks the cursor and keeps TIME$.

4537H - Run the Task in Slot A

Register A = the slot (0-11). Points Index Register IX at the slot's task block and jumps to the routine whose address is the block's first word. The address of the slot's table entry is kept in the operand at 4562H for @RPTSK and @KLTSK.

454AH - @KLTSK, @RMTSK and @ADTSK

454AH (@KLTSK, the jump at 4046H that the reset installs) is called by a running task to remove itself; 454FH (@RMTSK) removes the task in slot Register A; 4552H (@ADTSK) puts the block at Register Pair DE into slot Register A. Interrupts are off while the two bytes of an entry change. A slot number of 12 or more is ignored.

456BH - Change a Drive's Density

Called by the read and write engine (4680H) when the controller reported record not found, with Register A = byte +03H of the drive code table at Index Register IY. It flips bit 6 (double density) and sets bytes +07H and +08H to the geometry of the new density: 10 sectors a track in two granules of five for single density, 18 sectors a track in three granules of six for double density. After a change to double density the head goes back to cylinder 0.

4583H - The Floppy Disk Driver: Function Dispatch

The address every floppy drive code table jumps to (4700H +00H: JP 4583H). The controller is reached through ports F0H (command and status), F1H (track), F2H (sector), F3H (data) and F4H (drive select, side, density and wait states). Register B = the function: 00H nothing, 01H select, 02H-04H restore to cylinder 0, 05H step in one cylinder, 06H seek, 07H wait until not busy, 08H, 09H and 0BH read a sector, 0AH verify a sector, 0CH and 0DH write a sector, 0EH write a sector with the deleted data mark, 0FH write a track. Register D = the cylinder, Register E = the sector, Register Pair HL = the buffer, Index Register IY = the drive code table. Returns with the Z FLAG set and Register A = 00H when the function succeeded, otherwise Register A = the error number.

45A6H - Select the Drive

Waits until the controller is not busy, then writes the drive's select bit, the side bit, the double density bit and, on a double density cylinder above the directory cylinder, the write precompensation bit to port F4H, and keeps the value at PDRV$ (4423H). When the controller reported NOT READY before the select (its motor was off), waits for the motor through the ROM's delay: once when bit 2 of byte +03H of the drive code table is set, twice when it is clear.

45DEH - Seek: Cylinder D, Sector E

Function 06H, and the first step of every sector transfer (465FH). The sector number in Register E counts through both sides of a cylinder: a number above the highest sector of a track (byte +07H, bits 4-0) sets bit 4 of byte +03H (side 1) and is reduced by the sectors of a track. The current cylinder goes to the track register, the sector to the sector register and the cylinder Register D to the data register, and the Seek command is issued, with the verify bit when the head has to move.

461AH - The Read and Write Engine

Functions 08H and up. Register B gets the number of tries (6) and Register C the controller command: 82H Read Sector with the side compared (functions 08H, 09H, 0AH, 0BH), A2H Write Sector (0CH, 0DH), A3H Write Sector with the deleted data mark (0EH) and F0H Write Track (0FH). The three bytes after each CALL 464CH are its parameters, not code: the first error number of the operation and the address of the transfer loop. A write is refused with error 0FH when bit 7 of byte +03H of the drive code table (the software write protect) is set.

4692H - The Write Loop

The transfer loop of the write commands (the parameter at 464AH). It issues the command, waits for the first data request, writes the first byte, turns on the NMI for the end of the command (port E4H) and then writes byte after byte with wait states, in a loop that only the NMI ends: the NMI routine at 46F9H drops the loop's address and returns to the engine at 4668H.

46BEH - The Verify and Read Loops

46BEH, the verify, points Register Pair HL at 38xxH, the keyboard addresses, where the bytes read are not kept, and goes on into the read loop at 46C0H. The read loop issues the command, waits for the first data request, then takes the 256 bytes of the sector into the buffer with wait states and returns when the controller is not busy.

46D4H - Wait Until the Controller Is Not Busy

Function 07H and the wait of every command. Returns when bit 0 (BUSY) of the controller's status is clear, with the status in Register A and the Z FLAG set. While it waits it writes the last drive select value (PDRV$, 4423H) to port F4H again, which keeps the drive selected and its motor running.

46E0H - Issue a Read or Write Command

Called by the transfer loops with the command in Register C and the cylinder in Register D. Writes the cylinder to the track register, takes the drive select value of PDRV$ with the wait state bit (bit 6), adds the side compare bit for side 1 when the command has its side compare enable bit, and issues the command. Returns with Register D = the drive select value with wait states, Register C = F3H (the data port) and Register B = 00H.

46F9H - The NMI Routine

The reset stores 46F9H at 404AH, the NMI vector (4E07H-4E0CH). The controller's interrupt request at the end of a write causes the NMI (port E4H bits 7-6 set at 46A5H): the NMI pushes the address of the write loop, which this routine drops, so that its RET goes back to the engine at 4668H.

4700H - DCT$, the Drive Code Tables

Eight entries of 10 bytes, drives 0-7 (GETDCT, 478FH, points Index Register IY at entry 4700H + the drive x 10). +00H C3H for a drive that is present (a JP) or C9H for one that is not (a RET, so a call returns at once); +01H-+02H the driver address; +03H flags (bits 1-0 the step rate, bit 2 one motor wait, bit 4 side 1, bit 6 double density, bit 7 software write protect); +04H bits 3-0 the drive select bit; +05H the cylinder the head is on; +06H the highest cylinder; +07H bits 4-0 the highest sector of a track; +08H bits 4-0 the sectors in a granule less one, bits 7-5 the granules on a track less one; +09H the directory cylinder. The reset takes the step rate and the directory cylinder of drive 0 from the boot sector (4E77H-4E88H) and drives 1-7 from the system information sector (4FC8H-4FD1H).

4750H - The Disk Primitives

The named entry points the system and the utilities use for a sector operation: each loads the driver function into Register A and joins 4779H, which calls the driver of the drive in Register C through its drive code table. Each entry is five bytes, and the fifth byte is a variable. 4750H is the same as SELECT with the drive of the last call (LDRV$, 4427H).

478FH - GETDCT and DCTBYT: Find a Drive's Code Table

478FH (GETDCT) points Index Register IY at the drive code table of drive Register C (bits 2-0). 479CH (DCTBYT) returns in Register A byte Register A (an offset 0-9) of drive Register C's table; 4797H does that for byte +08H of the drive in byte +06H of the file control block at Index Register IX. 47A5H works out the address; FORMAT/CMD calls it too.

47B4H - Copy a System File's Extents into SFCB$

The overlay loader (4C36H) calls this with Register A = the low byte of the first extent's address in the directory record in the buffer at 4300H (the record + 16H). It copies the first extent (cylinder, granule byte) to 42AFH-42B0H, stores the number of granules of that extent as a word at 42B1H-42B2H, and copies the second extent (record + 18H) to 42B3H-42B4H.

47CBH - @SKIP and @POSN: Position a File

47CBH (@SKIP) works out the current record (484DH) and positions to the next one; 47CFH (@POSN) positions to record Register Pair BC. Register Pair DE = the file control block (Index Register IX after the prologue). In byte mode (bit 7 of +01H) with a record length below 256, the record number is turned into a sector and an offset (record x length); otherwise the record is the sector. When the buffer already holds that sector only the offset changes; else the buffer is written if it was changed, the next record number (+0AH-+0BH) becomes the sector and bit 5 of +01H marks the buffer to be read before the next byte. Then the end of file is tested (4A1DH).

480FH - @RREAD and @BKSP

480FH (@RREAD) marks the sector the buffer holds to be read again; 4816H (@BKSP) moves back one record (in byte mode by the record length within the buffer when it can, else to the sector before). Both end at 47FEH with the new next record number on the stack.

4835H - @REW and @PEOF

4835H (@REW) positions the file at its first record; 483CH (@PEOF) at its end of file: the ending record number (+0CH-+0DH), less one when the end of file byte (+08H) is not 0, with the end of file byte as the offset.

484DH - @LOC and @LOF

484DH (@LOC) returns in Register Pair BC the current record number of the file; 4878H (@LOF) the number of records (from the ending record number and the end of file byte). A position in sectors and bytes is divided by the record length; a partial record counts as one. Register A returns the high byte of the sector quotient. The result is put where the prologue's restore (4A14H) takes Register Pair BC from.

4886H - @WEOF: Write the End of File to the Directory

Writes the buffer if it changed, then reads the file's directory record (drive +06H, record number +07H) and stores the end of file byte (record +03H) and the ending record number (record +14H-+15H) from the file control block. 49EDH enters at 488CH after a write when bit 3 of +01H asks for it.

48ADH - @READ, @WRITE and @VER

48ADH reads the next record: with 256 byte records the next sector is read into the file's buffer (494FH); with shorter records the record's bytes are taken one by one into the record area at Register Pair HL. 48CBH writes the next record the same way (from the buffer, 49ABH, or byte by byte from Register Pair HL), and 48E6H does the same with the verify switch (49CFH) on.

48ECH - A File Used as a Device

@DVRHK (4D6FH) comes here when a device's control block is an open file (type above 10H): Index Register IX = the file control block, Register B = the request (01H input, 02H output, 04H control), Register C = the character. The file is put into byte mode (bit 7 of +01H) and one byte is taken from it or put into it. 48FCH, the byte fetch, is also used by @READ.

4919H - Put a Byte into a File

Puts the byte in Register A at the current position of the file at Index Register IX: reads the sector first if needed, stores the byte, marks the buffer changed (bit 4 of +01H), and moves the end of file (+08H, +0CH-+0DH) when the byte is at or past it, unless the file was positioned inside (bit 6 of +01H). When the buffer fills it is written out (49A1H).

494FH - Read the Sector of the Next Record Number

494FH tests the end of file first; 4953H does not. The file's access (bits 2-0 of +01H) must allow reading (below 6, else error 25H). The next record number is turned into a cylinder and sector (4A41H, which allocates space when needed), the sector is read into the buffer through RDSECT (4777H), bit 5 is cleared and the next record number goes up by one. A sector with the deleted data mark (error 06H) is accepted.

4993H - Write the Buffer When It Was Changed

4993H writes the buffer to the sector before the next record number only when the file is in byte mode (bit 7 of +01H) and the buffer was changed (bit 4); 499EH (@RWRIT) always writes it, 49A1H writes it after the prologue and 49ABH writes it as the next sector. The access (bits 2-0 of +01H) must allow writing (below 5, else error 25H). After the write (and a verify when 49CFH is 01H) the next record number goes up by one; when the write was at or past the end of file and the file was not positioned inside, the ending record number moves up, and bit 3 of +01H makes the directory record follow at once (488CH).

49F1H - The File Prologue

Every file routine calls 49F3H first (49F1H skips the open test). Register Pair DE = the file control block. 49F3H loads byte +00H and rotates bit 7 (open) into the CARRY FLAG; 49F1H sets the CARRY FLAG instead (the JP NC that follows it is never taken: its bytes 1AH 07H are the LD A,(DE) / RLCA of 49F3H). The routine notes the caller's address in JRET$ (4BCAH) and the control block in JDCB$ (4220H), returns error 26H (file not open) when bit 7 is clear, and otherwise points Index Register IX at the block, saves Register Pairs BC, DE and HL and Index Register IX under the caller's return address with 4A14H on top, and returns with Register A = 00H. The caller's final RET then goes to 4A14H, which restores them.

4A1AH - @CKEOF: Test the End of File

4A1AH (@CKEOF) runs the prologue first; 4A1DH is called by the file routines. It compares the current position (the sector worked out from the next record number by 4D9BH, and the byte position +05H) with the ending record number (+0CH-+0DH) and the end of file byte (+08H). Returns Register A = 00H with the Z FLAG before the end, 1CH (error 28, end of file encountered) at the end, 1DH (error 29, record number out of range) past it, with the NZ FLAG. Register Pair HL comes back as the next record number and Register C as the position in the buffer.

4A41H - Find the Sector of the Next Record Number

Turns the next record number (+0AH-+0BH) of the file at Index Register IX into a cylinder (Register D) and sector (Register E) on drive Register C. The record number divided by the sectors in a granule gives the file's granule and the sector in it (kept in the operand at 4B0CH). The file's extents are searched in the control block (+0EH-+1FH: the first extent at +0EH-+0FH starting at granule 0, then four entries of a starting granule word, a cylinder and a granule byte); an entry not in use has FFH as its cylinder. When the granule is in none of them, SYS8/SYS (request 9AH, @ALLOC) finds or allocates it and updates the entries. A hit in the third to fifth entry is moved to the second entry. The granule then becomes a cylinder (granules a cylinder from byte +08H and +04H bit 5 of the drive code table) and a sector. Returns with Register A = 00H and the Z FLAG set, or with the error number from SYS8/SYS.

4B10H - DIRRD and DIRWR: Read and Write a Directory Sector

4B10H (DIRRD) reads the directory sector that holds record Register B of drive Register C into 4300H and returns Register Pair HL pointing at the record (error 11H, directory read error, on failure). 4B1FH (DIRWR) writes the sector at 4300H back with the deleted data mark and verifies it (error 12H, directory write error, or 0FH, write protected). Directory record B is the 32 byte slot (B AND E0H) of sector (B AND 1FH) + 2 of the directory cylinder. Register Pair DE is kept.

4B45H - RDSSEC: Read a Directory Sector

Reads cylinder Register D, sector Register E of drive Register C into the buffer at Register Pair HL and accepts it only when it carries the deleted data mark (read error 06H). When it does not, the diskette in the drive may have its directory on another cylinder: the boot sector (cylinder 0, sector 0) is read, byte 2 (the directory cylinder) is stored in the drive's code table (+09H) and the sector is read again from that cylinder. Returns the Z FLAG set on success; Register A = the read result less 6.

4B6BH - MULTEA, DIVEA, @MULT and @DIV

Four arithmetic routines. 4B6BH (MULTEA): Register A = Register A x Register E (8 bits). 4B7AH (DIVEA): Register E / Register A, the quotient in Register A and the remainder in Register E. 4B8EH (@MULT, 444EH): Register Pair HL x Register A, a 24 bit product in Register Pair HL (high 16 bits) and Register A (low 8 bits). 4BA8H (@DIV, 4451H): Register Pair HL / Register A, the quotient in Register Pair HL and the remainder in Register A. Register Pair BC is kept by all four.

4BBBH - The Clock Tick Divider

Called by the clock interrupt (4518H) on every tick. Register Pair DE gets the address of the ROM's real time clock routine, which the reset copied into the operand at 4BBCH from the ROM's clock vector at 4047H (4E01H-4E04H). The pattern at 4762H is rotated one place; when the bit that comes out is set the tick runs the tasks, otherwise the interrupt of the clock is cleared here and the tasks and the ROM's routine are passed over for this tick. With FFH at 4762H every tick runs them.

4BCCH - The Supervisor Dispatcher (RST 28H)

ROM 0028H jumps to 400CH and so here with the request code in Register A. A code below 80H is handled at 4BEEH. For 80H and above, the return address of the RST is dropped (the overlay returns straight to the program that called the request stub), the BREAK trap switch (4405H) is turned off and saved, the system file the code names is loaded when it is not already at 4E00H (4BF4H), and its entry is called with Register A = the request code from OVRLY$ (4414H). Then the BREAK trap switch is put back.

4BF4H - Load the System File of a Request

Register A = the request code, Register B = the library command (for 88H and 89H). A library request (88H, SYS6/SYS, or 89H, SYS7/SYS) always loads, because each command is its own member of the file. For the others nothing is loaded when the file named by the low four bits is already at 4E00H (OVRLY$, 4414H). Otherwise OVRLY$ gets the new code and the file is read through SFCB$ (42A1H): its directory record (3-7, or 20H-26H for the files from 8 on) is read from drive 0, its first extents copied, and the module loader (4C8CH) loads it, returning its entry address. A file missing from the directory or a load error displays SYS Error and aborts.

4C5DH - @RUN and @LOAD

4C5DH (@RUN) sets bit 2 of SFLAG$ (442BH), loads the program file named in the control block at Register Pair DE (@LOAD) and runs it at its transfer address; when DEBUG is on (bit 7 of 442BH) and bit 1 is clear, it enters DEBUG at the program's first instruction instead. An error goes to @ERROR (4409H). 4C76H (@LOAD) opens the file with the buffer 4300H and loads it (4C8CH), returning the transfer address in Register Pair HL; a file not found becomes error 1FH (program not found), and bit 6 is set in every error number.

4C76H - @LOAD: Load a Program File

Register Pair DE = a file control block with the program's file specification. The file is opened with the buffer 4300H and 256 byte records (@OPEN) and loaded by 4C8CH, which returns the transfer address in Register Pair HL. On failure bit 6 is set in the error number (the short message), and 18H (file not in directory) becomes 1FH (program not found).

4C8CH - The Module Loader

Loads the load module of the open file whose control block is at Register Pair DE, its sectors read into 4300H. Register B = the library member wanted (for SYS6/SYS and SYS7/SYS). Record types: 01H a load block (length, address, data), 02H the transfer address, 04H the end of a library member, 08H a library member's header (its number, entry address, the record of the file where it starts and the byte in that record), 0AH and 20H-FFH are a load file format error (22H), every other type below 20H is passed over by its length. Each data byte is checked after it is stored: a byte that does not stay is error 23H (memory fault) or 24H (read only memory), with bit 6 set. Returns the Z FLAG and the transfer (or member entry) address in Register Pair HL.

4D39H - @DSPLY, @MSG and @PRINT: Send a Text to a Device

4D39H (@DSPLY, 4467H) sends to the video (401DH), 4D4EH (@PRINT, 446AH) to the printer (4025H) and 4D3CH (@MSG, 4402H) to the device control block in Register Pair DE. The text at Register Pair HL ends with 03H (not sent) or 0DH (sent); each byte goes out through the ROM's @PUT at 001BH. Register Pair HL comes back unchanged.

4D53H - The Route Routines and @DVRHK

4D53H-4D61H are the four route routines: the loads of Register Pair HL at 4D53H, 4D57H, 4D5BH and 4D5FH (the last three are the LD HL after the DDH prefix of an LD IX), each running on into 4D62H. ROUTE (SYS6/SYS, member 13, its 5261H-5294H) stores the control block a device is routed to into the operand of a free one (low byte 00H) and points the device's +01H-+02H at it, so a request to the device goes to the destination's driver or file; KILL, DEVICE, RESET and SPOOL follow a route through the operand, and ROUTE and RESET clear it again. 4D62H takes a device control block in Register Pair HL (SYS2/SYS jumps there, its 4F3AH) and 4D65H, @DVRHK, the jump at 4033H from the ROM's character routine, enters the driver of the block at Index Register IX: an open file (bit 7 of the type byte) goes to 48ECH, any other block to the address in its bytes +01H-+02H with the flags of the request (CARRY input, Z output, NZ control).

4D76H - The Program Counter Display Task

4D76H is a task block that SYS7/SYS puts into a task slot (Register Pair DE = 4D76H at its 52D9H): its first word is 4D78H, the routine, which writes the address the interrupted program was at as four hex digits at 3C2EH, row 0 of the screen. 4D87H writes Register A as two hex characters at Register Pair HL; LCOMM/CMD, SYS6/SYS and SYS7/SYS use it too.

4D9BH - The Current Sector of a File

4D9BH saves Register Pair HL under the return address and goes on into 4D9EH; 4D9EH loads Register C with the position in the buffer (+05H); 4DA1H (Register C given) adjusts Register Pair HL, the next record number less one or the next record number, to the sector of the current position: in byte mode (bit 7 of +01H) one is added when Register C is not 0, and one is taken away when the buffer holds the sector before the next record number (bit 5 clear). In record mode Register Pair HL is not changed.

4DB2H - The Video Driver with Interrupts On

The reset puts 4DB2H into the video's device control block (401EH) unless RIGHT ARROW is held at boot (4E57H-4E68H). It sets bit 7 of 401CH, the ROM's blink switch, so that the clock interrupt does not blink the cursor while the character is put on the screen, and calls the ROM's video driver at 0474H, after its DI, so interrupts stay on; then it clears the bit. Index Register IX = the video's device control block (401DH).

4DBEH - The Keyboard Scan of Every Interrupt

Called by the interrupt routine (44BAH) on every interrupt, and by BACKUP/CMD (its 53F1H, 5414H). It reads the keyboard rows directly: SHIFT (3880H, bits 1-0) with @ (3801H, bit 0) sets bit 1 of KFLAG$ (429FH), the pause; ENTER (3840H, bit 0) sets bit 2; BREAK (3840H, bit 2) without SHIFT sets bit 0 unless BREAK is disabled (bit 4 of 442BH). Returns with the NZ FLAG set when BREAK is held and the CARRY FLAG set when a SHIFT key is held.

4DF0H - Base Cells for Resident Modules

Sixteen bytes before the reset code that the system files do not load over. Members of SYS6/SYS keep values in 4DF0H, 4DF1H, 4DF6H and 4DF7H (its 5216H, 54D6H, 520EH, 5318H, 531CH) and members of SYS7/SYS read 4DF2H and 4DF6H (its 535BH, 5270H).

4E00H - The Reset: Vectors, Memory, Video and Drive 0

The transfer address of SYS0/SYS: the boot sector jumps here with interrupts off and the NMI vector at 4049H pointing at its own end of read. The reset takes over the ROM's clock vector and the NMI, clears the spare device control blocks, sets port ECH and the interrupt mask, finds the top of memory, installs its keyboard, video and printer drivers, sets up drive 0 from the boot sector, enables the interrupts and reads the system information sector (cylinder 0, sector 2) into 4300H. All of 4E00H-50FFH is used only here; the system files load over it afterwards.

4E9BH - The Reset: The Date

The system information sector is now at 4300H. Its byte 01H is saved on the stack and replaced by 00H. When its date prompt switch (43C2H) is not 00H the date is skipped. When the date was set before a reset (442FH holds a month OR 50H) it is used again without a prompt; 442FH = 50H skips the date and the time. Otherwise Date? is asked at 3F17H until three good fields are typed (MM/DD/YY, years 80-99 for 1980-1999 and 00-11 for 2000-2011).

4EFFH - The Reset: Store and Display the Date

Stores the month, the day and the year in DATE$ (421AH-421CH), works out the day of the year (4417H, bit 0 of 4418H) and the day of the week (bits 3-1 of 4418H, from 1 for Sunday), and displays the date at 3F17H as, for example, Tue, Jan 1, 1980.

4F94H - The Reset: The Time

When the time prompt switch (43C3H) is 00H, Time? is asked at 3F57H: hours, minutes and seconds, two digits each, separated by any character below 3BH (the : included). Seconds, or minutes and seconds, may be left out (they count as 0). A field out of range asks again; a good time goes into TIME$ (4217H-4219H).

4FC8H - The Reset: Drives and the Diskette

Copies the drive code tables of drives 1-7 from the second block of the system information sector, reads the allocation table of the diskette in drive 0 into 4300H, notes a diskette with two sides in drive 0's table and shows the diskette's name and date on the screen (3CD1H, 3CE5H).

4FFBH - The Reset: AUTO, CONFIG/SYS and the Return to LDOS

Decides what runs after the boot. An AUTO command (the allocation table's 43E0H) is taken unless it is empty (0DH) or ENTER (or @) is held; one that starts with 2AH cannot be stopped that way and runs with BREAK disabled. D (or DOWN ARROW) held enters DEBUG. The AUTO command is copied to INBUF$ (4225H). The end of the reset is copied to 405DH and run there, because loading CONFIG/SYS (through @LOAD, 4430H) loads system files over 4E00H-51FFH. CONFIG/SYS is loaded unless byte 01H of the system information sector has bit 1 or bit 7 set or CLEAR (or 9) or SPACE (or /) is held. The return addresses pushed make the last RET display the AUTO command (4467H) and carry it out (4299H), or go to LDOS Ready (4296H).

5054H - The End of the Reset, Run at 405DH

5054H-5081H run as a copy at 405DH-408AH (5033H-503CH). The Z FLAG says whether CONFIG/SYS was loaded. Each comment gives the address the instruction runs at.

5082H - The Reset's Display Helpers

5082H displays three letter name number Register B of the table at Register Pair HL; 5092H a comma and a space; 5097H a space; 509CH Register A (0-99) as two digits, the tens left out when it is 0 and Register D is 0. All display through the ROM at 0033H.