DOSPLUS 3.5 for the Model III - SYS8/SYS Disassembled

SYS8/SYS

Other Navigation

DOSPLUS 3.5 SYS8/SYS Disassembly - SORT@, CAT@, FILPTR@ and RAMDIR@ (Model III)

SYS8/SYS is the low overlay of four service routines: SORT@ (4482HH, request code 73H), CAT@ (4419HH, 74H), FILPTR@ (428DHH, 75H) and RAMDIR@ (4290HH, 76H). The file is a load module of 9 blocks, 873 bytes, from 4E00H to 5176H, with the transfer address 4E00H, and carries a 07H record with the name SYS8M1 (Model I) or SYS8M3 (Model III). Four of its blocks are patches that load over earlier bytes: two one byte blocks at 514FH and 5162H, a block at 507FH-5081H that changes a CALL, and a block at 5164H-5176H that adds a routine. 4F15H-4F22H is not loaded: it is SORT@'s work area. Of the other files of the diskette only SYS9/SYS calls SORT@; none calls CAT@, FILPTR@ or RAMDIR@.

The Parts of SYS8/SYS

SORT@

SORT@ sorts a list of entries of one length (Register C) from Index Register IX (the first entry) to Register Pair DE (the last) by a key of Register L bytes at offset Register B, ascending when Register H is 00H, else descending. It is a Shell sort: the gap starts at half the number of entries and is halved after each pass; each pass compares every entry with the one a gap after it and swaps them when they are out of order, then follows the moved entry back down the list a gap at a time. Keys are compared as unsigned bytes from the first; equal keys are never swapped. The order is set by storing the opcode of the jump at 4E47H, JR C for ascending or JR NC for descending. Wrong parameters return error codes that are not DOS error numbers: 04H a key of no length, 03H an entry of no length, 02H a key offset outside the entry, 01H a key running past the entry, 05H no entries (4EF8H).

CAT@

CAT@ takes the drive from the ASCII digit at 4271HH, which it clears, or else from Register C. When the display is FORCEd or JOINed it posts error 27H, Device in use. It checks the drive, reads the GAT, clears the screen and shows FILE CATALOG: with the drive's name and the diskette's name (+D0H of the GAT), then reads directory sectors 2 to the last and shows each file as NAME/EXT in a column of 15 characters, four to a line. It pauses (waits for a key) after the first 13 lines and then every 15, and when the space bar is pressed. Only entries whose flag byte is exactly 10H are shown, so system files, invisible files and files with a protection level other than 0 are left out. Errors go to ERROR@ with bits 7 and 6 set, which shows the message and returns to the caller (5007H).

FILPTR@ and RAMDIR@

FILPTR@ checks the file control block at Register Pair DE through SYS0/SYS's file routine wrapper (448EH) and loads Register B with the drive (+06H) and Register C with the logical file number (+07H). The wrapper restores Register Pair BC when the routine returns, so the caller gets its own BC back: FILPTR@ as it stands returns only Register A = 00H, or error 26H for a file that is not open.

RAMDIR@ takes the drive in Register B, the function in Register C and a buffer at Register Pair HL. Function 00H copies every entry with bit 4 set and bit 7 clear (system and invisible files included) as a 22 byte record and puts a + after the last. Functions 01H-FEH copy the entry whose logical file number is Register C, without looking at its flags; a patch (5165H) added the check that the number's sector is inside the directory (error 10H). Function FFH stores the kilobytes used and free from the GAT. Each record is the name, /extension and :drive padded with spaces to 15 characters, of which only the first character of the drive's name stays (the padding starts over its second), then the entry's whole flag byte (the manual says the protection level), the end of file byte, the logical record length, the number of sectors and two FFH bytes (5083H).

The Patches

The block at 507FH-5081H changes RAMDIR@'s CALL 490CH, the read of an entry's sector, into CALL 5165H, which the block at 5164H-5176H adds: it makes the same call only after checking the logical file number. The one byte blocks at 514FH and 5162H change PUSH HL and POP HL of 514EH into PUSH BC and POP BC, so the routine keeps Register Pair BC, which its two LDI count down, and no longer keeps Register Pair HL; neither caller needs Register Pair HL afterwards.

Differences from the Manual

FILPTR@ does not return the drive and logical file number in Register Pair BC. SORT@'s error codes 01H-05H are its own. CAT@ leaves out every file whose flag byte is not 10H, including protected ones. RAMDIR@'s byte +0FH is the whole flag byte, its drive field keeps one character, and a single entry is copied whatever its flags.

Differences from the Model I

The code is the Model I SYS8/SYS at the same addresses, the patches included; only the addresses in SYS0/SYS differ: the ASCII drive of CAT@ is at 4271H (Model I 442BH), the system buffer at 4300H (4200H), so the diskette's name is at 43D0H and the cylinder byte at 43CCH, and the calls go to the Model III entry points: 4485H for the register saving wrapper (4525H), 4488H DISKIO% (4485H), 44A0H LOCDCB% (4488H), 44A3H LOCDCT% (448BH), 444EH MULT@ (444BH), 4451H DIVD@ (444EH), 448EH the file routine wrapper (4CDBH), 449AH the directory sector read (490CH), DCTTBL 44E8H (43ABH).

4E00H - The Routine Table

Data: SYS8/SYS's table of routines 2-6, one word each, used by SYS0/SYS's overlay request handler (its 49D3H-49E6H) for the request codes 72H-76H: SORT@ (4482H) requests 73H, CAT@ (4419H) 74H, FILPTR@ (428DH) 75H and RAMDIR@ (4290H) 76H. No file of the diskette requests 72H; SORT@ is called by SYS9/SYS, and no file calls CAT@, FILPTR@ or RAMDIR@.

4E0AH - Routine 2

Nothing to do when SYS0/SYS's record locator brings SYS8/SYS back.

4E0CH - SORT@

Routine 3, requested by SORT@ (4482H). Index Register IX = the first entry, Register Pair DE = the last entry, Register C = the length of an entry, Register B = the offset of the key in the entry, Register L = the length of the key, Register H = 00H for an ascending sort, else descending. The entries are sorted in place by a Shell sort: the gap starts at half the number of entries and is halved after each pass; entries a gap apart are compared byte by byte from the key's first byte and swapped when out of order. Returns the Z FLAG and Register A = 00H, or the NZ FLAG and Register A = 01H-05H when the parameters are wrong (4EF8H). The registers other than Register Pair AF are saved (4485H).

4E1BH - A Pass

4F1DH holds the gap; a gap of 0 ends the sort. For each entry i from 0 to the number of entries less the gap, the entry is compared with the one a gap after it and, while they are out of order, swapped and followed back down the list a gap at a time (4F1BH).

4E84H - The Addresses of Two Entries

Register Pair HL = an entry number j, Register Pair DE = the gap: returns Register Pair HL = the address of entry j and Register Pair DE = the address of entry j plus the gap.

4E90H - The Address of an Entry

Register Pair HL = the entry number: returns Register Pair HL = Index Register IX (the first entry) plus the number times the entry length.

4EA4H - Compare Two Keys

Compares the keys of the entries at Register Pair HL (j) and Register Pair DE (j plus the gap), byte by byte from the offset at 4F15H for the length at 4F16H: the Z FLAG when equal, else the flags of the first byte that differs (the C FLAG when the key of entry j is lower).

4EBEH - The Number of Entries

Register Pair DE = the last entry, Index Register IX = the first, Register C = the entry length: returns Register Pair DE = (the last less the first) divided by the length, plus 1.

4ECEH - Store the Parameters

Checks the parameters (4EF8H), then stores the number of entries (4F19H), half of it as the first gap (4F1DH), the key's length (4F16H) and offset (4F15H), the entry length (4F18H), and the order: the opcode at 4E47H becomes 38H (JR C) for an ascending sort, 30H (JR NC) for a descending one.

4EF8H - Check the Parameters

Returns Register A = 04H when the key length (Register L) is 0, 03H when the entry length (Register C) is 0, 02H when the key's offset (Register B) is not below the entry length, 01H when the key runs past the end of the entry, 05H when there are no entries (Register Pair DE = 0000H), else 00H. SORT@ returns these as its error codes.

4F15H - SORT@'s Work Area

Not in the file: no load block fills 4F15H-4F22H, which SORT@ uses for its parameters and counters.

4F23H - CAT@

Routine 4, requested by CAT@ (4419H). The drive is the ASCII digit 0-7 at 4271H, which is then cleared, or else the drive number in Register C. Unless the display is FORCEd or JOINed (error 27H), CAT@ clears the screen, shows FILE CATALOG: with the drive's name and the diskette's name from its GAT, then the names of the files, four to a line, 15 characters each, pausing after 13 lines and then every 15 (until a key is pressed) and when the space bar is pressed. Only directory entries whose flag byte is exactly 10H are shown: active, not a system file, not invisible, protection level 0. An error goes to ERROR@ (4409H) with bits 7 and 6 set. The registers other than Register Pair AF are saved (4485H).

4F86H - A Directory Sector

Reads sector Register E of the directory and shows each of its eight entries whose flag byte is 10H.

5007H - Posting an Error

Register A = the error code. Bits 7 and 6 are set, so ERROR@ displays the message without its frame and returns to the caller of CAT@ (SYS5/SYS).

500CH - The Heading

Data: the heading of CAT@, displayed by DSPLY@ (4F75H) after CAT@ has put in the drive's name and the diskette's name.

502DH - FILPTR@

Routine 5, requested by FILPTR@ (428DH). Register Pair DE = an open file control block. The routine loads Register B with the drive (+06H) and Register C with the logical file number (+07H), but it runs inside SYS0/SYS's file routine wrapper (448EH), whose return through 4CFAH restores Register Pair BC as the caller had it: FILPTR@ returns only Register A = 00H with the Z FLAG, or error 26H (I/O attempted to unopen file) when the control block is not open. The manual's B and C results do not reach the caller.

5037H - RAMDIR@

Routine 6, requested by RAMDIR@ (4290H). Register B = the drive, Register C = the function, Register Pair HL = the buffer. Function 00H: every entry of the directory whose flag byte has bit 4 set and bit 7 clear (system and invisible files too) is copied as a 22 byte record (5083H), with a + (2BH) after the last. Functions 01H-FEH: the entry whose logical file number is Register C, whatever its flags. Function FFH: four bytes, the kilobytes used and free on the diskette. Errors: 08H when the drive is not ready, 10H when the logical file number is outside the directory (5165H), or a read error. The registers other than Register Pair AF are saved (4485H).

5083H - Copy an Entry

Register Pair HL = a directory entry, Register Pair DE = the buffer, Register C = the drive. Writes a 22 byte record and a + after it, and returns Register Pair DE at the +, where the next record goes: +00H-+0EH the name, /extension and :drive padded with spaces (only the drive name's first character stays), +0FH the entry's flag byte, +10H the end of file byte, +11H the logical record length, +12H-+13H the number of sectors, +14H-+15H FFH FFH.

50E4H - The Space Used and Free

Function FFH of RAMDIR@: counts the granules of the GAT, bit by bit for each cylinder (the cylinders less 35 at +CCH), the granules per cylinder from the drive control table, and stores the kilobytes used at +00H-+01H and the kilobytes free at +02H-+03H of the buffer.

5133H - Granules to Kilobytes

Register Pair DE = a count of granules: returns Register Pair DE = the count times the sectors per granule (Index Register IY+0FH) divided by 4, the kilobytes of 256 byte sectors.

514EH - Copy a Drive's Name

Copies the two character name of drive Register C from its DCTTBL entry (+02H) to Register Pair DE, which is kept. Register Pair HL returns past the name. A patch (one byte blocks at 514FH and 5162H) changed PUSH HL and POP HL into PUSH BC and POP BC, so Register Pair BC, which the two LDI count down, is kept instead of Register Pair HL.

5165H - Read an Entry's Sector

Added by a patch block (5164H-5176H, with the CALL at 507FH): reads the directory sector of logical file number Register B (SYS0/SYS's 449AH) only when its sector, bits 4-0 plus 2, is inside the directory; otherwise returns error 10H (Illegal logical file number) with the NZ FLAG.