DOSPLUS 3.5 for the Model III - SYS0/SYS Disassembled

SYS0/SYS

Other Navigation

DOSPLUS 3.5 SYS0/SYS Disassembly - The Resident System (Model III)

SYS0/SYS is the resident part of DOSPLUS 3.5: the boot sector loads it and it stays in memory up to 4DFFH for as long as DOSPLUS runs. It holds the restart vectors, the system variables, the device and drive tables, the entry points every program calls, the character I/O switching for FORCE, JOIN and NIL devices, the interrupt handler and its eight task slots, the floppy disk driver for the controller at ports F0H-F4H, the overlay request handler and loader, the program loader, the file routines (READ@, WRITE@, POSN@ and the rest) with the record locator, and the keyboard driver. Everything else (the command interpreter, OPEN@, CLOSE@, the allocation routines, the error messages, DEBUG, the library commands) is in the overlays SYS1/SYS-SYS16/SYS, which SYS0/SYS loads at 4E00H (SYS1-SYS8) or 5200H (SYS9-SYS16) when a request code asks for them. The Model III ROM does part of the work: the time and date conversions of GTTIME@ and GTDATE@, the clock task in slot 7, the keyboard scan and the cassette interrupts.

The file is a load module of 36 blocks, 3337 bytes, from 400CH to 50F2H; its transfer address is 4E00H. The blocks skip every byte the system does not need to load (the ROM's RAM, the unused bytes between the entry points, HMEM$, the buffers), so the page shows those gaps as DEFS rows where the code uses them. 4E00H-50F2H is the start-up, which runs once after the boot and is overwritten by the first low overlay.

The Parts of SYS0/SYS

Overlay Requests

Interrupts and the NMI

Files: the File Control Block as SYS0/SYS Uses It

The Start-Up

Differences From the Manual

400CH - Restart Vectors and the ROM Device Control Blocks

The Model III ROM sends RST 28H, RST 30H and RST 38H to 400CH, 400FH and 4012H, and its character I/O to the device control blocks at 4015H, 401DH and 4025H. SYS0/SYS loads a jump into each of the three restart vectors and into EXIT@, ABORT@ and 4033H; the control blocks, the keyboard row images and the ROM's interrupt vectors between them stay as the ROM set them, apart from what the start-up stores.

4206H - Bytes of the ROM's RAM that SYS0/SYS Uses

Not in the file. 4206H and 4209H are the RS-232 interrupt vectors the interrupt handler jumps to; the start-up fills the others: 4210H is the ROM's copy of port ECH, TIME$ and DATE$ are at 4217H and 421AH, and the command buffer INPBUF$ is at 4225H.

428DH - FILPTR@ and RAMDIR@

Two system entry points that the Model III keeps below the variables, at the addresses the manual gives (T/30, T/31): each loads its request code into Register A and executes RST 28H.

4293H - System Variables at 4293H-42BDH

The tick count, the drive select state, the NMI mask value, the system flags SFLAG1$, the last error code, the overlay request state and the overlay bytes OVLYL$ and OVLYH$ (4293H-429EH are in the file); then the overlay table addresses, the command buffer pointer, the top of memory, LOW$, DODCB$, BREAK$ and the saved date, which the start-up and the other routines fill.

42BEH - The Interrupt Slots, and the System File Control Block

42BEH-42CDH is the table of the eight interrupt slots (0-3 slow, 4-7 fast), each the address of a task block; SET@ and RESET@ change them and the clock task at 4657H runs them. 42CEH-42EDH is the 32 byte file control block the overlay loader opens each /SYS file in (49EDH-4A37H), with its buffer at 4300H; its first 16 bytes are in the file, the rest of its segment list is not.

4400H - The System Entry Points

The documented entry points of DOSPLUS, 4400H-44A5H. Each routine that lives in SYS0/SYS is a JP to it; each routine that lives in an overlay is LD A,request code followed by RST 28H, which goes through 400CH to the overlay request handler at 498EH. The high four bits of a request code are the system number less 1 (03H SYS1/SYS, 13H SYS2/SYS ... 73H SYS8/SYS) and the low four bits pick the routine from the overlay's routine table (2 is its first entry). The RST 28H pushes the address after it, which the handler discards, so the routine returns to the caller of the entry point. Blocks of the file skip the bytes between the entries (4403H-4404H, 4408H, 4411H-4412H, 441FH, 4423H, 4427H, 442BH, 442FH, 445AH-4466H): SYS0/SYS does not load them. 4411H-4412H, after the RST 28H of DEBUG@, is HMEM$.

44A6H - The DCB Table (DCBTBL)

Six 11 byte entries, one for each character device: +00H the DCB address (FFFFH none), +02H the filter table address, +04H the linking DCB of a JOIN, +06H the driver address and +08H the DCB type saved during a FORCE or JOIN, +09H the two character device name. LOCDCB% (44A0H, 45ECH) returns the DCB address of a device from its number. @RS, @U1 and @U2 have no DCB of their own: their entries point to the NIL control block at 4508H.

44E8H - The Drive Table (DCTTBL)

Eight 4 byte entries, one for each drive: +00H the address of the drive's drive control table (DCT), +02H the two character drive name. LOCDCT% (44A3H, 45D4H) loads Index Register IY from the entry of drive Register C. Drives 0-3 have their tables at 450BH-455AH; drives 4-7 point to the NIL control block at 4508H.

4508H - The NIL Control Block

The control block of every device and drive that has none: type 08H, NIL, and no driver.

450BH - The Drive Control Tables of Drives 0-3

Four 20 byte drive control tables (DCTs), at 450BH, 451FH, 4533H and 4547H, the ones DCTTBL (44E8H) points to. Bytes +00H-0AH describe the drive and stay as CONFIG sets them; bytes +0BH-13H describe the diskette: +0BH-11H are set again from the table at 48FAH when the density changes or the drive is logged (4707H-470FH, 4718H, 48D1H-48F9H), and the start-up copies drive 0's +0BH-13H from sector 2 of BOOT/SYS (4EA6H-4EB9H) and stores the step rate code of 5216H into +04H of all four (4E69H-4E78H). The file holds the values of a one sided, eighteen sector double density diskette of 40 cylinders; drive 0's head position and directory cylinder are 11H, the other drives' 14H.

455BH - Character I/O: Files, FORCE, JOIN and NIL

4033H comes to 455EH from the ROM's device routine at 0674H: its 0687H jumps to 4033H when bit 7 of the control block's type byte is set and the type lacks the bits Register B asks for (01H input, 02H output, 04H control). On entry Index Register IX and Register Pair DE point to the control block, Register C holds the character to output and the ROM has stacked Register Pairs BC, HL, the old IX and DE and its return to 0694H. A file control block (type 80H) goes to the file routine at 4B97H; a FORCEd device is replaced by the device it is forced to; a JOINed device runs its own driver and then the linked device's; a NIL device returns at once.

45A2H - Call a Routine With the Registers Saved

Called with the address of a routine on the stack under the return address: CALL 45A2H followed by the routine to wrap, which runs with Register Pairs BC, DE, HL and Index Registers IX and IY saved around it, and returns to the caller of the caller with Register Pair AF as the routine left it. 4485H is a jump to it; DISKIO% (46A4H), DSPLY@ and PRINT@ (45BFH), the logging routine (4715H) and the geometry routine (48D1H) use it.

45B9H - PRINT@ and DSPLY@

PRINT@ (446AH) and DSPLY@ (4467H): send the text at Register Pair HL, up to and including a 0DH or up to a 03H, to the printer (device 2) or the display (device 1) through the ROM's output routine, so a FORCE or JOIN of the device applies.

45D4H - LOCDCT% and LOCDCB%

LOCDCT% (44A3H): Index Register IY = the drive control table address of drive Register C, from DCTTBL at 44E8H. LOCDCB% (44A0H): Register Pair DE = the DCB address of device Register A, from the DCB table at 44A6H.

45FEH - The Interrupt Handler

RST 38H (4012H) comes here for every maskable interrupt. The handler reads the interrupt status at port E0H and serves the first source whose bit is 0, taking the bits from bit 0 up: bits 0 and 1 (the cassette edges) go straight to the ROM's routines at 3365H and 3369H; for bits 2-7 the handler saves the registers and jumps to the RAM vector of the source (4046H, 403DH, 4206H, 4209H, 4040H, 4043H) with 462DH as its return address. Only one source is served per interrupt. On the way out it checks the BREAK key: when BREAK and the key of bit 1 of keyboard row 3880H are down and the DEBUG on BREAK switch at 429BH is set, the interrupted program continues in DEBUG@.

4657H - The Clock Task and the Interrupt Slots

The real time clock routine: the start-up puts JP 4657H at 4046H, the vector of bit 2 of port E0H. On every tick it reads port ECH and runs the tasks of the fast slots 4-7, then counts the tick at 4293H and runs one of the slow slots 0-3 in turn (each slow slot every fourth tick). A slot of the table at 42BEH holds the address of a task block; the block's first word is the task's address, and the task runs with Index Register IX pointing to its block.

4688H - RESET@ and SET@

RESET@ (4416H): put the empty task block 469CH into slot Register A. SET@ (4413H): put the task block at Register Pair DE into slot Register A (0-7). The two task blocks of SYS0/SYS follow: the empty block, and the block of the ROM's clock task, which the start-up installs in slot 7.

46A4H - DISKIO%

DISKIO% (4488H): Register A = the function (0-9), Register C = the drive, Register D = the cylinder, Register E = the sector, Register Pair HL = the 256 byte buffer. The registers other than Register Pair AF come back as they were; Register A returns 00H with the Z FLAG set, or an error code with the NZ FLAG set. A NIL drive returns error 08H; any other goes to the driver at DCT+01H-02H.

46BEH - The Floppy Disk Driver: Function Dispatch

The driver of the drive control tables at 450BH-455AH. Register A (the function, 0-9) picks the routine from the table at 46CEH; the routine is entered with Register Pair HL the buffer again and Index Register IY the drive control table.

46E2H - SREAD, Reading the Directory Cylinder, and Logging a Diskette

SREAD reads sector Register E of the directory cylinder (DCT+12H). The directory is written with the deleted data address mark, so the controller reports the record type (error code 06H) for a good directory read; SREAD turns that into 00H. When the first read fails the drive is logged again and the read repeated; a second failure is error 11H. Logging (4715H) restores the head, reads cylinder 0 sector 0 (in either density) and takes the directory cylinder from its byte 2.

4733H - DCHECK

Function 0: select the drive and wait for an index pulse to go by. Register A returns 00H with the Z FLAG set when the drive is ready, and the C FLAG set as well when the diskette (status bit 6) or the drive (DCT+03H bit 6) is write protected; when no index pulse comes within the count, Register A returns FFH with the NZ FLAG set.

475BH - DHOME, and Waiting for a Command

Function 1: send the Restore command and wait for it. 4767H sends any command in Register A and waits while the controller is busy, sending the drive select again on each status read so the motor keeps running, then lets the head settle and returns the not ready, seek error and CRC error bits of the status.

477FH - DSEEK

Function 2: select the drive and the side, put the sector in the sector register (port F2H) and, unless the head is already there, seek cylinder Register D (two steps a cylinder when DCT+03H bit 2 is set). Sectors at or above the sectors per track (DCT+0DH) are on side 1: bit 4 of the drive select value is set and the sectors per track are taken off. Register A returns 00H with the Z FLAG set, or the status error bits of the seek.

47BDH - The Sector Functions and Their Parameter Blocks

Functions 3, 4, 5, 7, 8 and 9 each call 47E3H with a four byte parameter block after the CALL: the controller command, the number of tries, the first error code (01H for a read, 09H for a write) and the kind (01H a read, 02H a write, 04H a track write; the transfer tests only bit 0, so a track write is handled like a write). SWRITE first loads Register D with the directory cylinder and goes on into DWRITA.

47E3H - The Sector Transfer

Entered from the function routines with the parameter block's address on the stack. A write is refused when the drive's write protect flag is set; then the head is placed (DSEEK) and the command sent with interrupts off. The first byte is moved once the controller has data or is no longer busy; the rest go in a loop that holds the processor in wait states (bit 6 of the drive select at port F4H) until each byte is ready. The loop has no exit of its own: the controller's interrupt request at the end of the command raises a non maskable interrupt (enabled through port E4H), and the NMI vector 4049H, set by the start-up to JP 4842H, ends it. A failed try is retried, after a restore unless the error was lost data; write protect and the record type bit end the tries at once. The error code is the block's first error code plus the number of the lowest error bit of the status.

4870H - Selecting the Drive

Builds the drive select value at 4295H from the drive's physical number and density (48A5H); when the drive is not the one used last (4294H) it stores the new drive and loads the drive's head position into the track register. A drive whose DCT+03H bit 4 is set and which reports not ready gets a delay for its motor to come up to speed. The select value goes to port F4H.

48BFH - Sending a Command and Setting the Geometry

48BFH sends two Force Interrupt commands. 48C8H disables interrupts and 48C9H sends a command to port F0H and waits while the controller's status settles. 48D1H sets DCT+0BH-11H from the table at 48FAH, by density (DCT+0BH bit 7) and surface count (DCT+0CH).

4916H - Reading and Writing a Directory Entry's Sector

4916H reads, 491FH writes, the directory sector holding the entry of logical file number Register B on drive Register C, through the buffer at 4300H; Register Pair HL returns the entry's address in the buffer. A logical file number holds the entry's position: bits 7-5 the entry within its sector (32 bytes each), bits 4-0 the sector less 2 (sectors 0 and 1 are the GAT and the HIT). Register D is set to the directory cylinder by SREAD or SWRITE.

493EH - The Arithmetic Routines

493EH: Register A = Register A times Register E (the low eight bits). 494DH: Register A = Register E divided by Register A, Register E = the remainder. 4961H, MULT@ (444BH): Register Pair HL times Register A, a 24 bit product in Register Pair HL (high bytes) and Register A (low byte). 497BH, DIVD@ (444EH): Register Pair HL divided by Register A, the quotient in Register Pair HL and the remainder in Register A.

498EH - The Overlay Request Handler

RST 28H (400CH) comes here with a request code in Register A. Request code 01H runs the BREAK vector at 42ADH unless the BREAK key is disabled. Any other code names an overlay (bits 7-4, the system number less 1) and a routine (bits 3-0): the overlay is loaded unless it is resident (429DH for SYS1-SYS8 at 4E00H, 429EH for SYS9-SYS16 at 5200H), the routine's address is taken from the table at the overlay's transfer address (entry = bits 3-0 less 2) and the routine runs with every register but Register Pair AF as the caller left them. It returns through 49E7H, which puts back the word at 429AH-429BH.

49EDH - Loading an Overlay

Register A = the overlay bits of a request code. The /SYS files have fixed directory entries on drive 0: SYS0/SYS is logical file number 2 (sector 4, entry 0) and SYSn/SYS is n + 2, running on into the second and third entries of the sectors when the directory ends. The routine reads the entry, checks that it is an active system file, sets up the system file control block at 42CEH with the file's first segment and loads the file through 4A9BH, which returns its transfer address in Register Pair HL.

4A3EH - System Error

An overlay could not be loaded: its overlay byte is set to FFH, so the next request loads it again, System error is displayed and DOSPLUS returns to the command level through ABORT@.

4A5FH - RUN@

RUN@ (4433H): load the program file of the file control block at Register Pair DE and run it. The run access flag (bit 1 of SFLAG1$) is set during the load so a run only file may be opened. The program starts with Register Pair BC = LOW$ and Register Pair DE = HMEM$. When the DEBUG flag (bit 2 of SFLAG1$) is set, a program opened with an access level below 6 starts in DEBUG@ instead; for one with level 6 or 7 the DEBUG on BREAK switch at 429BH is set to the level less 6. A load error goes to ERROR@.

4A89H - LOAD@ and the Program Loader

LOAD@ (4430H) opens the file of the file control block at Register Pair DE with a record length of 256 and its buffer at 4300H, then the loader at 4A9BH reads it record by record: type 01H a load block (length, address, then the bytes, each checked after it is stored), type 02H the transfer address, which ends the load, any other type below 20H skipped. 4AD5H supplies the next byte, reading a sector through READ@ each time the buffer is used up. Errors return with bit 6 of the error code set: 1FH Program not found, 22H a record type of 20H or more (not a program file), 23H memory that does not keep a byte, or the error of OPEN@ or READ@.

4AF2H - POSN@, REW@, PEOF@ and BKSP@

POSN@ (4442H) sets the position of the file control block at Register Pair DE to logical record Register Pair BC and sets the random access flag (bit 6 of FCB+01H). For a blocked file (bit 7 of FCB+01H) the record number times the record length gives the sector (Register Pair BC) and the byte in it (Register A); otherwise Register Pair BC is the sector. 4B09H stores the byte offset to FCB+05H; when the buffer holds the sector of the old position (bit 5 of FCB+01H clear) and the sector changes, an updated buffer is written first (4C7CH) and bit 5 is set, so the next access reads the new sector. The sector goes to FCB+0AH-0BH and 4CC5H returns the end of file status. REW@ (443FH) positions to the start of the file, PEOF@ (4448H) to its end and BKSP@ (4445H) one logical record back. All four run under 4CE5H, which checks that the file is open, points Index Register IX to it and saves the registers.

4B61H - READ@ and WRITE@

READ@ (4436H) reads the next logical record of the file at Register Pair DE: a file that is not blocked reads its next sector into its buffer (4C03H); a blocked file takes the record length's bytes one at a time through 4BA6H into the user record at Register Pair HL. WRITE@ (4439H) and VER@ (443CH) both come to 4B7CH: the buffer is written as the next sector (4C3EH), or the record's bytes are put one at a time through 4BC9H. VER@ has no code of its own: every sector write is read back when the verify switch (bit 3 of SFLAG1$) is on (4C67H).

4B97H - Character I/O on a File, and the Byte Routines

4563H comes to 4B97H when a character I/O call (GET@, PUT@ or a control call) names an open file control block: Index Register IX points to it, Register B is the I/O type (bit 0 set for input) and Register C the character to put. The file is switched to blocked records (bit 7 of FCB+01H) and one byte is read (4BA6H) or written (4BC9H). 4BA6H returns the byte at FCB+05H of the buffer, reading the sector first when bit 5 of FCB+01H is set, and moves on, writing an updated buffer back and stepping to the next sector at the end of one. 4BC9H stores a byte the same way, reading the sector first when it holds bytes of the file, sets the buffer updated flag (bit 4) and moves the end of the file where it is due (4C92H).

4C03H - Reading and Writing a Whole Sector

4C03H (READ@ of a file that is not blocked) reads sector FCB+0AH-0BH into the buffer and steps to the next sector. 4C10H reads the sector of the next record number: a file opened with an access level of 6 or 7 is refused unless a program is being loaded (bit 1 of SFLAG1$); the cylinder and sector come from 4D07H and DISKIO% function 3 (DREAD) reads it. 4C3EH (WRITE@ of a file that is not blocked) writes the buffer and steps on. 4C4AH writes the sector: an access level of 5 or more is refused, the sector is written with function 5 (DWRITE) and, with the verify switch on, read back with function 4 (DVERF). A refusal returns error 25H, Illegal access attempted to protected file.

4C7CH - Buffer and Position Helpers

4C7CH writes the buffer of a blocked file when it holds updated bytes (bits 7 and 4 of FCB+01H). 4C86H steps the next record number on by one sector and sets bit 5, the buffer is to be read. 4C92H runs after each write: it sets the modified flag (bit 6 of FCB+02H) and, unless a random access file is written before its end, makes the position the end of the file (FCB+08H, FCB+0CH-0DH), so a sequential write shrinks the file to the last byte written. 4CB3H gives the address of the current byte in the buffer.

4CC2H - CKEOF@ and the End of File Test

CKEOF@ (4457H) checks the file at Register Pair DE, then 4CC5H compares the position (FCB+0AH-0BH and FCB+05H) with the end (FCB+0CH-0DH and FCB+08H): Register A returns 00H with the Z FLAG set before the end, 1CH (Attempted to read past eof) at the end and 1DH (Attempted to read outside of file limits) past it, both with the NZ FLAG set.

4CE5H - Checking a File Control Block

Called first by each file routine (POSN@, REW@, PEOF@, BKSP@, READ@, WRITE@, character I/O on a file, CKEOF@). When bit 7 of the type byte at Register Pair DE is clear the file is not open: the routine's own return address is dropped and error 26H (I/O attempted to unopen file) goes back to the routine's caller. Otherwise Index Register IX is pointed to the file control block, Index Registers IX and IY and Register Pairs HL, DE and BC are saved, 4CFAH is put on the stack as the routine's return and the rest of the routine is entered with Register A = 00H; when it returns, 4CFAH restores the registers, so only Register Pair AF carries the result back.

4D07H - The Record Locator

Finds sector FCB+0AH-0BH of the file at Index Register IX on the diskette. The sector number divided by the sectors per granule gives the granule of the file and the sector within it. The segment list at FCB+0EH-1FH holds five segments: the descriptor at FCB+0EH (the segment that starts the file), then four 4 byte elements at FCB+10H, FCB+14H, FCB+18H and FCB+1CH, each the count of granules of the file before the segment (two bytes) and the segment's descriptor (the cylinder, then the starting granule in bits 7-5 and the granules less 1 in bits 4-0); a cylinder of FFH marks an empty entry. When the granule is in a segment of the list and that segment is the third, fourth or fifth, its element is moved to the second place and the ones between move up (4D89H-4DA6H), so the list keeps the segments used last. When it is in none, SYS4/SYS is called (request 33H), and the low overlay that was resident is loaded back. Register C returns the drive, Register D the cylinder and Register E the sector.