LDOS 5.3.1 for the Model III - BASIC/OV3 Disassembled

BASIC/OV3

Other Navigation

LDOS 5.3.1 BASIC/OV3 Disassembly - the Error Messages, CMD"O", RUN With V and the M and C Commands (Model III)

BASIC/OV3 is the overlay BASIC/CMD calls back into while BASIC runs: it holds the texts of the BASIC errors, turns LDOS errors into BASIC errors, sorts a string array for CMD"O", parks the variables for a RUN with V, and moves or copies a program line for the M and C commands at READY. BASIC/CMD's 54DEH loads it at 4E00H, the overlay area of LDOS, and calls it with the number of a function in Register A'; once loaded it stays until a system file is loaded there, and 4414H (OVRLY$) holds 01H while it is there (4E00H).

The file is a load module of 1229 bytes: a copyright record, the code and data 4E00H-5281H in five load blocks, and the transfer address 4E00H. The last 130 bytes, 5200H-5281H, load over the start of BASIC/CMD's image, its banner and the messages of its start, which BASIC/CMD uses only when it starts.

The Functions

The Messages

About This Page

4E00H - The Entry: the Function in Register A'

The transfer address and the only entry. BASIC/CMD calls BASIC/OV3 through its 54DEH with the number of a function in Register A' (put there by EX AF,AF'): it JUMPs to 4E00H when the file is already in the overlay area, or loads it with @LOAD and RETurns to 4E00H. 4414H, OVRLY$, gets 01H first, the mark BASIC/CMD's 54DEH tests to know the file is still at 4E00H. Function 01H gives the text of a BASIC error, 02H turns an LDOS error into a BASIC error, 03H sorts a string array (CMD"O"), 04H parks the variables for a RUN with V, 05H moves a line (M at READY) and 06H copies one (C); any other number runs the copy too.

4E1BH - Function 01H: the Text of a BASIC Error

BASIC/CMD's 5A72H (the error vector 41A6H) calls it with Register L = the error's E value from the ROM's error handler. The E value picks one of the messages of the table at 5057H: E values 00H-2EH give messages 2-25 (E / 2 + 2), 64H-90H give messages 26-48 (the disk errors), any other even value message 21, Unprintable error; an odd value (only the 19H of LDOS code 00H) has bit 7 set by the RRCA and sends the search past the end of the table. Each message is a list of word numbers from the dictionary at 50D6H, bit 7 set on the last; the words are copied to 543CH (in BASIC/CMD's image) with a space after each and 00H at the end, and the first letter is made upper case. It RETurns with Register Pair HL = 543CH.

4E6BH - Function 02H: an LDOS Error Becomes a BASIC Error

BASIC/CMD's 6463H calls it with Register L = the error code an LDOS service returned. The code is kept at 660BH for CMD"E"; codes from 29H up are taken as 29H; the table at 502DH gives the E value of the BASIC error, and the ROM's error handler is entered with it. It does not RETurn.

4E80H - Function 03H: CMD"O", Sort a String Array

BASIC/CMD's 5858H calls it for CMD"O",count,array$(first) with Register Pair HL at the text after "O". The count goes into the operand at 4EA0H, the address of the first element (from the ROM's PTRGET) into the operand at 4EBBH. The elements are sorted in ascending order by a Shell sort: the gap starts at half the count and is halved after each round until it is 0. Only the 3 byte string descriptors (length, address) are exchanged, never the text. Nothing tests that the variable is a string array or that the elements stay inside the array. It RETurns to BASIC/CMD with Register Pair HL after the array name.

4E95H - The Next Round: Halve the Gap

Register Pair BC = the gap of the round before (the count at the start). It is halved; at 0 the sort is done. 4F0FH gets the count less the gap, the number of comparisons of the round, and the position at 4EAEH starts again at 0.

4EADH - The Next Position: Compare Two Elements

The element at the position (4EAEH, copied to 4EB4H as the working position) is compared with the element one gap after it. Each element is 3 bytes from the first one (4EBBH). The shorter length is compared character by character; when the shorter string is the same as the start of the longer one, the shorter goes first. An element above its partner (or the same) is exchanged with it, and the working position steps back by the gap to compare again.

4EE9H - Exchange the Two Descriptors

The 3 bytes of the two descriptors are exchanged, so the lower element moves one gap down; the working position (4EB4H) steps back by the gap and the compare is made again while it is 0 or more.

4F04H - In Order: the Next Position

The two elements are in order: the three words saved at 4EC3H-4EC5H are taken back, and the position of the round (4EAEH) goes up by one. While it is below the count less the gap (4F0FH) the next position is compared, else the next round begins with half the gap.

4F19H - Function 04H: Park the Variables for a RUN With V

BASIC/CMD's 5EC1H calls it for RUN"file",V before the ROM's NEW. The simple variables (40F9H-40FAH up to 40FBH) are walked first: each entry is a type byte (the size of the value: 02H, 03H, 04H, 08H), two name bytes and the value. A DEF FN entry (bit 7 of its second name byte) gets its pointer into the program set to 0000H, since the program goes away. A string's text that lies in the program (a constant) is copied into string space (4F6AH). The arrays (40FBH up to 40FDH) come next, every element of a string array the same way. Then 4F99H moves the whole block up below the stack and keeps the pointers for BASIC/CMD's 5F70H.

4F23H - The Simple Variables

Register Pair HL steps over each entry by Register C, the size of its value; DE = the end of the simple variables.

4F3FH - The Arrays

Each array is a type byte, two name bytes, the length of the rest (2 bytes, from the count of dimensions to the end), the count of dimensions and 2 bytes for each dimension, then the elements. A number array is passed over in one step; in a string array every 3 byte descriptor goes to 4F6AH.

4F6AH - Move a String Out of the Program

Register Pair HL = a string descriptor (length, address of the text), Register Pair DE = the end of the area being walked (the start of the arrays, or the end of the array). A text at or above Register Pair DE (in string space) or below 40A4H is left alone; a text between them is in the program, and goes to new string space from the ROM's GETSPA (28BFH), the descriptor then pointing at the copy. It RETurns with Register Pair HL 3 bytes on and Register Pair DE as it was.

4F99H - Park the Block

The variables and arrays (40F9H up to 40FDH) are moved up to end 128 bytes below the Stack Pointer, with LDDR; when the block already reaches that place it is Out of memory. The start of string space (40A0H) is set just below the parked block, so the ROM's NEW puts the stack under it. The old values go into BASIC/CMD's operands for 5F70H: 5F72H the old 40F9H, 5F85H the length, 5F79H the old 40FBH, 5F92H the old 40D6H, 5F98H the old 40A0H; 6608H gets D6H.

4FD6H - Functions 05H and 06H: M and C, Move or Copy a Line

BASIC/CMD's 6578H calls it for a line typed at READY that is M or C with two line numbers, M old,new or C old,new; Register Pair HL = the line, its letter replaced by the function number and 00H after it. 4FD6H (M) is OR AFH, which leaves the NZ FLAG; 4FD7H (C) is the AFH alone, XOR A, which leaves the Z FLAG. The old line must exist (Undefined line number) and the new one must not (Illegal function call); a missing line number, a line number of 0 (either one) or more text after the second number is a Syntax error. The old line's text is turned back into characters in the input buffer, and the ROM's EDIT exit (2FEBH) takes it in as the new line, as if typed; for C no READY is shown. For M the line input vector (41AFH) is pointed at 501AH, so that when the ROM next asks for a line the old line is deleted.

501AH - M: Delete the Old Line

Reached through the line input vector (41AFH) from the ROM's 0368H, when the ROM asks for a line after the new one went in. The vector gets back BASIC/CMD's 5BDFH, the two return addresses (from 0368H and from 1A7BH) are dropped, and the old line (its number at 5023H) is deleted by the ROM's DELETE from 2BCAH, which shows READY and goes back to the command loop.

502EH - The LDOS Errors as BASIC Errors

One byte for each LDOS error code from 01H to 29H (4E6BH): the E value of the BASIC error it becomes. The entry for code 00H is 19H, the last byte of the JP at 502BH; codes from 29H up use the entry of 29H. Each row names the LDOS error and the BASIC message its E value gives (4E1BH).

5057H - The Messages

49 messages, each a list of word numbers of the dictionary at 50D6H, bit 7 set on the last; function 01H passes over E / 2 + 2 messages (4E35H). Messages 0 and 1 are never chosen: no E value gives a number below 2. Messages 24, 32, 35 and 36 (the E values 2CH, 70H, 76H and 78H) are the word ? alone.

50D6H - The Dictionary

78 words in lower case unless shown in capitals, each ended by bit 7 set on its last character; word n is reached by passing over n words from 50D6H (4E47H). Word 0 is the byte D2H alone, which only marks the start, so word 1 begins at 50D7H. The first letter of a message is made upper case at 4E68H.