LDOS 5.3.1 for the Model III - BASIC/OV4 Disassembled

BASIC/OV4

Other Navigation

LDOS 5.3.1 BASIC/OV4 Disassembly - CMD"V", the Variables of a BASIC Program (Model III)

BASIC/OV4 lists the variables and arrays of the BASIC program in memory with their values, and the functions made by DEF FN with their definitions: CMD"V [*DO or *PR] [-S] [-A] [=letter]". BASIC/CMD runs it with @RUN when CMD is given a V (its 547CH and 5490H); the file loads over BASIC/CMD at 5200H, and when it is done it runs BASIC/CMD again with an asterisk, back to the program in memory with its variables (5217H). It reads only the tables of the variables, so it can be given while a program is stopped.

The file is a load module of 960 bytes: a copyright record, the code and data 5200H-5569H and 5574H-557EH in five load blocks, and the transfer address 5200H. 556AH-5573H, the counters of the subscripts, is not in the file.

The Parameters

How It Works

About This Page

5200H - The Start: the Parameters and the Two Dumps

The transfer address. BASIC/CMD runs this file with @RUN for CMD"V text" (its 547CH, and 5490H for CMD"V" alone): the file loads over BASIC/CMD at 5200H and is entered with Register Pair HL at 4226H, the text after the V, which BASIC/CMD copied there with a 0DH after it. 544AH reads the parameters (a device, -S, -A, =letter): the device is an asterisk and DO or PR; 5439H sends the 0DH that ends them, a new line on the chosen device. The simple variables are listed when the operand at 520CH is 01H, the arrays when the operand at 5212H is 01H; -A clears the first and -S the second. Then BASIC/CMD is run again.

5217H - Back to BASIC

Also the way out after BREAK (52A4H, 534EH, 53A3H) and after an error in the parameters (54AEH). The 11 bytes at 522DH, BASIC/CMD, 03H and the byte 21H after it, go to 4485H (CFCB$), an asterisk to 4225H, and @RUN runs BASIC/CMD with 4225H as its command line: the asterisk, then the rest of the old parameters and their 0DH, which BASIC/CMD does not read after the asterisk; it goes back to the program in memory with its variables.

5237H - The Simple Variables

The heading, then every entry from 40F9H up to 40FBH. Each entry: +00H the type, which is also the size of the value (02H integer, 03H string, 04H single, 08H double), +01H the second character of the name (00H when the name has only one character), +02H the first character (bit 7 set for a function made by DEF FN), +03H the value. With =letter only names starting with it are listed. An ordinary variable is printed by the ROM's PRINT from a line built at 557BH: a quoted text with the name and an equals sign, then the name again, so the ROM prints its value. A DEF FN function is listed as the name and its definition turned back into text, with <User Def Func>.

52AAH - The Arrays

The heading, then every array from 40FBH up to 40FDH. Each array: +00H the type, +01H the second character of the name, +02H the first, +03H-+04H the length of the rest (from +05H to the end), +05H the count of dimensions, then a word for each dimension, the number of its elements, the last dimension first, then the elements. With =letter only names starting with it are listed. An array of 6 or more dimensions gets the text Too many subscripts (5510H) instead. Every element is printed, its subscripts counted from 0 in the counters at 556AH (one word for each dimension, the leftmost first): the line is the name, the subscripts in parentheses, an equals sign, then the same element again for the ROM's PRINT.

52F9H - The Next Element

The stack holds the place in the line of each subscript from the leftmost to the one being worked on (5567H); Index Register IY points at its counter and IX+04H-IX+05H at its number of elements. While the counter is below that number, the counter is written as text at its place and goes up by one; the next subscript is then worked on, from its place after a comma; after the last one the element is printed. A counter that reaches its number of elements goes back to 0 and the subscript before it is worked on (536CH); when the leftmost does, the array is done.

5354H - Print the Element

The last subscript is written: a right parenthesis, an equals sign and a quote close the text, then the name and the subscripts are copied again after it, and the ROM's PRINT runs the line. The place of the last subscript goes back on the stack for its next value.

536CH - A Subscript Used Up

Its counter goes back to 0, IY and IX move back to the subscript before it, and 5567H goes down by one. Two places come off the stack, this subscript's and the one before's; 52F9H puts the one before's back, so its next value is written from there. When the leftmost subscript was used up, the second POP takes the start of the array, which 52F9H puts back for 5391H.

5388H - Too Many Subscripts

An array of 6 or more dimensions: the text at 5510H (Too many subscripts between two asterisks, then a right parenthesis) follows the name, with no left parenthesis before it, and the ROM's PRINT shows the line as a quoted text.

5391H - The Next Array

The start of the array comes off the stack; the next array is 5 bytes plus the length at +03H-+04H further on.

53A9H - The Name and Its Type Character

The name of the entry at Index Register IX goes to 557FH: the first character (IX+02H, without bit 7), the second (IX+01H) when it is not 00H, then the type character worked out from the type byte at IX+00H: 27H less 02H, 03H, 04H or 06H (for 08H) gives %, $, # or !. It RETurns with Register Pair HL after the type character.

53D6H - Copy a Text

Copies from Register Pair DE to Register Pair HL until a 00H, which is not copied. Entered at 53D8H with a character in Register B, it also stops at that character outside quotes: the character is stored and Register Pair HL is left on it. Register C is the quote flag, 00H outside quotes and 22H inside, flipped at each quote. Entered at 53D6H, Register B = 00H, so only the 00H ends it. It RETurns with Register Pair HL at the 00H's place or on the stop character, Register Pair DE on it in the source.

53EFH - A Number as Five Digits

Register Pair HL = a number (a subscript) is turned into five decimal digits at 5575H-5579H, the last digit first, by @DIV with 10. It RETurns with Register Pair DE = 5575H, the first digit.

5405H - Print the Line

Register Pair HL = the end of the line: 00H is stored there, and the ROM runs the line from 557BH as the items of a PRINT statement, entered at 2069H, inside LPRINT after its LD A,01H: 409CH gets the device from 5569H (00H the video, 01H the printer). Index Registers IX and IY are kept across it.

5419H - Compare IX and DE

The Z FLAG when Index Register IX equals Register Pair DE (the end of a table). Register Pair HL is changed.

5420H - The Keyboard: SHIFT @ and BREAK

The keyboard is scanned once: SHIFT @ (60H) waits for another key; the key (none is 00H) is then tested for BREAK (01H). It RETurns with the Z FLAG for BREAK; Index Registers IX and IY are kept.

5439H - Send a Text

The text at Register Pair HL, up to its 0DH, goes to the video with @DSPLY when 5569H holds 00H, or to the printer with @PRINT when it holds 01H. Index Register IX is kept.

544AH - The Parameters

Register Pair HL = the text after the V. Spaces are passed over; the first parameter can be a device: an asterisk and DO (the video, as in the file) or PR (the printer: 5569H = 01H); any other device is Invalid output device!. Then any number of =letter (5574H, A-Z), -S (only the simple variables: 5212H = 00H) and -A (only the arrays: 520CH = 00H); anything else is Parameter error!. Letters are taken in upper or lower case. It RETurns at the 0DH with Register Pair HL on it; after an error it shows the message and goes back to BASIC.

54A4H - The Errors

54A4H points Register Pair HL at Parameter error!; its next instruction, LD IX,5550H, holds at 54A8H a second entry, LD HL,5550H, for Invalid output device!. The message is shown with @LOGOT and BASIC/CMD is run again.

54B1H - Pass Over Spaces

54B2H RETurns with Register A = the character at Register Pair HL, or the first one after spaces, and the Z FLAG for 0DH; 54B1H steps one character first.

54BBH - The Next Character in Upper Case

Register Pair HL moves on by one; Register A = the character there with bit 5 cleared, so a lower case letter becomes upper case.

54C0H - The Texts and the Work Cells

The banner (never shown), the two headings, the texts of the lines and the messages, then the cells of the dump. Texts for 5439H and @LOGOT end with 0DH; texts for the copy at 53D6H end with 00H. 556AH-5573H, the counters, are not in the file; from 557BH on is the line given to the ROM's PRINT.