DOSPLUS 3.5 for the Model III - BASIC/CMD Disassembled

BASIC/CMD

Other Navigation

DOSPLUS 3.5 BASIC/CMD Disassembly - Extended Disk BASIC 1.7 (Model III)

BASIC/CMD is DOSPLUS 3.5's Extended Disk BASIC, version 1.7: the disk extension of the Model III's Level II ROM BASIC. It loads at 5200H-6DE1H (4821 bytes, transfer address 5200H), in the area the DOS keeps for its command overlays. A DOS library command used from BASIC through CMD"command" loads over part of that area, so the resident high overlay is read again afterwards. BASIC/CMD is a load module whose first block, at 5C00H, loads before the start-up block at 5200H, so the blocks are not in address order.

The Model III and Model IIIII files are the same length and differ in only eleven bytes, all of them ROM entry points that differ between the two machines (the NMI vector read by the start-up, the error vector stored for the BREAK key, SFLAG1$, and the ROM's multiply and divide and CKEOF entry addresses). The DOSPLUS code is identical; the Model IIIII page is this page with those addresses changed.

The Parts of BASIC/CMD

The Disk BASIC Links

The start-up (5200H) copies 49 three-byte jumps into the ROM's hook table at 4152H-41E4H, where the Level II ROM calls or jumps to the Disk BASIC functions and statements. Each link row at 532AH names the address it becomes. Through these links the ROM reaches CVI/CVS/CVD, FN, EOF, LOC, LOF, MKI$/MKS$/MKD$, CMD, TIME$, OPEN, FIELD, GET, PUT, CLOSE, LOAD, MERGE, NAME (labels), KILL, &H, LSET, RSET, INSTR, SAVE, LINE INPUT, USR, and the output, keyboard and PRINT/INPUT hooks that redirect I/O to a file.

Files

Every file operation goes through SYS0/SYS's entry points (OPEN@, INIT@, CLOSE@, KILL@, READ@, WRITE@, POSN@, REW@, BKSP@, PEOF@, CKEOF@) by way of the helpers at 6B92H on, which take the file's area as an Index Register. A file area (one per file, 0 to 15, and one more, area 0, for LOAD, RUN, SAVE, MERGE and KILL) is 0222H bytes from 6DE1H: a mode byte, a column byte, a 32-byte file control block and two 256-byte buffers. OPEN's mode letter is I (input), O (output), E (append), or R or D (random). A DOS error from any entry point is mapped to a Disk BASIC error code by the table at 6CB6H.

Program Files

A BASIC program is saved compressed (tokenized, the file beginning with FFH) or as ASCII (SAVE"file",A). The compressed loader (6723H) makes room by moving the variable tables and reads the program in record by record; an ASCII program is read line by line through the line-input link, as though typed. LOAD,V verifies a compressed file. A program loaded under an access level of 6 or 7 may not be listed or saved: at READY it is wiped and the message RUN access only is shown (6C47H).

Differences from the Manual

These are stated from the bytes. CMD"R" and CMD"T" (5C83H) turn the interrupts on and off by storing the opcode JP or RET at the RST 38H vector 4012H. The shorthand (63D1H) expands a letter to a token only when it stands alone as a statement's word with no = in the statement; L followed by a quotation mark becomes LOAD, otherwise LIST. DI and DU (6441H) work only in a direct line. OPEN of a random file (6ABCH) parses a record-length argument but does not store it in the file control block, which keeps the length the file was created with (6B29H). MERGE (684AH) requires an ASCII program and gives Bad file mode for a compressed one. LOAD,V of an ASCII program gives Bad file mode (verify applies only to a compressed file).

The variables are in BASIC/CMD's own area 62F5H-631DH, which the start-up and the file routines read and write; the program, its variables and the string space lie above the file areas, which start at 6DE1H.

5200H - Start-up

BASIC/CMD's transfer address. Entered from the DOS with Register Pair HL at the rest of the command line after BASIC. The start-up runs once in the area 5200H-5418H, which later serves the DOS overlays and ERROR/OVL. It puts the stack at 4288H, sends RST 10H to 64E2H, puts 5CD6H into the vector at 4203H-4205H and copies the 49 Disk BASIC links (532AH) to 4152H-41E4H. A command line starting with * is the re-entry BASIC * (52EBH). Otherwise it copies the ROM's RAM table to 4080H, takes the file specification and the options -F:nn (files, 0-15) and -M:nnnnn (top of memory), sets up the file areas (52F5H), the program start and the top of memory, clears the program (NEW), and either shows the heading and goes to READY, or loads and runs the program named.

52F5H - The File Areas

Builds the table 62FEH of the addresses of the file areas: one area for each file (62FAH) and one more, area 0, that LOAD, RUN, SAVE, MERGE and KILL use. The areas are 0222H bytes each from 6DE1H: the mode byte, the column byte, the file control block (32 bytes) and two buffers of 256 bytes. With the C FLAG clear the first byte of each area is set to 00H (closed). Register Pair HL returns the end of the last area, where the program starts.

5314H - The Value of an Option

Takes :nnnnn after the letter of an option: the number goes to Register Pair DE. Returns the Z FLAG when a - follows (another option), the NZ FLAG at the end of the command line or at ;. Anything else is a syntax error.

532AH - The Disk BASIC Links

Data: the 49 jumps that the start-up copies to 4152H-41E4H, where the ROM calls or jumps to the Disk BASIC functions, statements and hooks. Each row names the link it becomes.

53BDH - The Heading

Data: the heading that the start-up shows when no program is named (52E2H).

5C00H - The Error Hook

Link 41A6H, called by the ROM's error routine with Register E = the error's offset (the ERR value). 62F5H decides: bit 0 clear (no ERROR/OVL) returns with Register A = 00H, and an offset of 63H or more (a disk error) becomes 26H, so that the ROM shows the two letter code UE of its own table. Bit 0 set pushes ERROR/OVL's entry (62F8H-62F9H) and returns into it, which shows the long message; when bit 1 is set too, ERROR/OVL is first loaded into the overlay area 5200H with LOAD@, through the file control block of file area 0, and 62F5H becomes 01H (loaded) or 00H (not on the diskette: the short messages from then on). 62F5H is 03H in the file, and CMD" sets bit 1 again (5CC5H), because a library command loads over ERROR/OVL.

5C48H - CMD

Link 4173H, the statement CMD, with Register Pair HL at the text after it and the Z FLAG at the end of the statement. CMD alone goes back to the DOS through EXIT@. Otherwise the expression must be a string: one character is an option, I (a second string as the command), D (DEBUG@), E (the last DOS error with ERROR@), T (interrupts off), R (interrupts on), M (CMD"M", the simple variables) or S (the DOS); any other single character, and every longer string, is a DOS command. The command (up to 63 characters) is copied into file area 0 with 03H after it, ABORT@ is pointed to 5CD6H so that an error of the command comes back to BASIC, and CMNDI@ runs it; the statement then goes on.

5CD6H - Back to READY

ABORT@ (4030H, set at 5CCDH) and the vector at 4203H-4205H (5210H) come here. The ROM's 19AEH resets the stack and the BASIC pointers and goes on at 1A18H, which falls into READY.

5CDCH - CMD"M"

Shows every simple variable from VARTAB (40F9H) to ARYTAB (40FBH): the name in four columns with its type character ($, % or #; none for single precision), " = " and the value, one a line; names with bit 7 set (user functions) are passed over. With ,P the output goes to the printer (409CH = 01H). The current line becomes FFFFH (direct mode); the ROM's 1D9BH lets SHIFT @ pause and BREAK stop the list, and the end is READY.

5D71H - Output and Count

Outputs the character in Register A to the selected device (the ROM's 032AH) and decrements Register B: the Z FLAG when the count reaches zero.

5D76H - TIME$

Link 4176H, the function TIME$: a new string of 17 characters, the date MM/DD/YY from GTDATE@, a space, and the time HH:MM:SS from GTTIME@.

5D8CH - DEF

Link 415BH, the statement DEF, with Register A = the token after it. DEFUSRn=address (C1H, the token of USR) stores the address into the table 5DBEH. DEF FN stores the address of the definition's text into the value of the function's entry, a variable whose name has bit 7 set; a definition is allowed only in a program line (the ROM's 2828H), and its parameter list is only checked here, then the rest of the line is passed over as DATA is.

5DBEH - The USR Table

Data: the addresses of USR0-USR9, set by DEFUSRn. Each starts as 1E4AH, the ROM's Illegal function call error, so a USR that was not defined gives that error.

5DD2H - Save a Parameter

Part of FN (5E37H): saves the value of a parameter variable before FN gives it the argument. Register Pair HL is the variable's value, 40AFH its type. A string's descriptor is copied into the ROM's pool of temporary strings (2888H); a number's value is pushed, one word for an integer, two for single and four for double precision. Then the variable's address and Register Pair AF (Register A = the type less 3, with its flags and the C FLAG set; 00H and the Z FLAG for a string) are pushed for the restore at 5E7BH. FN always comes here with the C FLAG set, so 5DEDH and the jump to 2423H are not reached.

5DFBH - Find a Function

Checks the token of FN at Register Pair HL and finds the function's entry with the ROM's variable search, its name's first character with bit 7 set (so it is apart from the variable of that name) and no subscripts (40DCH = 80H): Register Pair DE returns the address of its value.

5E07H - FN

Link 4155H, a call of a function defined by DEF FN. The function's entry gives the address of its definition (none: Undefined user function, 5EFEH). With parameters, each parameter variable's value is saved (5DD2H) and the arguments are assigned to them one by one (the ROM's 1F2BH, as LET); the definition's expression is evaluated, and the saved values are put back (5E7BH). A string result is moved to 40D3H first, so it survives the restore. The result is converted to the function's own type (the ROM's 281AH), which returns with Register Pair HL at the text after the call.

5ECCH - USR

Link 41A9H, the function USR. The ROM's return is dropped and the argument in parentheses is evaluated. The routine of the USR table (5DBEH) is entered by RET with Register A = the argument's type (02H, 03H, 04H or 08H), Register Pair HL = 4121H (the accumulator) and Register Pair DE = the string's descriptor for a string; it returns to the ROM's 26E7H, which restores the text pointer.

5EECH - The USR Number

Takes the digit after USR (none is USR0): Register Pair DE returns the address of its entry in the table 5DBEH, Register Pair HL the text after it.

5F03H - INSTR

Link 419DH, the function INSTR([n,]a$,b$): the position of b$ in a$, 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 a$, when a$ is empty or when b$ is not found; an empty b$ gives n. The routine returns Register A to the ROM's 27F8H, which makes it the integer result, and then to 26E7H, which restores the text pointer.

5F8BH - MID$ =

Link 41D9H, MID$(v$,n[,m])=x$ on the left of an assignment, entered by the ROM's jump at 2AECH. A string whose characters are still in the program text is first copied into the string space, so that the program is not changed. Characters of x$ replace those of v$ from n, at most m (255 when m is not given), at most the rest of v$ and at most the length of x$; the length of v$ never changes. n = 0 or past the end of v$ is Illegal function call.

5FFCH - The Length of MID$ =

Takes the optional ,m and the ) of MID$(v$,n,m): Register E returns m, or FFH when the ) follows n.

600AH - &H

Link 4194H, a constant &Hnnnn (the H may be left out): up to four hexadecimal digits 0-9 and A-F, upper case, form an integer in the accumulator. A fifth digit is Overflow; the first other character ends the number.

603EH - PRINT #

Link 41CAH, called by the ROM's PRINT (206FH) with Register Pair HL at the #. PRINT #-1 is the ROM's cassette and is left to it. Otherwise the file number is evaluated (656FH): the file must be open for output (mode 02H, else Bad file mode), a comma must follow, and the file's area becomes the current one (62FCH), to which the output link 41C1H sends PRINT's characters.

604AH - INPUT # and INPUT @

Link 41D6H, called by the ROM's INPUT (219EH) with Register A = the character after INPUT. INPUT @pos,["prompt",]len,"format";v$ (6064H) is the controlled input of a field. INPUT #-1 is the ROM's cassette. INPUT #n reads its line from a file open for input (656DH): the ROM's return is dropped and the items are taken by the ROM's INPUT code from 21EBH on, which gets them through the link 41DCH (65E9H).

60CAH - LINE INPUT

Link 41A3H, the statement LINE, which must be LINE INPUT (the token 89H). It is not allowed in the direct mode. LINE INPUT # goes to 65FDH. Otherwise the ROM's 21CDH shows a quoted prompt, the line is taken from the keyboard by the ROM's 0361H (INPUT @ takes its field with 6101H instead, 60C8H), and the whole line, without any change, is assigned to the string variable (the ROM's 1F32H). BREAK goes to the ROM's 1DBEH.

6101H - The INPUT @ Field

Takes the field of INPUT @ (6128H) into the input buffer, ended by 00H. When nothing was typed, the key that ended the field is put in the buffer before the 00H. The ROM's cursor column (40A6H) is set from the cursor address. Returns Register Pair HL at the byte before the buffer, Register A the key that ended the field and the C FLAG for BREAK.

6128H - The Field Editor

The field of Register B characters is shown as underscores at the cursor, and the cursor is put back to its start. Keys are taken by the ROM's 0049H with the cursor shown. A printable key is stored and shown while the field has room; in a numeric field (bit 0 of the flags) only the digits and . + - are taken. A full field ends by itself when the format had the asterisk (bit 1), else it waits for a control key. ENTER and CLEAR end the field, BREAK ends it with the C FLAG, the left arrow (08H) takes back one character and SHIFT left arrow (18H) all of them; the other control keys are ignored. At the end a carriage return follows the text in the buffer and the rest of the field is cleared with spaces. Returns Register B = the characters typed and Register A = the key that ended the field.

61C2H - Cursor Left

Sends 18H, the display driver's cursor left. Before it, 61D9H moves the cursor address 4020H up a line when it is at the start of a line; in the 32 character mode (bit 3 of 403DH, which the ROM's display driver also tests) the address one place before is tested the same way.

61E5H - The End of INPUT and of a Listed Line

Link 41DFH, called by the ROM at 2278H (the end of INPUT) and at 2B44H (each line of LIST). With no current file it returns. With a file the ROM's return is dropped: INPUT # goes to 2282H, past the ROM's Extra ignored test; LIST to a file (SAVE ,A) goes to 2B4AH, past the ROM's BREAK and SHIFT @ test.

61FBH - The Line Input Link

Link 41AFH, the ROM's line input at 0368H. With no current file it goes to 631EH, BASIC's own line input with its editing keys. With a file (LOAD and MERGE of a program saved in ASCII) the ROM's return is dropped and a line of up to 255 characters is read into the input buffer through the ROM's 0384H, which gets the bytes from the file through the keyboard link (623DH); a line feed at the start of a line is passed over, the carriage return ends the line and 00H is put after it.

622AH - The Output Link

Link 41C1H, the ROM's output of a byte (032CH) with the byte in Register C. With no current file it returns and the ROM sends the byte to its device. With a file (PRINT # or SAVE ,A) the ROM's return is dropped, Register Pair BC (saved by the ROM's 032AH) is restored, and 6BA4H writes the byte to the file, returning to the ROM's caller.

623DH - The Keyboard Link

Link 41C4H, the ROM's keyboard scan at 0358H. The ROM's return is dropped and the caller is told by its return address. For INKEY$ (01A8H) the keyboard is scanned. For the ROM's wait for a key (0387H) with a current file, the next byte of the file is returned (6B92H); at the end of the file (an ASCII program loaded) file area 0 is closed, and BASIC either RUNs the program (the run flag 62F7H) or shows READY and returns a carriage return. Any other scan (the ROM's BREAK tests) gives no key while a DO file runs (bit 5 of SFLAG1$), so the DO file's bytes are not taken by them.

6290H - SYSTEM

Link 41E2H, called by the ROM's SYSTEM (02B2H) before its prompt. The stack is put back to 4288H, the prompt (an asterisk and the ROM's question mark) is shown and a line is taken by the ROM's 1BB3H. A line goes to the ROM's SYSTEM at 02C6H; BREAK goes back to BASIC's READY (5CD6H).

62A4H - Comma and TAB

Link 41D3H, called by the ROM's PRINT for a comma (2108H) and for TAB (2141H). With a current file the file area's column byte (+01H) takes the place of the device's position: the comma goes on at the ROM's 2130H and TAB at 2156H. Without a file the comma goes back to 210BH; TAB to the printer (409CH = 01H) evaluates its argument again from the TAB( token, so that the ROM's AND 7FH is left out and the printer can be tabbed up to 255; TAB elsewhere goes back to 2144H.

62D5H - The Current File

Four links that keep the current file area (62FCH-62FDH): 41BEH (the end of PRINT, the ROM's 2174H after it set Register A to 00H) ends it; 41B5H (1AECH) saves it into 40F3H-40F4H over the ROM's 1B5DH when a program line is entered, and 41B8H (1AF2H) restores it; 41CDH (20C6H) sends a number to a file without the ROM's test of the line's room (20E9H).

62F4H - The Variables

Link 41D0H (the ROM's 2103H, after PRINT's carriage return) is a RET. Then BASIC's variables: 62F5H-62F7H are loaded, 62F8H-631DH are not.

631EH - BASIC's Line Input

Reached from the line input link (6202H) when no file is current. The ROM's return into its own line input (036BH) is dropped; when the caller is not BASIC's command level (its return address 1A7EH) the ROM's line input is entered at 036BH. At the command level the first key is read here: a key that lists or edits a line acts at once (the current line is 40ECH), any other key goes into the ROM's line input at 05E3H as its first character.

63D1H - Shorthand, DI and DU

Called by the link 41B2H (6877H) after a typed line has been tokenized, with the C FLAG for a program line. In each statement a letter that stands alone as the statement's word, with no = in the statement, becomes the token of the table 6484H (L followed by a quotation mark becomes LOAD). D alone in the first statement of a direct line followed by I or U is DI or DU (6441H). Quoted strings are passed over, and nothing after REM is changed.

6433H - The Next Character

RST 10H, then a quoted string is passed over to its closing quotation mark: returns the Z FLAG at the end of the statement (or of the line inside a string).

6441H - DI and DU

DI old,new and DU old,new in the direct mode. The text of line old is copied after a line number word in front of the input buffer, as a tokenized line; DI then deletes line old (the ROM's 2BE4H and 1AF8H). The ROM's 1AA7H then puts the copy into the program as line new. Line old must exist (Undefined line number).

6484H - The Shorthand Table

Data: pairs of a letter and the token it becomes when it stands alone as a statement's word, ended by 00H.

6499H - TRON

The RST 10H hook (64E2H) comes here when RST 10H was not called by the ROM's line number scan. Unless the call is the statement dispatcher's (return address 1D5BH) with TRON on (411BH not 00H), the ROM's RST 10H (1D78H) is done. With TRON, the statement about to run is shown (64CDH) and a key is awaited: BREAK stops the program through the ROM's 1DB7H, any other key lets the statement run.

64C2H - Show a Line

64C2H shows the line number in Register Pair DE and a space, then 64CDH expands the tokenized text at Register Pair HL into file area 0's file control block and buffer (256 bytes, ended by 00H) with the ROM's LIST code (2B85H), shows it (2B75H) and starts a new line.

64E2H - The RST 10H Hook

The RST 10H vector (4003H, set at 520AH) comes here. A call from anywhere but the ROM's line number scan (its RST 10H at 1E5EH, return 1E5FH) goes to 6499H (TRON, else the ROM's 1D78H). For the line number scan the ROM's scan is replaced, and its own return is dropped, so this code returns to the scan's caller with Register Pair DE = the line number: callers below 1B0FH take digits only (6515H); the others take digits, or a label: the name of a line that starts with NAME (64FBH, 651BH).

656AH - NAME

Link 418EH, the statement NAME that puts a label on its line: when it runs, the rest of the statement is passed over as by DATA.

656DH - The File Number

656DH (mode 01H, input) and 656FH (mode in Register C) take #n, followed by a comma, at Register Pair HL: the file must be open in that mode (else Bad file mode), and its area becomes the current file (62FCH). Without # they return at once. 6582H evaluates the file number: 0 is Bad record number (6C95H), above the number of files Bad file number (6593H). 6593H: Register A = a file number; returns Index Register IX = its area, Register Pair DE = the area's file control block (+02H), Register A = the mode byte and the Z FLAG when the file is closed.

65B3H - MKI$, MKS$ and MKD$

Links 416AH (65B3H, MKI$: 2 bytes), 416DH (65B6H, MKS$: 4 bytes) and 4170H (65B9H, MKD$: 8 bytes). The number is converted to that type (the ROM's 2819H) and its bytes become a new string.

65CCH - CVI, CVS and CVD

Links 4152H (65CCH, CVI), 4158H (65CFH, CVS) and 415EH (65D2H, CVD): the first 2, 4 or 8 bytes of the string become the value of that type. A shorter string is Illegal function call.

65E9H - INPUT # Items and LINE INPUT #

65E9H is the link 41DCH, called by the ROM's INPUT for each item (222DH). With no current file it returns. With a file the ROM's return is dropped and the item is read from the file into the input buffer (6610H) with the flags in Register D: bit 0 pass over leading spaces, bit 1 a number (a space or a comma ends it), bit 2 a string may be quoted, bit 3 inside the quotes. A number is converted by the ROM's 0E6CH, a string becomes a temporary string (2868H). The item then goes back into the ROM's INPUT at 2243H. LINE INPUT # (65FDH) reads everything up to the carriage return (Register D = 00H) and assigns it through the ROM's 1F31H. A carriage return or the end of the file ends an item; an item of 255 characters ends there. Reading the first byte past the end of the file is Input past end.

66B2H - RUN and LOAD

Link 41C7H (66B2H, RUN with a file name or a line number, from the ROM's 1EA6H) and link 4188H (66B5H, LOAD). RUN of a line number returns to the ROM. Otherwise the file is opened as area 0 for input; ,R sets the run flag and ,V the verify flag (62F7H, 66F1H), or a line number after a comma becomes the line RUN starts at (40F3H). Unless verify, the program is cleared (the ROM's NEW) first. A file whose first byte is not FFH is an ASCII program: it is left open and the command level reads it line by line through the line input link. A compressed program (first byte FFH) is loaded by 6723H. Then, for RUN, the program is run from the line in 40F3H.

6723H - The Compressed Loader

A compressed program's records hold the program text. The program's length is the file's size (the sector count in the file control block and the bytes in the last sector); it must fit below the start of the string space and below the top of memory (else Out of memory). The variable tables (VARTAB, ARYTAB, STREND) are moved up or down by that length to make room, their string pointers adjusted (67D1H), then the program bytes are read record by record into the text area. The links are rebuilt (the ROM's 1AF8H), the pointers reset and the stack reinitialized.

67D1H - Move the String Pointers

Walks the simple variables and then the arrays; for each string whose characters are in the program text (below the start of the variables and above the top of the string space), the ROM's 2843H copies the string into the string space, so it survives the move of the program. Used before the compressed loader moves the variable tables.

6826H - The READY Link

Link 41ACH, called by the ROM's 1A1CH just before the READY prompt. File area 0 is closed (683AH), the output is reset (the ROM's 2169H), and when the call is the ROM's READY (its 1A1FH follows) a protected program (62FBH) is wiped (6C47H), then the ROM's 1BAFH restores its text pointer and goes on.

683AH - Close a File Area

Closes the file area whose number is in Register A (0 for area 0). CLOSE@ is called only for a file open for output; the area's mode byte is then set to 00H. An error from CLOSE@ is posted.

684AH - MERGE

Link 418BH, the statement MERGE. The file is opened as area 0 for input; ,R sets the run flag. The file must be an ASCII program (first byte not FFH, else Bad file mode); it is rewound and the command level reads its lines, which are added to the program in memory.

6877H - Direct Statement in a File

Link 41B2H, called after a line read from a file was tokenized. The shorthand and DI/DU are expanded (63D1H); a line with a number is a program line, kept. A direct statement from a file (no line number) is run at once by the ROM's dispatcher, unless there is still a current file, when it is Direct statement in file.

688BH - SAVE

Link 41A0H, the statement SAVE. The file is opened as area 0 for output; ,A saves the program as ASCII, else it is saved compressed. For a compressed save the program text (TXTTAB to VARTAB) is written as records headed by FFH and ended by three 00H; the file control block's sector count is set from the length. For an ASCII save the program is listed to the file through the output link (the ROM's LIST).

68D9H - CLOSE

Link 4185H, the statement CLOSE. CLOSE alone closes every file (683AH for each). CLOSE #n closes those files: the file number is evaluated, its area closed, and more follow after a comma.

68FFH - Close All Files

Link 41BBH, called by the ROM's NEW and END. Every file is closed (68D9H with no #n) and Register A returns 00H.

6909H - FIELD

Link 417CH, the statement FIELD n,w AS v$,... Each width w names a part of the file's buffer: the string variable v$ is given a descriptor whose length is w and whose address is the next free place in the buffer. The widths must not run past the buffer (256 bytes), else Field overflow. The file must be open (Bad file mode when closed).

6959H - LSET and RSET

Links 4197H (695AH, LSET) and 419AH (6959H, RSET). The string value is placed into the buffer field named by the variable: LSET at its left, RSET at its right, the rest filled with spaces, cut to the field's width. A value still in the program text is copied into the string space first. The C FLAG tells RSET (6959H sets it clear through OR 37H, then 695AH, LSET, sets it with SCF) from LSET.

69FBH - EOF

Link 4161H, the function EOF(n): true (-1) at the end of the file, false (0) before it. The file must be open and not for output (Bad file mode). CKEOF@ (4457H) gives the answer.

6A10H - LOC

Link 4164H, the function LOC(n): the number of the record last read or written. The file's position (file control block) gives it (6C11H).

6A1DH - LOF

Link 4167H, the function LOF(n): the number of records in the file. The file control block's sector count gives it (6C1FH).

6A29H - GET and PUT

Links 417FH (6A2AH, GET) and 4182H (6A29H, PUT). The record is read into the buffer (GET) or the buffer is written (PUT); with an optional record number the file is positioned there first (POSN@). Only a random file (mode 03H) is allowed. PUT of a record past the end fills the new records with 00H.

6A8CH - Take a File Field

Evaluates the next string at Register Pair HL as a file specification (empty: Bad file name; over 24 characters: Bad file name) and copies it into the file control block at Register Pair DE with 03H after it.

6AACH - Copy a File Specification

Copies the file specification at Register Pair HL (length in Register C) into the file control block at Register Pair DE, with 03H after it, so CMNDI@ and the file routines can read it. A device name (@ first) is Bad file name.

6ABCH - OPEN

Link 4179H, the statement OPEN "mode",n,"file"[,reclen]. The mode letter is I (input, 01H), O (output, 02H), E (append/extend, 04H), R or D (random, 03H); any other is Bad file mode. The file is opened as area n: input by OPEN@, output and random by INIT@ (open or create); E then positions at the end (PEOF@). A random file may give a record length. A file already open in area n is File already open.

6B7AH - KILL

Link 4191H, the statement KILL "file": the file is opened as area 0, then deleted by KILL@, and the area is marked closed.

6B92H - Read a Byte from the File

Reads the next byte of the file of Index Register IX into Register A through the ROM's GET@ (0013H): the Z FLAG for a byte, the C FLAG at the end of the file (error 1CH), any other error posted.

6BA4H - Write a Byte to the File

Writes the byte in Register A to the file of Index Register IX through the ROM's PUT@ (001BH). The column (Index Register IX+01H) counts the characters on the line: it is cleared by a carriage return and otherwise increased so that it stays below 256.

6BCDH - Rewind the File

Rewinds the file of Index Register IX to its first record through REW@ (443FH).

6BD9H - Back Up a Record

Decrements the record count of the write (Index Register IX+07H) and, when it reaches zero, backs the file up one record through BKSP@ (4445H): used while reading the items of INPUT # from a file.

6BEDH - Read a Record

Reads the next record (sector) of the file of Index Register IX into its buffer through READ@ (4436H): Register Pair HL returns the buffer (6BF8H).

6BFFH - Write a Record

Writes the file's buffer as the next record through WRITE@ (4439H): Register Pair DE returns the buffer (6C0AH).

6C11H - The Record Last Accessed

Works out the number of the record last read or written, for LOC: the record is the position's sector times the record length plus the byte offset in it, plus 1. The position is at Index Register IX+0CH-0DH (the file control block's current sector) and the record length at Index Register IX+07H.

6C1FH - The Number of Records

Works out the number of records in the file, for LOF: the file's last sector (Index Register IX+0EH-0FH) times the record length plus the bytes in the last sector (Index Register IX+0AH).

6C47H - Wipe a Protected Program

When a program was loaded with an access level of 6 or 7 (62FBH), it may not be listed or saved: at READY, or before a direct statement, the program text is overwritten with 00H, cleared by the ROM's NEW, and the text RUN access only is shown. Otherwise the routine returns at once.

6C83H - The Error Exits

Ten entries, each loading a BASIC error offset into Register E, then the ROM's error routine. The entries after the first are each entered inside a LD BC,xx1EH instruction, at its 1EH xxH bytes, which read as LD E,xxH; from above they only load Register Pair BC.

6CA3H - Post a DOS Error

Takes a DOS error code in Register A, saves it for CMD"E" (62F6H), maps it to a BASIC error offset through the table 6CB6H (a code of 27H or more maps to the second entry, Internal error), and jumps to the ROM's error routine.