LDOS 5.3.1 for the Model III - SYS9/SYS Disassembled

SYS9/SYS

Other Navigation

LDOS 5.3.1 SYS9/SYS Disassembly - The Extended DEBUG Commands (Model III)

SYS9/SYS holds the extended commands of DEBUG. DEBUG (EXT) issues request 8BH; the supervisor dispatcher loads SYS9/SYS into the overlay area at 4E00H and calls it, and the code at 4E00H copies the 984 bytes 4E26H-51FDH to the top of memory below the old HIGH$, lowers HIGH$ (4411H) by 03D8H to keep them there, and points the word at 4400H at the copy. DEBUG (SYS5/SYS) jumps to the address at 4400H with every key it does not know, with Register A = the key in lower case and the address of its command loop (4E49H) on the stack; before the extended commands are installed that address is 4876H, an OR A / RET of SYS0/SYS. The manual says SYS9/SYS is of no use without SYS5/SYS: the module reads its keys and numbers and shows its values through SYS5/SYS's routines, and works on DEBUG's cells at 405EH-4064H and 407BH-407CH.

The file is a load module of 1099 bytes: a record of type 1FH with the text Copyright 1991 MISOSYS, Inc., All rights reserved, four load blocks for 4E00H-51FDH, a load block for the two bytes 4BC8H-4BC9H (03FEH, the 1022 bytes that SYS9/SYS takes up in the overlay area) and the transfer address record for 4E00H.

The Module in High Memory

The Commands

About This Page

4BC8H - The Overlay Length (Data)

Every system file from SYS1/SYS to SYS12/SYS carries a load block for the two bytes 4BC8H-4BC9H in the resident area of SYS0/SYS. They hold the length of the file's part in the overlay area: for SYS9/SYS 03FEH, the 1022 bytes 4E00H-51FDH. In the file this block is the last load block, after the four blocks of 4E00H-51FDH and before the transfer address record (4E00H). The two bytes are data, not instructions.

4E00H - Install the Extended Commands in High Memory

DEBUG (EXT) issues request 8BH (SYS7/SYS, its DEBUG member); the supervisor dispatcher loads SYS9/SYS into 4E00H and calls 4E00H. This is the only code of the file that runs where it is loaded. DEBUG (SYS5/SYS) jumps to the address held at 4400H-4401H with any key it does not know; that address is 4876H, an OR A / RET in SYS0/SYS, until the extended commands are installed. When 4400H still holds 4876H, HIGH$ (4411H) is lowered by 03D8H, the 984 bytes 4E26H-51FDH are copied to the space above the new HIGH$, the old HIGH$ goes into the copy's link word, and 4400H is pointed at the copy, so that DEBUG hands its unknown keys to it. When 4400H holds anything else (the commands are already installed) nothing is done.

4E26H - The Module Header

The 984 bytes 4E26H-51FDH are the module that runs in high memory, at the old HIGH$ less 03D7H. They start with the header that a module installed above HIGH$ carries: a JR over the header, the link word (the HIGH$ before the module was installed), the length of the name and the name EXTDBG. Every branch of the module is relative or goes outside it (the ROM, SYS0/SYS, or SYS5/SYS's routines at 5189H-51F1H), so it runs wherever it is copied. The addresses on this page from here on are those of the file; at run time each is (old HIGH$ less 03D7H) + (address less 4E26H). An address 5189H, 51A4H, 51D1H, 51D5H, 51DAH or 51F1H in an instruction of the module is a routine of SYS5/SYS, which is in the overlay area while DEBUG runs, not a byte of this page.

4E31H - The Key Test and the O Command

Register A = the key DEBUG did not know, made lower case by its key reader (5189H of SYS5/SYS). The commands are tested one after the other: o, b, e, f, j, l, n, q, t, v, w, the drives 0-7 (506CH) and p (513EH). A handler returns to DEBUG's command loop (4E49H of SYS5/SYS), which puts the Stack Pointer back and draws the screen again; a key that is none of them returns there at once. O ENTER leaves DEBUG for LDOS Ready through @EXIT.

4E3CH - The B Command: Move a Block of Memory

B aaaa,bbbb,nnnn ENTER copies nnnn bytes from aaaa to bbbb with LDIR. Each number may be left out by typing only the comma or space: aaaa is then the memory display address (4063H), bbbb the M address (4060H) and nnnn 0100H, and the value taken is shown. ENTER after aaaa ends the command; ENTER after bbbb moves 0100H bytes. A count of 0000H moves 65536 bytes. aaaa is left in 4063H, and 4060H ends at the byte after the copy.

4E88H - The E Command: Examine and Change Memory in Hexadecimal

E aaaa SPACE shows the byte at aaaa and a minus sign and waits for a value: two hexadecimal digits and a space or comma store it and go on to the next byte, a space or comma alone goes on without changing it, ENTER (after a value, which it stores, or alone) ends. Without aaaa the M address (4060H) is used and shown. The M address follows the bytes as they are passed.

4EBBH - The F Command: Fill Memory

F aaaa,bbbb,cc ENTER stores the byte cc from aaaa to bbbb. All three numbers must be typed; one left out ends the command. The first test is made with the CARRY FLAG clear (HL less BC: aaaa below bbbb), every later one with the CARRY FLAG still set from the test before (HL less BC less 1), so the fill runs from aaaa up to and including bbbb; when aaaa is not below bbbb nothing is stored, so aaaa equal to bbbb fills no byte.

4EDBH - The J Command: Skip a Byte

J steps the program's saved PC (407BH-407CH, which DEBUG keeps) on by one byte, so that the program goes on after it.

4EE7H - The L Command: Locate a Byte

L aaaa,dd ENTER searches memory from aaaa for the byte dd. Without aaaa the search starts at the byte after the M address (4060H), which is shown; without dd the byte of the last search (4062H) is used and shown, and a byte typed is kept there for the next search. The search runs over up to 65536 bytes (CPIR with Register Pair BC = 0000H); since the byte at 4062H holds the value searched for, it always finds one. The M address is set on the byte found and the memory display (4063H) on the 64 byte boundary below it. When aaaa is typed and dd is not, the byte shown is the low byte of aaaa, though the search is for the byte at 4062H.

4F2EH - The N Command: Go to the Next Record of a Load Module

N aaaa ENTER, or N ENTER for the M address (4060H): the byte there is taken as the type byte of a record of a load module, and the next byte as its length; the M address is moved to the type byte of the next record (the address + 2 + the length). A length of 00H, 01H or 02H counts 256 more, as for a load block, whose length byte counts its two address bytes too and is 00H-02H for blocks of 254-256 bytes of data. The memory display (4063H) is set on the 64 byte boundary below. With the M address on the opcode of a JR that jumps forward, the M address moves to the JR's destination.

4F4FH - The Q Command: Port Input and Output

Q ii ENTER reads port ii and shows =dd, then waits for a key so that the value can be read before the screen is drawn again. Q oo,dd ENTER sends the byte dd to port oo. A port or byte left out ends the command.

4F73H - The T Command: Type Text into Memory

T aaaa SPACE shows the byte at aaaa as a character and a minus sign and waits for a key: the key is stored there as typed, upper or lower case, and the next byte is shown; a space goes on without changing the byte; ENTER ends. Without aaaa the M address (4060H) is used and shown. To keep the case of the keys, the SET 5,A of SYS5/SYS's key reader (5195H) is made BIT 5,A while a key is read, by writing 6FH over its second byte at 5196H, and put back to SET 5,A (EFH) afterwards. A byte is shown with bit 7 cleared, and as a period when that is a control code (below 20H); the second test, against C0H, can never be met after bit 7 is cleared.

4FBBH - The V Command: Compare Two Blocks

V aaaa,bbbb,nnnn ENTER compares nnnn bytes from aaaa with those from bbbb and stops at the first pair that differ: the memory display address (4063H) is left on the byte of the first block and the M address (4060H) on the byte of the second, so the screen shows both. When all nnnn pairs are the same they are left one past the blocks. Left out, aaaa is the memory display address, bbbb the M address and nnnn 0000H (65536 bytes), and the values taken are shown; ENTER after a number takes the defaults for the numbers after it.

5016H - The W Command: Locate a Word

W aaaa,dddd ENTER searches memory from aaaa for the word dddd, low byte first. Without aaaa the search starts two bytes after the M address (4060H), which is shown; without dddd the word of the last search is used and shown. The word is kept in two cells of DEBUG that are not next to each other: the low byte at 4062H, the high byte at 405FH. CPIR finds the low byte and the byte after it is compared with the high byte; when it differs the CPIR goes on from there with the count it had. The count of 65536 runs over the whole search, so a word that is not in memory ends the command when it runs out (RET PO). The M address is set on the low byte of the word found and the memory display (4063H) on the 64 byte boundary below it. When aaaa is typed and dddd is not, the word shown is aaaa itself, though the search is for the word kept.

506CH - The Drive Commands: Read and Write Sectors

d,cc,ss,o,aaaa,nn ENTER, the command key d being the drive 0-7: cylinder cc (left out: the directory cylinder, byte +09H of the drive code table), first sector ss, operation o (r read, w write, or the asterisk key: write with the deleted data mark used for directory sectors), memory address aaaa, and nn sectors. With ss typed the count is 1, else the transfer starts at sector 0 and the count is the sectors of a cylinder (the heads times the sectors of a track, doubled for two sides, kept at 405FH). ENTER before the operation ends the command. Each sector goes to or from the next 256 bytes of memory, and the sector after the cylinder's last starts the next cylinder. An error shows the error number in hexadecimal between two asterisk characters and waits for a key: ENTER stops, any other key goes on with the next sector. A read with r ends with the memory display (4063H) and the M address (4060H) on the first page read and DEBUG's screen layout (405EH) set to 73H, the full screen of 256 bytes. When aaaa is left out, the memory address is the last number read before it (the sector, or the cylinder).

513EH - The P Command: Print a Block of Memory

Register A = the key less 30H (from 506CH), so the test against 40H is met by the key p (70H). P aaaa,bbbb ENTER prints memory through the ROM's printer routine (003BH), sixteen bytes a line from the 16 byte boundary at or below aaaa: two carriage returns first; then for each line the address in four hexadecimal digits, two spaces, the sixteen bytes in hexadecimal each followed by a space with one more space after every fourth byte, a space, the sixteen bytes as characters (a period for a byte below 20H or from 80H up) and a carriage return. Lines are printed while the next line starts below bbbb; three more carriage returns end the listing. Both numbers must be typed. Each hexadecimal digit is made by ADD 90H / DAA / ADC 40H / DAA. The ROM routine at 003BH gives Register A back, which the double spaces and returns rely on. A key that is not p comes to the RET NZ and goes back to DEBUG's command loop.