TRS-80 DOS - TRSDOS v2.3 for the Model I - BASIC/CMD Disassembled

BASIC/CMD

Other Navigation

TRSDOS v2.3 BASIC/CMD Disassembly - Disk BASIC (Model I)

BASIC/CMD is Radio Shack Disk BASIC version 2.2, the Disk BASIC of TRSDOS 2.3 (its copyright text, shown by CMD"#"#, names Microsoft, 1978). It does not hold a BASIC interpreter of its own: it extends the Level II BASIC in the ROM. At start-up it copies 49 jumps into the ROM's RAM vectors at 4152H-41E4H, so that the statements and functions the ROM leaves to Disk BASIC (OPEN, CLOSE, FIELD, GET, PUT, LSET, RSET, LOAD, SAVE, MERGE, KILL, CMD, DEF FN, DEF USR, LINE INPUT, CVI, MKI$, EOF, LOC, LOF, TIME$, INSTR, the &H and &O constants, MID$ on the left of =) come here, and so that the ROM's own PRINT, INPUT, LIST, its line input and character routines and its error messages can be turned to files.

The file is 5,120 bytes: 20 load records and a transfer record (5200H), then 16 bytes that are not part of the module (they repeat the bytes of 64A4H-64B3H). The records hold 5,020 bytes, 5200H-659BH: nineteen records of 256 bytes, whose length byte 02H means 256, and one of 156 bytes (6500H-659BH). There is no name record and no comment record. Every loaded byte is on one row, checked against S:\1\BASIC.CMD and its listing. RST 08H rows show the byte after the RST, which the ROM's syntax check compares with the next character of the program, as RST 08H => nnH.

Memory Map

How BASIC/CMD Joins the ROM

The ROM sets 4152H-41A5H to jumps to its L3 ERROR and 41A6H-41E4H to RET. BASIC/CMD's start-up (5C06H) saves the program start, the number of files and the start of string space, points SYS0/SYS's hook at 4313H to 5D4DH (so that the ROM's BREAK code 01H reaches BASIC), disarms the BREAK vector at 4315H, copies the ROM's 39 bytes of RAM routines to 4080H as the ROM does, moves the input buffer to 5D56H (40A7H) and copies the 49 jumps from 54C3H to 4152H. The table at 54C3H lists, for each jump, how the ROM reaches it and what it does. TRSDOS below version 2.2 (403EH) stops with USE TRSDOS 2.2 OR LATER.

BASIC followed by an asterisk keeps the program in memory and goes back to READY. Otherwise HOW MANY FILES? takes 0-15 (3 for ENTER), with V for record buffers, and MEM SIZE? the end of memory (the top of memory for ENTER); the file blocks are laid out from 659BH, the program starts after them, at least 300 bytes must be free and 50 bytes of string space are set aside. CMD"S" puts the hook at 4313H back and goes to DOS READY; CMD"A" goes to 4030H.

Disk Files

Each file has a block of 0122H bytes: byte 0 the mode (00H closed, 01H input, 02H output, 03H random), byte 1 the column for PRINT #, bytes 02H-21H the FCB, bytes 22H-121H the sector buffer; with V another 256 bytes follow, and a random file opened with a record length then has its sector buffer at byte 122H and its record buffer at byte 22H. The table at 5B8FH holds the block address of each file; file 0 is used by LOAD, RUN, MERGE, SAVE and KILL. The current file (5B8DH) is the one that PRINT #, INPUT #, LIST and the ROM's character routines use.

Sequential files are read and written a character at a time through the ROM's device routines (0013H, 001BH) with the FCB as the device control block. PRINT # keeps a column count in byte 1 for commas and TAB. INPUT # reads items ending at a comma or ENTER (numbers also at a space), strings in quotes up to the closing quote; LINE INPUT # reads a whole line. GET and PUT position the random file with 4442H and read or write one record with 4436H and 4439H; FIELD points string variables into the record buffer, and LSET and RSET fill them.

SAVE writes FFH and the tokenized program, or with A the program as text through LIST. LOAD and RUN read either form; a text file goes line by line through the ROM's command loop, with 59EAH and 5A30H taking the lines from the file. MERGE takes text files only. DOS errors become BASIC errors through the table at 6575H; CMD"E" shows the DOS text of the last one.

Statements and Functions

Notes from the Code

• LOC starts with CALL 6547H (62FEH), the Bad file mode error entry, so every LOC ends with that error; LOF, which shares its code from 6307H, works.
• OPEN tests whether a random file with a record length may use the second 256 bytes of its block by reading 0000H (64BBH), the ROM's first byte F3H, so the test never fails: without V the sector buffer then lies in the next file's block or past the last one.
• The protection clearing at 64FEH-6519H depends on 6520H, which is set from bit 1 of 430FH after RUN of a file (64DBH-64E1H); no TRSDOS 2.3 module sets that bit, so the memory is never cleared.
• LSET and RSET with string space short (62A0H) test flags popped at 62A0H, left by 29D7H at 621DH. When B$ was the newest temporary string whose text was the last allocated, 62ADH calls the ROM's 2884H, which is written to be jumped to: its POP HL takes the return address, and its RET goes to the address formed by Register Pair BC.
• NAME is accepted by the ROM's tables but BASIC/CMD gives ILLEGAL FUNCTION CALL for it (6544H).
• The texts for error codes 70H, 76H and 78H are only a question mark.
• CMD"I" runs the DOS command through 4405H, which ends at DOS READY, so the program is left; the bytes after 572EH run only if 4405H returns.
• CMD"T" stores RET at the interrupt vector 4012H: the next interrupt returns there with interrupts disabled, so the clock and the other interrupt work stop until CMD"R".
• When reading a line from a file (59EAH), bit 7 is cleared from the characters until one below 80H has been read; a line feed at the start of a line is skipped.
• The 255 bytes 5A78H-5B76H are not used; of the stand-in block at 5A77H only its mode byte matters.
• 5A71H stores Register A, as the caller of the ROM's 0358H left it, into 40A9H whenever 0358H is called by anything other than the wait for a key.
• The texts of the DOS error numbers go through the table at 6575H; numbers 27H and above count as 01H, and 5B8CH keeps 01H for them, so CMD"E" then shows the text of error 01H.

Variables and Changed Operands

5200H - Start Jump and the Error Messages

The transfer address of BASIC/CMD is 5200H: the jump to the start-up code at 5C06H. Then the texts of the error messages, each ending with 00H, in the order of the error codes: 57E6H takes the code from Register E, turns it into a count and skips that many texts from 5203H, then shows the text with the ROM. Codes 00H-2CH are the ROM's own errors, 2EH is the first one Disk BASIC adds, and 64H-8AH are the disk errors; any other code shows Unprintable error.

54C3H - The Link Table Copied into the ROM's RAM Vectors

49 jumps, copied as one block of 147 bytes to 4152H-41E4H by the LDIR at 5C5BH. 4152H-41A5H are the ROM's vectors for the Disk BASIC statements and functions: without Disk BASIC each one leads to the L3 error. 41A6H-41E4H are the links the ROM calls at fixed points of its own routines so that Disk BASIC can take over. The rows say where each jump lands in RAM, how the ROM reaches it, and where it goes in BASIC/CMD.

5556H - FN: Save the Value of a Parameter

Register Pair HL = the address of a parameter variable's value (from the ROM's 260DH), 40AFH = its type, the CARRY FLAG set. Before a user function is evaluated, the current value of each of its parameter variables is saved on the stack, so that the call can give them the argument values and put the old ones back afterwards (5604H). A number is pushed as one, two or four words of its value; a string's descriptor is copied into a new temporary string (ROM 2888H) instead. Then Register Pair HL (the address of the last byte saved) and Register Pair AF (the type flags) are pushed as well. 55BFH is the only entry, always with the CARRY FLAG set.

5582H - Find a Function Name

Register Pair HL = the text at the FN token. Checks the FN token and finds the variable that holds the function, named by the letters after FN with bit 7 set in the first letter, so that it can never be the same as an ordinary variable. Returns Register Pair DE = the address of its two-byte value (the address of the function's text after its name, stored by DEF), Register Pair HL past the name, and 40AFH = the function's type. Called by 558EH and 5659H.

558EH - FN: Call a User Function

The ROM jumps to 4155H, and from there here, when an expression holds FN. Finds the function; an undefined one gives error 2EH. When the definition has parameters, each parameter variable's value is saved (5556H) and then given the value of the matching argument in the call (ROM 1F2BH). The definition's expression is evaluated, the parameter variables get their old values back (5604H), and the result is converted to the function's type (ROM 281AH).

5604H - FN: Give the Parameters Their Old Values

Takes the entries 5556H pushed off the stack, last parameter first, and puts each value back: for a number the words go back into the variable, for a string the descriptor saved in the newest temporary string goes back into the variable and that temporary is released. The entry 5595H pushed ends the loop, and the result is converted to the function's type.

5655H - DEF: Define a Function or a USR Address

The ROM's statement table sends DEF to 415BH, and from there here. DEF USRn=address goes to 56ABH. DEF FN stores the address of the text after the function name into the function variable (it may not be typed as a direct statement), checks the names in the parameter list, and skips the rest of the statement with the ROM's DATA routine; the expression is only evaluated when the function is called.

5679H - USR: Call a Machine Language Routine

The ROM's USR function calls the link at 41A9H first (27FEH), and from there it comes here. The return address into the ROM is dropped: BASIC/CMD does the whole call. USR or USR0-USR9 picks one of ten addresses at 5B77H. The argument in parentheses is evaluated; the routine is entered with Register Pair HL = 4121H (the accumulator) and Register A = the argument's type, and its RET goes to the ROM's 26E7H, which puts the text pointer back into Register Pair HL.

5699H - Read the Number after USR

Register Pair HL = the text at the USR token. Takes an optional digit 0-9 after it. Returns Register Pair DE = 5B77H plus twice the digit, the slot of that USR address, and Register Pair HL = the text after the token or the digit.

56ABH - DEF USR: Set a USR Address

DEF USRn=expression stores the value, converted to an integer, into the slot of USRn. 5657H jumps here.

56BFH - PRINT: Is It PRINT # to a File?

The ROM calls the link at 41CAH at the start of PRINT (206FH) with Register A = the first character after PRINT and Register Pair HL at it. PRINT #-1 (the cassette) is left to the ROM. Anything else goes to 5EC5H with mode 02H, which returns at once when there is no # and otherwise checks that the file is open for output and makes it the current file for the characters PRINT sends.

56CBH - CMD: the Letter Commands

The ROM's statement table sends CMD to 4173H, and from there here. The argument is a string; its first character picks the command: D enters DEBUG, E shows the text of the last disk error, T stops the interrupts, R starts them again, S and A leave BASIC for DOS, # shows the copyright message and I runs a DOS command. Anything else, or an empty string, gives ILLEGAL FUNCTION CALL. Each command takes the text pointer, pushed at 56CEH, back off the stack before it returns.

5745H - TIME$: the Date and Time as a String

The ROM jumps to 4176H for the TIME$ token, and from there here. Builds a 17-character string MM/DD/YY HH:MM:SS from SYS0/SYS's clock bytes at 4046H down to 4041H (month, day, year, hours, minutes, seconds).

5776H - Two Digits

Register Pair DE = a clock byte (binary, 0-99), Register Pair HL = where to store. Stores it as two digit characters and moves Register Pair HL on by two and Register Pair DE back by one.

5786H - LINE INPUT

The ROM's statement table sends LINE to 41A3H, and from there here. LINE INPUT # reads from a file (5F4CH). Otherwise it is not allowed as a direct statement; it shows an optional prompt, reads a whole line from the keyboard (commas and quotes included) and assigns it to a string variable.

57B0H - End of PRINT: No Current File

The ROM calls the link at 41BEH at the end of PRINT (2174H) with Register A = 00H. Stores 0000H into 5B8DH, the current file: the characters go to the screen or printer again.

57B8H - INPUT: Is It INPUT # from a File?

The ROM calls the link at 41D6H at the start of INPUT (219EH) with Register A = the character after INPUT. Without # it returns. INPUT #-1 is left to the ROM. For a file number, the ROM's own INPUT start is dropped: 5EC3H checks that the file is open for input and makes it current, and the ROM goes on at 21EBH as if a line had been typed, with the input buffer pointer at the comma it stores there, so the items are read by 5F35H.

57D0H - INPUT # and LIST to a File

The ROM calls the link at 41DFH in INPUT after the items (2278H) and in LIST before each line (2B44H). Without a current file it returns. With one, the return address picks the case: in INPUT the ?EXTRA IGNORED message is skipped (2282H); in LIST the test for a key between lines (1D9BH) is skipped (2B4AH).

57E6H - Show an Error as Text

The ROM calls the link at 41A6H in its error handler (19ECH) with Register E = the error code. The ROM would show a two-letter code; BASIC/CMD drops that return and shows the error's text from 5203H instead. An error during the start-up questions (line number FFFEH) starts BASIC/CMD again at 5C06H. Otherwise 64F2H clears a protected program, and the ROM goes on at 1A11H, which adds IN and the line number and returns to READY.

5818H - CMD"#": the Copyright Message

CMD"#" must be followed by # and the end of the statement; it shows the copyright text at 582CH.

588BH - INSTR: Find One String in Another

The ROM jumps to 419DH for the INSTR token (2506H), and from there here. INSTR([n,]A$,B$) gives the position of B$ in A$, searching from position n (1 when it is left out; 0 gives ILLEGAL FUNCTION CALL). The result is 0 when n is past the end of A$, when A$ is empty or when B$ is not found, and n itself when B$ is empty. It returns through the ROM's 27F8H, which makes Register A an integer result, and 26E7H, which takes the text pointer back.

5913H - &H and &O: Hexadecimal and Octal Constants

The ROM jumps to 4194H when an expression holds an ampersand (24C8H), and from there here. &H takes up to four hexadecimal digits (a fifth gives OVERFLOW); &O, or & followed straight by digits, takes octal digits (8 or 9 gives a syntax error, more than 16 bits OVERFLOW). The value goes into the accumulator as an integer, and Register Pair HL is left at the character after the digits.

5969H - MID$ on the Left of =

The ROM jumps to 41D9H (2AECH) for a statement that starts with MID$, and from there here. MID$(A$,n[,m])=B$ puts the characters of B$ into A$ from position n, at most m of them, at most as many as B$ has, and never past the end of A$; the length of A$ does not change. A string that is not in string space (one assigned from a constant in the program text) is first copied there so that the program is not changed.

59DCH - The Optional Length in MID$

Register Pair HL = the text after the position, Register A = its character. Returns Register E = the length after a comma, or FFH when the closing parenthesis comes first; checks the closing parenthesis.

59EAH - Read a Line from the Current File

The ROM calls the link at 41AFH when it starts to read a line from the keyboard (0368H, inside 0361H). With no current file it returns. With one, the rest of the ROM's routine is dropped: up to 240 characters are read with 0384H (whose 0358H then takes them from the file through 5A30H) into the input buffer, a line feed at the very start of the line is skipped, the line ends at ENTER, and the routine returns to 0361H's caller as the ROM would. Until a character below 80H has been read, bit 7 is cleared from each character.

5A21H - Send a Character to the Current File

The ROM calls the link at 41C1H as it sends a character to the current device (032CH, with the character in Register C and the caller's Register Pair BC pushed at 032AH). With no current file it returns. With one, the ROM's output is dropped and the character goes into the file through 631CH.

5A30H - Take a Character from the Current File

The ROM calls the link at 41C4H as it reads the keyboard (0358H). Only a call from the ROM's wait for a key (0384H) is taken over, and only while a file is current: the character comes from the file (63C4H). At the end of the file the file is closed; after a LOAD with R the program is run, otherwise READY is shown and ENTER is given to end the line. Every other call stores Register A into 40A9H and goes on with the ROM's keyboard code.

5A77H - Variables, the USR Table and the File Table

Work bytes of Disk BASIC, all 00H in the file except the USR table. A file block is 0122H bytes: byte 0 the mode (00H closed, 01H input, 02H output, 03H random), byte 1 the print column, bytes 02H-21H the FCB given to the DOS, bytes 22H-121H the sector buffer; FILES with V adds 256 bytes for a record buffer. The blocks themselves lie after BASIC/CMD from 659BH (5CD0H).

5BB3H - End of SYSTEM Prompt: Nothing to Do

The ROM calls the link at 41E2H each time its SYSTEM command shows its prompt (02B2H). Disk BASIC does nothing there.

5BB4H - CMD"S" and CMD"A": Back to DOS

Puts SYS0/SYS's hook at 4313H back as it was before BASIC/CMD started (5C1CH), arms the BREAK vector at 4315H with the jump opcode, and leaves for DOS READY (CMD"S") or for the exit after an error at 4030H (CMD"A", with the CARRY FLAG set). The program in memory stays as it is.

5BC7H - PRINT Comma and TAB in a File

The ROM calls the link at 41D3H for a comma in PRINT (2108H) and for TAB (2141H). With a current file, the column is taken from byte 1 of its block instead of the screen, and the ROM goes on with its own computation: at 2130H for the comma (the next zone of 16 columns) or at 2156H for TAB.

5BDFH - Around the ROM's CLEAR after a Line Is Put In

The ROM calls the link at 41B5H after it has put a program line in (1AECH), then runs its CLEAR (1B5DH, which closes all files through 41BBH) and calls 41B8H (1AF2H). 5BDFH keeps the current file pointer in 40F3H and points file 0 at the closed stand-in block 5A77H; 5BEEH puts both back. So a file being loaded or merged line by line stays open while the lines go in.

5BFBH - After a Carriage Return in PRINT: Nothing to Do

The ROM calls the link at 41D0H after PRINT has sent a carriage return (2103H). Disk BASIC does nothing there.

5BFCH - PRINT a Number to a File

The ROM calls the link at 41CDH in PRINT after a number has been turned into text (20C6H). With a current file, the ROM's test whether the number still fits on the line is skipped: the text and the space after it are sent at once (20E9H).

5C06H - Start: Link Disk BASIC into the ROM

5200H jumps here after SYS0/SYS has loaded BASIC/CMD, with Register Pair HL at the command line after BASIC. Saves the ROM's program start, the number of files and the start of string space, puts its own hook at 4313H, copies the ROM's RAM routines to 4080H as the ROM does at start-up, moves the input buffer to 5D56H and copies the 49 links to 4152H. TRSDOS older than 2.2 (403EH below 22H) gets USE TRSDOS 2.2 OR LATER for ever. BASIC followed by an asterisk goes back to READY with the program already in memory; otherwise FILES and MEM SIZE are asked for.

5C9FH - Start: HOW MANY FILES and MEM SIZE

Asks HOW MANY FILES? ; ENTER alone gives 3, a number 0-15 is taken, and a V after the number adds a 256-byte record buffer to each file. Then sets up the file blocks from 659BH and puts the program after them. Then asks MEM SIZE? (ENTER alone: the top of memory, at most FFF8H); at least 300 bytes must be left for the program, and 50 bytes of string space are set aside. NEW, the banner and READY follow. A wrong answer asks again; a syntax error goes through 57E6H back to 5C06H, as the line number is FFFEH.

5CD0H - Set Up the File Blocks

Register A = the number of files. Makes Register A plus 1 blocks (file 0 and files 1 to Register A) of 0122H bytes from 659BH, 0222H with V, marks each closed and stores its address into the file table at 5B8FH. After an asterisk start it returns there; otherwise the program text starts after the last block and the MEM SIZE question follows.

5D4DH - Disk BASIC's Hook for RST 28H Codes Below 80H

SYS0/SYS's RST 28H code jumps through 4312H to here for a function code with bit 7 clear (4BA5H), having dropped the RST's return address. The ROM's keyboard routine passes 01H when BREAK is pressed (0456H): it is returned to the keyboard routine's caller as it is, so BASIC sees BREAK; SYS0/SYS's own hook (4BA0H) would return 00H. Any other code goes to the old hook, whose address 5C1FH stored at 5D51H.

5D53H - The Input Buffer and the Start-up Texts

5D53H-5D55H get a colon, 00H and a comma (5C44H-5C4EH), and 40A7H points to 5D56H: the ROM reads typed lines into 5D56H-5E55H, and 5E56H stays 00H. The three texts are used only at the start. 5EA3H-5EC2H holds a file name for 441CH.

5EC3H - # and a File Number for INPUT # and PRINT #

5EC3H is for input (mode 01H), 5EC5H takes the mode in Register C (02H from PRINT, 56C6H). Register A = the character at Register Pair HL. Without # it returns at once. Otherwise it reads the file number, checks that the file is open in that mode (Bad file mode, 6547H, if not), expects a comma after the number and makes the file current at 5B8DH.

5EDBH - Read a File Number and Find Its Block

Register Pair HL = the text at the file number, with or without #. 5EE5H takes the number from the accumulator instead, 5EE8H from Register A. A number above the number of files (408EH) gives Bad file number (654AH). Returns Register Pair BC = the file's block from the table at 5B8FH, Register A = its mode byte and the Z FLAG for a closed file; Register Pair HL is kept.

5EFFH - MKI$, MKS$ and MKD$

The ROM's function table sends MKI$ to 416AH, MKS$ to 416DH and MKD$ to 4170H, and from there to 5EFFH, 5F02H and 5F05H. The number in the accumulator is converted to an integer (2 bytes), single (4) or double (8) and its bytes become a string of that length, for a random file's field.

5F18H - CVI, CVS and CVD

The ROM's function table sends CVI to 4152H, CVS to 4158H and CVD to 415EH, and from there to 5F18H, 5F1BH and 5F1EH. The first 2, 4 or 8 bytes of the string argument become the value of an integer, single or double; a shorter string gives ILLEGAL FUNCTION CALL.

5F35H - INPUT #: Read One Item from the File

The ROM calls the link at 41DCH in READ and INPUT before it stores an item into a variable (222DH). With no current file it returns. With one, the ROM's own reading is dropped and the item comes from the file: a number ends at a comma, a space or ENTER, a string at a comma or ENTER, a string in quotes at the closing quote. The common reader at 5F60H also serves LINE INPUT #, which takes the whole line. The item is built in the input buffer and becomes a number (ROM 0E6CH) or a string (ROM 2868H).

5F4CH - LINE INPUT #

578EH jumps here for LINE INPUT #. The file must be open for input. A whole line, up to ENTER (commas, quotes and spaces kept, at most 255 characters), is stored into the string variable.

600EH - Give One Character Back to the File

Register Pair HL = byte 07H of the file's block, the FCB's byte position (FCB byte 05H). Steps it back by one. When it becomes 00H, bit 5 of the FCB's flags is set (read the buffer again before the next byte) and the next record number is stepped back. When it wraps to FFH, the file is moved back one record (4445H) and the position set to FFH.

6056H - Store a Character of the Item

Register A = the character, Register Pair HL = the place in the buffer, Register B = the room left. A 00H is not stored. When 255 characters are stored, the item ends at once (603DH).

6060H - Open File 0

6060H opens file 0 for input (LOAD, RUN, MERGE), 6062H with the mode in Register D (SAVE, 02H). It joins OPEN at 6474H with the file name at Register Pair HL.

6066H - RUN with a File Name, and LOAD

The ROM calls the link at 41C7H for RUN followed by something other than a line number (1EA6H); LOAD comes through 4188H to 606EH. File 0 is opened for input. NEW clears the old program; without R it also closes all files, with R the open files stay open (408EH is 0 during NEW). A file starting with FFH is a program saved in its tokenized form: it is read into memory from 40A4H and the ROM's CLEAR runs; RUN or R then starts it. Any other file is a program saved as text: its lines are read through the ROM's command loop (1A33H), and at the end 5A30H runs it or shows READY.

60EFH - End of LOAD, MERGE or SAVE: Close File 0

The ROM calls the link at 41ACH as it returns to READY (1A1CH); 5A51H calls here at the end of a LOAD or MERGE, and SAVE and MERGE jump here. Ends output to the cassette or printer (ROM 2169H, which also clears the current file), closes file 0, and at READY calls 64F2H. Returns with Register Pair HL = the text pointer from 40DFH (ROM 1BAFH).

6109H - MERGE

The ROM's statement table sends MERGE to 418BH, and from there here. Opens file 0 for input. A file saved in tokenized form (first byte FFH) gives Bad file mode; a text file's lines are read through the ROM's command loop and go in among the lines already there.

6133H - A Direct Statement Typed or Read

The ROM calls the link at 41B2H after a line has been tokenized (1AA1H), with the CARRY FLAG set for a line with a number. A line without a number read from a file gives Direct statement in file (84H). One typed at the keyboard is run after 64F2H.

6148H - SAVE

The ROM's statement table sends SAVE to 41A0H, and from there here. Opens file 0 for output. SAVE "name" writes FFH and the program text as it is in memory; SAVE "name",A sends the program through the ROM's LIST into the file as text (the rest of the statement goes to LIST as its line range). File 0 is closed at the end (60EFH, or READY for LIST).

6173H - CLOSE

The ROM's statement table sends CLOSE to 4185H, and from there here, with the Z FLAG set when nothing follows CLOSE. CLOSE alone closes every file from the number in 408EH down to 0; CLOSE n,m closes the files listed (# is allowed before each). Each file is closed by 62DDH, called through a RET with 618DH or 6185H as the return.

61A5H - Close All Files

The ROM calls the link at 41BBH from NEW (1B8CH, also part of its CLEAR) and from END (1DB0H). Closes files 0 to the number in 408EH through CLOSE with the Z FLAG set, and returns Register A = 00H with the Z FLAG set.

61AFH - FIELD

The ROM's statement table sends FIELD to 417CH, and from there here. FIELD #n, w AS A$, w AS B$ ... makes each string variable describe the next w bytes of the file's record buffer at block byte 22H on, without copying anything. The file must be open for random access (mode 03H). The widths together may not go past the record length (block byte 0BH, the FCB's record length; 00H means 256) nor past 256: FIELD overflow (655CH).

620AH - LSET and RSET

The ROM's statement table sends LSET to 4197H and RSET to 419AH, and from there to 620BH and 620AH. LSET A$=B$ or RSET A$=B$ copies B$ into the space A$ already has (normally a field), without changing A$'s length: LSET puts it at the left and fills the rest with spaces, RSET at the right with spaces before it; extra characters of B$ are left out. A string variable whose text lies inside the program (assigned from a constant) gets a copy in string space first, so that the program is not changed.

6296H - Store Spaces

Register C = the number of spaces, Register Pair DE = where. Stores the spaces and returns with Register Pair DE after them.

62A0H - LSET and RSET with String Space Short

624BH jumps here when string space may be too small for the copy of A$. The stack is set up again as 624EH expects, with A$'s address in place of B$'s descriptor (6258H fetches that descriptor again after the garbage collection), and 624EH takes the space. The flags tested at 62A5H are those of the Register Pair AF popped at 62A0H, pushed at 6226H: the flags 29D7H left at 621DH, the Z FLAG when B$ was the newest temporary string and its text the last string allocated. Only then do 62A8H-62B0H run, and their CALL 2884H goes wrong: 2884H is written to be jumped to with the text pointer on the stack, so its POP HL takes this CALL's return address and its RET goes to the address formed by Register Pair BC (the two lengths) pushed at 62A8H.

62B8H - EOF

The ROM's function table sends EOF to 4161H, and from there here. EOF(n) gives -1 at the end of file n and 0 otherwise: at the end means that the next record number (block bytes 0CH-0DH) equals the ending record number (bytes 0EH-0FH) and the byte position (byte 07H) equals the end-of-file byte (byte 0AH). When the record numbers differ, the differing byte of the ending record number is tested instead, which gives -1 only when that byte is 00H. A file open for output gives Bad file mode.

62DDH - Close the File in Register A

Register A = the file number. A closed file is left alone. A file open for input is only cleared; any other is marked closed and closed by the DOS (4428H), which writes its last sector and its directory entry. Then bytes 00H-21H of the block (mode, column, FCB) are cleared.

62FEH - LOC and LOF

The ROM's function table sends LOC to 4164H and LOF to 4167H, and from there to 62FEH and 630FH. LOF(n) gives the ending record number of file n (block bytes 0EH-0FH). LOC was meant to give the next record number (bytes 0CH-0DH), but its first instruction calls 6547H, which gives Bad file mode at once, so LOC always ends with that error; 6301H-630EH are reached only from LOF.

631BH - Put a Character into the Current File

Register A = the character; the current file is at 5B8DH. A file open for input takes nothing (ROM 1DFDH). Otherwise byte 1 of the block counts the column (ENTER sets it to 0, characters 20H and above add 1) and the character goes to the DOS through the ROM's output (001BH) with the FCB as the device. A DOS error with the FCB open (bit 7) becomes a BASIC error.

6354H - GET and PUT

The ROM's statement table sends GET to 417FH and PUT to 4182H, and from there to 6355H and 6354H. GET #n[,r] reads record r (the next record when r is left out) of a random file into its buffer; PUT #n[,r] writes the buffer as record r. Record 0 gives Bad record number. A GET beyond the end of the file fills the buffer with 00H; a PUT beyond the end writes the record, which makes the file longer.

63C4H - Read a Character from the Current File

Returns Register A = the next character of the current file, the CARRY FLAG set at the end of the file (DOS error 1CH); any other DOS error becomes a BASIC error. The character comes through the ROM's input (0013H) with the FCB as the device. When bit 7 of the FCB's first byte is clear (not an open file), an empty result is read again until a character comes. Register Pairs BC, DE and HL are kept.

63EDH - Put a File Name into the FCB

Register Pair HL = the text at the name, Register Pair BC = the file's block. The name is evaluated as a string, which must have 1 to 22 characters, copied in capitals to 5EA3H with a 00H after it, and read by SYS0/SYS's 441CH into the FCB at block byte 02H. A bad name gives Bad file name (6556H). Returns Register Pair BC = the block and Register Pair HL = the text after the name.

6434H - OPEN

The ROM's statement table sends OPEN to 4179H, and from there here. OPEN "O"|"I"|"R", [#]n, "name" [,record length]: the first letter of the mode string picks output (02H), input (01H) or random (03H); file 0 cannot be opened this way. A file already open gives File already open. LOAD, RUN, MERGE, SAVE and KILL enter at 6474H for file 0 with the mode in Register D. The file is opened (4424H for input) or opened or created (4420H) with the buffer at block byte 22H; a random file with a record length uses the second 256 bytes of the block as its sector buffer. The mode is stored in byte 0 of the block and the column cleared.

64F2H - Clear a Protected Program

Called at READY (60FDH), before a direct statement (6142H) and after an error message (5812H). Clears 651FH. When 6520H is not 00H (set at 64E1H after RUN of a protected file), 1100 bytes from the program start are cleared, NEW is done, PROTECTION HAS CLEARED MEMORY is shown and BASIC returns to READY. In TRSDOS 2.3, 6520H always becomes 00H (see 64E0H), so the clearing never happens.

6521H - KILL

The ROM's statement table sends KILL to 4191H, and from there here. KILL "name" puts the name into the FCB of file 0, opens the file (4424H) and kills it (442CH); file 0 is marked closed again.

6544H - NAME

The ROM's statement table sends NAME to 418EH, and from there here. NAME is not done by this Disk BASIC: it gives ILLEGAL FUNCTION CALL.

6547H - The Disk BASIC Error Entries

Each entry loads Register E with an error code and goes to the ROM's error handler (19A2H); the bytes in between are LD BC,nn instructions that only skip the LD E of the next entry. 6547H Bad file mode, 654AH Bad file number, 654DH Internal error, 6550H Input past end, 6553H File already open, 6556H Bad file name, 6559H Bad record number, 655CH FIELD overflow.

6561H - Turn a DOS Error into a BASIC Error

Register A = the DOS error number from a SYS0/SYS call. Numbers 27H and above count as 01H. The number is kept at 5B8CH for CMD"E", and the table at 6575H gives the BASIC error code for the ROM's error handler.

6575H - The DOS Error Table

One byte for each DOS error number 01H-26H, read by 656EH: the BASIC error code shown for it.