TRS-80 DOS - LDOS 5.3.1 for the Model I - BASIC/OV1 Disassembled

BASIC/OV1

Other Navigation

LDOS 5.3.1 BASIC/OV1 Disassembly - The LBASIC Line-Renumber Overlay (Model I)

BASIC/OV1 is the line-renumbering overlay of LBASIC, the LDOS Disk BASIC extension. It implements the CMD"N ..." statement, which renumbers the program currently in memory and, unlike the DOS-level MOVE command, correctly adjusts every internal line-number reference in GOTO, GOSUB, THEN, ELSE, RESUME, RUN, ON...GOTO/GOSUB and ERL. The MISOSYS BASIC Reference Manual (M-40-061) gives the syntax CMD"N ! line,newline,inc,last": line and last bound the old line range to renumber, newline is the new starting number, inc the increment, and the optional leading ! skips the pre-renumber error scan.

The overlay is a transient program, not a resident module. When the interpreter meets CMD"N ..." its CMD dispatcher builds the filespec BASIC/OV1, loads the overlay with the resident @RUN service so it replaces BASIC/CMD's own image at 5200H, and enters it at 5200H with Register Pair HL pointing at the text that followed the N. Because the file overlays the interpreter, the overlay finishes by reloading BASIC/CMD with @RUN, passing the command * so the interpreter returns quietly to its Ready prompt. Both BASIC/CMD and BASIC/OV1 must therefore be present on the disk.

Renumbering is done in stages. A first pass over the program stores each line's new number in that line's two-byte link word (the field that normally holds the address of the next line), assigning the running newline, newline+inc, ... sequence to lines inside the range and leaving lines outside it with their own numbers, while validating that the result stays in ascending order and within the 65529 line-number ceiling. A validation pass then scans every line for reference tokens and confirms each referenced line exists, printing Can not find line for any that do not (the ! option skips this pass). A rewrite pass rebuilds each line in a work buffer, replacing the ASCII digits of each reference with the new number read from the target line's link word, and splices the rebuilt line back into the program, growing or shrinking the text as the digit counts change. Finally each line's new number is copied from its link word into its line-number field, all link words are rebuilt to point at the following line, and VARTAB, ARYTAB and STREND are reset just past the renumbered program.

The overlay was byte-verified for this disassembly: the memory image rebuilt from the LDOS load records in BASIC/OV1 (1189 bytes over 5200H-56A4H, transfer address 5200H) matches the listing exactly, with full coverage and no gaps.

File and Memory Map

Variables and Self-Modified Cells

Major Routines

Cross-References

Entered from: the CMD dispatcher of BASIC/CMD (LBASIC), which loads BASIC/OV1 to 5200H with the resident @RUN service and enters it at 5200H with Register Pair HL at the parameter string.

LDOS resident services used: @DSPLY (4467H) to display the banner and messages, and @RUN (4433H) to reload BASIC/CMD on exit.

Level II ROM routines used: FNDLIN (1B2CH) to find a line, LINPRT (0FAFH) to print a line number, MAKINT (0A9AH), FOUINI (1034H) and FOUT2 (0FD9H) to format a number to ASCII, and DCOMPR (RST 18H, 0018H) to compare line numbers.

BASIC workspace touched: TXTTAB (40A4H), HIGH$ (4049H), VARTAB (40F9H), ARYTAB (40FBH), STREND (40FDH), INBUF$ (4318H) and CFCB$ (4480H).

5200H - Entry: Skip Blanks and Show the Banner

The renumber overlay is entered here at 5200H after BASIC/CMD's CMD dispatcher loads it over the interpreter image with @RUN. Register Pair HL points at the parameter text that followed the N in CMD"N ..."; leading blanks are skipped and the sign-on banner is displayed.

5215H - Verify a Program Is Present

The first program line's line-number word is tested; an empty program (or a program whose first line is line 0) is rejected to the empty-program error at 5545H.

5221H - Switch Stacks and Read the "!" Option

The stack is moved to the top of protected memory (HIGH$) and the optional leading ! is detected. The ! presets the pass flag 56A7H so the error-checking pass is skipped.

5237H - Parse the Four Numeric Parameters

Up to four comma-separated decimal numbers - line,newline,inc,last - are parsed into the parameter table at 569BH, each field defaulting to the value already stored there. A malformed field aborts to the Bad parameters error.

527BH - Resolve the "last" Line Boundary

The last parameter is resolved against the actual program with ROM FNDLIN, so renumbering can stop at the correct line even when last falls between two existing line numbers.

5295H - Pass 0: Assign a New Number to Every Line

Every line record is walked once. The 16-bit link word of each record - normally the address of the next line - is overwritten with the line's NEW number: its own old number for lines outside the selected range, and the running newline, newline+inc, ... sequence for lines inside it. Ordering and 16-bit overflow are validated; any violation aborts to Bad parameters.

5313H - Choose the Error-Check and Rewrite Passes

The running new-number counter is reset and the pass flag 56A7H selects the two reference passes: a validation pass (unless ! was given) followed by the rewrite pass.

5333H - Reference Pass: Scan and Rebuild Each Line

Each program line is copied a byte at a time into the work buffer at 5700H. Text inside quoted strings is passed through untouched; outside strings, a reference-introducing token (THEN, GOTO, GOSUB, ELSE, RESUME, RUN, ERL) triggers the line-number-reference handler at 53FBH. On the rewrite pass the rebuilt line is spliced back into the program, growing or shrinking the text as the reference digits change length.

53FBH - Handle a Line-Number Reference

The old target number that follows a reference token is accumulated, the line carrying that old number is found, its NEW number (held in its link word from pass 0) is converted to ASCII, and those digits are written into the rebuilt line in place of the old ones. A target that does not exist raises Can not find line.

5479H - Commit the New Numbers into the Line-Number Fields

With every reference already rewritten, each line's new number - still sitting in its link word - is copied into the line-number field of the record.

5493H - Buffer Overflow Error

A rebuilt line longer than 254 bytes cannot fit the work buffer; the offending line is named and Buffer overflow is displayed before the links are rebuilt and control returns to BASIC.

549EH - Can Not Find Line Error

A GOTO/GOSUB/etc. that targets a non-existent line is reported with the offending line number and the missing target number.

54B9H - Unreferenced Stub

This three-instruction fragment stores 01H into the first byte of the program text and joins the exit path. No instruction in the overlay transfers control to it.

54C1H - Bad Parameters Error

Displays Bad parameters and falls through to the link rebuild and exit.

54C7H - Rebuild the Line Links, Fix the Pointers, Exit

Because reference rewriting may have moved text, every line's link word is rebuilt to point at the following line, and VARTAB/ARYTAB/STREND are set just past the new end of the program. Control then goes to the BASIC/CMD reload at 5551H.

54EFH - Parse a Decimal Number (helper)

Reads consecutive ASCII digits at (HL) into Register Pair DE, advancing HL past them; Carry is returned on 16-bit overflow.

54FFH - Digit Test (helper)

Returns Carry clear when Register A holds an ASCII digit 0-9, Carry set otherwise.

5506H - Multiply by Ten and Add a Digit (helper)

Computes DE = DE*10 + (A-'0') by nine repeated additions; Carry is set on 16-bit overflow.

5520H - Display "Error in line NNNN. " (helper)

Prints the Error in line message, the current line's number, and a trailing period.

5538H - Display-String Helper

A wrapper around @DSPLY that preserves Register Pair IY and DE across the call. Entry at 5538H displays a lone carriage return; entry at 553BH displays the string at (HL).

5545H - Empty-Program Error, then Return to BASIC

Patches the Error in line message to read "line 0", displays it, and falls into the reload of BASIC/CMD.

5551H - Reload BASIC/CMD and Return to Ready

The overlay replaced the interpreter's image at 5200H, so the normal exit reloads BASIC/CMD through @RUN, passing the command * so the interpreter simply returns to its Ready prompt.

5566H - Uppercase a String (helper)

Folds lowercase letters a-z to uppercase in the string at (HL) up to the first control byte. No instruction in the overlay calls this routine.

557EH - Convert a Line Number to ASCII (helper)

Uses the ROM number-formatter to turn the 16-bit line number in Register Pair HL into an ASCII digit string, returning Register Pair DE at the first digit.

558EH - Advance to the Next Line Record (helper)

Steps Register IX past the four-byte link and line-number header and over the tokens to the following line's link word.

559EH - End-of-Program Test (helper)

Returns the Zero flag set when the link word at (IX+00H/+01H) is 0000H, the end-of-program marker.

55A8H - Reference-Token Test (helper)

Returns the Zero flag set when Register A holds one of the seven keyword tokens that a line-number reference can follow.

55BEH - Skip Blanks (helper)

Advances Register Pair HL one byte and then over any run of blanks, preserving Register A.

55C7H - Filespec, Banner, Messages, and Parameter Table

The tail of the file holds the reload filespec, the sign-on banner, the status and error messages, and the parameter table whose default values are baked into the image.