TRS-80 DOS - NEWDOS/80 v2.0 for the Model III - SYS19/SYS Disassembled

SYS19/SYS

Other Navigation

NEWDOS/80 v2.0 SYS19/SYS Disassembly - LOAD, RUN, MERGE, SAVE and CMD"F",DELETE (Model III)

SYS19/SYS carries out the Disk BASIC statements that read or write a whole program. It loads 5200H-56E7H in five load records (transfer address 5200H); the code ends at 5650H and 5651H-56E7H are 151 bytes of 00H. It is one of the BASIC overlays that BASIC/CMD loads at 5200H through its loader at 576CH (RST 28H code 35H). 5200H itself only returns with the Z FLAG set; BASIC/CMD then jumps to the entry it put in Register Pair BC. BASIC/CMD has already opened the file in its work area 5700H-572DH (Index Register IX = 5700H, the FCB at 570DH, the sector buffer at 4300H). There are four entries:

• 5202H, LOAD and RUN with a file name (from BASIC/CMD 574FH; LOAD through the ROM vector 4188H, RUN through the link 41C7H).
• 5334H, MERGE (from BASIC/CMD 5731H, the ROM vector 418BH).
• 559CH, CMD"F",DELETE (from BASIC/CMD 5736H, the CMD letter dispatch at 57CEH).
• 55C5H, SAVE (from BASIC/CMD 5741H, the ROM vector 41A0H).

The page shows every byte of the file once, in address order.

Commands

A file that starts with FFH is a tokenized program, read line by line from the sector buffer. Any other file is BASIC text: each line (at most 240 characters, ended by a carriage return) must start with a line number (else DIRECT STATEMENT IN FILE) and is tokenized by the ROM's CRUNCH. A line 65535 in the file gives SEQ # OVERFLOW.

While the file is read the program in memory and its variables are moved up to 160 bytes below the stack, and the old lines are copied in among the new ones as the new lines arrive (53B4H). The pointers of string variables and DEF FN functions whose text lies in the old lines are moved with them (5478H). BASIC/CMD's statement-end CALL at 6426H is pointed at 543EH for the length of the load, so an error during the load still puts the program and the variables back together.

A file with access level EXEC can be RUN (or MERGEd by a running program) but not LOADed: SYS19/SYS lowers the level in the FCB to READ, sets BASIC/CMD's RUN ONLY flag at 63FAH and makes the BREAK hook at 4478H a jump to 4546H, so BREAK is ignored. A file with access level LOCK gives FILE ACCESS DENIED. When the SYSTEM option AB (RUN ONLY) is on, the RUN ONLY and BREAK settings are left as they are.

Variables

ROM Addresses

DOS Addresses

BASIC/CMD Addresses

Operands Changed at Run Time

Outside Routines

5200H - Load Entry

BASIC/CMD loads SYS19/SYS through its overlay loader at 576CH with RST 28H code 35H (function 1 of directory slot 15H) into 5200H-56E7H. After loading, the SYS0/SYS dispatcher calls 5200H, which must return with the Z FLAG set (no error); BASIC/CMD then jumps to the entry address it put in Register Pair BC (5202H, 5334H, 559CH or 55C5H).

5202H - LOAD and RUN with a File Name

Entered from BASIC 574FH for LOAD "file" (BASIC 574AH, the ROM vector 4188H, Register A = 0) and RUN "file" (BASIC 5746H, the ROM link 41C7H, Register A = 1). BASIC has opened the file in its work area 5700H-572DH (BASIC 6073H; Index Register IX = 5700H, the FCB at 570DH, its sector buffer at 4300H) and pushed Register Pair AF. Options after the name: R (run it, and leave the open files open) and V (run it and keep the variables). A program whose access level is EXEC can be RUN but not LOADed: it is read at level READ, BREAK is disabled and BASIC is set to RUN ONLY. Register Pair HL is BASIC's text pointer after the file name.

5289H - Make Room and Read a Tokenized File

The program in memory (for MERGE and V) and its variables are moved up to just below the stack, keeping 160 bytes free; the new program is then built from the program's start (40A4H), and the old lines are copied in among the new ones by line number (53B4H). While this runs, BASIC's statement-end clean-up calls 543EH, so an error during the load still puts memory back in order. A file starting with FFH is a tokenized program, read line by line straight from the sector buffer at 4300H.

5334H - MERGE

Entered from BASIC 5731H for MERGE "file" (BASIC 572EH, the ROM vector 418BH), with the file open in the work area as for LOAD. The file's lines are put in among the program's lines. Typed as a command, MERGE ends at READY; in a running program its lines may not replace existing ones (ILLEGAL FUNCTION CALL) and the program goes on with the line after the MERGE statement. Register Pair HL is BASIC's text pointer after the file name.

535BH - Load a Text File

A file that does not start with FFH is BASIC text. Each line (ended by a carriage return, at most 240 characters, 00H bytes and a line feed at the start skipped) is read into BASIC's input buffer, must start with a line number (else error 84H DIRECT STATEMENT IN FILE), and is tokenized by the ROM's CRUNCH; then it is put in like a tokenized line. Register Pair DE is the program pointer.

53B4H - Put In a Line

Called with Register Pair BC = the new line's number and Register Pair DE = the program pointer; the next old line's number lies on the stack below the return address. Old lines with smaller numbers are copied in first (53FEH); an old line with the same number is dropped, the new one replacing it (not allowed in mode 2); then the new line's header (a non-zero dummy link and the number) is stored. The real links are made at the end by the ROM's LINKER (543EH). Register Pair HL (the caller's position in the file data) is kept on the stack meanwhile.

543EH - Close Up

Moves the old lines that are left (from 53DCH) down behind the new program, then the simple variables and the arrays; stores the new pointers at 40F9H, 40FBH and 40FDH; rebuilds the line links with the ROM's LINKER; and puts BASIC's statement-end CALL at 6426H back (6497H). Also reached from BASIC's clean-up at 6423H if an error ends the load (the CALL was pointed here at 52DAH).

5478H - Move the String Pointers into the Old Lines

Called before each run of old lines is copied and before the close-up. The new bytes put in since the last old line was placed (the program pointer 5442H minus 547FH) push the old lines not yet copied further along; every string or DEF FN pointer of a variable that points into them (the range from 5429H to 5488H, in the addresses they had before the move, corrected by the offset 5642H) is moved by that distance, which is then added to the offset. Register Pairs HL, DE and BC are kept.

54B2H - Read the Next Sector, Check the Room

54B2H reads the next sector of the file into 4300H (called when Register L wraps to 00H, so Register Pair HL is 4300H again afterwards). 54BDH checks that the new program (Register Pair DE) is still at least 256 bytes below the next old line, else OUT OF MEMORY.

54C8H - Delete Lines, Keeping the Variables

Called with Register Pair HL = the last byte and Register Pair DE = the first line of the part of the program to delete (from 5263H for V, from 55BCH for CMD"F",DELETE). Strings of variables whose text lies in that part are copied to the string space first (54F2H with mode 0); then 543EH closes the program up, treating the rest of the program as the old lines left.

54F2H - Fix the String Pointers of the Variables

Walks the simple variables (from 40F9H to 40FBH) and the arrays (to 40FDH). Every string, and every DEF FN pointer (bit 7 of the name's first character), whose text lies after the start and up to the end of the range (both corrected by the offset at 5642H) is either copied into the string space (mode 0, used when lines are deleted; a DEF FN pointer becomes 0000H) or moved by the distance at 557AH (any other mode). Called with Register A = the mode, Register Pair HL = the start and Register Pair DE = the end of the range.

559CH - CMD"F",DELETE

Entered from BASIC 5736H for CMD"F" (from the CMD letter dispatch at BASIC 57CEH). CMD"F",DELETE range in a running program deletes the lines of the range (written as for the ROM's LIST and DELETE) without losing the variables (their strings in those lines are copied to the string space) and goes on with the line after the statement. Register Pair HL is BASIC's text pointer after the CMD string, Register A its next character.

55C5H - SAVE

Entered from BASIC 5741H for SAVE (BASIC 573BH, the ROM vector 41A0H) with the file opened new in BASIC's work area (Index Register IX = 5700H, the FCB at 570DH). SAVE "file" writes the program as it is in memory, after an FFH byte, 256 bytes a sector straight from memory, then reads the file back to check it. SAVE "file",A writes it as text through the ROM's LIST. Register Pair HL is BASIC's text pointer after the file name.

5620H - Small Helpers

5620H clears the offset at 5642H and returns Register Pair HL = 543EH. 562AH adds the last distance (557AH) to the offset and finishes 5478H. 5638H clears the offset and runs 54F2H. 5641H and 5649H are the two range tests used at 5568H and 556FH; when a string is out of range they abandon it by jumping to 5599H.