LDOS 5.3.1 for the Model III - BASIC/CMD Disassembled

BASIC/CMD

Other Navigation

LDOS 5.3.1 BASIC/CMD Disassembly - Disk BASIC for the Model III ROM (Model III)

BASIC/CMD adds the disk to the BASIC of the Model III ROM: BASIC [*] [(FILES=n,MEM=a,BLK=sw,EXT=sw,HIGH|LOW)] [command]. The ROM jumps through 49 vectors at 4152H-41E4H for the disk keywords and calls them at its exits (output of a byte, the keyboard, a line typed, READY, an error, CLEAR, PRINT, INPUT, LIST); without a disk they hold RET or an error. The start (52ECH, the transfer address) copies the image at 4E00H to those vectors and the restart vectors to 4000H-400BH, so RST 10H goes to 658DH, reads the parameters with @PARAM, lays out the file buffers above the code and starts the ROM's BASIC. The code of the start (5329H on) then becomes the line buffer, and 543CH holds the filespecs.

The file is a load module of 5438 bytes: a copyright record, the vector image 4E00H-4E9EH, the code and data 5200H-660FH, and the transfer address 52ECH. BASIC/OV3 is loaded at 4E00H when it is needed (54DEH); BASIC/OV1, BASIC/OV2 and BASIC/OV4 are run over 5200H by CMD"N", CMD"X" and CMD"V".

The Parameters

Files

About This Page

4E00H - The Image of the Disk BASIC Vectors

Not run here: 535AH copies these 49 JP instructions (147 bytes) to 4152H-41E4H, the ROM's vectors for the disk keywords and its exits, which are RET or an error without a disk. After the copy the area from 4E00H on is free (BASIC/OV3 is loaded there, 54DEH). Each row names its vector.

4E93H - The Image of the Restart Vectors

Not run here: 532EH copies these 12 bytes to 4000H-400BH, the vectors of RST 08H, RST 10H, RST 18H and RST 20H. Three go to the ROM's own routines; RST 10H, which takes the next character of the BASIC text, goes to LBASIC's 658DH, and 57E2H puts the ROM's 1D78H back at the end.

5200H - The Banner, the Messages and the Parameter Table

Texts for the ROM's STROUT (28A7H, ended by 00H) and for @LOGOT (428AH, ended by 0DH), then the table of @PARAM (53CEH): MEM, FILES, BLK, EXT, HIGH and LOW (the last two only in the Model III file) and their short forms, 6 characters and the address of the cell, ended by 00H. BASIC/OV1, BASIC/OV2 and BASIC/OV4 are loaded over this area when they run.

52ECH - The Start: Saving the State, the Vectors, the Stack

The transfer address. LDOS runs BASIC with Register Pair HL at the command line after BASIC. The BREAK trap and OVRLY$ are cleared, the first character of the line (an asterisk asks to go back to the program in memory) and the line pointer, HIGH$, the start of the program text, the word at 408EH and the top of string space are kept in operands, the ROM's 39 bytes go to 4080H as at power on, the restart vectors to 4000H, the stack below the top of string space, the line buffer is set at 5331H (over this code), and the 49 vectors are copied to 4152H.

5364H - The LDOS Version, and Going Back to the Program

OSVER$ must be 51H or more, else Use LDOS 5.3 or later! and the end. BASIC with an asterisk first on the line builds the file buffers again for the old number of files and puts back the start of the program text and the top of string space as they were; when HIGH$ has come down below the old top of memory, the top moves down with it and the variables are cleared. Then the ROM's READY is reached with the program in memory.

53B7H - A New Start: the USR Vectors and the Parameters

The ten USR vectors (6630H-6643H) get 6443H, so a USR that DEF USR never set gives an error; 6644H gets 0000H. @PARAM reads MEM, FILES, BLK, EXT, HIGH and LOW with the table at 528BH; LOW sets the ROM's cassette speed at 4211H to 500 baud, else it is 1500 baud. BLK's high byte goes to 408FH; FILES must be 0-15 and goes to 408EH.

53F7H - Build the File Buffers

Register A = the number of files. Buffers for files 0 to that number are laid out from 6646H up, 0122H bytes each (0222H in blocked mode, 408FH not 00H), their addresses go to the table at 660EH, the first also to 662EH, and the first byte of each gets 00H. For BASIC with an asterisk it returns to 537FH; else the program text starts after the last buffer, with a 00H before it.

5425H - MEM

MEM (or HIGH$) must not be above HIGH$, and less 1 must leave 300 bytes above the start of the program text, else Out of memory. It becomes the top of memory (40B1H), with 50 bytes of string space below it; then the ROM's NEW empties the program.

5449H - The Banner and the Start of BASIC

The banner is shown. When the command line has more after the parameters, it is taken as a line typed at READY (ended by 00H) and run by the ROM; else the ROM's READY follows.

547CH - CMD"command": an Overlay or a Command of LDOS

CMD with a text of 2 or more characters (57F3H): Register A = the length (less than 64, else Illegal function call), Register Pair DE = the text. N, X or V followed by a space runs BASIC/OV1, BASIC/OV2 or BASIC/OV4 with @RUN and the rest of the text as its command line; anything else goes to the LDOS command shell (5514H). 5490H is the entry of 582BH for a single letter.

54CDH - The Name of an Overlay

Puts BASIC/OVn and 00H in the control block at 4485H (CFCB$), n the digit in Register B.

54DEH - Call BASIC/OV3

BASIC/OV3 is loaded at 4E00H and called. When OVRLY$ (4414H) holds 01H, BASIC/OV3 is still there and is entered at once. Otherwise it is loaded with @LOAD and entered at its transfer address; a failure gives the error's message, Can't load OV3 and READY.

5509H - Copy a Command

Copies Register C bytes from Register Pair HL to 4225H (INBUF$, the command line buffer of LDOS) and puts 0DH after them.

5514H - CMD"command": Run an LDOS Command and Come Back

The text goes to 4225H. If the stack is at least 3944 bytes above the end of BASIC's variables (40FDH), the vectors @EXIT, @ABORT and @ERROR are saved at 5432H-543BH, and BASIC's memory (5200H up to 40FDH, then 407DH-41E4H, then a header of 6 bytes for a module named &) is moved below the stack; HIGH$ goes below it, the three vectors are pointed into the moved copy (55C4H, 55C3H, 55BEH), and @CMNDI runs the command over the memory BASIC has left. The moved copy then brings everything back (55C6H).

55B8H - The Module Header and the Three Ways Back

Moved with the block below HIGH$. 55B8H-55BDH is the header of a module named & (JR to itself, the old HIGH$, the length 01H, the name), so the memory shows in the chain of modules. @ERROR comes to 55BEH: an error whose number has bit 7 set (return to the caller) goes on into the kept start of @ERROR; another error, @ABORT (55C3H: OR AFH, bit 7 set) and @EXIT (55C4H: XOR A, the Z FLAG) keep their result in Register Pair AF' and go on at 55C6H.

55C6H - The Way Back

Runs in the moved copy until 55DEH. The cells 407DH-41E4H and the first 0E00H bytes of 5200H come back, then the original code goes on at 55E1H: the rest of the block, HIGH$, the Stack Pointer and the three vectors are put back. @EXIT returns to the CMD statement; @ABORT gives System command aborted; an error is made a BASIC error (6463H).

5613H - Find a Function's Name

For FN (561FH) and DEF FN (5704H): the FN token (BEH) must come next; the name's first letter gets bit 7 (OR 80H) and goes into the ROM's variable search after its first character (2612H), with 40DCH = 80H (no array). Returns Register Pair DE at the function's value, the address of its definition, and its type at 40AFH.

561FH - FN: Call a Function Defined by DEF FN

Vector 1 (4155H). The function's value holds the address of its definition text (after the name). With parameters, the values of the variables named in the definition's list are saved on the stack (2, 4 or 8 bytes, or a string's descriptor), the arguments of the call are assigned to them, the body after = is evaluated, and the saved values are put back; the result is made the function's type (DEF FNA$, FNA%, ...). A function never defined gives Undefined user function.

5700H - DEF: DEF FN and DEF USR

Vector 3 (415BH), with Register A = the token after DEF. DEF USRn goes to 5755H. DEF FN (not in a line typed at READY) stores the address of the text after the name in the function's value, checks the list of parameters (every name is made a variable), and passes over the rest of the statement.

5723H - USR: Call a Machine Language Routine

Vector 29 (41A9H), CALLed by the ROM's USR at 27FEH. The ROM's return address is dropped; the digit after USR (none: USR0) picks one of the ten vectors at 6630H, the argument in brackets is evaluated, and the routine is entered by a RET with 26E7H below it on the stack, Register Pair HL = 4121H (the accumulator), Register A = the type (a string argument's descriptor in Register Pair DE).

5743H - The Number of a USR

The character after USR: a digit 0-9 picks USR0-USR9, anything else USR0. Register Pair DE returns at its vector, 6630H + 2 x n.

5755H - DEF USR

DEF USRn = address: the value after = (an integer) is stored in the vector of USRn.

5764H - PRINT#: a File Number

Vector 40 (41CAH), CALLed by the ROM's PRINT at 206FH with Register Pair HL at the character after PRINT, the # (Register A). PRINT #- (the cassette) is left to the ROM; PRINT #n goes to 5CF0H for a file open for output (Register C = 02H).

5770H - ON or OFF

The second argument of CMD"B" and CMD"D": a comma, then a text of 2 or more characters; its second character (F of OFF, N of ON) gives the Z FLAG for OFF.

578CH - CMD"L": Load a Program File

CMD"L","filespec": the file is loaded with @LOAD and not run (a USR can call it). A failure gives the BASIC error of the LDOS error.

579EH - CMD"P": the Printer's Status

CMD"P",variable: the printer's status (37E8H, bits 7-4, the address the Model I file reads; the Model III answers there too: ROM C passes reads of 37E8H-37E9H through to the printer, the status the ROM's own routine at 044BH reads from port F8H) goes into the variable, as a number or, for a string variable, as the text of the number.

57CBH - CMD"B": the BREAK Key

CMD"B","OFF" sets bit 4 of SFLAG$ (442BH) and puts RET Z (C8H) at 4BEFH in SYS0/SYS's request code 01H; CMD"B","ON" clears the bit and puts back 00H.

57E2H - Back to LDOS

CMD"S", CMD"A" and the start's errors: the ROM's 1D78H goes back into the RST 10H vector, then @ABORT with the CARRY FLAG, else @EXIT.

57EEH - CMD: the Letters

Vector 11 (4173H). The text after CMD: 2 characters or more go to 547CH; one letter (upper or lower case) picks L, P, T, R, S, A, I, the asterisk, O, B, E or D. Any other letter goes to 5490H, where N, X and V run their overlay with no command line, and anything else gives Illegal function call.

5836H - CMD"R" and CMD"T": the Clock Display

On the Model III CMD"R" turns the clock display on and CMD"T" turns it off, through the ROM's routines at 0298H and 02A1H, which set and clear bit 0 of 4210H, the switch the ROM's clock interrupt tests before it shows the time. The Model I file enables and disables the interrupts here.

583CH - CMD with an Asterisk: Print the Screen

The 1024 characters of the screen (3C00H-3FFFH) go to the printer, a new line before each row of 64; every code is sent as it is (the Model I file prints codes below 20H as 40H-5FH; that step is not in this file). BREAK stops it.

5858H - CMD"O": Sort an Array

BASIC/OV3 does the sort: Register A' = 03H, its function, and BASIC/OV3 is called (54DEH).

585EH - CMD"I": Run a Command and Stay in LDOS

CMD"I","command": the command gets 0DH at its end and runs through @CMNDI with the stack of LDOS; BASIC does not come back.

586EH - CMD"E": the Last LDOS Error

The LDOS error kept at 660BH (stored by BASIC/OV3 function 02H, which 6463H calls) is displayed by @ERROR with bits 7 and 6 set (the short message, and back to the caller).

5876H - CMD"D": DEBUG

CMD"D" alone enters DEBUG at once (@DEBUG). CMD"D","ON" puts C3H in the BREAK trap switch (4405H), so BREAK enters DEBUG; CMD"D","OFF" puts C9H there.

588BH - The Text of a CMD

588BH wants a comma first. A string expression is evaluated and freed; an empty string gives Illegal function call. Returns Register A = the length, Register Pair DE = the text.

589FH - The End of PRINT

Vector 36 (41BEH), CALLed by the ROM at 2174H after it set 409CH to 00H (Register A = 00H): 660CH-660DH, the current file, gets 0000H, so the output goes to the video again.

58A6H - INPUT# and INPUT@

Vector 44 (41D6H), CALLed by the ROM's INPUT at 219EH with Register A = the character after INPUT. INPUT #- is left to the ROM (the cassette). INPUT #n makes file n current (open for input, 5CEEH) and joins the ROM's INPUT at 21EBH, where the values are taken. INPUT @pos moves the cursor (pos 0-1023); without a field it is the ROM's INPUT with its prompt; with ,"prompt",width,"spec"; it reads a field (5946H). The spec is $ (any character 20H-7FH) or # (digits), an optional asterisk (the field ends when full), and a fill character (5FH, the underline, if none). A fill character of 60H-7FH also flips bit 6 (the asterisk) and is shown as itself less 40H (592DH).

5936H - LINE INPUT

Vector 27 (41A3H), the token LINE: INPUT must follow (89H), not in a line typed at READY. LINE INPUT# goes to 5D71H. Else after an optional prompt a whole line from the keyboard (0361H) goes into a string variable; 5946H is shared with INPUT@'s field (Register B = the width, Register C = its code), read by 596DH.

596DH - Read a Field

INPUT@ with a width: the field editor (5984H) reads at most Register B characters into the line buffer (40A7H); the text gets 00H at its end. An empty field (ended by ENTER) keeps the 0DH in Register A before the 00H, so the string is CHR$(13). Returns Register Pair HL at the byte before the text and the CARRY FLAG for BREAK.

5984H - Field Editor

CALLed from 5970H with Register Pair HL = the line buffer, Register B = the width and Register C = the field's code (bit 7 digits only, bit 6 end when full, bits 5-0 the fill character less 20H). The field is painted with the fill character and the cursor put back at its start; then keys are read (0049H) until ENTER, BREAK, or a full field with bit 6. Left arrow erases one character, shifted left arrow all of them. Returns Register B = the characters typed and the CARRY FLAG for BREAK.

59C2H - Erase One Character

Puts the fill character back in the last place typed and moves the cursor onto it. Register Pair HL (the buffer) goes back one byte and Register B (the places left) up one. Returns the Z FLAG when nothing was typed: Register B equal to Register C (the width).

59D6H - Take a Printable Character

Keys from 80H up are ignored, and so is any key when the field is full. A field of digits (bit 7 of the code) takes 0-9 and the characters minus, point and plus. The character goes into the buffer and on the screen; a field with bit 6 set ends when its last place is filled.

5A06H - End the Field

Reached on ENTER (59ABH), BREAK (59AFH, the CARRY FLAG set) and a full field (5A05H). The cursor goes off, the places not typed are blanked with spaces, the ROM's column (40A6H) is set from the cursor, and Register B becomes the number of characters typed.

5A28H - Cursor Left

Sends 18H (backspace) to the display. When the cursor is at the left edge of a line, 5A3FH first moves the cursor's address in 4020H up one line; in the wide character mode (bit 2 of 4210H, the copy of port ECH) the place before is tested too, as each character there takes two places.

5A3FH - Cursor Up at the Left Edge

5A3FH: if Register Pair HL is at column 0, 4020H gets Register Pair HL less 40H (64), one line up. 5A46H is entered from 58CCH by INPUT@: 4020H gets Register Pair HL + Register Pair DE.

5A4BH - Display the Fill Character

Register A gets the fill character that 598BH stored in the operand at 5A4CH, and it is displayed (0033H).

5A50H - INPUT and LIST With a File

Vector 47 (41DFH), CALLed by the ROM at 2278H (the end of INPUT and READ) and at 2B44H (LIST). With no current file (660CH = 0000H) the ROM goes on. With one, INPUT skips the ROM's Extra ignored message (227BH) and goes on at 2282H; LIST (a SAVE with A) skips the ROM's test of the keyboard (CALL 1D9BH at 2B47H) and goes on at 2B4AH.

5A66H - Error Messages

Vector 28 (41A6H), CALLed by the ROM's error handler with Register E = the error's E value. If 6608H holds D6H (a RUN with V whose variables are parked, 5F64H), 5F97H puts 40A0H and the stack back, clears 6608H and starts the program (5FC5H); it never comes back. Else BASIC/OV3 function 01H puts the message's text in Register Pair HL; it is displayed, 6401H makes the protection test, and the ROM at 1A11H adds IN and the line number.

5A85H - INSTR

Vector 25 (419DH): INSTR([n,]a$,b$) is the position of b$ in a$, the search starting at character n (1-255, 1 if left out). It is 0 when n is past the end of a$, a$ is empty, or b$ is not found; n when b$ is empty. The result goes through the ROM at 27F8H (an integer from Register A) and 26E7H (the text pointer back).

5B0DH - &

Vector 22 (4194H), the constants &H (hexadecimal, at most 4 digits) and &O or & alone (octal) as an integer in the accumulator. A fifth hexadecimal digit or an octal value past FFFFH is the ROM's Overflow (07B2H); a digit 8 or 9 in an octal number is a Syntax error.

5B5EH - MID$ =

Vector 45 (41D9H), reached by the ROM's JP at 2AECH for MID$(v$,p[,n]) = x$. A string still in the program text (below 40A0H) is first copied to string space (2843H, 09D3H), so the program is not changed. Then at most n characters of x$ (all of it if n is left out, E = FFH) go over v$ from position p, never past v$'s end; v$'s length is not changed. A p past v$'s end is the ROM's Illegal function call.

5BD1H - Optional Count

For MID$ =: with Register A = the character at Register Pair HL, a right parenthesis leaves Register E = FFH; else a comma and a byte (2B1CH) give Register E. The right parenthesis must follow.

5BDFH - Line Input From a File

Vector 31 (41AFH), CALLed by the ROM's line input at 0368H. With no current file the keyboard line input at 646DH takes over. With one, up to 240 (F0H) bytes are read through 0384H (the keyboard exit 5C1CH then reads the file) into the line buffer up to a 0DH, which becomes 00H; a 0AH as the first byte is dropped. It RETurns past the ROM's line input with Register Pair HL at the byte before the buffer and the CARRY FLAG clear.

5C0EH - Byte Output to a File

Vector 37 (41C1H), CALLed by the ROM at 032CH with Register C = the byte to send. With no current file the ROM goes on to its devices. With one, both the ROM's return address and the Register Pair BC it saved at 032AH are taken off the stack, and 61E4H writes the byte to the file and RETurns to the ROM's caller.

5C1CH - Keyboard Exit

Vector 38 (41C4H), CALLed by the ROM at 0358H, the bottom of every key request. Both return addresses are taken: 035BH and the caller's. For 0384H (wait for a key, return 0387H): with no current file the ROM scans the keyboard (035BH); with one, the next byte of the file (628FH) is the key, and at the end of the file the program is RUN (a run state other than 00H) or READY is shown and 0DH given (00H), a RUN with V going to 5F68H. Other callers go to 5C61H.

5C61H - BREAK and Pause

The keyboard exit for every caller but 0384H. INKEY$ (return 01A8H) goes to the ROM's scan. For the others (the BREAK test at 1D9BH while a program runs) @KITSK (4285H) is called and KFLAG$ (429FH) read: BREAK gives Register A = 01H; the pause (SHIFT and @) waits for a key other than 60H, clears the flags (5CA7H), and gives 01H if that key was BREAK. Else Register A = 00H, no key. Register A, as the compare of 5C22H left it, goes to 40A9H, which nothing in BASIC/CMD reads.

5C8DH - Point the BREAK Vector at READY, Then Clear KFLAG$

CALLed at 52FAH (the start) and 5601H (after CMD"command"). The word at 4204H, the operand of the JP at 4203H that the ROM's waits for the cassette and the RS-232 take on BREAK, gets 1A19H, the ROM's READY, so BREAK there comes back to BASIC; then bits 2-0 of KFLAG$ are cleared. The Model I file only clears KFLAG$ here.

5C95H - Read KFLAG$

Register A = KFLAG$ (429FH). When BREAK or the pause (bits 0 and 1) is set, the keys queued are read away through the ROM at 035BH until it gives 00H. RETurns the NZ FLAG for BREAK (bit 0). CALLed from 5C72H and 584CH.

5CA7H - Clear the Key Flags

Clears bits 2-0 of KFLAG$ (429FH): ENTER, the pause and BREAK. Register Pair AF is kept. CALLed from 5C82H, 6486H and 652FH, and reached by the JP at 5C93H.

5CB2H - Comma and TAB to a File

Vector 43 (41D3H), CALLed by the ROM at 2108H (a comma in PRINT) and 2141H (TAB). With no current file the ROM goes on. With one, the file's column (the byte after the one 660CH points to) is given to the ROM: at 2130H for a comma (to the next zone of 16), at 2156H for TAB.

5CCAH - Before CLEAR

Vector 33 (41B5H), CALLed by the ROM at 1AECH before its RUN set up (1B5DH). The current file pointer is kept at 40F3H, and file 0's slot in the pointer table (660EH) points to 6606H, a 00H byte, while the ROM clears.

5CD7H - After CLEAR

Vector 34 (41B8H), CALLed by the ROM at 1AF2H after its RUN set up. The current file pointer comes back from 40F3H and file 0's slot (660EH) gets the address of buffer 0 from 662EH.

5CE4H - A Number to a File

Vector 41 (41CDH), CALLed by the ROM's PRINT at 20C6H after a number is made text. With no current file the ROM goes on. With one, the ROM's test of the line's length is skipped: 20E9H prints the text and a space.

5CEEH - #n: Make a File Current

With Register A = the character at Register Pair HL: no # RETurns at once (the NZ FLAG). Else #n is read (5D03H), file n must be open in the mode in Register C (01H here, input; PRINT# enters at 5CF0H from 576DH with Register C = 02H, output), a comma must follow, and 660CH gets the file's buffer address.

5D03H - The Buffer of File n

Reads a file number (an optional # and an expression, 0-255) at Register Pair HL. More than the files set aside (408EH) is Bad file number. Returns Register Pair BC = the buffer from the pointer table at 660EH, Register A = its first byte (the mode, 00H when closed) and the Z FLAG for a closed file. 5D10H is entered with the number in Register A.

5D27H - MKI$, MKS$ and MKD$

Vectors 8 (416AH), 9 (416DH) and 10 (4170H), with the argument already evaluated by the ROM. Register A = 02H (MKI$, 5D27H), 04H (MKS$, 5D2AH, inside the LD BC at 5D29H) or 08H (MKD$, 5D2DH, inside the LD BC at 5D2CH): the number is made that type (2819H), and a string of that many bytes is made from the accumulator.

5D40H - CVI, CVS and CVD

Vectors 0 (4152H), 2 (4158H) and 4 (415EH). Register A = 01H (CVI, 5D40H), 03H (CVS, 5D43H, inside the LD BC at 5D42H) or 07H (CVD, 5D46H, inside the LD BC at 5D45H), one less than the bytes needed: a shorter string is Illegal function call. The type (40AFH) becomes 2, 4 or 8 and the string's first bytes are copied into the accumulator (09F7H).

5D5DH - READ and INPUT From a File

Vector 46 (41DCH), CALLed by the ROM at 222DH for each variable of INPUT# (the variable's type in 40AFH). With no current file the ROM goes on. With one, the field is read from the file (5D85H) and the ROM's assignment at 2243H takes it. A number ends at a space or a comma (Register E = 20H, Register D = 2CH); a string at a comma (both 2CH), or at a quote when it begins with one; outside quotes a 0DH ends any field.

5D71H - LINE INPUT#

Reached from 593CH. File n is made current for input, the string variable found, and the whole line, up to a 0DH, read (no ends: Register Pair DE = 0000H); the ROM's assignment at 1F31H puts it in the variable and 2169H ends the statement. 5D85H is the field reader shared with INPUT#: leading spaces of a field are skipped, at most 255 bytes kept in the line buffer, 00H bytes dropped, a 0DH followed by 0AH taken as one end, and the end of the file before the field is Input past end.

5E2AH - Keep a Byte

Register A (unless 00H) is stored at Register Pair HL in the line buffer and Register B (the room left) counted down. When the buffer is full the caller's return address is dropped and the field ends at 5E12H.

5E33H - Open a Program File

For MERGE (5E57H) and LOAD and RUN (5E97H): Register D = 01H, input, and Register A = 00H, file 0, then OPEN's common part at 6347H, which RETurns to the caller.

5E39H - Back Up One Byte

The current file is moved back one byte: the record length byte (FCB byte 9, at buffer + 0BH) is made 01H for @BKSP (4445H) and then put back. A DOS error goes to 6463H.

5E56H - MERGE

Vector 19 (418BH). The program file is opened as file 0 (5E33H); anything after the filespec is a Syntax error (5FD8H closes the file first). A file whose first byte is FFH is not ASCII: Bad file mode. Else the byte is given back (5E39H) and the ROM's command loop (1A33H) takes the file's lines as if typed (5BDFH, 5C1CH); with 6608H = 00H, READY ends it.

5E78H - A Starting Line

For the R and V options of RUN and LOAD: after the letter an optional comma and line number; 5E7CH is entered at a digit. The line number goes in the operand at 5FC6H, where the program will start.

5E84H - RUN and LOAD a Program

5E84H is vector 39 (41C7H), CALLed by the ROM's RUN at 1EA6H (with the CARRY FLAG for a line number, which the ROM keeps); 5E8CH, inside the OR at 5E8BH, is vector 18 (4188H), LOAD. 6644H is set for RUN (the protection state is noted at 63D8H) and 6608H gets FFH for RUN or 00H for LOAD. After the filespec: R (keep the files open and run), V (OV3 function 04H keeps the variables too, 6608H = D6H) or a line number, each with an optional starting line. A program SAVEd without A (first byte FFH) is read straight into the program area; else the ROM's command loop takes it line by line.

5F70H - Bring the Variables Back

For a RUN with V, with Register Pair HL = the end of the new program (40F9H). BASIC/OV3 parked the variables above 40A0H and stored the old values in the operands at 5F72H (the old 40F9H), 5F79H (the old 40FBH), 5F85H (the length), 5F92H (40D6H) and 5F98H (40A0H). The variables are moved down after the new program, the pointers set, 6608H cleared, the stack put back, the READY exit made and the program started (5FC5H). 5A6EH CALLs 5F97H to finish an error the same way.

5FACH - The End of a Load

MAXFIL (408EH) is made 0 across the ROM's RUN set up (1B5DH), so it closes no file, then put back. A plain LOAD (6608H = 00H) goes to READY (1A19H); else the program starts at the line in 5FC6H, or at its first line when that is 0000H.

5FD8H - READY Exit

Vector 30 (41ACH), CALLed by the ROM at 1A1CH on its way to READY, and from 5C44H, 5E5EH, 5FA7H and the JP at 6054H. The output goes back to the display (2169H, which leaves Register A = 00H) and file 0 is closed (61A8H). Only for the ROM's READY (return address 1A1FH) is the protection test made (6401H). It RETurns with Register Pair HL = 40DFH's word (1BAFH).

5FECH - A Line Typed

Vector 32 (41B2H), CALLed by the ROM at 1AA1H after a line is tokenized, the CARRY FLAG for a line with a number (the ROM stores it). A line without a number read from a file is Direct statement in file (E = 84H). Else the protection test (6401H) is made and the statement executed (1D5AH).

6000H - SAVE

Vector 26 (41A0H). The file is opened as file 0 for output (5E35H with Register D = 02H). SAVE "file",A goes to the ROM's LIST (2B2EH), whose text goes to the file through 5C0EH. Without A the program is written as it is in memory: the byte before it (40A4H less 1) is made FFH, the file is first written at its last record to give it its size (@POSN, @WRITE, @REW), then a record is written from each page of memory; the end of file byte is set and 5FD8H closes the file.

6057H - CLOSE

Vector 17 (4185H). With the NZ FLAG (a list follows) each [#]n of the list is closed by 61A8H; with the Z FLAG every file from the number set aside (408EH) down to 0 is closed. 61A8H is reached by a RET (6067H) and by JP (HL) (6087H) with return addresses pushed before it.

6088H - Close Every File

Vector 35 (41BBH), CALLed by the ROM at 1B8CH, in the clear shared by RUN (1B5DH) and NEW, and at 1DB0H in END; STOP jumps past that call (1DABH), so it closes nothing here. XOR A gives CLOSE (6057H) the Z FLAG: every file is closed.

6092H - FIELD

Vector 14 (417CH). FIELD [#]n, w AS v$, ... for a file open for random (mode 03H). Each v$'s descriptor is pointed at the next w bytes of the file's data area (buffer + 22H). More than the record length (the FCB's byte 9, 00H for 256; kept at 6607H) is FIELD overflow (E = 64H). When the fields total exactly 256 bytes FIELD ends there; that total is not tested against a shorter record length (Register B = 00H at 60D1H), so a record of 80 bytes may be fielded as 256.

60ECH - RSET and LSET

60ECH (OR 37H, the CARRY FLAG clear) is vector 24 (419AH), RSET; 60EDH (SCF, inside it) is vector 23 (4197H), LSET. v$ = x$: v$ keeps its length and place; x$ is copied in, cut to v$'s length, and padded with spaces (6170H) on the left for RSET or the right for LSET. A v$ whose text is still in the program (between 40A4H and 40F9H) is first given space of its own (28BFH); when string space is short and x$ was a temporary just freed by 29D7H, 6179H tries to reserve it again, but that path goes wrong (6185H).

6170H - Spaces

Stores Register C spaces (20H) at Register Pair DE onward.

6179H - Keep x$ Safe

Reached from 6129H when string space is short and 28BFH may collect garbage. The flags saved at 6108H are those of 29D7H: with the Z FLAG x$ was a temporary just freed, and 2857H and 2884H are meant to reserve x$'s length again as a temporary over the same bytes; but 2884H RETurns through the saved lengths (6185H), so this path fails. With the NZ FLAG 612BH allocates v$'s space.

618FH - EOF

Vector 5 (4161H), with the file number already in the accumulator: -1 at the end of the file (@CKEOF NZ), else 0. A file open for output is Bad file mode.

61A8H - Close One File

Closes file Register A: nothing for a closed file. A file open for input (mode 01H) is not given to @CLOSE; for the others the mode is cleared first and @CLOSE (4428H) called. The buffer's first 22H (34) bytes, the mode, the column and the FCB, are then cleared.

61C6H - LOC and LOF

61C6H is vector 6 (4164H), LOC, with @LOC (446DH); 61CBH is vector 7 (4167H), LOF, with @LOF (4470H). The file number is already in the accumulator; a closed file is Bad file number. The value the call gives in Register Pair BC (the current record, or the number of records) is the result, an integer; an error from the call is the ROM's Overflow (07B2H).

61E4H - A Byte to the Current File

From 5C0EH with Register A = the byte. A file open for input takes nothing (1DFDH: POP AF, POP HL and RET). Else the file's column (buffer + 01H) goes to 0 for 0DH and up one for a byte of 20H or more, and the byte is written with $PUT (001BH). An error ends at 6463H only for an open disk file (bit 7 of the FCB's byte 0); for a device it is ignored. Every register is kept.

6218H - PUT and GET

6218H (OR AFH, Register A not 00H) is vector 16 (4182H), PUT; 6219H (XOR A, inside it) is GET, Register A = 00H; 660AH keeps which. [#]n[,r] for a file open for random (mode 03H): with r, @POSN goes to record r-1 (r = 0 is Bad record number); without it @CKEOF tests the place. A GET past the end (1CH or 1DH) gives a record of 256 zero bytes; else @READ, or @WRITE for PUT, with Register Pair HL at the data area (buffer + 22H).

628FH - Read a Byte of the Current File

$GET (0013H) at the FCB of the current file. For an open disk file (bit 7 of the FCB's byte 0): NO CARRY with the byte in Register A, CARRY at the end of the file (1CH); other errors go to 6463H. For a device, a Z FLAG reads again and anything else is RETurned. Registers BC, DE and HL are kept.

62B5H - A Filespec Into an FCB

The string expression at Register Pair HL (1 to 24 characters, else Bad file name) is copied to 543CH with a 00H after it, and @FSPEC (441CH) puts it into the FCB of the buffer in Register Pair BC (buffer + 02H). An error, or a character after the filespec (Register A not 00H), is Bad file name (E = 80H). Register Pair BC is kept.

62EFH - OPEN

Vector 13 (4179H): OPEN "m",[#]n,"filespec"[,length]. The first letter of m gives the mode byte in Register D: I 11H (input, the file must exist), O 02H (output), R 0BH (random, a record length may follow), E 06H (output at the end of the file); lower case is taken. After O, R or E a second letter O sets bit 4 (the file must exist) and N bit 5 (it must be new). File 0 is kept for LOAD and SAVE (Bad file number). 2169H, pushed first, is where the RET at 6400H goes.

6401H - The Protection Test

CALLed from 5A7FH, 5FE6H and 5FFAH. 6644H is cleared. When 6645H is set (a program opened to run only, 63E8H) the program area is cleared (044DH bytes from 40A4H), 6645H cleared, the ROM's NEW made and the error Protection has cleared memory (E = 90H) given. Else every register is kept.

6426H - KILL

Vector 21 (4191H). The filespec is put in file 0's FCB (62B5H), the file opened (@OPEN, 4424H) and killed (@KILL, 442CH); file 0's mode is then cleared.

6443H - BASIC Errors

Each entry loads Register E with an error's E value; the 3 bytes after it are LD BC, so the next entries are skipped, and 6460H JUMPs to the ROM's error handler (19A2H). 6443H is also the USR vector set by 53B7H for a USR with no DEF USR. 6463H: a DOS error in Register A goes to Register L, and BASIC/OV3 function 02H gives its E value.

646DH - The Command Line at READY

5BE6H JUMPs here when the ROM's line input (0361H) runs with no current file. Unless it was called from the ROM's command loop (return 1A7EH) or a JCL job runs (bit 5 of SFLAG$ 442BH), the ROM's line input goes on. Else the first key decides: up arrow (5BH), down arrow (0AH), period and comma work on the current line (40ECH), left arrow (08H) shows the first line and right arrow (09H) the last; a line is shown by the ROM's LIST (2B33H) or, for comma, edited (2E65H). Any other key starts a line, collected by the ROM (05E3H) and RETurned to 652EH.

652EH - A Line Was Typed

The ROM's collector RETurns here with Register Pair HL at the line, Register B = its length and the CARRY FLAG for BREAK. A line of a single letter A, D, E or L, alone or followed by a digit, period or minus sign (no left parenthesis or equal sign up to the 0DH), gets the letter changed into a token: AUTO, DELETE, EDIT or LIST. M and C give BASIC/OV3's functions 05H and 06H instead. The line then goes on at 0375H in the ROM's line input.

658DH - The RST 10H Code

4003H JUMPs here (the LDIR at 532EH copies the vector) for every RST 10H. The ROM's own code (1D78H) fetches the character. Only for the statement fetch of the ROM's interpreter (return address 1D5BH) and a token: SET EOF (83H then E9H) [#]n sets a random file's end at its current place; RESTORE (90H) n makes READ start at line n. Else Register A and the flags are RETurned as the ROM gave them.

6606H - Work Cells

The last bytes of the file, 00H in the file, and the memory BASIC/CMD uses above it (not in the file): the table of the file buffers, the USR vectors and two flags. The file buffers follow from 6646H (53B7H, 53F7H).