Percom DoubleDOS 4.24 for the Model I - BASIC/CMD Disassembled

BASIC/CMD

Other Navigation

Percom DoubleDOS 4.24 BASIC/CMD Disassembly (Model I)

BASIC/CMD is the Disk BASIC of DoubleDOS (DBLDOS in Percom's manual): the Disk BASIC extensions that the Level II ROM reaches through its vectors at 4152H-41E4H, the file input and output, CMD, and a start-up that takes the number of files, the memory size and a first command from the DOS command line (BASIC F, M, command, the manual's 3.4). Almost all of it is TRSDOS 2.1's BASIC/CMD at the same addresses (Disk BASIC 1.1, the banner RADIO SHACK DISK BASIC VERSION 1.1); DBLDOS put its own code at 5200H-5548H, a new start-up at 5BA4H-5DA5H, a fast LOAD and SAVE, and some small changes, each named on its row ("TRSDOS 2.1 has ... here"). The long error messages, which TRSDOS 2.1 keeps in BASIC/CMD, are in SYS7/SYS (overlay 9), called through the vector 41A6H.

The file is 4983 bytes: a name record, two runs of load blocks, 4D00H-4DE8H (233 bytes) and 5200H-6431H (4658 bytes), and the transfer address 5BADH. Every one of the 4891 loaded bytes is on exactly one row below. BASIC/CMD is identical in 4.20, 4.23 (all three sets) and 4.24. It uses no overlay of its own; the free memory for BASIC starts at 6431H, where the start-up puts the file areas (290 bytes each, file 0 first) and after them the program text.

Load Map

Addresses	Contents
4D00H-4D92H	The table of the 49 Disk BASIC vectors, copied to 4152H-41E4H at start-up (4D00H); 47 entries are TRSDOS 2.1's, 41A6H loads SYS7/SYS and 41CAH points to 5A15H
4D93H-4DE8H	The first part of the banner (4D93H)
5200H-5555H	DBLDOS's own code: OPEN "E" (5216H, 521FH), the command line input after READY (5238H, 5303H), and 581 bytes that nothing reaches: line recall, abbreviations, REF and RENUM, CMD with a DOS command (525EH, 5307H, 53A4H); the room test of LOAD (552BH); the tail of TRSDOS 2.1's vector table (5549H-5555H)
5556H-5713H	FN and DEF FN (5556H, 5655H), USR and DEFUSR (5679H), CMD (56C4H)
5714H-57B1H	TIME$ (5714H), LINE INPUT (5756H), the hooks of PRINT # and INPUT # (577CH, 5784H, 579CH)
57B2H-582EH	DBLDOS's LOAD and SAVE of a program in memory form, a sector at a time (57B2H, 57D5H, 57E5H)
582FH-5A20H	INSTR (582FH), &H and &O (58B7H), MID$ on the left of = (590DH), the line input from a file (598EH, 5996H), output and keyboard hooks (59BEH, 59CDH), PRINT # (5A15H)
5A21H-5B13H	Unused (zeros, and TRSDOS 2.1's copy of the PRINT # hook at 5A5BH)
5B14H-5B50H	The variables (5B14H)
5B51H-5BACH	Small hooks: SYSTEM, back to the DOS, comma and TAB to a file, the line table exits, a number to a file, the BREAK key (5B51H to 5BA4H)
5BADH-5D24H	The start-up (5BADH, 5CA0H), the command after BASIC (5D02H)
5D25H-5DE7H	Texts, FIELD's 256th byte (5D6AH), never run capitals helpers (5D77H), the file name buffer (5DA6H)
5DE8H-5F77H	Choose a file (5DE8H, 5E00H), MKI$/MKS$/MKD$ and CVI/CVS/CVD (5E2DH, 5E46H), INPUT # and LINE INPUT # (5E63H, 5E7AH), open file 0 (5F72H)
5F78H-60E4H	RUN and LOAD (5F78H), the READY exit (5FFCH), MERGE (600BH), SAVE (6044H), CLOSE (606FH), FIELD (60ABH)
60E5H-6348H	LSET and RSET (60E5H), EOF (61EBH), close a file (6210H), LOC and LOF (6231H), byte output and input (624FH, 62E5H), GET and PUT (627BH), the file name (62FFH), NAME (6346H)
6349H-6431H	OPEN (6349H), KILL (63C0H), the errors and the table of DOS error codes (63E3H, 640BH)

The Start-up

SYS1/SYS runs BASIC/CMD with Register Pair HL past the name BASIC. The start-up (5BADH) takes, separated by commas, numbers below 256 as F, the highest file number (0-15; 3 when none is given), and numbers of 256 or more as M, the memory size (the top of memory is M less 1). The first item that is not a number is a command for BASIC; anything else after a number, or an F of 16 or more, goes back to DOS READY without a message. BASIC * keeps the program that is in memory: the start-up checks that the old program's first link lies above its start and that it ends with the link 0000H, works out from the start of the old program how many file areas there were, and links the program again after NEW (5CD6H-5CE2H); with no program it goes back to the DOS.

Then: the target of RST 28H for request codes with bit 7 clear (the JP at 4312H of SYS0/SYS) is changed to 5BA4H, so that the ROM's BREAK code 01H (0456H) comes back to BASIC; the BREAK flag 4315H is cleared; the ROM's work space 4080H-40A6H is set from 18F7H; the vector table is copied; the input buffer is put at 5BADH, over the start-up code; the file areas are cleared from 6431H; the top of memory (M, the old top for BASIC *, else 4049H) is tested by writing to it (a top that is not memory goes back to the DOS) and must leave 300 bytes for the program (else Out of memory); 50 bytes are kept for strings. The banner is shown, NEW clears the program, and READY follows. A command given after BASIC is put into the first command line by 5D02H, called once from the line input at 5249H.

Files

Each file has an area of 290 bytes: +00H the mode (00H closed, 01H input, 02H output, 03H random), +01H the position in the line written (for comma and TAB, 5B65H), +02H-+21H the FCB, +22H-+121H the record buffer of 256 bytes. The table at 5B2CH holds the area of each file number 0-15; file 0, the first area at 6431H, is used by LOAD, RUN, MERGE, SAVE and KILL and cannot be named in OPEN. The word at 5B2AH is the file in use: PRINT #, INPUT # and LINE INPUT # set it, the end of each PRINT and INPUT clears it (577CH), and while it is set the ROM's character output (59BEH) and line input (5996H, 59CDH) go to and come from the file.

OPEN takes the modes O, I, R and, new in DBLDOS, E: a file opened with E is positioned at its end by @PEOF and then written as an output file (5216H, 521FH). Percom's manual does not mention the mode E. Errors from the DOS are turned into BASIC errors through the table at 640BH; the DOS code is kept at 5B29H, and CMD"E" shows its message.

LOAD and SAVE

SAVE "name" writes FFH and then the program text from 40A4H to 40F9H, a sector at a time (57E5H), and then reads the whole file back to its end (5811H) so that a write error shows at once. LOAD and RUN "name" read the first sector: if its first byte is FFH, the size of the file (end of file sector and offset) is tested against the room below the string space (552BH, 57B2H) and the program is copied a sector at a time (57C5H); else the file is read as ASCII lines through the ROM's command input. TRSDOS 2.1's BASIC/CMD does both a byte at a time through 624FH and 62E5H. SAVE "name",A lists the program to the file. LOAD "name",R runs the program after loading it and keeps the files open, by making the highest file number 0 while NEW and the variable reset run (5F78H).

Code That Never Runs

No instruction of any DoubleDOS file reaches 5200H-5215H, 525EH-5302H, 53A4H-5548H and 5D77H-5DA5H. As instructions they would make a line capitals, recall program lines with the arrow keys, expand the abbreviations L, E and D, run REF and RENUM through overlays (codes 8DH and 8EH, which DoubleDOS does not have), and run a DOS command from BASIC with CMD"command" (BASIC copied below the stack and checked by a 64 byte sum on its return). The only way in would be CMD with a string of two or more characters, and DBLDOS's CMD takes exactly one (56CCH). These parts are paged as never run, as SYS0/SYS 4E32H is. The hook of SYS0/SYS at 4358H-435EH is set only by this code (5444H).

Differences From TRSDOS 2.1's BASIC/CMD

Address	Change
4D00H	The vector table is at 4D00H (TRSDOS 2.1: 54C3H, whose last 13 bytes are left at 5549H-5555H); 41A6H is LD A,89H / RST 28H, SYS7/SYS, where TRSDOS 2.1 has JP 57B2H, and 41CAH is JP 5A15H (2.1: JP 5A5BH).
5200H	TRSDOS 2.1 has JP 5BA4H and its error messages at 5200H-5548H; DBLDOS has its own code there.
56CCH	CMD takes a string of exactly one character (2.1: any string that is not empty); CMD"X" is Illegal function call (56F2H; 2.1 jumped to 57E1H).
57B2H	The load routine of LOAD, where TRSDOS 2.1 has the code that shows the long error messages (57B2H-57E9H).
57E5H	The save routine of SAVE, where TRSDOS 2.1 has the end of CMD"X" and the text THIS BASIC WAS AUTHORED AND IS COPYRIGHTED BY MICROSOFT, 1978.
5993H	The line input exit goes to DBLDOS's 5238H for the command after BASIC.
5A15H	The PRINT # hook, moved from 5A5BH.
5B53H	The old target of 4312H is kept at 5BA8H (2.1: 5C8FH).
5BA4H-5DA5H	DBLDOS's start-up, BASIC F, M, command and BASIC *; TRSDOS 2.1's start-up at 5BA4H is other code, and 5DA6H-5DC6H held the end of its banner.
5FB6H	LOAD reads a program in memory form a sector at a time (552BH); one INC HL is a NOP at 5FDCH.
6055H	SAVE writes the program a sector at a time (57E5H).
60D6H, 60E2H	FIELD allows a total of exactly 256 bytes (5D6AH); 2.1 gives FIELD overflow above 255.
61FBH, 6200H	EOF subtracts where 2.1 compares, so that only equal sectors and offsets give -1.
6231H	LOC calls 5E0AH; 2.1 calls 63E3H, Bad file mode, so its LOC never worked.
62BFH	PUT writes with @VERF (443CH), which reads the record back; 2.1 uses @WRITE (4439H).
630CH	A file name may have 23 characters (2.1: 22).
6372H	OPEN goes to 5216H for the mode E.
63B6H	OPEN goes to 521FH, which positions an E file at its end.

Bugs

No. Address	What happens
B40 552FH	LOAD's room test subtracts with the C FLAG that the ADD HL,DE at 5FD4H leaves set, so the room taken is one byte less than the 56H margin below the string space gives: a program of exactly that size is refused with Out of memory (DBLDOS's code).
B41 555DH	SCF after OR A sets the C FLAG on every path, so JR C at 5571H is always taken (5573H never runs) and JP NC,2423H at 55C2H is never taken. The code is TRSDOS 2.1's; nothing a program does is changed.
B42 5CE5H	For BASIC * the command given to the first READY is 5D59H, a byte 00H with no 0DH after it; the copy of 5D02H runs to the first 0DH, at 5E7EH, and writes 294 bytes from 5BADH, past the 240 bytes of the input buffer, up to 5CD2H. Only start-up code that has run is overwritten, and the line is empty because its first byte is 00H.

Every bug found in DoubleDOS is listed, with what a user would do to set it off, on the DoubleDOS reference page.

Differences From the Manual

• The manual (3.4) gives BASIC F, M, {COMMAND}, all optional. The bytes agree, and add BASIC *, which keeps the program in memory, and silent returns to DOS READY for an F above 15, a top of memory that is not memory, or a character other than a comma or the end after a number.
• The manual gives M as 16,384 bytes to 48K; nothing tests that range: any number of 256 or more is taken, the top being M less 1, as long as a byte written there is kept and 300 bytes are left for the program.
• The manual says nothing of OPEN "E", of the one character CMD, of FIELD records filled to 256 bytes, or of the fast LOAD and SAVE.
• For everything else the manual refers to the Radio Shack TRSDOS and Disk BASIC Reference Manual.

Notes

• An 80 Microcomputing reader (August 1982) reported that Radio Shack's Versafile lost earlier records when it wrote under DBLDOS. The random file code (GET and PUT 627BH, the byte routines 624FH and 62E5H, FIELD) was read for this: PUT writes with @VERF and GET past the end gives an empty record, as named above; no cause of lost records was found in BASIC/CMD.
• The last byte of the error code table, 6431H (DOS code 27H), is also the first byte of file 0's area, which the start-up clears; no DOS file gives code 27H.
• The start-up stores 00H at 5CACH, the first byte of an LD BC instruction of the start-up that has already run; nothing runs or reads it again.
• A disk error code with bit 6 set would index the table at 63FDH past its end; the DOS routines BASIC calls return codes below 40H.

Places in BASIC/CMD

Address Size	Contents
5249H-524BH 2 bytes	The Display Call of the Command Input The operand of CALL 0033H at 5249H; 5D02H until the first command line when a command followed BASIC (5CF8H), 0033H again from 5D07H.
57C6H, 57F9H 1 byte each	The Count at Which a Sector Is Read or Written The operands 57C7H and 57FAH, the low byte of the size, stored by 57BDH and 57E5H.
5A14H 1 byte	A Closed File Area 00H; put in the table for file 0 while a program line is stored and during LOAD's NEW.
5B14H-5B27H 20 bytes	The USR Addresses USR0-USR9, 1E4AH until DEFUSR sets them.
5B28H 1 byte	GET or PUT 00H GET, AFH PUT.
5B29H 1 byte	The Last DOS Error Code Shown by CMD"E".
5B2AH-5B2BH 2 bytes	The File in Use Its area, or 0000H for the screen and keyboard.
5B2CH-5B4BH 32 bytes	The Table of the File Areas A word for each file number 0-15.
5B4CH-5B4DH 2 bytes	The Area of File 0 6431H.
5B4EH 1 byte	Run After Loading Not 00H for RUN "name" and LOAD "name",R.
5B4FH 1 byte	The Highest File Number Kept While 5B50H is 00H during a load.
5B50H 1 byte	The Highest File Number F of BASIC F.
5BA7H-5BA9H 2 bytes	The Old Target of 4312H 4BA0H, saved by 5C29H and put back by 5B53H.
5C5BH, 5C86H, 5CCEH, 5CD6H, 5CDFH 1 or 2 bytes	The Start-up's Values The highest file number (5C5CH), the top of memory given (5C87H), the command after BASIC (5CCFH), the first link and the end of the old program for BASIC * (5CD7H, 5CE0H), stored in the operands of these instructions.
5DC8H-5DE7H 32 bytes	The File Name in Capitals For @FSPEC.
6431H up 290 bytes a file	The File Areas Mode, position, FCB and a 256 byte record buffer for files 0 to F, then a byte 00H and the program text.

Places Outside BASIC/CMD

Address Size	Contents
4012H 1 byte	The RST 38H Vector Its JP made RET by CMD"T" and JP again by CMD"R".
4041H-4046H 6 bytes	The Clock and the Date Read by TIME$.
4049H-404AH 2 bytes	The Top of Memory found by SYS0/SYS.
4080H-40A6H 39 bytes	The ROM's Work Space Set from 18F7H at start-up.
40A0H, 40A2H, 40A4H, 40A7H, 40B1H, 40D6H, 40F9H	The ROM's Pointers The string space, the current line (FFFEH during start-up), the program text, the input buffer (5BADH), the top of memory, the next free string byte, the end of the program.
40DFH, 40F3H 2 bytes each	ROM Work Words 40DFH keeps OPEN's text pointer; 40F3H keeps the file in use while a line is stored.
40A9H 1 byte	The Cassette Input Flag Stored by the keyboard scan hook (5A0EH), as in TRSDOS 2.1.
4121H, 40AFH, 40D3H-40D5H	The Accumulator, Its Type and the Temporary String Descriptor
4152H-41E4H 147 bytes	The Disk BASIC Vectors Copied from 4D00H.
430EH, 4312H, 4315H 1-2 bytes	SYS0/SYS: The Overlay in Memory, the Target for Codes Without Bit 7, the BREAK Flag 430EH cleared at start-up; 4313H made 5BA4H; 4315H 00H while BASIC runs, C3H when it returns to the DOS.
4D00H-4DE8H 233 bytes	The Vector Table and Banner Free after the start-up: SYS7/SYS loads there for each long error message.

Outside Routines

Address	Use
402DH	SYS0/SYS: DOS READY, the normal exit
4030H	SYS0/SYS: The Exit After an Error, for CMD"A"
4409H	SYS0/SYS: @ERROR (SYS4/SYS), for CMD"E"
440DH	SYS0/SYS: DEBUG (SYS5/SYS), for CMD"D"
441CH	SYS0/SYS: Parse a File Specification (SYS1/SYS)
4420H	SYS0/SYS: @INIT, open or make a file (SYS2/SYS)
4424H	SYS0/SYS: @OPEN (SYS2/SYS)
4428H	SYS0/SYS: @CLOSE (SYS3/SYS)
442CH	SYS0/SYS: @KILL (SYS3/SYS)
4436H	SYS0/SYS: @READ
4439H	SYS0/SYS: @WRITE
443CH	SYS0/SYS: @VERF, write and read back
443FH	SYS0/SYS: @REW
4442H	SYS0/SYS: @POSN
4445H	SYS0/SYS: @BKSP
4448H	SYS0/SYS: @PEOF
4467H	SYS0/SYS: Display a Text
0013H	ROM: Read a Byte from a Device or File
001BH	ROM: Write a Byte to a Device or File
0033H	ROM: Display a Character
0358H	ROM: The Keyboard Scan
0361H	ROM: The Keyboard Line Input
0384H	ROM: Wait for a Key
0A9AH	ROM: An Integer Result
0AF4H	ROM: Test for a String
0E6CH	ROM: ASCII to a Number
1997H	ROM: Syntax Error
19A2H	ROM: The Error Routine
1A19H	ROM: READY
1A33H	ROM: The Command Input
1B4DH	ROM: NEW
1B5DH	ROM: RUN's Reset of the Variables
1D1EH	ROM: NEWSTT, the Next Statement
1E4AH	ROM: Illegal Function Call
1E5AH	ROM: A Decimal Number
2337H	ROM: Evaluate an Expression
2B1CH	ROM: An Expression as a Byte
260DH	ROM: Find a Variable
2857H	ROM: Room for a String
2868H	ROM: A String Up to an End Byte
28A7H	ROM: Display a Text
29D7H	ROM: Free a Temporary String

4D00H - The Disk BASIC Vector Table

147 bytes that the start-up copies to 4152H-41E4H (5C44H-5C4DH), forty-nine three byte entries, one for each Disk BASIC vector and DOS exit of the Level II ROM (the RAM addresses page names each). Forty-seven entries are the same as in the table of TRSDOS 2.1's BASIC/CMD (at 54C3H there); DBLDOS changed the error vector 41A6H, which now loads SYS7/SYS, and the print exit 41CAH. Once copied, the block 4D00H-4DE8H is free: SYS7/SYS loads here for each error message, and SYS0/SYS can read the GAT here (B2 on the SYS0/SYS page). The comments give each entry as it stands at its place in 4152H-41E4H.

4D93H - The Disk BASIC Banner

The first part of the banner, shown by 5CBFH-5CC2H through 4467H; the second part, DBLDOS ADAPTATIONS COPYRIGHT 1980 BY PERCOM., follows from 5D25H (5CC5H). The text is TRSDOS 2.1's.

5200H - Make the Rest of a Line Capitals (Never Run)

Twenty-two bytes that no instruction of any DoubleDOS file reaches: nothing jumps to 5200H, and the vector table puts JP 6033H, not 5200H, at the exit 41B2H (4D60H). As instructions they would change every small letter of the line after Register Pair HL to a capital and go on to 6033H. TRSDOS 2.1's BASIC/CMD has JP 5BA4H and its error messages here; DBLDOS put its own code at 5200H-5548H.

5216H - OPEN Mode E

Called from the OPEN statement at 6372H after the modes O (02H), I (01H) and R (03H) were tested: DBLDOS adds the mode E, 04H, which opens a file to add records at its end. TRSDOS 2.1's BASIC/CMD has JP NZ,63E3H at 6372H, so any other letter was Bad file mode there.

521FH - OPEN Mode E: Position to the End

Reached by the jump at 63B6H after the file was opened (63ABH or 63B0H) without an error. For the mode E the file is positioned at its end with @PEOF and is then marked as open for output (mode 02H), so that PRINT # and PUT add to it. TRSDOS 2.1 has POP HL, POP AF and LD (HL),A at 63B6H, which this replaces.

5238H - The Keyboard Line Input Exit (41AFH)

598EH, reached through the exit 41AFH from the ROM's line input at 0368H, loads (5B2AH) and jumps here. TRSDOS 2.1's BASIC/CMD has OR L, POP HL and RET Z at 5993H, so with no command file open the ROM took the line from the keyboard. DBLDOS's version does the same for an INPUT, but for the command line after READY it does the ROM's work itself, to show the command given after BASIC on the DOS line at the first READY (5D02H).

525EH - Line Recall by Arrow Keys (Never Run)

165 bytes that no instruction reaches. As instructions, they take the key in Register A: SHIFT and up arrow (1BH) or down arrow (1AH) would look for the line before or after the current line (40ECH) and list it with the ROM's LIST (2B33H) in place of the input, the line READY being overwritten. The live code at 5247H-525DH takes the key and goes straight to the ROM's line input instead. The text READY and five spaces at 52F9H-5302H belongs to it.

5303H - The Return of the Line Input

5250H puts 5303H on the stack as the return address of the ROM's line input, in place of ROM 0374H: the flags of the line input are saved and the ROM goes on at 0375H as after its own call.

5307H - Abbreviations and REF/RENUM (Never Run)

157 bytes that no instruction reaches. As instructions they look at a command line just typed (made capitals by 5D80H): a line starting with L, E or D and a period or a number would get the rest of a keyword from the texts at 5D58H, 5D5EH or 5D63H inserted, and a line starting REF or RENUM would load overlay 8EH or 8DH (directory records 26H and 25H, which hold no file on a DBLDOS diskette) and go on to READY. The texts at 5D58H-5D69H are 04H and zeros in the shipped file, the start-up's command line buffer (5D59H).

5397H - Scan for = or ( (Never Run)

Used only by 5336H and 5375H, which nothing reaches: Z when = or ( comes before the carriage return, NZ at the carriage return.

53A4H - The Memory Check of CMD with a DOS Command (Never Run)

Used only by the code at 53EEH-552AH, which nothing reaches. 53A4H fills the 64 bytes at the address in 53D5H with A5H and folds into them, by XOR, every byte from the address in 54D6H to that place and from 64 bytes after it to the top of memory (40B1H) plus one; 53AEH folds again without the fill. Folding the same bytes twice gives A5H again, so the Z FLAG at the end says the memory is unchanged since the first fold.

53EEH - CMD with a DOS Command (Never Run)

317 bytes that no instruction reaches. As instructions they would take a CMD string of 2 to 63 characters (with Register A its length and Register Pair HL its descriptor, as CMD leaves them at 56CBH) as a DOS command: the string, or the string variable it names when it ends with $, is copied in capitals to 4318H; BASIC 5200H-6FFFH and the area 407DH-41FFH are copied below the stack; the DOS return 402DH, the abnormal exit 4030H and the @ERROR vector (440AH, through 4358H) are pointed at the copy of 54C3H-54CEH; and the command is run through 4405H. Back from the DOS, BASIC is copied back to 5200H, the fold of 53AEH must show the memory unchanged (or 0000H, RESET, is jumped to), and BASIC goes on after the CMD, with a DOS error made a BASIC error. CMD at 56C4H-56CDH now accepts only one character (TRSDOS 2.1 has OR A and JP Z,1E4AH at 56CCH), and nothing jumps here.

552BH - LOAD: The Room for a Program File

Called from LOAD at 5FD5H with Register Pair HL the start of the string space (40A0H) less 56H, and Index Register IX the file control block. The size of the file is taken from its end of file sector and offset and checked against the room from the start of the program (40A4H) at 57B2H. TRSDOS 2.1 has other code here; DBLDOS's 5FD2H-5FD5H calls this.

553DH - CMD with a DOS Command: No Room (Never Run)

Reached only from 5479H and 5486H, which nothing reaches: the vectors are put back by 54F7H and the return at 551DH goes to 197AH.

5556H - FN: Save the Value of a Parameter

TRSDOS 2.1's code, unchanged from here to 56CBH. Reached by the jump at 55BFH with Register Pair HL the value of a variable named in the parameter list of DEF FN and the C FLAG set: its old value is pushed on the stack, two bytes at a time, so that 5604H can put it back after the function. The type at 40AFH (02H integer, 03H string, 04H single, 08H double) says how many bytes.

5582H - FN: Find the Function's Name

Called from FN (558EH) and DEF FN (5659H) with Register Pair HL at the token FN: the name after it is looked up by the ROM as a variable whose first letter has bit 7 set, so the functions do not mix with the variables.

558EH - FN: Call a User Function

The vector 4155H. The value of the function's name is the address of its DEF FN text after the name (stored by DEF at 565FH). The parameters named there get the values of the expressions given, their old values being saved on the stack (5556H); the expression of the definition is evaluated, the old values are put back (5604H) and the result is left in the accumulator with the function's type.

5655H - DEF: DEF FN and DEFUSR

The vector 415BH. DEF USR goes to 56ABH. DEF FN, allowed only in a program, stores the address of the text after the function's name as the value of the name (5582H) and makes each parameter a variable, then passes over the rest of the statement with the ROM's DATA (1F05H): the expression is evaluated only when FN calls it.

5679H - USR: Call a Machine Language Routine

The DOS link 41A9H, called at 27FEH for USR. The digit after USR (none is 0) picks one of the ten addresses at 5B14H-5B27H set by DEFUSR; the argument in parentheses is evaluated and the routine is entered with Register A the type of the argument and Register Pair HL 4121H, the accumulator, returning to the ROM at 26E7H.

5699H - USR and DEFUSR: The Digit

Register Pair DE is 5B14H plus twice the digit after USR (00H when there is none).

56C4H - CMD

The vector 4173H. The argument must be a string of exactly one character (DBLDOS's 56CCH: TRSDOS 2.1 has OR A and JP Z,1E4AH, which took any string that is not empty). CMD"D" enters DEBUG, CMD"E" shows the long text of the last disk error, CMD"T" and CMD"R" turn the clock interrupt off and on (the RST 38H vector 4012H made RET or JP), CMD"S" and CMD"A" go back to the DOS (5B52H, CMD"A" with the C FLAG set). CMD"X" is refused: TRSDOS 2.1 has JP Z,57E1H at 56F4H, DBLDOS JP Z,1E4AH. Other letters are Illegal function call.

5714H - TIME$

The vector 4176H. A string of 17 characters is made from the six bytes 4046H down to 4041H: the date as DATE shows it, a space, and the hours, minutes and seconds of the clock (4043H, 4042H, 4041H), each two digits, with slashes and colons between.

5756H - LINE INPUT

The vector 41A3H. LINE INPUT # goes to 5E7AH. Otherwise the optional prompt is shown (21CDH), the variable named must be a string (0AF4H), a line is taken from the keyboard by the ROM's 0361H and the whole of it, commas and quotation marks included, is made a string (2868H with the end byte 00H) and given to the variable by the ROM's LET (1F32H).

577CH - The End of a PRINT: Back to the Screen

The hook 41BEH, called from 2174H at the end of each PRINT and PRINT # with Register A 00H (2170H): the word at 5B2AH, the area of the file a PRINT # or INPUT # uses, is cleared, so that the next output goes to the screen again.

5784H - INPUT #: Choose the File

The hook 41D6H, called from 219EH at the start of INPUT with Register A the character at Register Pair HL. INPUT without # and INPUT #-1, the cassette, go back to the ROM. INPUT #n chooses the file (5DE8H) and enters the ROM's input of data at 21EBH, where the values are read as READ reads DATA; the characters come from the file through the hook 41AFH (598EH, 5996H).

579CH - The End of an INPUT # or a LIST Line

The hook 41DFH, called from 2278H at the end of READ and INPUT and from 2B44H in LIST. With no file in use (5B2AH 0000H) nothing changes. With a file: an INPUT # ends at 2282H, without the ROM's EXTRA IGNORED test; a LIST to a file (SAVE with A, 604EH) goes on at 2B4AH, which passes over the ROM's BREAK test at 2B47H.

57B2H - LOAD: Read the Program into Memory

Entered from 553AH with Register Pair BC the size of the file, Register A the byte above it, Register Pair HL the room, Index Register IX the FCB and its first sector in the buffer (5FBBH). A file of 65536 bytes or more, or larger than the room, gives Out of memory (6005H). The bytes after the first (FFH, the mark of a BASIC program in memory form) are copied to the start of the program (40A4H), a sector being read each 256 bytes. DBLDOS's code: TRSDOS 2.1's BASIC/CMD has here (57B2H-57E9H) the routine that shows the long error messages, which DBLDOS moved to SYS7/SYS.

57D5H - Read the Next Sector

Called from 57C8H, and from LOAD at 5FBBH for the first sector, with Index Register IX the FCB. A disk error goes to 63FDH; else Register Pair DE is the buffer's address.

57E5H - SAVE: Write the Program in Memory Form

Entered from 606CH with Register Pair BC the length of the program plus one, Register Pair HL its start (40A4H), Register A the low byte of the length and Index Register IX the FCB of the new file. FFH and the program are put in the buffer, each full buffer written (57EFH); the offset of the last byte goes to FCB+05H and the last sector is written. The file is then set back to its start and read to its end, so that a disk error shows now. DBLDOS's code: TRSDOS 2.1 has the end of CMD"X" here and at 57F0H its text THIS BASIC WAS AUTHORED AND IS COPYRIGHTED BY MICROSOFT, 1978.

582AH - Data Not Used

Five bytes left from TRSDOS 2.1's text, after DBLDOS's 57E5H-5829H.

582FH - INSTR

The vector 419DH. INSTR([n,] string1, string2): the place of string2 in string1, searched from character n (1 when n is not given; n 0 is Illegal function call). The result is 0 when n is past the end of string1, when string1 is empty or when string2 is not found, and n when string2 is empty. The result goes back as an integer through 27F8H, and 26E7H restores the text pointer. TRSDOS 2.1's code.

58B7H - &H and &O Constants

The vector 4194H, entered with Register Pair HL at the sign &. &H takes up to four hexadecimal digits 0-9 and A-F (capitals only), a fifth gives Overflow; &O or & alone takes octal digits 0-7 until the number passes 65535 (Overflow); 8 or 9 is a Syntax error. The value goes to 4121H as an integer (0A9AH). TRSDOS 2.1's code.

590DH - MID$ on the Left of =

The vector 41D9H, a JP at 2AECH. MID$(v$, n [, m]) = x$ puts the characters of x$ into v$ from character n, at most m of them (all when m is not given), never past the end of v$; the length of v$ does not change. A string of v$ that is still in the program text is first copied into the string space (2843H), so that the program is not changed. n of 0 or past the end of v$ is Illegal function call. TRSDOS 2.1's code.

5980H - MID$: The Optional Count

Called from 593AH with Register A the character at Register Pair HL. Register E is FFH when the close parenthesis follows, else the byte after the comma; the close parenthesis is checked in both cases.

598EH - The Keyboard Line Input Exit

The DOS exit 41AFH, called at 0368H by the ROM's keyboard line input. The word at 5B2AH, the area of the file in use, is loaded and the work goes on in DBLDOS's code at 5238H (TRSDOS 2.1 has OR L, POP HL and RET Z here, at 5993H-5995H).

5996H - A Line from the File

Reached from 523AH when a file is in use (an INPUT # or LINE INPUT # line, or a program loaded in ASCII form). The characters are taken by the ROM's 0384H, whose keyboard scan the hook 41C4H (59CDH) turns into a byte from the file, into the ROM's input buffer (40A7H) up to 0DH or 240 characters; a line feed before the first character is passed over. The line ends with 00H, and the ROM goes on with Register Pair HL the buffer less one, as after a keyboard line.

59BEH - Output of a Character

The hook 41C1H, called at 032CH by the ROM's output of the character in Register C. With no file in use the ROM goes on; with a file the character is written to it (624FH) and the ROM's output is passed over.

59CDH - The Keyboard Scan Hook

The hook 41C4H, called at 0358H, the ROM's keyboard scan used by INKEY$, the BREAK test and 0384H. Only when the caller is 0384H (the line input of 5996H) and a file is in use is a byte taken from the file (62E5H); at the end of the file all files are closed (5FFCH), and the program is run (LOAD with R, 5B4EH) or READY is shown and the line ended with 0DH. Any other caller stores Register A at 40A9H, the cassette input flag, and scans the keyboard (035BH). TRSDOS 2.1's code.

5A15H - PRINT #: Choose the File

The DOS exit 41CAH, called at 206FH by PRINT with Register A the character at Register Pair HL. PRINT #-1, the cassette, goes back to the ROM; PRINT #n chooses the file, which must be open for output (mode 02H, 5DEAH). TRSDOS 2.1 has the same code at 5A5BH, and its vector 41CAH points there; DBLDOS moved it to 5A15H, where TRSDOS 2.1 has zeros.

5A21H - Unused Space

243 bytes that nothing reads or runs: zeros, with at 5A5BH-5A66H the PRINT # code of TRSDOS 2.1 left where TRSDOS 2.1 has it. DBLDOS's vector 41CAH points to its copy at 5A15H, so these twelve bytes are never run. TRSDOS 2.1's BASIC/CMD has the same 243 bytes here.

5B14H - The Variables of Disk BASIC

The USR addresses, the GET/PUT switch, the last disk error, the file in use, the table of the file areas and the LOAD switches. The start-up (5C5BH-5C83H) fills the table: file 0, the area of LOAD, SAVE, RUN and MERGE, is at 6431H, then one area of 290 bytes (0122H) for each of the files (BASIC F, 3 when none is given); the program text starts after them. The bytes are as in the file.

5B51H - The SYSTEM Command Hook

The hook 41E2H, called from 02B2H before SYSTEM asks for a tape file name: nothing is done.

5B52H - Back to the DOS

Entered from CMD"S" (56E9H) and CMD"A" (56EFH, the C FLAG set), and from 5CEEH at start-up when the memory size is not memory. The target of RST 28H for a code with bit 7 clear is put back (5BA8H, saved by 5C29H) and the BREAK flag 4315H set to C3H again; then 402DH, or 4030H for CMD"A".

5B65H - Comma and TAB to a File

The DOS exit 41D3H, called from 2108H (the comma of PRINT) and 2141H (TAB). With a file in use the position in its line is the second byte of the file's area, and the ROM's code goes on at 2130H (comma) or 2156H (TAB) with it in Register A, instead of the position on the screen or printer.

5B7DH - A Line Is Stored: Keep the File

The DOS exit 41B5H, called from 1AECH after a program line has been put in the program, before the ROM's 1B5DH clears the variables. 1B5DH also closes the files through 41BBH (60A1H, from 1B8CH). The file in use is kept at 40F3H, and file 0 is marked closed by the table entry 5A14H (a byte 00H), so that 60A1H passes over it; 41B8H (5B8CH) puts both back. So a program loaded in ASCII form (file 0, a line at a time) goes on being read, while files 1 to F are closed when a line is stored.

5B8CH - After a Line Is Stored: Put the File Back

The DOS exit 41B8H, called from 1AF2H after 1B5DH: the file in use (from 40F3H) and the area of file 0 (5B4CH) are put back.

5B99H - After PRINT's Carriage Return

The DOS exit 41D0H, called from 2103H: nothing is done.

5B9AH - A Number to a File

The DOS exit 41CDH, called from 20C6H after PRINT has made a number ASCII. With a file in use the ROM's test of the room left on the line (20C9H-20E6H) is passed over and the text is sent at once (20E9H).

5BA4H - The BREAK Key in BASIC

The target of the JP at 4312H of SYS0/SYS while BASIC runs (5C2CH-5C2FH): the dispatcher of RST 28H (4BA2H) jumps there for a request code with bit 7 clear. The ROM's keyboard driver does LD A,01H then RST 28H at 0456H when BREAK is pressed; the DOS's own target 4BA0H clears Register A, so the key is lost. Here code 01H returns at once with Register A still 01H, so BASIC sees BREAK; any other code goes to the old target, whose address 5C29H stores at 5BA8H.

5BADH - The Start-up: BASIC F, M, Command and the asterisk form of BASIC

The transfer address of BASIC/CMD, entered from SYS1/SYS's @RUN (4433H) with Register Pair HL past the name BASIC on the command line. The numbers after BASIC are F (below 256: the highest file number, 0-15; 16 or more goes back to the DOS) and M (256 or more: the memory size, the top being M less 1), in either order, separated by commas; the first item that is not a number is a command for BASIC (5D02H). the asterisk form of BASIC keeps the program in memory (5BBAH). The bytes of the start-up are DBLDOS's: TRSDOS 2.1's start-up at 5BA4H is other code.

5CA0H - The Start-up: Memory and the Banner

The top of memory must hold a byte written to it (else back to the DOS, 5CEDH), and must leave 300 bytes after the start of the program (else Out of memory). 50 bytes are kept for strings. The banner is shown, the program cleared (1B4DH), and for the asterisk form of BASIC the old program is linked again (5CD6H-5CE2H).

5D02H - The Command after BASIC

Called once, by the CALL at 5249H when the operand 524AH has been made 5D02H (5CF8H), when the first command line after READY is to be taken. The CALL is made 0033H again; 1DH, 1BH and 1FH are shown (5D54H); the command is copied from (5CCFH) into the input buffer up to and with its 0DH; and the line input ends at 0379H as if the line had been typed. For the asterisk form of BASIC the command is at 5D59H, a byte 00H: an empty line; the copy, which stops only at a 0DH, takes 294 bytes, to 5E7EH, into 5BADH-5CD2H, the start-up code, which has run.

5D25H - The Texts of the Start-up

The second part of the banner, the codes shown by 5D02H, and the texts of the never run abbreviations of 5307H at 5D58H-5D69H.

5D6AH - FIELD: A Record Filled to Its Last Byte

DBLDOS's code, called from 60D6H when the length of a field takes the total past 255 bytes, and entered from 60E2H after every field. TRSDOS 2.1 has JP C,63F8H at 60D6H (FIELD overflow for any total above 255) and JP 60B9H at 60E2H, so the 256th byte of a record could not be in a field. Here a total of exactly 256 (Register A 00H, the Z FLAG and C FLAG set by the ADD at 60D5H) is allowed when it is the last field of the statement.

5D77H - Capitals Helpers (Never Run)

Used only by the never run code of 5307H and 5404H: 5D77H makes a small letter a capital, 5D80H makes a command line capitals outside its quotation marks, 5D9CH copies Register B characters as capitals.

5DA6H - The File Name Buffer

66 bytes 00H. 5DC8H-5DE7H take a file name made capitals by 62FFH (6315H, at most 23 characters and an end byte), for @FSPEC (6334H-6339H). TRSDOS 2.1 has at 5DA6H-5DC6H the end of its banner (DIO SHACK DISK BASIC VERSION 1.1 and 0DH), which DBLDOS has at 4D93H.

5DE8H - Choose the File after #

5DE8H for INPUT # and LINE INPUT # (mode 01H, input), 5DEAH with Register C the mode from PRINT # (02H). With Register A not the sign # nothing is done. The file number must be open in the mode of Register C (Bad file mode, 63E3H), and must be followed by a comma; its area goes to 5B2AH. TRSDOS 2.1's code.

5E00H - A File Number and Its Area

Entered with Register Pair HL at the file number (5E00H, an optional # first), or at 5E0AH with the number's value in 4121H, or at 5E0DH with the number in Register A. A number above the highest (5B50H) is Bad file number (63E6H). Register Pair BC is the area from the table 5B2CH, Register A its first byte, the mode (00H closed, 01H input, 02H output, 03H random), with the Z FLAG set when it is closed. TRSDOS 2.1's code.

5E2DH - MKI$, MKS$ and MKD$

The vectors 416AH (5E2DH, MKI$, Register A 02H), 416DH (5E30H, MKS$, 04H) and 4170H (5E33H, MKD$, 08H), entered inside the LD BC instructions. The value in 4121H is made of that type (2819H) and copied, 2, 4 or 8 bytes, into a new string of that length. TRSDOS 2.1's code.

5E46H - CVI, CVS and CVD

The vectors 4152H (5E46H, CVI, Register A 01H), 4158H (5E49H, CVS, 03H) and 415EH (5E4CH, CVD, 07H). The string must have more characters than Register A, one less than the length of the type (else Illegal function call); its first 2, 4 or 8 bytes are copied to 4121H as a number of that type. TRSDOS 2.1's code.

5E63H - INPUT # and READ: A Value from the File

The hook 41DCH, called from 222DH for each variable of READ and INPUT. With no file in use the ROM goes on. For INPUT # the value is taken from the file: a number ends at a space, a comma or a carriage return; a string at a comma or a carriage return, or, when it starts with a quotation mark, at the next quotation mark. The value goes back to the ROM at 2243H. TRSDOS 2.1's code from here to 5F71H.

5E7AH - LINE INPUT #

Reached from LINE INPUT at 575AH. The file is chosen (5DE8H, mode input), the variable must be a string, and the characters up to the carriage return, spaces, commas and quotation marks included, are read by 5E8EH with Register D and Register E 00H and given to the variable by the ROM's LET (1F31H); 2169H ends the statement.

5F72H - Open File 0

5F72H for LOAD, RUN and MERGE (Register D 01H, input), 5F74H with the mode in Register D for SAVE (02H). Register A 00H, the file number; the open is done by OPEN's code at 6389H with Register Pair HL at the file name.

5F78H - RUN with a File Name and LOAD

5F78H is the DOS exit 41C7H from 1EA6H, RUN: with a line number (the C FLAG set) the ROM goes on; with a name the program is loaded and run (Register A AFH). 5F7BH is the vector 4188H, LOAD (Register A 00H, set to F1H by the option R). LOAD,R keeps the files open: the highest file number is made 0 while the program is cleared (1B4DH) and the variables reset. A program in memory form (the first byte FFH) is read at once (552BH, 57B2H); one in ASCII form is read a line at a time by the ROM's command input from file 0 (6030H, 5996H).

5FFCH - The READY Exit: Close File 0

The DOS link 41ACH, called from 1A1CH before READY is shown, and called at the end of SAVE (5827H), of a LOAD in ASCII form (59EEH) and of a bad MERGE (6014H). Output goes back to the screen (2169H, which clears 5B2AH through 41BEH), file 0 is closed (6210H with Register A 00H), and Register Pair HL is the text pointer kept at 40DFH (1BAFH).

6005H - LOAD: Out of Memory

Reached from 57B3H and 57B8H when the program in the file does not fit: the program in memory, partly overwritten or not, is cleared (NEW) before the error.

600BH - MERGE

The vector 418BH. File 0 is opened for input; nothing may follow the name (else file 0 is closed and Syntax error). A program in memory form (first byte FFH) is Bad file mode. The first byte is put back (FCB+05H less one), and the ROM's command input takes the lines from the file (1A33H, 5996H): each line with a number goes into the program, a line without one is Direct statement in file (6033H). TRSDOS 2.1's code.

6033H - A Line Tokenized: Direct Statement in File

The DOS exit 41B2H, called from 1AA1H after a line has been tokenized, with the C FLAG set when it has a line number. A line without a number is run by the ROM (1D5AH), but not while the lines come from a file (LOAD in ASCII form, MERGE): then Direct statement in file.

6044H - SAVE

The vector 41A0H. File 0 is opened for output (Register D 02H). SAVE "name",A writes the program in ASCII form, as LIST does (2B2EH, the lines going to the file through 41C1H); without A the program is written in memory form by 57E5H. DBLDOS's 6055H-606EH: TRSDOS 2.1 wrote FFH and then the program a byte at a time through 624FH.

606FH - CLOSE

The vector 4185H, and from 60A4H (NEW, END) with Register A 00H and the Z FLAG set. CLOSE alone closes every file from the highest number down to file 0 (6210H for each, 6081H); CLOSE n, m, ... closes each file named, a # before the number allowed (6090H, 6089H). TRSDOS 2.1's code.

60A1H - NEW and END: Close the Files

The DOS exit 41BBH, called from 1B8CH (NEW, RUN, CLEAR) and 1DB0H (END): every file is closed through CLOSE (606FH) with the Z FLAG set. TRSDOS 2.1's code.

60ABH - FIELD

The vector 417CH. FIELD n, w AS v$, ...: the file must be open in mode 03H, random (else Bad file mode; closed, Bad file number). Each string variable is pointed at w bytes of the record buffer, the area from +22H on, one field after the other. The total may be 256 bytes, the last field ending at the record's last byte (DBLDOS's 5D6AH; TRSDOS 2.1 allows 255).

60E5H - LSET and RSET

The vectors 419AH (60E5H, RSET: OR 37H, the C FLAG clear) and 4197H (60E6H, LSET: 37H is SCF, the C FLAG set). The string is put into the variable's own characters, a field of a file's buffer: LSET from the left, spaces after it, RSET from the right, spaces before it; a longer string is cut to the field's length. A variable whose characters are still in the program text is first given new room in the string space (6118H). TRSDOS 2.1's code.

61EBH - EOF

The vector 4161H. EOF(f) is -1 when the next byte of the file is past its end: the next sector (FCB+0AH-+0BH) is the end of file sector (FCB+0CH-+0DH) and the offset (FCB+05H) is the end of file offset (FCB+08H); else 0. A file open for output is Bad file mode. DBLDOS has SUB (HL) at 61FBH and 6200H, TRSDOS 2.1 CP (HL): with CP, Register A at 620AH was the byte of the end sector, not the difference, so EOF was -1 at another sector when that byte was 00H.

6210H - Close a File

Called by CLOSE (6080H, 60A0H) and 5FFFH with Register A the file number. A file that is not open is passed over; one open for input is only cleared; others are closed by @CLOSE (4428H). The 34 bytes of the area before the buffer (mode, position and the FCB) are then cleared. TRSDOS 2.1's code.

6231H - LOC and LOF

The vectors 4164H (6231H, LOC) and 4167H (6242H, LOF). LOC(f) is the number of the next sector of the file (FCB+0AH-+0BH), LOF(f) its end of file sector (FCB+0CH-+0DH), each as an integer; a file that is not open is Bad file number. DBLDOS's 6232H-6233H: TRSDOS 2.1 has CALL 63E3H at 6231H, so its LOC always gave Bad file mode.

624FH - A Byte to the File

Entered from 59CAH with Register A the character for the file in use (5B2AH). For a file open for input nothing is written (1DFDH). The position in the line (the area's second byte) is set to 0 by a carriage return and counted up by each character from 20H on; the byte goes to the file through the ROM's 001BH with Register Pair DE the FCB, a disk error going to 63FDH. TRSDOS 2.1's code.

627BH - GET and PUT

The vectors 417FH (627CH, GET: XOR A) and 4182H (627BH, PUT: OR AFH, the byte AFH being the XOR A of GET). GET f [,r] and PUT f [,r] on a file open in mode 03H, random: the record r (the next one when not given; 0 is Bad record number) is set by @POSN (4442H). GET reads it into the buffer (4436H); a record past the end gives a buffer of 00H. PUT writes the buffer and reads it back (@VERF, 443CH; TRSDOS 2.1 has @WRITE, 4439H, at 62BFH).

62E5H - A Byte from the File

Called with a file in use (5B2AH): the next byte of the file is read through the ROM's 0013H with Register Pair DE the FCB. At the end of the file (error 1CH) the C FLAG is set; any other error goes to 63FDH. TRSDOS 2.1's code.

62FFH - The File Name into the FCB

Called by OPEN (6391H) and KILL (63C4H) with Register Pair BC the file's area. The name string, 1 to 23 characters (24 or more, or none, is Bad file name), is copied to 5DC8H in capitals with an end byte 00H and given to @FSPEC (441CH), which fills the FCB. DBLDOS's 630DH is CP 18H, TRSDOS 2.1's CP 17H, which allowed 22 characters.

6346H - NAME

The vector 418EH: the NAME statement is not supported.

6349H - OPEN

The vector 4179H. OPEN "m", f, "name": the mode is the first letter of the string, O (02H, output), I (01H, input), R (03H, random) or, new in DBLDOS (5216H), E (output at the end of the file); file numbers 1 to the highest; a file already open is File already open. The name is put in the FCB (62FFH); I opens a file that must exist (@OPEN, 4424H), the others open or make it (@INIT, 4420H), with the buffer in the area at +22H and records of 256 bytes. DBLDOS's 6372H-6374H and 63B6H-63B8H lead to 5216H and 521FH. 6389H is also entered from 5F75H for file 0.

63C0H - KILL

The vector 4191H. The name is put in the FCB of file 0 (62FFH), the file is opened (@OPEN, it must exist) and killed (@KILL, 442CH), and file 0 is marked closed. TRSDOS 2.1's code.

63E3H - The Errors of Disk BASIC

Each entry loads Register E with the code of an error, 2 x (number - 1), and the others pass over it inside LD BC instructions; 19A2H gives the error, whose long message SYS7/SYS shows. 63FDH turns a DOS error code in Register A into one of these through the table 640BH, and keeps the DOS code at 5B29H for CMD"E". TRSDOS 2.1's code.

640BH - The DOS Error Codes as BASIC Errors

One byte for each DOS error code 01H-27H (its SYS4/SYS message): 72H Disk I/O error (58), 80H Bad file name (65), 88H Disk write protected (69), 66H Internal error (52), 6AH File not found (54), 8AH File access denied (70), 86H Too many files (68), 7AH Disk full (62). The last byte, at 6431H, is also the first byte of file 0's area (5C61H, 5C74H), which the start-up clears: it is for code 27H, which no DOS file gives. TRSDOS 2.1's table.