DOSPLUS 3.5 for the Model I - SYS0/SYS Disassembled

SYS0/SYS

Other Navigation

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

SYS0/SYS is the resident part of DOSPLUS 3.5: the boot sector loads it and it stays in memory from 4000H 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 task slots, the floppy disk driver, 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 file is a load module of 37 blocks, 3465 bytes, from 400CH to 50F0H; its transfer address is 4E00H. The blocks skip every byte the system does not need to load (the ROM's RAM between the vectors, the unused bytes between the entry points, the buffers), so the page shows those gaps as DEFS rows where the code uses them. 4E00H-50F0H 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

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 I 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; the device control blocks stay in RAM the ROM set up and are not part of the file.

404BH - Interrupt Latch Copy, Enable Mask and Vectors

The interrupt handler at 4581H reads the expansion interface's interrupt latch (37E0H), keeps it at 404BH, masks it with the enable bits at 404CH and calls the vector of each latch bit that is set, from bit 0 up: bit n has its vector at 404DH + 2n.

4300H - System Variables at 4300H-435BH

Bytes SYS0/SYS keeps below its code: the drive and density of the last disk access, the drive select value, the system flags SFLAG1$, the last error code, the RS-232 settings, the overlay request state and the overlay bytes OVLYL$ and OVLYH$ (4300H-430BH are in the file); then the overlay table addresses, the command buffer and its pointer, the BREAK vector, the saved date and the top of memory and DO block pointers, which the start-up and the other routines fill.

4369H - 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% (4488H, 456FH) 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 43CBH.

43ABH - 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% (448BH, 4557H) loads Index Register IY from the entry of drive Register C. Drives 0-3 have their tables at 448EH-44DDH; drives 4-7 point to the NIL control block at 43CBH.

43CBH - The NIL Control Block and the System File Control Block

43CBH is the control block of every device and drive that has none: type 08H, NIL. 43CEH-43EDH is the 32 byte file control block the overlay loader opens each /SYS file in (49E3H-4A2DH), with its buffer at 4200H; 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-448DH. 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 4984H. 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, 441FH, 4423H, 4427H, 442BH, 442FH, 4461H-4466H): SYS0/SYS does not load them.

448EH - The Drive Control Tables of Drives 0-3

Four 20 byte drive control tables (DCTs), at 448EH, 44A2H, 44B6H and 44CAH, the ones DCTTBL (43ABH) points to. Bytes +00H-0AH describe the drive and stay as CONFIG sets them; bytes +0BH-13H describe the diskette and are set again from the table at 48F0H when the drive is logged (46CCH-46E8H, 48C7H-48EFH); the start-up copies drive 0's from sector 2 of BOOT/SYS (4E9EH-4EB1H) and stores the step rate code of 5216H into +04H of all four (4E61H-4E70H). The file holds the values of a one sided, ten sector single density diskette of 35 cylinders.

44DEH - Character I/O: Files, FORCE, JOIN and NIL

4033H comes to 44E1H from the ROM's device routine (03C2H) when a control block's type byte lacks the bit 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 03DDH. A file control block (type 80H) goes to the file routine at 4B8DH; 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.

4525H - Call a Routine With the Registers Saved

Called with the address of a routine on the stack under the return address: CALL 4525H 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. DISKIO% (465FH), DSPLY@ and PRINT@ (4542H), the logging routine (46D0H) and 48C7H use it.

453CH - 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.

4557H - LOCDCT% and LOCDCB%

LOCDCT% (448BH): Index Register IY = the drive control table address of drive Register C, from DCTTBL at 43ABH. LOCDCB% (4488H): Register Pair DE = the DCB address of device Register A, from the DCB table at 4369H.

4581H - The Interrupt Handler

RST 38H (4012H) comes here for every interrupt. The handler reads the interrupt latch at 37E0H (reading it also clears the real time clock's request), calls the vector of each set and enabled latch bit, and then, when the BREAK key is down and the DEBUG on BREAK switch at 4308H is set, enters DEBUG@ in place of returning to the interrupted program.

45C7H - The Clock Task and the Interrupt Slots

The vector of latch bit 7 (405BH), installed by the start-up: on every tick of the real time clock (every 25 milliseconds) it runs the tasks of slots 4 and 5, the fast chain, and then one of slots 0-3, the slow chain, in turn, so each slow slot runs every 100 milliseconds. A slot holds the address of a task block whose first word is the task's address; the task runs with Index Register IX pointing to its block. SET@ and RESET@ change the slots.

45F8H - RESET@ and SET@

RESET@ (4413H, 4419H): put the empty task block 460CH into slot Register A. SET@ (4410H, 4416H): put the task block Register Pair DE into slot Register A. A slot number of 06H or more is ignored. Register Pair BC is altered.

460FH - The Time Task

Task block 460FH, which the start-up puts into slot 3: every 100 milliseconds its task counts down the byte at 4611H, and on every tenth call it adds one second to TIME$ (4041H-4043H), carrying into the minutes and hours.

462FH - The Clock Display Task, GTTIME@ and GTDATE@

Task block 462FH: every tenth call its task writes the time into the top line of the screen at 3C35H. GTTIME@ (446DH) writes TIME$ at Register Pair HL as HH:MM:SS, GTDATE@ (4470H) writes DATE$ as MM/DD/YY; both leave Register Pair HL after the last digit.

465FH - DISKIO%

DISKIO% (4485H): 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 are saved around the call (4525H). A NIL drive returns error 08H; otherwise the routine jumps to the driver address in the drive's drive control table with Index Register IY pointing to the table. On return Register A is the error code and the Z FLAG is set when there was none.

4679H - The Floppy Disk Driver: Function Dispatch

The driver of the drive control tables at 448EH-44DDH. Register A (the function, 0-9) picks the routine from the table at 4689H; the routine is entered by a RET with Register Pair HL restored.

469DH - 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 a special data address mark, so a good directory read ends in error 06H (the record type status), which SREAD turns into success. When the read fails the density is switched and the read tried again (46BEH). A drive whose log flag (bit 0 of DCT+03H) is set is logged first: the density and geometry are found from cylinder 0, sector 0 (46CCH).

46EEH - 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 (or the drive's write protect flag in DCT+03H) is write protected. With no index pulse before the count at 46F4H runs out, Register A returns FFH with the NZ FLAG set.

4717H - DHOME, and Waiting for a Command

Function 1: send the Restore command and wait for it. 4723H sends any command in Register A and waits while the controller is busy, keeping the drive selected so its motor stays on; 4737H returns the status AND 98H (not ready, seek error, CRC error). 4737H is also the interrupt vector of the floppy disk controller (4059H): reading the status clears its interrupt.

473DH - DSEEK

Function 2: select the drive and the side, put the sector in the sector register and, unless the head is already there, seek cylinder Register D (two steps a cylinder when DCT+03H bit 2 asks for it). A sector number at or above the sectors per track is on side 1. Register A returns the status AND 98H, or 00H when no seek was needed.

4781H - The Sector Functions and Their Parameter Blocks

Functions 3, 4, 5, 7, 8 and 9 each call 47A7H with a four byte parameter block after the CALL: +00H the controller command, +01H the number of tries, +02H the first error code, +03H the kind of transfer (bit 0 set for a read). 47A7H takes the block's address from the stack and does not return to it.

47A7H - 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), the command sent with interrupts off, and each byte moved between the controller's data register 37EFH and the buffer while DATA REQUEST is set, until BUSY goes off. A failed try is retried, after a restore unless the error was lost data; write protect and the record type of a read 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.

484CH - Selecting the Drive

Builds the drive select value at 4301H from the drive's physical number, and when the drive or its density differs from the last access (4300H) switches the double density adapter and loads the drive's head position into the track register. When the drive asks for a motor delay (DCT+03H bit 4) and reports not ready, it is selected and a delay run before the second select. 4884H sends the select value to the drive select latch 37E1H.

489FH - Switching the Density, Sending a Command and Setting the Geometry

489FH writes FFH (double density) or FEH (single density) to 37ECH, the commands the double density adapter DOSPLUS ships for takes; RS/TXT on the diskette patches these bytes for the Radio Shack Double Density Kit (80H or A0H stored to 37EEH). 48BEH stores a command to 37ECH and waits for the controller to take it. 48C7H copies the diskette geometry for the density and side count of the drive control table from the table at 48F0H into DCT+0BH-11H.

490CH - Reading and Writing a Directory Entry's Sector

490CH reads, 4915H writes, the directory sector holding the entry of logical file number Register B on drive Register C, through the buffer at 4200H; 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.

4934H - The Arithmetic Routines

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

4984H - The Overlay Request Handler

RST 28H (400CH) comes here with a request code in Register A. Request code 01H runs the BREAK vector at 4312H 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 (430AH for SYS1-SYS8 at 4E00H, 430BH 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 49DDH, which puts back the word at 4307H-4308H.

49E3H - 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 43CEH with the file's first segment and loads the file through 4A91H, which returns its transfer address in Register Pair HL.

4A34H - 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@.

4A55H - 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 4308H is set to the level less 6. A load error goes to ERROR@.

4A7FH - 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 4200H, then the loader at 4A91H 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. 4ACBH 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@.

4AE8H - 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. 4AFFH 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 (4C72H) and bit 5 is set, so the next access reads the new sector. The sector goes to FCB+0AH-0BH and 4CBBH 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 4CDBH, which checks that the file is open, points Index Register IX to it and saves the registers.

4B57H - 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 (4BF9H); a blocked file takes the record length's bytes one at a time through 4B9CH into the user record at Register Pair HL. WRITE@ (4439H) and VER@ (443CH) both come to 4B72H: the buffer is written as the next sector (4C34H), or the record's bytes are put one at a time through 4BBFH. VER@ has no code of its own: every sector write is read back when the verify switch (bit 3 of SFLAG1$) is on (4C5DH).

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

44E6H comes to 4B8DH 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 (4B9CH) or written (4BBFH). 4B9CH 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. 4BBFH 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 (4C88H).

4BF9H - Reading and Writing a Whole Sector

4BF9H (READ@ of a file that is not blocked) reads sector FCB+0AH-0BH into the buffer and steps to the next sector. 4C06H 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 4CFDH and DISKIO% function 3 (DREAD) reads it. 4C34H (WRITE@ of a file that is not blocked) writes the buffer and steps on. 4C40H 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.

4C72H - Buffer and Position Helpers

4C72H writes the buffer of a blocked file when it holds updated bytes (bits 7 and 4 of FCB+01H). 4C7CH steps the next record number on by one sector and sets bit 5, the buffer is to be read. 4C88H 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. 4CA9H gives the address of the current byte in the buffer.

4CB8H - CKEOF@ and the End of File Test

CKEOF@ (4451H) checks the file at Register Pair DE, then 4CBBH 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.

4CDBH - 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, 4CF0H 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, 4CF0H restores the registers, so only Register Pair AF carries the result back.

4CFDH - 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 (4D7FH-4D9CH), 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.