LS-DOS 6.3.1 for the Model 4 - SYS4/SYS Disassembled

Page Customization

Introduction/Summary

LS-DOS 6.3.1 SYS4/SYS Disassembly (Model 4)

SYS4/SYS is the system overlay of LS-DOS 6.3.1 that turns an error number into its message: the system error dictionary behind @ERROR (SVC 26). It is a load module of 1307 bytes, 1242 of them loaded in two ranges and the length word, 1E00H-2171H, 2177H-22DCH and 23FEH-23FFH, with its transfer address at 1E00H. CKMOD@ on the SYS0/SYS page reads it into 1E00H whenever an SVC asks for overlay 6 and it is not already resident, and RST28 calls 1E00H with the request in Register A: 96H from the @ERROR stub at 1B0FH, which has pushed the error number first (1E00H, 1EAFH).

A program gives @ERROR the error number in Register C, with bit 6 set for the short display (the message alone) and bit 7 set to get control back; with bit 7 clear the program is ended through @ABORT (1FB9H, 1FC1H). SFLAG$ bit 6 cancels bit 6 of the number, CFLAG$ bit 6 suppresses every display (error 63 too, where the TRM says 0 to 62), and CFLAG$ bit 7 puts the short message into the program's buffer at Register Pair DE instead of on the screen (1EEFH). The long display is the format the TRM gives for version 6.2:

LineText (for error 24 after an @OPEN)
1After a line feed: two asterisk signs, a space, Error code = 24, Returns to X'3012'
2Two asterisk signs, a space, File not in directory
3File = REPORT/TXT:1
4Last SVC = 59, Returned to X'300C'

The first line holds the number in two decimal digits and the address after the program's RST 28H (1EFBH); the second the message; the third the file or device of the error, from the FCB or DCB that the last file SVC used (1FC4H); the fourth the number and the return address of the SVC before @ERROR (205AH).

The messages are not stored as text. Each error from 0 to 45 has a sentence: a list of word numbers in page 1EH (1E03H), found through the table of low bytes CODTAB (2178H). The words are in a dictionary of 58 words, each ended by its last character's bit 7 (21A6H). ERR2A (1F67H) finds each word by counting endings from the start of the dictionary, copies it with a space after it, and makes the first letter a capital. Error 63, the extended error, has a line of its own that shows the program's Register Pair HL in hex (1F3FH), and every number from 46 to 62 gives Unknown error code.

The bytes are those of the LS-DOS 6.3.1 level 1H system diskette. The labels are those of the LS-DOS 6.3.1 source code of SYS4, which assembles to this file byte for byte.

Notes

The messages, as the code builds them: 0 No error, 1 Parity error during header read, 2 Seek error during read, 3 Lost data during read, 4 Parity error during read, 5 Data record not found during read, 6 Attempted to read system data record, 7 Attempted to read locked/deleted data record, 8 Device not available, 9 Parity error during header write, 10 Seek error during write, 11 Lost data during write, 12 Parity error during write, 13 Data record not found during write, 14 Write fault on disk drive, 15 Write protected disk, 16 Illegal logical file number, 17 Directory read error, 18 Directory write error, 19 Illegal file name, 20 GAT read error, 21 GAT write error, 22 HIT read error, 23 HIT write error, 24 File not in directory, 25 File access denied, 26 No directory space available, 27 Disk space full, 28 End of file encountered, 29 Record number out of range, 30 Directory full - can't extend file, 31 Program not found, 32 Illegal drive number, 33 No device space available, 34 Load file format error, 35 Memory fault, 36 Attempted to load read only memory, 37 Illegal access attempted to protected file, 38 File not open, 39 Device in use, 40 Protected system device, 41 File already open, 42 Logical record length open fault, 43 SVC parameter error, 44 Parameter error, 45 to 62 Unknown error code, 63 Extended error, HL = X'xxxx'. They match the TRM's list but for 35 and 36, which it does not list, and 42, which it calls LRL open fault. Every message but the extended error's ends with a space before its 0DH, in the program's buffer too (the line of error 63 ends with its quote and keeps its two asterisk signs in the buffer as well); TED, which takes the message into its buffer, steps back from the 0DH to that space and marks it as the last character.

The library commands of the DOS all call @ERROR with bits 6 and 7 set (the short message and a return), so the long display is seen only from a program that leaves bit 6 clear (the TRM's own sample programs set it) or with SFLAG$ bit 6 set, which no command of the DOS sets. With CFLAG$ bit 7 the message is always the short one, even with SFLAG$ bit 6, and SYS4 resets the bit after the call, so each call that wants the buffer must set it again; with CFLAG$ bit 6 set too, @ERROR leaves before that and bit 7 stays. The file line is taken from JDCB$ (0024H), the FCB of the last file SVC, whatever the error: after an error that has nothing to do with a file (35, 43 or 44, say) it describes the FCB of the last file SVC: its drive and DEC while it is open, and for any FCB with bit 7 clear, a closed one too, a false device name made of its seventh and eighth characters (B30); and a file specification that was typed with a password shows the password. A specification with an exclamation mark, which @FSPEC keeps in the FCB, gives Unknown FCB/DCB.

@ERROR returns (bit 7 set) through 1A77H in RST28 with Register Pairs BC, DE and HL as the program had them and Register A holding the error number as adjusted, with the S flag set and NZ: the TRM's Success always does not mean Register A = 0. Request 86H only loads SYS4 (nothing sends it); requests A6H to F6H are taken as @ERROR too, although no stub pushes an error number for them. The source's comment at ERR2A still says that a number above 43 becomes 44: the code makes it 45.

There are no hidden instructions. Six operands are changed while SYS4 runs: 1F24H (the program's return address), 1F46H (its Register Pair HL), 1FBFH (the way back, 1A77H), 1FF2H (the target of the device name, B27), 205EH (the last SVC) and 2072H (its return address). SYS4 also writes into its own texts: the hex of the extended error (20BDH), the device name (20EBH, 213AH), the file specification (20F5H on), the drive and DEC of an open FCB (211DH, 2124H) and the Last SVC line (2158H, 216CH). LILBUF (2172H-2176H) is not loaded.

Bugs (listed on the LS-DOS reference page): B25, for error 63 in the long form the header with the return address is built in SBUFF$ but only the line in SYS4 is shown, so the header is lost (the file and Last SVC lines are left out on purpose) (1F61H); B26, a test of bit 6 of Register C, which the source comments as Extended error?, can never be true because the number was masked to bits 5-0, so the two asterisk signs are always written (1F31H, no effect); B27, DSPC2 changes the target of the device name store to the line Device = for good, so a later Open DCB line in the same load of SYS4 shows the old name (200BH, latent); B28, a file text of 24 characters without an end puts its 0DH over the first letter of Open FCB (2031H, latent); B29, errors 41 and 42 are marked as errors of an unopened specification, but SYS2 returns them with the FCB open, so their file line is always Unknown FCB/DCB (1FCBH); B30, the open FCB line takes every FCB with bit 7 clear as a device, so a closed FCB or a specification not opened gives Open DCB with its seventh and eighth characters as the device name (1FDBH).

Variables

Memory Used by SYS4/SYS

Address
Size
Contents
000BH-000CH
2 bytes
SVCRET$
The address the last SVC before @ERROR returned to (SVCUSER does not store it for SVC 26), copied for the Last SVC line (1ECBH).
000DH
1 byte
LSVC$
The number of that SVC, copied for the Last SVC line (1EB3H).
0024H-0025H
2 bytes
JDCB$
The FCB or DCB of the last call of CKOPEN@ or LNKFCB@, read for the file line (1FC6H).
006CH
1 byte
CFLAG$
Bit 6 no display (1EE1H); bit 7 the short message to the program's buffer at Register Pair DE, tested and reset (1EE6H, 1F5DH, 1FA7H; not reset when bit 6 is set).
007CH
1 byte
SFLAG$
Bit 6, extended error messages wanted: clears bit 6 of the error number (1ED2H).
1D00H-1DFFH
256 bytes
SBUFF$
Where the long header and the message are built and shown from (1EEAH, 1FABH).
1F24H-1F25H
2 bytes
USRET operand
The return address of the program's RST 28H (1EC4H).
1F46H-1F47H
2 bytes
EXTEND operand
The program's Register Pair HL, shown for error 63 (1EBAH).
1FBFH-1FC0H
2 bytes
ERR7 operand
1A77H, the return into RST28 (1EBEH).
1FF2H-1FF3H
2 bytes
DSPC1A operand
Where DSPC1 stores the device name: 213AH in the file, 20EBH once DSPC2 has run (200BH).
205EH
1 byte
SVSVC operand
The number of the last SVC (1EB6H).
2072H-2073H
2 bytes
SVRET operand
The address the last SVC returned to (1ECEH).
20BDH-20C0H
4 bytes
EXT$ERR+26
The program's Register Pair HL in hex (1F4BH).
20EBH-20ECH
2 bytes
DEV$NAM
The device name of the line Device = (1FF0H after 200BH).
20F5H-210DH
25 bytes
FILE$EQ+7
The file specification from the FCB and its 0DH (202EH, 2054H).
211DH, 2124H-2125H
3 bytes
OPN$FCB+16, OPN$FCB+23
The drive digit and the DEC in hex of an open FCB (2043H, 204AH).
213AH-213BH
2 bytes
OPN$DCB+18
The device name of an open DCB (1FF0H).
2158H-215BH
4 bytes
SVC$NUM+11
The last SVC number in decimal and 03H (2068H, 206DH).
216CH-216FH
4 bytes
SVC$RET+16
The return address of the last SVC in hex (2074H).
2172H-2176H
5 bytes
LILBUF
Not loaded: the SVC number in five decimal characters from @HEXDEC (2062H).
23FEH-23FFH
2 bytes
Overlay length
04DDH, the length of SYS4 read by SYSTEM (SYSRES).

Routines of Other Files Called

AddressRoutine
0500H@LOGOT (BOOT/SYS): shows a line and writes it to the job log, which @LOGER skips when JL is NIL (1F62H, 1FAEH, 2057H, 207AH, 2080H).
06F6H@HEXDEC (BOOT/SYS): the SVC number in decimal (2062H).
07BDH, 07C2H@HEX16 and @HEX8 (BOOT/SYS): a word or a byte in hex (1F26H, 1F4BH, 2074H; 204AH).
1A77HThe end of RST28 (SYS0/SYS): restores @DBGHK and returns to the program (1FBEH).
1B08H@ABORT (SYS0/SYS): ends the program with the return code FFFFH (1FC1H).

Disassembly

1E00H - SYS4: the Entry and the Sentence Table

SYS4/SYS is the system error dictionary. CKMOD@ (1A7FH on the SYS0/SYS page) reads it into 1E00H whenever an SVC asks for overlay 6 and it is not already resident, and RST28 calls 1E00H with the request in Register A: 96H from the @ERROR stub at 1B0FH. The entry jumps over the sentence table: one list of word numbers for each error from 0 to 45, each byte the number of a word of the dictionary at 21A6H in its bits 5-0, the last byte of a list with bit 7 set. Bit 6 of the last byte tells DSPSPEC (1FC4H) where the long display finds the file or device of the error: set (C0H) for the errors that come from a specification not yet opened, where the FCB still holds the text; clear (80H) for the others, where the FCB or DCB is open. CODTAB (2178H) holds the low byte of each list; the source requires the whole table to lie in page 1EH.

1E00SYS4
SYS4: jump to 1EAFH (BEGIN) over the sentence table, with Register A holding the request handed over by RST28: 96H from @ERROR (86H and A6H to F6H, which nothing sends, would come here too).
1E03-1E04MSG0
DEFB 01H, 82H 01 82
MSG0, 1E03H-1E04H: the message of error 0 (00H), No error: 01H (word 1, no); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E05-1E09MSG1
DEFB 04H, 02H, 05H, 06H, 89H 04 02 05 06 89
MSG1, 1E05H-1E09H: the message of error 1 (01H), Parity error during header read: 04H (word 4, parity); 02H (word 2, error); 05H (word 5, during); 06H (word 6, header); 89H (word 9, read, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E0A-1E0DMSG2
DEFB 08H, 02H, 05H, 89H 08 02 05 89
MSG2, 1E0AH-1E0DH: the message of error 2 (02H), Seek error during read: 08H (word 8, seek); 02H (word 2, error); 05H (word 5, during); 89H (word 9, read, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E0E-1E11MSG3
DEFB 0BH, 07H, 05H, 89H 0B 07 05 89
MSG3, 1E0EH-1E11H: the message of error 3 (03H), Lost data during read: 0BH (word 11, lost); 07H (word 7, data); 05H (word 5, during); 89H (word 9, read, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E12-1E15MSG4
DEFB 04H, 02H, 05H, 89H 04 02 05 89
MSG4, 1E12H-1E15H: the message of error 4 (04H), Parity error during read: 04H (word 4, parity); 02H (word 2, error); 05H (word 5, during); 89H (word 9, read, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E16-1E1BMSG5
DEFB 07H, 1BH, 0CH, 2CH, 05H, 89H 07 1B 0C 2C 05 89
MSG5, 1E16H-1E1BH: the message of error 5 (05H), Data record not found during read: 07H (word 7, data); 1BH (word 27, record); 0CH (word 12, not); 2CH (word 44, found); 05H (word 5, during); 89H (word 9, read, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E1C-1E20MSG6
DEFB 0DH, 09H, 0FH, 07H, 9BH 0D 09 0F 07 9B
MSG6, 1E1CH-1E20H: the message of error 6 (06H), Attempted to read system data record: 0DH (word 13, attempted to); 09H (word 9, read); 0FH (word 15, system); 07H (word 7, data); 9BH (word 27, record, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E21-1E25MSG7
DEFB 0DH, 09H, 0EH, 07H, 9BH 0D 09 0E 07 9B
MSG7, 1E21H-1E25H: the message of error 7 (07H), Attempted to read locked/deleted data record: 0DH (word 13, attempted to); 09H (word 9, read); 0EH (word 14, locked/deleted); 07H (word 7, data); 9BH (word 27, record, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E26-1E28MSG8
DEFB 2AH, 0CH, 0F3H 2A 0C F3
MSG8, 1E26H-1E28H: the message of error 8 (08H), Device not available: 2AH (word 42, device); 0CH (word 12, not); F3H (word 51, available, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E29-1E2DMSG9
DEFB 04H, 02H, 05H, 06H, 8AH 04 02 05 06 8A
MSG9, 1E29H-1E2DH: the message of error 9 (09H), Parity error during header write: 04H (word 4, parity); 02H (word 2, error); 05H (word 5, during); 06H (word 6, header); 8AH (word 10, write, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E2E-1E31MSG10
DEFB 08H, 02H, 05H, 8AH 08 02 05 8A
MSG10, 1E2EH-1E31H: the message of error 10 (0AH), Seek error during write: 08H (word 8, seek); 02H (word 2, error); 05H (word 5, during); 8AH (word 10, write, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E32-1E35MSG11
DEFB 0BH, 07H, 05H, 8AH 0B 07 05 8A
MSG11, 1E32H-1E35H: the message of error 11 (0BH), Lost data during write: 0BH (word 11, lost); 07H (word 7, data); 05H (word 5, during); 8AH (word 10, write, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E36-1E39MSG12
DEFB 04H, 02H, 05H, 8AH 04 02 05 8A
MSG12, 1E36H-1E39H: the message of error 12 (0CH), Parity error during write: 04H (word 4, parity); 02H (word 2, error); 05H (word 5, during); 8AH (word 10, write, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E3A-1E3FMSG13
DEFB 07H, 1BH, 0CH, 2CH, 05H, 8AH 07 1B 0C 2C 05 8A
MSG13, 1E3AH-1E3FH: the message of error 13 (0DH), Data record not found during write: 07H (word 7, data); 1BH (word 27, record); 0CH (word 12, not); 2CH (word 44, found); 05H (word 5, during); 8AH (word 10, write, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E40-1E44MSG14
DEFB 0AH, 15H, 12H, 13H, 0B0H 0A 15 12 13 B0
MSG14, 1E40H-1E44H: the message of error 14 (0EH), Write fault on disk drive: 0AH (word 10, write); 15H (word 21, fault); 12H (word 18, on); 13H (word 19, disk); B0H (word 48, drive, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E45-1E47MSG15
DEFB 0AH, 16H, 93H 0A 16 93
MSG15, 1E45H-1E47H: the message of error 15 (0FH), Write protected disk: 0AH (word 10, write); 16H (word 22, protected); 93H (word 19, disk, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E48-1E4BMSG16
DEFB 17H, 18H, 1AH, 99H 17 18 1A 99
MSG16, 1E48H-1E4BH: the message of error 16 (10H), Illegal logical file number: 17H (word 23, illegal); 18H (word 24, logical); 1AH (word 26, file); 99H (word 25, number, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E4C-1E4EMSG17
DEFB 10H, 09H, 82H 10 09 82
MSG17, 1E4CH-1E4EH: the message of error 17 (11H), Directory read error: 10H (word 16, directory); 09H (word 9, read); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E4F-1E51MSG18
DEFB 10H, 0AH, 82H 10 0A 82
MSG18, 1E4FH-1E51H: the message of error 18 (12H), Directory write error: 10H (word 16, directory); 0AH (word 10, write); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E52-1E54MSG19
DEFB 17H, 1AH, 0E9H 17 1A E9
MSG19, 1E52H-1E54H: the message of error 19 (13H), Illegal file name: 17H (word 23, illegal); 1AH (word 26, file); E9H (word 41, name, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E55-1E57MSG20
DEFB 22H, 09H, 82H 22 09 82
MSG20, 1E55H-1E57H: the message of error 20 (14H), GAT read error: 22H (word 34, GAT); 09H (word 9, read); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E58-1E5AMSG21
DEFB 22H, 0AH, 82H 22 0A 82
MSG21, 1E58H-1E5AH: the message of error 21 (15H), GAT write error: 22H (word 34, GAT); 0AH (word 10, write); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E5B-1E5DMSG22
DEFB 23H, 09H, 82H 23 09 82
MSG22, 1E5BH-1E5DH: the message of error 22 (16H), HIT read error: 23H (word 35, HIT); 09H (word 9, read); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E5E-1E60MSG23
DEFB 23H, 0AH, 82H 23 0A 82
MSG23, 1E5EH-1E60H: the message of error 23 (17H), HIT write error: 23H (word 35, HIT); 0AH (word 10, write); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E61-1E64MSG24
DEFB 1AH, 0CH, 2DH, 0D0H 1A 0C 2D D0
MSG24, 1E61H-1E64H: the message of error 24 (18H), File not in directory: 1AH (word 26, file); 0CH (word 12, not); 2DH (word 45, in); D0H (word 16, directory, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E65-1E67MSG25
DEFB 1AH, 2EH, 0F1H 1A 2E F1
MSG25, 1E65H-1E67H: the message of error 25 (19H), File access denied: 1AH (word 26, file); 2EH (word 46, access); F1H (word 49, denied, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E68-1E6BMSG26
DEFB 01H, 10H, 27H, 0F3H 01 10 27 F3
MSG26, 1E68H-1E6BH: the message of error 26 (1AH), No directory space available: 01H (word 1, no); 10H (word 16, directory); 27H (word 39, space); F3H (word 51, available, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E6C-1E6EMSG27
DEFB 13H, 27H, 0AFH 13 27 AF
MSG27, 1E6CH-1E6EH: the message of error 27 (1BH), Disk space full: 13H (word 19, disk); 27H (word 39, space); AFH (word 47, full, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E6F-1E72MSG28
DEFB 1CH, 1DH, 1AH, 0A0H 1C 1D 1A A0
MSG28, 1E6FH-1E72H: the message of error 28 (1CH), End of file encountered: 1CH (word 28, end); 1DH (word 29, of); 1AH (word 26, file); A0H (word 32, encountered, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E73-1E77MSG29
DEFB 1BH, 19H, 1EH, 1DH, 9FH 1B 19 1E 1D 9F
MSG29, 1E73H-1E77H: the message of error 29 (1DH), Record number out of range: 1BH (word 27, record); 19H (word 25, number); 1EH (word 30, out); 1DH (word 29, of); 9FH (word 31, range, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E78-1E7BMSG30
DEFB 10H, 2FH, 34H, 9AH 10 2F 34 9A
MSG30, 1E78H-1E7BH: the message of error 30 (1EH), Directory full - can't extend file: 10H (word 16, directory); 2FH (word 47, full); 34H (word 52, - can't extend); 9AH (word 26, file, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E7C-1E7EMSG31
DEFB 32H, 0CH, 0ECH 32 0C EC
MSG31, 1E7CH-1E7EH: the message of error 31 (1FH), Program not found: 32H (word 50, program); 0CH (word 12, not); ECH (word 44, found, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E7F-1E81MSG32
DEFB 17H, 30H, 0D9H 17 30 D9
MSG32, 1E7FH-1E81H: the message of error 32 (20H), Illegal drive number: 17H (word 23, illegal); 30H (word 48, drive); D9H (word 25, number, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E82-1E85MSG33
DEFB 01H, 2AH, 27H, 0F3H 01 2A 27 F3
MSG33, 1E82H-1E85H: the message of error 33 (21H), No device space available: 01H (word 1, no); 2AH (word 42, device); 27H (word 39, space); F3H (word 51, available, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E86-1E89MSG34
DEFB 26H, 1AH, 2BH, 82H 26 1A 2B 82
MSG34, 1E86H-1E89H: the message of error 34 (22H), Load file format error: 26H (word 38, load); 1AH (word 26, file); 2BH (word 43, format); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E8A-1E8BMSG35
DEFB 11H, 95H 11 95
MSG35, 1E8AH-1E8BH: the message of error 35 (23H), Memory fault: 11H (word 17, memory); 95H (word 21, fault, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E8C-1E90MSG36
DEFB 0DH, 26H, 09H, 28H, 91H 0D 26 09 28 91
MSG36, 1E8CH-1E90H: the message of error 36 (24H), Attempted to load read only memory: 0DH (word 13, attempted to); 26H (word 38, load); 09H (word 9, read); 28H (word 40, only); 91H (word 17, memory, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E91-1E95MSG37
DEFB 17H, 2EH, 0DH, 16H, 9AH 17 2E 0D 16 9A
MSG37, 1E91H-1E95H: the message of error 37 (25H), Illegal access attempted to protected file: 17H (word 23, illegal); 2EH (word 46, access); 0DH (word 13, attempted to); 16H (word 22, protected); 9AH (word 26, file, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E96-1E98MSG38
DEFB 1AH, 0CH, 0F5H 1A 0C F5
MSG38, 1E96H-1E98H: the message of error 38 (26H), File not open: 1AH (word 26, file); 0CH (word 12, not); F5H (word 53, open, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1E99-1E9BMSG39
DEFB 2AH, 2DH, 0B6H 2A 2D B6
MSG39, 1E99H-1E9BH: the message of error 39 (27H), Device in use: 2AH (word 42, device); 2DH (word 45, in); B6H (word 54, use, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E9C-1E9EMSG40
DEFB 16H, 0FH, 0AAH 16 0F AA
MSG40, 1E9CH-1E9EH: the message of error 40 (28H), Protected system device: 16H (word 22, protected); 0FH (word 15, system); AAH (word 42, device, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1E9F-1EA1MSG41
DEFB 1AH, 39H, 0F5H 1A 39 F5
MSG41, 1E9FH-1EA1H: the message of error 41 (29H), File already open: 1AH (word 26, file); 39H (word 57, already); F5H (word 53, open, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1EA2-1EA6MSG42
DEFB 18H, 1BH, 3AH, 35H, 0D5H 18 1B 3A 35 D5
MSG42, 1EA2H-1EA6H: the message of error 42 (2AH), Logical record length open fault: 18H (word 24, logical); 1BH (word 27, record); 3AH (word 58, length); 35H (word 53, open); D5H (word 21, fault, bit 7 set: the last word). Bit 6 of the last byte set: the long display names the file or device from the text of the FCB, a specification that was not opened (DSPC2, 1FFFH).
1EA7-1EA9MSG43
DEFB 38H, 14H, 82H 38 14 82
MSG43, 1EA7H-1EA9H: the message of error 43 (2BH), SVC parameter error: 38H (word 56, SVC); 14H (word 20, parameter); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1EAA-1EABMSG44
DEFB 14H, 82H 14 82
MSG44, 1EAAH-1EABH: the message of error 44 (2CH), Parameter error: 14H (word 20, parameter); 82H (word 2, error, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH).
1EAC-1EAEMSG45
DEFB 25H, 02H, 0A1H 25 02 A1
MSG45, 1EACH-1EAEH: the message of error 45 (2DH), Unknown error code: 25H (word 37, unknown); 02H (word 2, error); A1H (word 33, code, bit 7 set: the last word). Bit 6 of the last byte clear: the long display names the drive and DEC of the open FCB, or the open DCB (1FCFH). ERR2A also uses it for every error number from 46 to 62.

1EAFH - BEGIN: @ERROR Takes Its Arguments

A program calls @ERROR (SVC 26) with the error number in Register C, bit 6 set for the short display and bit 7 set to be given control back. The SVC dispatcher stores neither LSVC$ nor SVCRET$ for SVC 26 (1A45H), so they still name the SVC before it; it hands the number over in Register A to the stub at 1B0FH, which pushes it and sends request 96H. RST28 drops the stub's own return address, so on entry the stack holds RST28's return address 1A77H, the pushed error number and the return address of the program's RST 28H. BEGIN plants these addresses, the caller's Register Pair HL (the value an extended error 63 shows) and the last SVC into the operands that use them, and saves Register Pairs HL, DE and BC. SFLAG$ bit 6 (extended messages wanted) cancels bit 6 of the number; CFLAG$ bit 6 suppresses all display and CFLAG$ bit 7 sends the short message to the program's buffer at Register Pair DE instead.

1EAFBEGIN
AND 70H E6 70
BEGIN: mask Register A (the request from RST28, 86H or 96H) with 70H, keeping bits 6-4, the function number times 10H.
1EB1
RET Z C8
Return at once if Register A is 00H: function 0 (request 86H) only gets SYS4 loaded. Neither an SVC stub nor any file of the 6.3.1 source sends it. Every other function, 10H (request 96H) to 70H, is taken below as @ERROR.
1EB2
PUSH AF F5
Save Register Pair AF (the function in Register A) on the stack while Register A is used to fetch the last SVC.
1EB3
LD A,(000DH) 3A 0D 00LD A,(LSVC$)
Load Register A with LSVC$ (000DH), the number of the last SVC called through RST 28H before @ERROR, stored by SVCUSER at 1A47H (SVC 26 itself is not stored).
1EB6
LD (205EH),A 32 5E 20
Store Register A at 205EH, the operand of LD A,nn at 205DH (SVSVC), for the Last SVC line of the long display.
1EB9
POP AF F1
Restore Register Pair AF from the stack: Register A is again the function number (10H for @ERROR).
1EBA
LD (1F46H),HL 22 46 1F
Store Register Pair HL, as the program had it at its RST 28H, at 1F46H, the operand of LD DE,nnnn at 1F45H (EXTEND): for error 63 (extended error) it is the code the program wants shown.
1EBD
EX (SP),HL E3
Exchange Register Pair HL with the top of the stack (Stack Pointer): Register Pair HL gets 1A77H, the return address into RST28 pushed by the CALL at 1A74H, and the program's Register Pair HL goes onto the stack in its place.
1EBE
LD (1FBFH),HL 22 BF 1F
Store Register Pair HL (1A77H) at 1FBFH, the operand of JP M,nnnn at 1FBEH (ERR7), the way back to the program when bit 7 of the error number is set.
1EC1
POP HL E1
Restore Register Pair HL (the program's) from the stack; the return address into RST28 is dropped, as ERR7 jumps there instead of returning.
1EC2
POP AF F1
Restore Register Pair AF from the stack: Register A is the error number the stub at 1B0FH pushed (the program's Register C, which the SVC dispatcher copied to Register A at 1A59H).
1EC3
EX (SP),HL E3
Exchange Register Pair HL with the top of the stack (Stack Pointer): Register Pair HL gets the return address of the program's RST 28H (the address after it), and Register Pair HL goes onto the stack in its place.
1EC4
LD (1F24H),HL 22 24 1F
Store Register Pair HL (the program's return address) at 1F24H, the operand of LD DE,nnnn at 1F23H (USRET), for Returns to X'dddd' in the long display.
1EC7
EX (SP),HL E3
Exchange Register Pair HL with the top of the stack (Stack Pointer) again: the program's Register Pair HL comes back and its return address is on the stack once more, where 1A77H will find it.
1EC8
PUSH HL E5
Save Register Pair HL (the program's) on the stack; ERR6A (1FB9H) restores it before the return.
1EC9
PUSH DE D5
Save Register Pair DE (the program's; with CFLAG$ bit 7 the address of its buffer) on the stack.
1ECA
PUSH BC C5
Save Register Pair BC (the program's, Register C holding the error number) on the stack.
1ECB
LD HL,(000BH) 2A 0B 00LD HL,(SVCRET$)
Load Register Pair HL with SVCRET$ (000BH), the address the last SVC before @ERROR returned to, stored by SVCUSER at 1A4BH.
1ECE
LD (2072H),HL 22 72 20
Store Register Pair HL at 2072H, the operand of LD DE,nnnn at 2071H (SVRET), for Returned to X'rrrr' in the long display.
1ED1
LD B,A 47
Load Register B with Register A, the error number with its two option bits: bit 7 return to the program, bit 6 short display.
1ED2
LD A,(007CH) 3A 7C 00LD A,(SFLAG$)
Load Register A with SFLAG$ (007CH), the system flags.
1ED5
AND 40H E6 40
Mask Register A with 40H, keeping bit 6 of SFLAG$, set when extended error messages are wanted (the TRM: it overrides bit 6 of Register C; no command of the DOS sets it, a program does through @FLAGS).
1ED7
XOR B A8
XOR Register A with Register B (the error number): bit 6 of Register A is now bit 6 of the number inverted when SFLAG$ bit 6 is set, and the other bits are those of the number.
1ED8
AND B A0
AND Register A with Register B: Register A is the error number with bit 6 cleared when SFLAG$ bit 6 is set, unchanged otherwise; the S flag is bit 7, the return option.
1ED9
LD B,A 47
Load Register B with Register A, the error number as adjusted, so that bit 6 of Register B now decides the short display.
1EDA
PUSH AF F5
Save Register Pair AF (the adjusted error number in Register A) on the stack: ERR6A (1FB9H) returns it to the program, and 1FB4H tests its bit 6 (1F9EH and 1FB2H take it back from the stack on the way).
1EDB
AND 3FH E6 3F
Mask Register A with 3FH, keeping bits 5-0, the error number alone (0 to 63).
1EDD
LD C,A 4F
Load Register C with Register A, the error number 0 to 63.
1EDE
LD HL,006CH 21 6C 00LD HL,CFLAG$
Point Register Pair HL at CFLAG$ (006CH), the condition flags.
1EE1
BIT 6,(HL) CB 76
Test bit 6 of CFLAG$ (Register Pair HL), set by a program that wants @ERROR to show nothing.
1EE3
If CFLAG$ bit 6 is set, jump to 1FB9H (ERR6A) without any display: the registers are restored and the program gets control back (bit 7 of the number set) or @ABORT ends it.
1EE6
BIT 7,(HL) CB 7E
Test bit 7 of CFLAG$ (Register Pair HL), set by a program that wants the message in its own buffer at Register Pair DE instead of on the display.
1EE8
If CFLAG$ bit 7 is set, jump relative to 1EEFH (ERR0), keeping the program's Register Pair DE as the place for the message.
1EEA
LD DE,1D00H 11 00 1DLD DE,SBUFF$
Point Register Pair DE at SBUFF$ (1D00H), the system buffer, where the message is built before it is shown.
1EED
Jump relative to 1EF5H (ERR0A) over the forced short display.

1EEFH - ERR0: the User Buffer, and the Header of the Long Display

With CFLAG$ bit 7 the message always goes to the program's buffer in the short form, whatever bit 6 of the number and SFLAG$ say. For the long form (bit 6 of the adjusted number clear) the first line is built in SBUFF$: a line feed, two asterisk signs, Error code = and the number in two decimal digits, then Returns to X' and the return address of the program's RST 28H in hex; the next line starts with two asterisks and a space, and the message itself follows. A test that the source comments as Extended error? looks at bit 6 of a number already masked to bits 5-0, so the two asterisk signs are always written (B26); for error 63 the header is never shown at all (B25).

1EEFERR0
SET 6,B CB F0
ERR0: set bit 6 of Register B, the copy of the error number that decides the form, so that the message for the program's buffer is always the short one.
1EF1
POP AF F1
Restore Register Pair AF from the stack: the adjusted error number saved at 1EDAH.
1EF2
SET 6,A CB F7
Set bit 6 of Register A as well, so that the number returned to the program, and the test at 1FB4H, also show the short form (no file or SVC lines).
1EF4
PUSH AF F5
Save Register Pair AF (the error number with bit 6 set) on the stack again in place of the old one.
1EF5ERR0A
BIT 6,B CB 70
ERR0A: test bit 6 of Register B: set for the short display (by the program, or forced at 1EEFH), clear for the long one.
1EF7
LD B,00H 06 00
Load Register B with 00H, so that Register Pair BC is the error number alone for ADD HL,BC at 1F71H; LD does not change the Z flag of the BIT.
1EF9
If bit 6 was set, jump relative to 1F3FH (ERR2) to build the message only, at Register Pair DE.
1EFB
PUSH BC C5
Save Register Pair BC (the error number in Register C) on the stack, because the LDIR below counts with it.
1EFC
LD HL,20C3H 21 C3 20LD HL,ERRMSG
Point Register Pair HL at 20C3H (ERRMSG): a line feed, two asterisk signs, a space and Error code = , the start of the long display.
1EFF
LD C,11H 0E 11
Load Register C with 11H (17), the length of ERRMSG; Register B is 00H, so Register Pair BC = 17.
1F01
LDIR ED B0
Copy the 17 bytes from Register Pair HL (20C3H) to Register Pair DE (SBUFF$ 1D00H) with LDIR, Register Pair BC counting down to 0; Register Pair DE ends at 1D11H.
1F03
POP BC C1
Restore Register Pair BC (the error number in Register C, Register B 00H) from the stack.
1F04
EX DE,HL EB
Exchange Register Pairs DE and HL: Register Pair HL is now the next free byte of the line in SBUFF$ (1D11H).
1F05
LD A,C 79
Load Register A with Register C, the error number 0 to 63, to be written in decimal.
1F06
LD (HL),2FH 36 2F
Store 2FH, one less than the character 0, at Register Pair HL, the tens digit, which the loop raises.
1F08ERR1
INC (HL) 34
ERR1: increment the tens digit at Register Pair HL by one character.
1F09
SUB 0AH D6 0A
Subtract 0AH (10) from Register A, the number; Carry when it goes below 0.
1F0B
If no Carry, jump relative to 1F08H (ERR1) to count another ten; at Carry the tens digit at Register Pair HL is right and Register A is the units less 10.
1F0D
INC L 2C
Increment Register L to the units position (a step of Register L alone, enough in SBUFF$, which starts at a page boundary).
1F0E
ADD A,3AH C6 3A
Add 3AH to Register A: the units less 10 plus 3AH is the units digit in ASCII (30H to 39H).
1F10
LD (HL),A 77
Store Register A, the units digit, at Register Pair HL: the number now stands in two digits, 00 to 63.
1F11
INC L 2C
Increment Register L to the next position of the line.
1F12
LD (HL),2CH 36 2C
Store 2CH, a comma, at Register Pair HL, after the two digits of the error number.
1F14
INC L 2C
Increment Register L to the next position of the line.
1F15
LD (HL),20H 36 20
Store 20H, a space, at Register Pair HL, after the comma; Returns to X' follows.
1F17
INC L 2C
Increment Register L to the next free position of the line.
1F18
EX DE,HL EB
Exchange Register Pairs DE and HL: Register Pair DE is again the next free byte of the line, for the LDIR below.
1F19
PUSH BC C5
Save Register Pair BC (the error number in Register C) on the stack again for the next LDIR.
1F1A
LD HL,20D4H 21 D4 20LD HL,ERRMSG1
Point Register Pair HL at 20D4H (ERRMSG1), the text Returns to X' with its quote.
1F1D
LD BC,000DH 01 0D 00LD BC,M1LEN
Load Register Pair BC with 000DH (13), the length of that text.
1F20
LDIR ED B0
Copy the 13 bytes from Register Pair HL (20D4H) to Register Pair DE in SBUFF$ with LDIR, Register Pair BC counting down to 0.
1F22
EX DE,HL EB
Exchange Register Pairs DE and HL: Register Pair HL is the next free byte of the line, where @HEX16 writes.
1F23USRET
LD DE,0000H 11 00 00
USRET: load Register Pair DE with the return address of the program's RST 28H; the 0000H in the file is the operand BEGIN stores at 1EC4H.
1F26
Call @HEX16 at 07BDH (on the BOOT/SYS page) to write Register Pair DE as four hexadecimal digits at Register Pair HL; Register Pair HL ends after them.
1F29
LD A,27H 3E 27
Load Register A with 27H, the closing quote of X'dddd'.
1F2B
LD (HL),A 77
Store Register A, the quote, at Register Pair HL.
1F2C
INC HL 23
Increment Register Pair HL to the next free byte.
1F2D
LD (HL),0AH 36 0A
Store 0AH, a line feed, at Register Pair HL: the end of the first line of the long display.
1F2F
INC HL 23
Increment Register Pair HL to the start of the second line.
1F30
POP BC C1
Restore Register Pair BC (the error number in Register C, Register B 00H) from the stack.
1F31
BIT 6,C CB 71
Test bit 6 of Register C, which the source comments as Extended error?. Register C holds the number masked to bits 5-0 at 1EDBH, so bit 6 is always 0 and the jump below is never taken (B26); what the test was meant to catch cannot be told from the code.
1F33
If bit 6 of Register C were set, jump relative to 1F3EH (ERR6) without the two asterisk signs (the source: Go if not); never taken.
1F35
LD (HL),2AH 36 2A
Store 2AH, an asterisk, at Register Pair HL, the start of the line that will hold the message.
1F37
INC HL 23
Increment Register Pair HL to the next free byte.
1F38
LD (HL),2AH 36 2A
Store 2AH, the second asterisk, at Register Pair HL.
1F3A
INC HL 23
Increment Register Pair HL to the next free byte.
1F3B
LD (HL),20H 36 20
Store 20H, a space, at Register Pair HL, between the asterisks and the message.
1F3D
INC HL 23
Increment Register Pair HL to the next free byte, where the message begins.
1F3EERR6
EX DE,HL EB
ERR6: exchange Register Pairs DE and HL: Register Pair DE is the place for the message in SBUFF$.

1F3FH - ERR2: Error 63, the Extended Error

Error 63 has no sentence: its message is the line Extended error, HL = X'xxxx' after two asterisk signs, at 20A3H, with the program's Register Pair HL written into it in hex. The line is copied to Register Pair DE (SBUFF$, after the long header if there is one, or the program's buffer), but what is shown is the line at 20A3H itself, so the long header built in SBUFF$ never reaches the display (B25). The file line and the Last SVC line are left out on purpose: the source handles error 63 alone (Do extended error only) and goes straight to ERR6A.

1F3FERR2
LD A,C 79
ERR2: load Register A with Register C, the error number 0 to 63.
1F40
CP 3FH FE 3F
Compare Register A with 3FH (63), the number of an extended error.
1F42
If Register A is not 63, jump relative to 1F67H (ERR2A) to build the message from the sentence table.
1F44
PUSH DE D5
Save Register Pair DE (the place for the message) on the stack while Register Pair DE carries the value to be shown.
1F45EXTEND
LD DE,0000H 11 00 00
EXTEND: load Register Pair DE with the program's Register Pair HL at its RST 28H; the 0000H in the file is the operand BEGIN stores at 1EBAH.
1F48
LD HL,20BDH 21 BD 20
Point Register Pair HL at 20BDH, the four x characters of X'xxxx' in EXT$ERR (20A3H + 26).
1F4B
Call @HEX16 at 07BDH (on the BOOT/SYS page) to write Register Pair DE as four hexadecimal digits at Register Pair HL, over the x characters of the text in SYS4 itself.
1F4E
LD HL,20A3H 21 A3 20LD HL,EXT$ERR
Point Register Pair HL at 20A3H (EXT$ERR), the line that starts with two asterisk signs and Extended error, HL = X'xxxx' and ends with 0DH.
1F51
POP DE D1
Restore Register Pair DE (the place for the message: SBUFF$ or the program's buffer) from the stack.
1F52
PUSH HL E5
Save Register Pair HL (20A3H) on the stack: it is the line @LOGOT shows below.
1F53
PUSH BC C5
Save Register Pair BC (the error number in Register C) on the stack.
1F54
LD BC,0020H 01 20 00LD BC,M2LEN
Load Register Pair BC with 0020H (32), the length of the line with its 0DH.
1F57
LDIR ED B0
Copy the 32 bytes from Register Pair HL (20A3H) to Register Pair DE with LDIR, Register Pair BC counting down to 0: the program's buffer (CFLAG$ bit 7) gets the line with its 0DH.
1F59
POP BC C1
Restore Register Pair BC (the error number in Register C) from the stack.
1F5A
LD HL,006CH 21 6C 00LD HL,CFLAG$
Point Register Pair HL at CFLAG$ (006CH), the condition flags, for the test of bit 7.
1F5D
BIT 7,(HL) CB 7E
Test bit 7 of CFLAG$ (Register Pair HL), the message to the program's buffer; the Z flag stays through the next two instructions.
1F5F
RES 7,(HL) CB BE
Reset bit 7 of CFLAG$ (Register Pair HL): the program's buffer is used for this one call only.
1F61
POP HL E1
Restore Register Pair HL from the stack: 20A3H, the line in SYS4, not the copy just made in SBUFF$ after the long header (B25).
1F62
If CFLAG$ bit 7 was clear, call @LOGOT at 0500H (on the BOOT/SYS page) to show the line at Register Pair HL (20A3H) and write it to the job log; the header in SBUFF$ is not shown.
1F65
Jump relative to 1FB9H (ERR6A) to restore the registers and return or abort, without the file and SVC lines.

1F67H - ERR2A: the Message Built from the Dictionary

An error number above 45 becomes 45 (Unknown error code); the source's comment still says 43 and 44. CODTAB gives the low byte of the sentence, and for each word number of the sentence LP1 counts word endings (bit 7) through the dictionary from 21A6H, LP2 copies the word with bit 7 cleared and a space after it. The first character of the message is made a capital (RES 5), the message ends with 0DH after the trailing space, and unless CFLAG$ bit 7 sent it to the program's buffer it is shown and logged by @LOGOT from SBUFF$, header and all. In the long form DSPSPEC then adds the file or device line and the Last SVC line.

1F67ERR2A
LD A,2DH 3E 2D
ERR2A: load Register A with 2DH (45), the highest error number that has a sentence of its own.
1F69
CP C B9
Compare Register A (45) with Register C, the error number: Carry when the number is 46 to 62.
1F6A
PUSH DE D5
Save Register Pair DE, the address of the first character of the message, on the stack; 1F98H takes it back to make that character a capital.
1F6B
If no Carry (the number is 45 or below), jump relative to 1F6EH (ERR3) with Register C as it is.
1F6D
LD C,A 4F
Load Register C with Register A (45): every number from 46 to 62 shows Unknown error code.
1F6EERR3
LD HL,2178H 21 78 21LD HL,CODTAB
ERR3: point Register Pair HL at 2178H (CODTAB), the low bytes of the 46 sentences.
1F71
ADD HL,BC 09
Add Register Pair BC (Register B 00H, Register C the error number) to Register Pair HL: Register Pair HL is the entry of the error in CODTAB.
1F72
LD L,(HL) 6E
Load Register L with the entry at Register Pair HL, the low byte of the sentence.
1F73
LD H,1EH 26 1E
Load Register H with 1EH, the page of every sentence (1E03H to 1EAEH): Register Pair HL now points at the first word byte of the sentence.
1F75ERR5
LD A,(HL) 7E
ERR5: load Register A with the word byte at Register Pair HL.
1F76
AND 3FH E6 3F
Mask Register A with 3FH, clearing bit 7 (last word) and bit 6 (where the file is shown) to leave the word number.
1F78
LD B,A 47
Load Register B with Register A, the word number, as the count of word endings to pass.
1F79
PUSH HL E5
Save Register Pair HL, the place in the sentence, on the stack.
1F7A
LD HL,21A6H 21 A6 21LD HL,WORDS
Point Register Pair HL at 21A6H (WORDS), the start of the dictionary: word 0, one character with bit 7 set.
1F7DLP1
LD A,(HL) 7E
LP1: load Register A with the dictionary byte at Register Pair HL.
1F7E
RLCA 07
Rotate Register A left: bit 7 of the byte, the end of a word, goes into Carry.
1F7F
INC HL 23
Increment Register Pair HL to the next dictionary byte; the Carry of the rotation stays.
1F80
If no Carry (not the last character of a word), jump relative to 1F7DH (LP1) to the next byte.
1F82
DEC B 05
Decrement Register B, the count of word endings still to pass.
1F83
If Register B is not 0, jump relative to 1F7DH (LP1) to pass the next word; at 0 Register Pair HL is at the first character of the wanted word.
1F85LP2
LD A,(HL) 7E
LP2: load Register A with the character at Register Pair HL.
1F86
RLCA 07
Rotate Register A left: bit 7 (the last character) goes into Carry and into bit 0.
1F87
SRL A CB 3F
Shift Register A right: bit 0 goes out into Carry again and bit 7 becomes 0, so Register A is the character with bit 7 cleared and Carry tells whether it ends the word.
1F89
LD (DE),A 12
Store Register A, the character, at Register Pair DE in the message.
1F8A
INC HL 23
Increment Register Pair HL to the next character of the dictionary; INC does not change Carry.
1F8B
INC DE 13
Increment Register Pair DE to the next place in the message.
1F8C
If no Carry (the word goes on), jump relative to 1F85H (LP2) for the next character.
1F8E
LD A,20H 3E 20
Load Register A with 20H, a space, to follow the word just copied.
1F90
LD (DE),A 12
Store Register A, the space, at Register Pair DE after the word; the last word gets one too, so every message ends with a space before its 0DH.
1F91
INC DE 13
Increment Register Pair DE to the next place in the message.
1F92
POP HL E1
Restore Register Pair HL, the place in the sentence, from the stack.
1F93
LD A,(HL) 7E
Load Register A with the word byte just used, at Register Pair HL.
1F94
INC HL 23
Increment Register Pair HL to the next word byte of the sentence; after the last word it points past the sentence.
1F95
RLCA 07
Rotate Register A left: bit 7, the last word of the sentence, goes into Carry.
1F96
If no Carry, jump relative to 1F75H (ERR5) for the next word.
1F98
EX (SP),HL E3
Exchange Register Pair HL with the top of the stack (Stack Pointer): Register Pair HL gets the address of the first character of the message (pushed at 1F6AH), the end of the sentence goes onto the stack.
1F99
LD A,(HL) 7E
Load Register A with the first character of the message, at Register Pair HL.
1F9A
RES 5,A CB AF
Reset bit 5 of Register A, which makes a lower case letter a capital (the capitals that start GAT, HIT and SVC stay as they are).
1F9C
LD (HL),A 77
Store Register A, the capital, back at Register Pair HL.
1F9D
POP HL E1
Restore Register Pair HL from the stack: the address just past the last word byte of the sentence.
1F9E
POP AF F1
Restore Register Pair AF from the stack: the adjusted error number saved at 1EDAH (or 1EF4H).
1F9F
PUSH AF F5
Save Register Pair AF on the stack again for ERR6A (1FB9H).
1FA0
PUSH HL E5
Save Register Pair HL (just past the sentence) on the stack for DSPSPEC, which reads the last word byte before it.
1FA1
LD A,0DH 3E 0D
Load Register A with 0DH, the end of a line, to end the message.
1FA3
LD (DE),A 12
Store Register A at Register Pair DE, after the trailing space: the message is complete, in SBUFF$ or in the program's buffer.
1FA4
LD HL,006CH 21 6C 00LD HL,CFLAG$
Point Register Pair HL at CFLAG$ (006CH), the condition flags, for the test of bit 7.
1FA7
BIT 7,(HL) CB 7E
Test bit 7 of CFLAG$ (Register Pair HL), the message to the program's buffer; the Z flag stays through the next two instructions.
1FA9
RES 7,(HL) CB BE
Reset bit 7 of CFLAG$ (Register Pair HL): the program's buffer is used for this one call only.
1FAB
LD HL,1D00H 21 00 1DLD HL,SBUFF$
Point Register Pair HL at SBUFF$ (1D00H), the start of what was built there: the long header, if any, and the message.
1FAE
If CFLAG$ bit 7 was clear, call @LOGOT at 0500H (on the BOOT/SYS page) to show the text at Register Pair HL (1D00H) up to its 0DH, its line feeds making new lines, and write it to the job log.
1FB1
POP HL E1
Restore Register Pair HL (just past the sentence) from the stack.
1FB2
POP AF F1
Restore Register Pair AF from the stack: the adjusted error number.
1FB3
PUSH AF F5
Save Register Pair AF on the stack again for ERR6A (1FB9H).
1FB4
BIT 6,A CB 77
Test bit 6 of Register A, the short display bit of the adjusted number (set too when the message went to the program's buffer). The source's comment calls it a test for a disk error.
1FB6
If bit 6 is clear (the long display), call 1FC4H (DSPSPEC) to show the file or device line and the Last SVC line, with Register Pair HL just past the sentence.

1FB9H - ERR6A: Back to the Program, or @ABORT

Every path of @ERROR ends here. The program's Register Pairs BC, DE and HL are restored and Register A holds the error number as adjusted (bit 6 cleared by SFLAG$ bit 6, set by CFLAG$ bit 7). With bit 7 of the number set, ERR7 jumps to 1A77H in RST28, which puts back the @DBGHK byte and returns to the instruction after the program's RST 28H with the S flag set and NZ; the TRM's Success always does not mean Register A = 0. With bit 7 clear the program is ended through @ABORT, which gives SYS1 the return code FFFFH.

1FB9ERR6A
POP AF F1
ERR6A: restore Register Pair AF from the stack: Register A is the adjusted error number saved at 1EDAH (or 1EF4H).
1FBA
POP BC C1
Restore Register Pair BC (the program's) from the stack.
1FBB
POP DE D1
Restore Register Pair DE (the program's, the buffer address with CFLAG$ bit 7) from the stack.
1FBC
POP HL E1
Restore Register Pair HL (the program's) from the stack.
1FBD
OR A B7
OR Register A with itself: the S flag is bit 7 of the error number, the return option.
1FBEERR7
JP M,0000H FA 00 00
ERR7: if bit 7 is set (M), jump to 1A77H in RST28 (on the SYS0/SYS page), the operand stored at 1EBEH, which restores @DBGHK and returns to the program after its RST 28H; the 0000H in the file is that operand.
1FC1
Bit 7 clear: jump to @ABORT at 1B08H (on the SYS0/SYS page), which loads Register Pair HL with FFFFH, the return code of an abort, and leaves through @EXIT: the program is ended.

1FC4H - DSPSPEC: the File or Device of the Error

DSPSPEC names what the error happened to, from the FCB or DCB of the last file SVC (JDCB$, set by CKOPEN@ and LNKFCB@), whatever the error is. Bit 6 of the sentence's last byte chooses how it reads it. Clear: the FCB is taken as open; a file (FCB+0 bit 7) gives Open FCB, Drive=d, DEC=nn from FCB+6 and FCB+7; any other FCB is taken as a device FCB (10H, from @OPEN of a device) and gives Open DCB, Device= and the asterisk sign with FCB+6 and FCB+7 as the name, so the text of a closed FCB or of a specification not opened gives its seventh and eighth characters as a device (B30). Set: the FCB still holds the specification as text; a device (asterisk sign first) gives Device = and the name, a file File = and its specification as @FSPEC stored it (in capitals), up to 24 characters of the characters CHKASC accepts. Anything that does not fit gives Unknown FCB/DCB. Errors 41 and 42 have bit 6 set but leave the FCB open, so they always give Unknown FCB/DCB (B29). DSPC2 changes the target of the device name store for good (B27), and a 24 character text puts its 0DH over the first letter of the next message (B28).

1FC4DSPSPEC
PUSH IX DD E5
DSPSPEC: save Index Register IX (the program's) on the stack, because it is used to read the FCB.
1FC6
LD IX,(0024H) DD 2A 24 00LD IX,(JDCB$)
Load Index Register IX with JDCB$ (0024H), the FCB or DCB address of the last call of CKOPEN@ or LNKFCB@ (1568H, 1566H), that is of the last file SVC, whether or not it belongs to this error.
1FCA
DEC HL 2B
Decrement Register Pair HL from just past the sentence to its last word byte.
1FCB
BIT 6,(HL) CB 76
Test bit 6 of the last word byte at Register Pair HL: set (C0H) when the error comes from a specification not yet opened.
1FCD
If bit 6 is set, jump relative to 1FFFH (DSPC2) to show the specification from the text in the FCB.
1FCF
LD C,(IX+06H) DD 4E 06
Load Register C with FCB+6 (Index Register IX+06H): the drive of an open file, or the first letter of a device's name.
1FD2
LD B,(IX+07H) DD 46 07
Load Register B with FCB+7 (Index Register IX+07H): the DEC of an open file, or the second letter of a device's name.
1FD5
BIT 7,(IX+00H) DD CB 00 7E
Test bit 7 of FCB+0 (Index Register IX+00H), set in the FCB of an open file.
1FD9
If the FCB is an open file, jump relative to 2038H (RCVSPEC) to show its drive and DEC.
1FDB
LD HL,2128H 21 28 21LD HL,OPN$DCB
Point Register Pair HL at 2128H (OPN$DCB), the line Open DCB, Device= with the asterisk sign and the place for the name, ended by 0DH. Every FCB with bit 7 clear comes here, not only a device FCB (10H): nothing tests for 10H, so a closed FCB or an unopened specification gives its seventh and eighth characters as a device name (B30).
1FDEDSPC1
LD A,C 79
DSPC1: load Register A with Register C, the first letter of the device name.
1FDF
CP 41H FE 41
Compare Register A with 41H, the letter A, the lowest first letter of a device name.
1FE1
If Register A is below A, jump relative to 1FF8H (DCBUNK): not a device name.
1FE3
CP 5BH FE 5B
Compare Register A with 5BH, one past the letter Z.
1FE5
If Register A is above Z, jump relative to 1FF8H (DCBUNK).
1FE7
LD A,B 78
Load Register A with Register B, the second letter of the device name.
1FE8
CP 30H FE 30
Compare Register A with 30H, the digit 0, the lowest second character of a device name.
1FEA
If Register A is below 0, jump relative to 1FF8H (DCBUNK).
1FEC
CP 5BH FE 5B
Compare Register A with 5BH, one past the letter Z: the second character may be a digit, a letter or one of the signs 3AH to 40H.
1FEE
If Register A is above Z, jump relative to 1FF8H (DCBUNK).
1FF0
LD (213AH),BC ED 43 3A 21
Store Register Pair BC (Register C the first letter, Register B the second) at 213AH, the place for the name in OPN$DCB. The operand (DSPC1A, 1FF2H) is 20EBH instead from the first time DSPC2 has run in this load of SYS4 (2008H): then the name goes into the line Device = and the Open DCB line keeps its old letters (B27).
1FF4
POP IX DD E1
Restore Index Register IX (the program's) from the stack.
1FF6
Jump relative to 2057H (RSPC6) to show the line at Register Pair HL.
1FF8DCBUNK
LD HL,213DH 21 3D 21LD HL,UNK$TYP
DCBUNK: point Register Pair HL at 213DH (UNK$TYP), the line Unknown FCB/DCB and 0DH.
1FFB
POP IX DD E1
Restore Index Register IX (the program's) from the stack.
1FFD
Jump relative to 2057H (RSPC6) to show the line at Register Pair HL.
1FFFDSPC2
LD C,(IX+01H) DD 4E 01
DSPC2: load Register C with FCB+1 (Index Register IX+01H): the first letter of a device name after the asterisk, or the second character of a file specification.
2002
LD B,(IX+02H) DD 46 02
Load Register B with FCB+2 (Index Register IX+02H): the second letter of a device name, or the third character of a specification.
2005
LD A,(IX+00H) DD 7E 00
Load Register A with FCB+0 (Index Register IX+00H), the first character of the text: an asterisk for a device.
2008
LD HL,20EBH 21 EB 20LD HL,DEV$NAM
Load Register Pair HL with 20EBH (DEV$NAM), the place of the two letters in the line Device = with its asterisk sign.
200B
LD (1FF2H),HL 22 F2 1FLD (DSPC1A),HL
Store Register Pair HL (20EBH) at 1FF2H, the operand of the store at 1FF0H, so that DSPC1 puts the name into that line. Nothing sets the operand back to 213AH while SYS4 stays in the overlay area (B27).
200E
LD HL,20E1H 21 E1 20LD HL,DEV$EQ
Point Register Pair HL at 20E1H (DEV$EQ), the line Device = with the asterisk sign and the name, ended by 0DH.
2011
CP 2AH FE 2A
Compare Register A, the first character of the text, with 2AH, an asterisk.
2013
If it is an asterisk, jump relative to 1FDEH (DSPC1) to check and store the device name in Register Pair BC.
2015
PUSH IX DD E5
Push Index Register IX (the FCB) on the stack.
2017
POP HL E1
Pop it into Register Pair HL: Register Pair HL now points at the text of the specification.
2018
LD DE,20F5H 11 F5 20
Point Register Pair DE at 20F5H (FILE$EQ + 7), after File = in the line, where the specification goes.
201B
LD B,18H 06 18
Load Register B with 18H (24), the most characters copied.
201DDSPC3
LD A,(HL) 7E
DSPC3: load Register A with the character of the specification at Register Pair HL.
201E
CP 03H FE 03
Compare Register A with 03H, the end of the text that @FSPEC leaves.
2020
If it is 03H, jump relative to 2033H (DSPC3A): the specification is complete.
2022
CP 0DH FE 0D
Compare Register A with 0DH, the end of a line.
2024
If it is 0DH, jump relative to 2033H (DSPC3A).
2026
OR A B7
OR Register A with itself to test for 00H, which also ends the specification.
2027
If it is 00H, jump relative to 2033H (DSPC3A): a zero ends it too.
2029
Call 2083H (CHKASC): Carry when the character at Register Pair HL is not one of . / 0 to 9 : and A to Z; Register A is the character.
202C
If Carry, jump relative to 1FF8H (DCBUNK): a lower case letter, an exclamation mark or a byte of an open FCB gives Unknown FCB/DCB.
202E
LD (DE),A 12
Store Register A, the character, at Register Pair DE in the line.
202F
INC DE 13
Increment Register Pair DE to the next place in the line.
2030
INC HL 23
Increment Register Pair HL to the next character of the specification.
2031
Decrement Register B and loop to 201DH (DSPC3) until 24 characters are copied. After 24 Register Pair DE is 210DH, past the 0DH of the line, and the 0DH stored at 2054H goes over the O of OPN$FCB (B28).
2033DSPC3A
LD HL,20EEH 21 EE 20LD HL,FILE$EQ
DSPC3A: point Register Pair HL at 20EEH (FILE$EQ), the line File = with the specification now in it.
2036
Jump relative to 2052H (RSPC5) to end the line with 0DH at Register Pair DE and show it.

2038H - RCVSPEC: the Open FCB Line, and the Last SVC Line

For an open file the line is Open FCB, Drive=d, DEC=nn, the drive as a digit 0 to 7 and the DEC in hex. RSPC5 ends the line built with 0DH and RSPC6 shows it with @LOGOT. Every path of DSPSPEC then shows the last SVC: Last SVC = and its number in decimal (LSVC$, the last SVC before @ERROR), and on the same line , Returned to X' and the address that SVC returned to (SVCRET$), in two calls of @LOGOT. The job log gets both parts on one line, each after a time stamp of its own, because the first part ends with 03H.

2038RCVSPEC
LD A,C 79
RCVSPEC: load Register A with Register C, the drive number of the open file (FCB+6).
2039
ADD A,30H C6 30
Add 30H to Register A, the drive as an ASCII digit.
203B
CP 30H FE 30
Compare Register A with 30H, the digit 0, the lowest drive number.
203D
If Register A is below 0, jump relative to 1FF8H (DCBUNK).
203F
CP 38H FE 38
Compare Register A with 38H, the digit 8, one past the highest drive number.
2041
If Register A is 8 or above (no drive of the DOS), jump relative to 1FF8H (DCBUNK).
2043
LD (211DH),A 32 1D 21
Store Register A, the drive digit, at 211DH, the n of Drive=n in OPN$FCB.
2046
LD A,B 78
Load Register A with Register B, the DEC of the file (FCB+7).
2047
LD HL,2124H 21 24 21
Point Register Pair HL at 2124H, after DEC= in OPN$FCB.
204A
Call @HEX8 at 07C2H (on the BOOT/SYS page) to write Register A as two hexadecimal digits at Register Pair HL; Register Pair HL ends at 2126H.
204D
EX DE,HL EB
Exchange Register Pairs DE and HL: Register Pair DE is 2126H, the space after the DEC.
204E
LD HL,210DH 21 0D 21LD HL,OPN$FCB
Point Register Pair HL at 210DH (OPN$FCB), the line to be shown.
2051
INC DE 13
Increment Register Pair DE to 2127H, where the line has its 0DH already.
2052RSPC5
LD A,0DH 3E 0D
RSPC5: load Register A with 0DH, the end of a line.
2054
LD (DE),A 12
Store Register A at Register Pair DE, ending the line just built (after the file specification, or again at 2127H).
2055
POP IX DD E1
Restore Index Register IX (the program's) from the stack.
2057RSPC6
RSPC6: call @LOGOT at 0500H (on the BOOT/SYS page) to show the line at Register Pair HL and write it to the job log.
205A
LD DE,2172H 11 72 21LD DE,LILBUF
Point Register Pair DE at 2172H (LILBUF), five bytes for the decimal number.
205DSVSVC
LD A,00H 3E 00
SVSVC: load Register A with the number of the last SVC before @ERROR; the 00H in the file is the operand BEGIN stores at 1EB6H from LSVC$.
205F
LD L,A 6F
Load Register L with Register A, the SVC number.
2060
LD H,00H 26 00
Load Register H with 00H, so that Register Pair HL is the SVC number, 0 to 127.
2062
Call @HEXDEC at 06F6H (on the BOOT/SYS page) to write Register Pair HL in decimal as five characters at Register Pair DE (2172H-2176H), spaces in front.
2065
LD DE,2158H 11 58 21
Point Register Pair DE at 2158H, the nnn of Last SVC = nnn in SVC$NUM.
2068
Call 2094H (EDEC) to copy the digits of LILBUF, without the spaces, to Register Pair DE; Register Pair DE ends after the last digit.
206B
LD A,03H 3E 03
Load Register A with 03H, the end of a text that leaves the cursor on the line.
206D
LD (DE),A 12
Store Register A at Register Pair DE, after the last digit.
206E
LD HL,216CH 21 6C 21
Point Register Pair HL at 216CH, the xxxx of X'xxxx' in SVC$RET.
2071SVRET
LD DE,0000H 11 00 00
SVRET: load Register Pair DE with the address the last SVC returned to; the 0000H in the file is the operand BEGIN stores at 1ECEH from SVCRET$.
2074
Call @HEX16 at 07BDH (on the BOOT/SYS page) to write Register Pair DE as four hexadecimal digits at Register Pair HL.
2077
LD HL,214DH 21 4D 21LD HL,SVC$NUM
Point Register Pair HL at 214DH (SVC$NUM), Last SVC = and the number, ended by 03H.
207A
Call @LOGOT at 0500H (on the BOOT/SYS page) to show the text at Register Pair HL, the cursor staying on the line, and write it to the job log.
207D
LD HL,215CH 21 5C 21LD HL,SVC$RET
Point Register Pair HL at 215CH (SVC$RET), , Returned to X'rrrr' and 0DH.
2080
Jump to @LOGOT at 0500H (on the BOOT/SYS page) to show the rest of the line at Register Pair HL; its RET goes back to 1FB9H, after the CALL of DSPSPEC.

2083H - CHKASC and EDEC

CHKASC accepts the characters of a file specification as DSPSPEC wants them: 2EH to 3AH (the period, the slash, the digits and the colon) and the capitals A to Z, with Carry clear; anything else returns Carry. EDEC copies the digits of a number written by @HEXDEC, passing over its leading spaces, up to the 00H that follows LILBUF.

2083CHKASC
LD A,(HL) 7E
CHKASC: load Register A with the character at Register Pair HL.
2084
CP 2EH FE 2E
Compare Register A with 2EH, the period, the lowest character accepted.
2086
RET C D8
Return with Carry if Register A is below the period: not accepted.
2087
CP 3BH FE 3B
Compare Register A with 3BH, one past the colon.
2089
If Register A is above the colon, jump relative to 208DH (CKASC1) to test for a capital letter.
208B
Jump relative to 2092H (CKASC2): Register A is one of . / 0 to 9 : and the Carry of the CP at 2087H is set, which CCF clears.
208DCKASC1
CP 41H FE 41
CKASC1: compare Register A with 41H, the letter A.
208F
RET C D8
Return with Carry if Register A is between the colon and A: not accepted.
2090
CP 5BH FE 5B
Compare Register A with 5BH, one past the letter Z: Carry for a capital letter.
2092CKASC2
CCF 3F
CKASC2: complement the Carry flag: clear for a character accepted, set for one above Z; Register A keeps the character.
2093
RET C9
Return to DSPC3 at 202CH with the Carry flag and the character in Register A.
2094EDEC
LD HL,2172H 21 72 21LD HL,LILBUF
EDEC: point Register Pair HL at 2172H (LILBUF), where @HEXDEC wrote the number.
2097ED1
LD A,(HL) 7E
ED1: load Register A with the character at Register Pair HL.
2098
OR A B7
OR Register A with itself to test for 00H, the end of LILBUF.
2099
RET Z C8
Return if Register A is 00H, the byte at 2177H after the five characters: Register Pair DE is after the last digit copied.
209A
CP 20H FE 20
Compare Register A with 20H, a space; the Z flag stays through the INC below.
209C
INC HL 23
Increment Register Pair HL to the next character of LILBUF.
209D
If the character was a space, jump relative to 2097H (ED1) without copying it.
209F
LD (DE),A 12
Store Register A, a digit, at Register Pair DE.
20A0
INC DE 13
Increment Register Pair DE to the next place.
20A1
Jump relative to 2097H (ED1) for the next character.

20A3H - The Texts of the Display

The fixed parts of the lines of @ERROR, with the places that SYS4 fills in: the hex of the extended error, the error number and the return address of the long header (written in SBUFF$, not here), the device name, the file specification, the drive and the DEC of an open FCB, the device of an open DCB, and the SVC number and return address of the Last SVC line. A 0DH ends a line; 03H ends a part after which the cursor stays on the line. What SYS4 writes into these texts stays there while SYS4 is in the overlay area.

20A3-20BCEXT$ERR
DEFM "** Extended error, HL = X'" 2A 2A 20 45 78 74 65 6E 64 65 64 20 65 72 72 6F 72 2C 20 48 4C 20 3D 20 58 27
EXT$ERR, 20A3H-20BCH: two asterisks, a space and Extended error, HL = X with its opening quote, 26 characters, the start of the message of error 63.
20BD-20C0
DEFM "xxxx" 78 78 78 78
20BDH-20C0H: four x characters, the place where 1F4BH writes the program's Register Pair HL in hex.
20C1-20C2
DEFM "'", 0DH 27 0D
20C1H-20C2H: the closing quote and 0DH, the end of the 32 byte line that 1F57H copies and 1F62H shows.
20C3-20D3ERRMSG
DEFM 0AH, "** Error code = " 0A 2A 2A 20 45 72 72 6F 72 20 63 6F 64 65 20 3D 20
ERRMSG, 20C3H-20D3H: a line feed, then two asterisks, a space and Error code = with a space after it, 17 bytes, the start of the long header (copied at 1F01H).
20D4-20E0ERRMSG1
DEFM "Returns to X'" 52 65 74 75 72 6E 73 20 74 6F 20 58 27
ERRMSG1, 20D4H-20E0H: Returns to X with its opening quote, 13 characters, copied after the error number at 1F20H.
20E1-20EADEV$EQ
DEFM "Device = *" 44 65 76 69 63 65 20 3D 20 2A
DEV$EQ, 20E1H-20EAH: Device = and the asterisk of a device name, 10 characters, the line DSPC2 shows for a device specification in the FCB.
20EB-20ECDEV$NAM
DEFM "XX" 58 58
DEV$NAM, 20EBH-20ECH: two X characters, the place where DSPC1 writes the two letters of the device name once 200BH has made 20EBH its target.
20ED
DEFB 0DH 0D
20EDH: 0DH, the end of the line Device = and the name.
20EE-20F4FILE$EQ
DEFM "File = " 46 69 6C 65 20 3D 20
FILE$EQ, 20EEH-20F4H: File = with a space after it, seven characters, the line DSPC2 shows for a file specification in the FCB.
20F5-210B
DEFM "NNNNNNNN/EEE.PPPPPPPP:D" 4E 4E 4E 4E 4E 4E 4E 4E 2F 45 45 45 2E 50 50 50 50 50 50 50 50 3A 44
20F5H-210BH: the pattern of a specification, name, extension, password and drive, 23 characters; DSPC3 writes the text of the FCB over it from 20F5H and ends it with 0DH.
210C
DEFB 0DH 0D
210CH: 0DH, the end of the line when the specification fills all 23 places; a text of 24 characters goes over it and puts its 0DH at 210DH (B28).
210D-211COPN$FCB
DEFM "Open FCB, Drive=" 4F 70 65 6E 20 46 43 42 2C 20 44 72 69 76 65 3D
OPN$FCB, 210DH-211CH: Open FCB, Drive= without a space after the equals sign, 16 characters, the line RCVSPEC shows for an open file.
211D
DEFM "n" 6E
211DH: the letter n, the place where RCVSPEC writes the drive digit (2043H).
211E-2123
DEFM ", DEC=" 2C 20 44 45 43 3D
211EH-2123H: a comma, a space and DEC= , six characters.
2124-2126
DEFM " " 20 20 20
2124H-2126H: three spaces; RCVSPEC writes the DEC in two hex digits at 2124H-2125H, the third stays a space.
2127
DEFB 0DH 0D
2127H: 0DH, the end of the line Open FCB, which 2054H stores again.
2128-2139OPN$DCB
DEFM "Open DCB, Device=*" 4F 70 65 6E 20 44 43 42 2C 20 44 65 76 69 63 65 3D 2A
OPN$DCB, 2128H-2139H: Open DCB, Device= and the asterisk of a device name, 18 characters, the line for an open device FCB.
213A-213B
DEFM "xx" 78 78
213AH-213BH: two x characters, where DSPC1 writes the device name (1FF0H) as long as its operand is still 213AH (B27).
213C
DEFB 0DH 0D
213CH: 0DH, the end of the line Open DCB, Device= and the name.
213D-214CUNK$TYP
DEFM "Unknown FCB/DCB", 0DH 55 6E 6B 6E 6F 77 6E 20 46 43 42 2F 44 43 42 0D
UNK$TYP, 213DH-214CH: Unknown FCB/DCB and 0DH, 16 bytes, the line shown when the FCB fits none of the forms above.
214D-2157SVC$NUM
DEFM "Last SVC = " 4C 61 73 74 20 53 56 43 20 3D 20
SVC$NUM, 214DH-2157H: Last SVC = with a space after it, 11 characters.
2158-215B
DEFM "nnn", 03H 6E 6E 6E 03
2158H-215BH: three n characters and 03H; EDEC writes the SVC number from 2158H and 206DH puts 03H after its last digit, so that @LOGOT leaves the cursor on the line.
215C-216BSVC$RET
DEFM ", Returned to X'" 2C 20 52 65 74 75 72 6E 65 64 20 74 6F 20 58 27
SVC$RET, 215CH-216BH: a comma, a space and Returned to X with its opening quote, 16 characters, shown on the same line after the SVC number.
216C-216F
DEFM "xxxx" 78 78 78 78
216CH-216FH: four x characters, the place where 2074H writes the return address of the last SVC in hex.
2170-2171
DEFM "'", 0DH 27 0D
2170H-2171H: the closing quote and 0DH, the end of the Last SVC line.
2172-2176LILBUF
DEFS 5
LILBUF, 2172H-2176H: five bytes not loaded by SYS4/SYS (they hold what was there before), where @HEXDEC writes the SVC number in decimal (2062H).
2177
DEFB 00H 00
2177H: 00H, loaded with the file, which stops EDEC after the five characters of LILBUF (2099H).

2178H - CODTAB: Where Each Sentence Starts

One byte for each error number from 0 to 45: the low byte of its sentence in page 1EH. ERR3 (1F6EH) adds the error number to 2178H and puts 1EH in front of the byte it finds there.

2178CODTAB
DEFB 03H 03
CODTAB+0, 2178H: 03H, the low byte of MSG0 at 1E03H, the word list of error 0 (00H), No error; ERR3 puts 1EH in front of it (1F73H).
2179
DEFB 05H 05
CODTAB+1, 2179H: 05H, the low byte of MSG1 at 1E05H, the word list of error 1 (01H), Parity error during header read; ERR3 puts 1EH in front of it (1F73H).
217A
DEFB 0AH 0A
CODTAB+2, 217AH: 0AH, the low byte of MSG2 at 1E0AH, the word list of error 2 (02H), Seek error during read; ERR3 puts 1EH in front of it (1F73H).
217B
DEFB 0EH 0E
CODTAB+3, 217BH: 0EH, the low byte of MSG3 at 1E0EH, the word list of error 3 (03H), Lost data during read; ERR3 puts 1EH in front of it (1F73H).
217C
DEFB 12H 12
CODTAB+4, 217CH: 12H, the low byte of MSG4 at 1E12H, the word list of error 4 (04H), Parity error during read; ERR3 puts 1EH in front of it (1F73H).
217D
DEFB 16H 16
CODTAB+5, 217DH: 16H, the low byte of MSG5 at 1E16H, the word list of error 5 (05H), Data record not found during read; ERR3 puts 1EH in front of it (1F73H).
217E
DEFB 1CH 1C
CODTAB+6, 217EH: 1CH, the low byte of MSG6 at 1E1CH, the word list of error 6 (06H), Attempted to read system data record; ERR3 puts 1EH in front of it (1F73H).
217F
DEFB 21H 21
CODTAB+7, 217FH: 21H, the low byte of MSG7 at 1E21H, the word list of error 7 (07H), Attempted to read locked/deleted data record; ERR3 puts 1EH in front of it (1F73H).
2180
DEFB 26H 26
CODTAB+8, 2180H: 26H, the low byte of MSG8 at 1E26H, the word list of error 8 (08H), Device not available; ERR3 puts 1EH in front of it (1F73H).
2181
DEFB 29H 29
CODTAB+9, 2181H: 29H, the low byte of MSG9 at 1E29H, the word list of error 9 (09H), Parity error during header write; ERR3 puts 1EH in front of it (1F73H).
2182
DEFB 2EH 2E
CODTAB+10, 2182H: 2EH, the low byte of MSG10 at 1E2EH, the word list of error 10 (0AH), Seek error during write; ERR3 puts 1EH in front of it (1F73H).
2183
DEFB 32H 32
CODTAB+11, 2183H: 32H, the low byte of MSG11 at 1E32H, the word list of error 11 (0BH), Lost data during write; ERR3 puts 1EH in front of it (1F73H).
2184
DEFB 36H 36
CODTAB+12, 2184H: 36H, the low byte of MSG12 at 1E36H, the word list of error 12 (0CH), Parity error during write; ERR3 puts 1EH in front of it (1F73H).
2185
DEFB 3AH 3A
CODTAB+13, 2185H: 3AH, the low byte of MSG13 at 1E3AH, the word list of error 13 (0DH), Data record not found during write; ERR3 puts 1EH in front of it (1F73H).
2186
DEFB 40H 40
CODTAB+14, 2186H: 40H, the low byte of MSG14 at 1E40H, the word list of error 14 (0EH), Write fault on disk drive; ERR3 puts 1EH in front of it (1F73H).
2187
DEFB 45H 45
CODTAB+15, 2187H: 45H, the low byte of MSG15 at 1E45H, the word list of error 15 (0FH), Write protected disk; ERR3 puts 1EH in front of it (1F73H).
2188
DEFB 48H 48
CODTAB+16, 2188H: 48H, the low byte of MSG16 at 1E48H, the word list of error 16 (10H), Illegal logical file number; ERR3 puts 1EH in front of it (1F73H).
2189
DEFB 4CH 4C
CODTAB+17, 2189H: 4CH, the low byte of MSG17 at 1E4CH, the word list of error 17 (11H), Directory read error; ERR3 puts 1EH in front of it (1F73H).
218A
DEFB 4FH 4F
CODTAB+18, 218AH: 4FH, the low byte of MSG18 at 1E4FH, the word list of error 18 (12H), Directory write error; ERR3 puts 1EH in front of it (1F73H).
218B
DEFB 52H 52
CODTAB+19, 218BH: 52H, the low byte of MSG19 at 1E52H, the word list of error 19 (13H), Illegal file name; ERR3 puts 1EH in front of it (1F73H).
218C
DEFB 55H 55
CODTAB+20, 218CH: 55H, the low byte of MSG20 at 1E55H, the word list of error 20 (14H), GAT read error; ERR3 puts 1EH in front of it (1F73H).
218D
DEFB 58H 58
CODTAB+21, 218DH: 58H, the low byte of MSG21 at 1E58H, the word list of error 21 (15H), GAT write error; ERR3 puts 1EH in front of it (1F73H).
218E
DEFB 5BH 5B
CODTAB+22, 218EH: 5BH, the low byte of MSG22 at 1E5BH, the word list of error 22 (16H), HIT read error; ERR3 puts 1EH in front of it (1F73H).
218F
DEFB 5EH 5E
CODTAB+23, 218FH: 5EH, the low byte of MSG23 at 1E5EH, the word list of error 23 (17H), HIT write error; ERR3 puts 1EH in front of it (1F73H).
2190
DEFB 61H 61
CODTAB+24, 2190H: 61H, the low byte of MSG24 at 1E61H, the word list of error 24 (18H), File not in directory; ERR3 puts 1EH in front of it (1F73H).
2191
DEFB 65H 65
CODTAB+25, 2191H: 65H, the low byte of MSG25 at 1E65H, the word list of error 25 (19H), File access denied; ERR3 puts 1EH in front of it (1F73H).
2192
DEFB 68H 68
CODTAB+26, 2192H: 68H, the low byte of MSG26 at 1E68H, the word list of error 26 (1AH), No directory space available; ERR3 puts 1EH in front of it (1F73H).
2193
DEFB 6CH 6C
CODTAB+27, 2193H: 6CH, the low byte of MSG27 at 1E6CH, the word list of error 27 (1BH), Disk space full; ERR3 puts 1EH in front of it (1F73H).
2194
DEFB 6FH 6F
CODTAB+28, 2194H: 6FH, the low byte of MSG28 at 1E6FH, the word list of error 28 (1CH), End of file encountered; ERR3 puts 1EH in front of it (1F73H).
2195
DEFB 73H 73
CODTAB+29, 2195H: 73H, the low byte of MSG29 at 1E73H, the word list of error 29 (1DH), Record number out of range; ERR3 puts 1EH in front of it (1F73H).
2196
DEFB 78H 78
CODTAB+30, 2196H: 78H, the low byte of MSG30 at 1E78H, the word list of error 30 (1EH), Directory full - can't extend file; ERR3 puts 1EH in front of it (1F73H).
2197
DEFB 7CH 7C
CODTAB+31, 2197H: 7CH, the low byte of MSG31 at 1E7CH, the word list of error 31 (1FH), Program not found; ERR3 puts 1EH in front of it (1F73H).
2198
DEFB 7FH 7F
CODTAB+32, 2198H: 7FH, the low byte of MSG32 at 1E7FH, the word list of error 32 (20H), Illegal drive number; ERR3 puts 1EH in front of it (1F73H).
2199
DEFB 82H 82
CODTAB+33, 2199H: 82H, the low byte of MSG33 at 1E82H, the word list of error 33 (21H), No device space available; ERR3 puts 1EH in front of it (1F73H).
219A
DEFB 86H 86
CODTAB+34, 219AH: 86H, the low byte of MSG34 at 1E86H, the word list of error 34 (22H), Load file format error; ERR3 puts 1EH in front of it (1F73H).
219B
DEFB 8AH 8A
CODTAB+35, 219BH: 8AH, the low byte of MSG35 at 1E8AH, the word list of error 35 (23H), Memory fault; ERR3 puts 1EH in front of it (1F73H).
219C
DEFB 8CH 8C
CODTAB+36, 219CH: 8CH, the low byte of MSG36 at 1E8CH, the word list of error 36 (24H), Attempted to load read only memory; ERR3 puts 1EH in front of it (1F73H).
219D
DEFB 91H 91
CODTAB+37, 219DH: 91H, the low byte of MSG37 at 1E91H, the word list of error 37 (25H), Illegal access attempted to protected file; ERR3 puts 1EH in front of it (1F73H).
219E
DEFB 96H 96
CODTAB+38, 219EH: 96H, the low byte of MSG38 at 1E96H, the word list of error 38 (26H), File not open; ERR3 puts 1EH in front of it (1F73H).
219F
DEFB 99H 99
CODTAB+39, 219FH: 99H, the low byte of MSG39 at 1E99H, the word list of error 39 (27H), Device in use; ERR3 puts 1EH in front of it (1F73H).
21A0
DEFB 9CH 9C
CODTAB+40, 21A0H: 9CH, the low byte of MSG40 at 1E9CH, the word list of error 40 (28H), Protected system device; ERR3 puts 1EH in front of it (1F73H).
21A1
DEFB 9FH 9F
CODTAB+41, 21A1H: 9FH, the low byte of MSG41 at 1E9FH, the word list of error 41 (29H), File already open; ERR3 puts 1EH in front of it (1F73H).
21A2
DEFB 0A2H A2
CODTAB+42, 21A2H: A2H, the low byte of MSG42 at 1EA2H, the word list of error 42 (2AH), Logical record length open fault; ERR3 puts 1EH in front of it (1F73H).
21A3
DEFB 0A7H A7
CODTAB+43, 21A3H: A7H, the low byte of MSG43 at 1EA7H, the word list of error 43 (2BH), SVC parameter error; ERR3 puts 1EH in front of it (1F73H).
21A4
DEFB 0AAH AA
CODTAB+44, 21A4H: AAH, the low byte of MSG44 at 1EAAH, the word list of error 44 (2CH), Parameter error; ERR3 puts 1EH in front of it (1F73H).
21A5
DEFB 0ACH AC
CODTAB+45, 21A5H: ACH, the low byte of MSG45 at 1EACH, the word list of error 45 (2DH), Unknown error code; ERR3 puts 1EH in front of it (1F73H). ERR2A sets every error number from 46 to 62 to 45, so this entry serves them too.

21A6H - WORDS: the Dictionary

The 58 words that the sentences are made of, numbered from 1, each ending with its last character's bit 7 set; the entry 0 before them only gives the count a start. LP1 (1F7DH) finds word n by counting n endings from 21A6H, so a word is found in a time that grows with its number. Three words are used by no sentence: 3 (o, which the source calls an extra word), 36 (y) and 55 (or).

21A6WORDS
DEFB 0D2H D2
21A6H: D2H, word 0, the letter R with bit 7 set. It is never shown: it only gives LP1 (1F7DH) an ending to count, so that the search for word n stops after n endings at the first character of word n.
21A7-21A8
DEFM "n", 0EFH 6E EF
21A7H-21A8H: word 1, no, 2 characters, the last one, o, with bit 7 set (EFH); in the messages of errors 0, 26, 33.
21A9-21AD
DEFM "erro", 0F2H 65 72 72 6F F2
21A9H-21ADH: word 2, error, 5 characters, the last one, r, with bit 7 set (F2H); in the messages of errors 0, 1, 2, 4, 9, 10, 12, 17, 18, 20, 21, 22, 23, 34, 43, 44, 45.
21AE
DEFB 0EFH EF
21AEH: word 3, o, one character, o with bit 7 set (EFH); no message uses it.
21AF-21B4
DEFM "parit", 0F9H 70 61 72 69 74 F9
21AFH-21B4H: word 4, parity, 6 characters, the last one, y, with bit 7 set (F9H); in the messages of errors 1, 4, 9, 12.
21B5-21BA
DEFM "durin", 0E7H 64 75 72 69 6E E7
21B5H-21BAH: word 5, during, 6 characters, the last one, g, with bit 7 set (E7H); in the messages of errors 1, 2, 3, 4, 5, 9, 10, 11, 12, 13.
21BB-21C0
DEFM "heade", 0F2H 68 65 61 64 65 F2
21BBH-21C0H: word 6, header, 6 characters, the last one, r, with bit 7 set (F2H); in the messages of errors 1, 9.
21C1-21C4
DEFM "dat", 0E1H 64 61 74 E1
21C1H-21C4H: word 7, data, 4 characters, the last one, a, with bit 7 set (E1H); in the messages of errors 3, 5, 6, 7, 11, 13.
21C5-21C8
DEFM "see", 0EBH 73 65 65 EB
21C5H-21C8H: word 8, seek, 4 characters, the last one, k, with bit 7 set (EBH); in the messages of errors 2, 10.
21C9-21CC
DEFM "rea", 0E4H 72 65 61 E4
21C9H-21CCH: word 9, read, 4 characters, the last one, d, with bit 7 set (E4H); in the messages of errors 1, 2, 3, 4, 5, 6, 7, 17, 20, 22, 36.
21CD-21D1
DEFM "writ", 0E5H 77 72 69 74 E5
21CDH-21D1H: word 10, write, 5 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 9, 10, 11, 12, 13, 14, 15, 18, 21, 23.
21D2-21D5
DEFM "los", 0F4H 6C 6F 73 F4
21D2H-21D5H: word 11, lost, 4 characters, the last one, t, with bit 7 set (F4H); in the messages of errors 3, 11.
21D6-21D8
DEFM "no", 0F4H 6E 6F F4
21D6H-21D8H: word 12, not, 3 characters, the last one, t, with bit 7 set (F4H); in the messages of errors 5, 8, 13, 24, 31, 38.
21D9-21E4
DEFM "attempted t", 0EFH 61 74 74 65 6D 70 74 65 64 20 74 EF
21D9H-21E4H: word 13, attempted to, 12 characters, the last one, o, with bit 7 set (EFH); in the messages of errors 6, 7, 36, 37.
21E5-21F2
DEFM "locked/delete", 0E4H 6C 6F 63 6B 65 64 2F 64 65 6C 65 74 65 E4
21E5H-21F2H: word 14, locked/deleted, 14 characters, the last one, d, with bit 7 set (E4H); in the message of error 7.
21F3-21F8
DEFM "syste", 0EDH 73 79 73 74 65 ED
21F3H-21F8H: word 15, system, 6 characters, the last one, m, with bit 7 set (EDH); in the messages of errors 6, 40.
21F9-2201
DEFM "director", 0F9H 64 69 72 65 63 74 6F 72 F9
21F9H-2201H: word 16, directory, 9 characters, the last one, y, with bit 7 set (F9H); in the messages of errors 17, 18, 24, 26, 30.
2202-2207
DEFM "memor", 0F9H 6D 65 6D 6F 72 F9
2202H-2207H: word 17, memory, 6 characters, the last one, y, with bit 7 set (F9H); in the messages of errors 35, 36.
2208-2209
DEFM "o", 0EEH 6F EE
2208H-2209H: word 18, on, 2 characters, the last one, n, with bit 7 set (EEH); in the message of error 14.
220A-220D
DEFM "dis", 0EBH 64 69 73 EB
220AH-220DH: word 19, disk, 4 characters, the last one, k, with bit 7 set (EBH); in the messages of errors 14, 15, 27.
220E-2216
DEFM "paramete", 0F2H 70 61 72 61 6D 65 74 65 F2
220EH-2216H: word 20, parameter, 9 characters, the last one, r, with bit 7 set (F2H); in the messages of errors 43, 44.
2217-221B
DEFM "faul", 0F4H 66 61 75 6C F4
2217H-221BH: word 21, fault, 5 characters, the last one, t, with bit 7 set (F4H); in the messages of errors 14, 35, 42.
221C-2224
DEFM "protecte", 0E4H 70 72 6F 74 65 63 74 65 E4
221CH-2224H: word 22, protected, 9 characters, the last one, d, with bit 7 set (E4H); in the messages of errors 15, 37, 40.
2225-222B
DEFM "illega", 0ECH 69 6C 6C 65 67 61 EC
2225H-222BH: word 23, illegal, 7 characters, the last one, l, with bit 7 set (ECH); in the messages of errors 16, 19, 32, 37.
222C-2232
DEFM "logica", 0ECH 6C 6F 67 69 63 61 EC
222CH-2232H: word 24, logical, 7 characters, the last one, l, with bit 7 set (ECH); in the messages of errors 16, 42.
2233-2238
DEFM "numbe", 0F2H 6E 75 6D 62 65 F2
2233H-2238H: word 25, number, 6 characters, the last one, r, with bit 7 set (F2H); in the messages of errors 16, 29, 32.
2239-223C
DEFM "fil", 0E5H 66 69 6C E5
2239H-223CH: word 26, file, 4 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 16, 19, 24, 25, 28, 30, 34, 37, 38, 41.
223D-2242
DEFM "recor", 0E4H 72 65 63 6F 72 E4
223DH-2242H: word 27, record, 6 characters, the last one, d, with bit 7 set (E4H); in the messages of errors 5, 6, 7, 13, 29, 42.
2243-2245
DEFM "en", 0E4H 65 6E E4
2243H-2245H: word 28, end, 3 characters, the last one, d, with bit 7 set (E4H); in the message of error 28.
2246-2247
DEFM "o", 0E6H 6F E6
2246H-2247H: word 29, of, 2 characters, the last one, f, with bit 7 set (E6H); in the messages of errors 28, 29.
2248-224A
DEFM "ou", 0F4H 6F 75 F4
2248H-224AH: word 30, out, 3 characters, the last one, t, with bit 7 set (F4H); in the message of error 29.
224B-224F
DEFM "rang", 0E5H 72 61 6E 67 E5
224BH-224FH: word 31, range, 5 characters, the last one, e, with bit 7 set (E5H); in the message of error 29.
2250-225A
DEFM "encountere", 0E4H 65 6E 63 6F 75 6E 74 65 72 65 E4
2250H-225AH: word 32, encountered, 11 characters, the last one, d, with bit 7 set (E4H); in the message of error 28.
225B-225E
DEFM "cod", 0E5H 63 6F 64 E5
225BH-225EH: word 33, code, 4 characters, the last one, e, with bit 7 set (E5H); in the message of error 45.
225F-2261
DEFM "GA", 0D4H 47 41 D4
225FH-2261H: word 34, GAT, 3 characters, the last one, T, with bit 7 set (D4H); in the messages of errors 20, 21.
2262-2264
DEFM "HI", 0D4H 48 49 D4
2262H-2264H: word 35, HIT, 3 characters, the last one, T, with bit 7 set (D4H); in the messages of errors 22, 23.
2265
DEFB 0F9H F9
2265H: word 36, y, one character, y with bit 7 set (F9H); no message uses it.
2266-226C
DEFM "unknow", 0EEH 75 6E 6B 6E 6F 77 EE
2266H-226CH: word 37, unknown, 7 characters, the last one, n, with bit 7 set (EEH); in the message of error 45.
226D-2270
DEFM "loa", 0E4H 6C 6F 61 E4
226DH-2270H: word 38, load, 4 characters, the last one, d, with bit 7 set (E4H); in the messages of errors 34, 36.
2271-2275
DEFM "spac", 0E5H 73 70 61 63 E5
2271H-2275H: word 39, space, 5 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 26, 27, 33.
2276-2279
DEFM "onl", 0F9H 6F 6E 6C F9
2276H-2279H: word 40, only, 4 characters, the last one, y, with bit 7 set (F9H); in the message of error 36.
227A-227D
DEFM "nam", 0E5H 6E 61 6D E5
227AH-227DH: word 41, name, 4 characters, the last one, e, with bit 7 set (E5H); in the message of error 19.
227E-2283
DEFM "devic", 0E5H 64 65 76 69 63 E5
227EH-2283H: word 42, device, 6 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 8, 33, 39, 40.
2284-2289
DEFM "forma", 0F4H 66 6F 72 6D 61 F4
2284H-2289H: word 43, format, 6 characters, the last one, t, with bit 7 set (F4H); in the message of error 34.
228A-228E
DEFM "foun", 0E4H 66 6F 75 6E E4
228AH-228EH: word 44, found, 5 characters, the last one, d, with bit 7 set (E4H); in the messages of errors 5, 13, 31.
228F-2290
DEFM "i", 0EEH 69 EE
228FH-2290H: word 45, in, 2 characters, the last one, n, with bit 7 set (EEH); in the messages of errors 24, 39.
2291-2296
DEFM "acces", 0F3H 61 63 63 65 73 F3
2291H-2296H: word 46, access, 6 characters, the last one, s, with bit 7 set (F3H); in the messages of errors 25, 37.
2297-229A
DEFM "ful", 0ECH 66 75 6C EC
2297H-229AH: word 47, full, 4 characters, the last one, l, with bit 7 set (ECH); in the messages of errors 27, 30.
229B-229F
DEFM "driv", 0E5H 64 72 69 76 E5
229BH-229FH: word 48, drive, 5 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 14, 32.
22A0-22A5
DEFM "denie", 0E4H 64 65 6E 69 65 E4
22A0H-22A5H: word 49, denied, 6 characters, the last one, d, with bit 7 set (E4H); in the message of error 25.
22A6-22AC
DEFM "progra", 0EDH 70 72 6F 67 72 61 ED
22A6H-22ACH: word 50, program, 7 characters, the last one, m, with bit 7 set (EDH); in the message of error 31.
22AD-22B5
DEFM "availabl", 0E5H 61 76 61 69 6C 61 62 6C E5
22ADH-22B5H: word 51, available, 9 characters, the last one, e, with bit 7 set (E5H); in the messages of errors 8, 26, 33.
22B6-22C3
DEFM "- can't exten", 0E4H 2D 20 63 61 6E 27 74 20 65 78 74 65 6E E4
22B6H-22C3H: word 52, - can't extend, 14 characters, the last one, d, with bit 7 set (E4H); in the message of error 30.
22C4-22C7
DEFM "ope", 0EEH 6F 70 65 EE
22C4H-22C7H: word 53, open, 4 characters, the last one, n, with bit 7 set (EEH); in the messages of errors 38, 41, 42.
22C8-22CA
DEFM "us", 0E5H 75 73 E5
22C8H-22CAH: word 54, use, 3 characters, the last one, e, with bit 7 set (E5H); in the message of error 39.
22CB-22CC
DEFM "o", 0F2H 6F F2
22CBH-22CCH: word 55, or, 2 characters, the last one, r, with bit 7 set (F2H); no message uses it.
22CD-22CF
DEFM "SV", 0C3H 53 56 C3
22CDH-22CFH: word 56, SVC, 3 characters, the last one, C, with bit 7 set (C3H); in the message of error 43.
22D0-22D6
DEFM "alread", 0F9H 61 6C 72 65 61 64 F9
22D0H-22D6H: word 57, already, 7 characters, the last one, y, with bit 7 set (F9H); in the message of error 41.
22D7-22DC
DEFM "lengt", 0E8H 6C 65 6E 67 74 E8
22D7H-22DCH: word 58, length, 6 characters, the last one, h, with bit 7 set (E8H); in the message of error 42.
22DD-23FD
DEFS 289
22DDH-23FDH: the rest of the overlay area, not loaded by SYS4/SYS; it holds what was there before. DIRBUF$ (2300H-23FFH) lies in it and overlaps the length word at 23FEH, which each load of SYS4 writes again.
23FE-23FF
DEFW 04DDH DD 04
23FEH-23FFH = 04DDH (1245): the length of SYS4, 1E00H to 22DCH (LAST less 1E00H). SYSTEM (SYSRES) reads it when it copies the overlay into high memory to keep it resident, and stores it back when it brings the copy into 1E00H again.