LDOS 5.3.1 for the Model III - BASIC/OV1 Disassembled

BASIC/OV1

Other Navigation

LDOS 5.3.1 BASIC/OV1 Disassembly - CMD"N", Renumbering a BASIC Program (Model III)

BASIC/OV1 renumbers the BASIC program in memory and changes the line numbers it refers to: CMD"N [!]first,new,increment,last". BASIC/CMD runs it with @RUN when CMD is given an N and a space (its 547CH); the file loads over BASIC/CMD at 5200H, so when it is done it runs BASIC/CMD again with an asterisk, which goes back to the program in memory (5551H). The variables are gone afterwards.

The file is a load module of 1264 bytes: a copyright record, the code and data 5200H-56A4H in five load blocks, and the transfer address 5200H.

The Parameters

How It Works

About This Page

5200H - The Start: the Banner

The transfer address. BASIC/CMD runs this file with @RUN for CMD"N text" (its 547CH): the file loads over BASIC/CMD at 5200H and is entered with Register Pair HL at the text after the N, which BASIC/CMD copied to 4226H with a 0DH after it. The spaces before the parameters are passed over, the banner is shown and then Checking for errors.

5215H - A Program Numbered from 0

The number of the first line of the program must not be 0, else Error in line 0. A line numbered 0 keeping its number would have 0000H in its link bytes during the passes, the end mark to 559EH.

5221H - The Stack and the ! Option

The stack is moved to HIGH$, above the program text. An exclamation mark first on the line sets 56A7H to 01H: the references are then changed in one pass with no check for errors before it.

5237H - The Four Parameters

CMD"N first,new,increment,last": the first line to renumber (569BH, 1 in the file), the new number of that line (569DH, 20), the increment (569FH, 20) and the last line to renumber (56A1H, 65529). Each is a decimal number; a comma alone keeps the value in the file. A number above 65535 or any other character than a comma after a number gives Bad parameters. A value of 0 is not stored and the slot is not passed, so the next number goes into it. Text after a fourth comma is not read.

527BH - The Bound of the New Numbers

When the last line to renumber is a line of the program, 56A1H becomes the number of the line after it less 1, or 65529 (FFF9H) when it is the last line of the program. The renumbered lines are then those up to it, and their new numbers must stay below the lines that follow. When the last line is not a line of the program, its number stays in 56A1H as both limits. Above 65530 gives Bad parameters.

529CH - The First Pass: the New Number of Every Line

Every line is given its new number in its link bytes (+00H-+01H), its own number staying at +02H-+03H: a line below the first line to renumber keeps its number, which must be below the new number of the first line; the lines from the first to the bound (56A1H) are numbered from 569DH by 569FH, each new number not above the bound and the next one below 65530; the lines after them keep their numbers. Any other case gives Bad parameters. The links are rebuilt from the text at the end (54C7H).

5313H - Which Pass Comes First

Without the ! option the references are first only checked (56A7H = 00H); when that pass ends with no error, No errors is shown, 56A7H becomes 01H and the same pass is run again to change them. With the ! option No errors is shown at once and only the pass that changes them is run. At the end of the changing pass the new numbers are put in place (5479H).

5333H - The Reference Pass: Copying a Line

Each line's text (from +04H) is copied to the buffer at 5700H, a byte at a time, with the count in the alternate Register A; 255 bytes give Buffer overflow. Outside quotes the tokens THEN, ELSE, RESUME, GOTO, GOSUB, RUN and ERL (55A8H) are followed by line numbers (53FBH). 56A5H is set when a number of the line is changed. In the pass that only checks, the buffer is not used further; in the pass that changes the references a changed line is written back (538AH).

5379H - The End of a Line

A line with no changed number, or any line of the pass that only checks, is passed over. In the pass that changes the references, a changed line is written back: the rest of the program (to the second byte of the end mark) is moved down or up by the difference in length, then the text in the buffer is copied over the old text. The program is moved up with no test for room.

53FBH - The Line Numbers after a Token

After the token, spaces and control characters, commas (the list of ON n GOTO), the = token (D5H, as in ERL=n) and the digit 0 are copied as they are; 0 starts no number, so GOTO 0 and RESUME 0 are left alone, and digits after a 0 are read as a number of their own. A number of other digits is read into Register Pair DE without copying it, the line with that number is searched for by its old number (+02H-+03H), and the text of its new number (from its link bytes) is put in the buffer. Any other character ends the numbers and is handled by the copy loop (5351H). A line not found, or a number above 65535 (shown as line 0), gives Can not find line.

5479H - The New Numbers Put in Place

After the pass that changed the references, the new number of each line is copied from its link bytes (+00H-+01H) to its number (+02H-+03H). The links are rebuilt next (54C7H).

5493H - The Errors

Buffer overflow and Can not find line follow Error in line n. (5520H), n the old number of the line being copied; Bad parameters stands alone. Then the links are rebuilt and BASIC/CMD run again (54C7H). An error in the pass that only checks leaves the program as it was; in the pass that changes the references (the ! option) the lines before the error are already changed, but no line gets its new number.

54C7H - The Links Rebuilt, Back to BASIC

Every line's link is set again to the start of the next line, found by its text; the ROM's pointers to the variables, the arrays and the end of the arrays are set just after the end mark, so the variables are gone. Then BASIC/CMD is run (5551H).

54EFH - A Decimal Number

Reads the digits at Register Pair HL into Register Pair DE. Returns the NO CARRY FLAG with Register Pair HL at the first character that is not a digit (Register Pair DE = 0000H when there is none), or the CARRY FLAG when the number goes above 65535. Register B is changed (5506H).

54FFH - A Digit

Tests Register A: the NO CARRY FLAG for a digit 0-9 (30H-39H), the CARRY FLAG for any other byte. Register A is not changed.

5506H - Times Ten Plus a Digit

Register Pair DE = Register Pair DE x 10 + the digit whose character is in Register A. The CARRY FLAG on return when the result is above 65535: Register Pair DE is then as it was when the overflow comes in the times ten, or the low 16 bits of the sum when it comes in adding the digit; the callers do not use Register Pair DE then. Register Pair HL is kept and Register B is changed; on the normal return Register A holds the digit's value.

5520H - Error in line n.

Displays Error in line, then the old number (+02H-+03H) of the line at Index Register IX in decimal, then a period and two spaces. Index Register IX is kept.

5538H - Showing a Text

5538H displays the 0DH at 5659H, the end of a line. 553BH displays the text at Register Pair HL with @DSPLY up to 03H (not shown) or 0DH (shown) and keeps Register Pair DE and Index Register IY.

5545H - A Line Numbered 0

From 521EH: 30H 0DH are written over 5696H-5697H, so the text at 5688H becomes Error in line 0 and a new line. Nothing in the program is changed.

5551H - Running BASIC/CMD Again

The name BASIC/CMD is put in the control block at 4485H and 2AH (an asterisk) over the first byte of the command line at 4225H, then @RUN loads BASIC/CMD and runs it with Register Pair HL at 4225H: BASIC with an asterisk goes back to the program in memory, and BASIC/CMD does not read the rest of that line on that path.

5566H - Upper Case (Not Used)

Turns the lower case letters (61H-7AH) of the text at Register Pair HL into upper case, up to the first control character; Register Pair AF and Register Pair HL are kept. No code calls 5566H.

557EH - A Line Number as Text

The ROM's LINPRT (0FAFH) without its display: Register Pair HL goes to the ROM's number buffer as text (at 4130H, a space for the sign first, ended by 00H). Returns Register Pair DE at the first digit (4131H); Register Pair HL is kept.

558EH - The Next Line by Its Text

Moves Index Register IX past the link and the number (4 bytes) and past the text to the 00H after it: Index Register IX = the next line. The links cannot be followed, since the passes put the new numbers in them. Then 559EH: the Z FLAG when the link of the line at Index Register IX is 0000H, the end mark of the program.

55A8H - Tokens Followed by Line Numbers

Returns the Z FLAG when Register A holds the token of THEN (CAH), ELSE (95H), RESUME (9FH), GOTO (8DH), GOSUB (91H), RUN (8EH) or ERL (C2H). Other line numbers, such as those of RESTORE, LIST, EDIT and DELETE, are not looked for.

55BEH - Past a Character and the Spaces

Steps Register Pair HL past the character at it and the spaces after it; Register Pair AF is kept.

55C7H - The Texts and the Parameters

The name BASIC/CMD for 5551H, the banner and the messages (each ended by 0DH, shown, or 03H, not shown), the four parameters and the address of the line buffer. The cells 56A5H-56A9H and the buffer 5700H-57FEH are not in the file.