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

SYS20/SYS

Other Navigation

NEWDOS/80 v2.0 SYS20/SYS Disassembly - CMD, FN, INSTR, MID$=, &H, OPEN and LINE INPUT (Model III)

SYS20/SYS carries out a set of Disk BASIC statements and functions. It loads 5200H-56E7H in five load records (transfer address 5200H); the code ends at 56ADH and 56AEH-56E7H are 58 bytes of 00H. It is one of the BASIC overlays that BASIC/CMD loads at 5200H through its loader at 576CH (RST 28H code 36H, from 5782H). 5200H itself only returns with the Z FLAG set; BASIC/CMD then jumps to the entry it put in Register Pair BC. The page shows every byte of the file once, in address order.

Entries

5621H reads an item from the file through BASIC 60F2H into the ROM's input buffer, at most 255 characters. Register D holds the rules: bit 0 skips leading spaces and line feeds and lets a comma end the item, bit 1 lets quotes enclose it, bit 2 lets a space end it; a string item uses 03H, a number 05H, LINE INPUT# 00H. A carriage return ends the item unless it follows a line feed, and a line feed after it is taken with it. A character read past the item is given back with SYS0/SYS 4445H. The end of the file before an item starts is INPUT PAST END; inside an item it ends the item.

Variables

ROM Addresses

DOS Addresses

BASIC/CMD Addresses

Operands Changed at Run Time

Outside Routines and Tables

5200H - Load Entry

BASIC/CMD loads SYS20/SYS through its overlay loader at 576CH with RST 28H code 36H (function 1 of directory slot 16H) 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, 534AH, 53F2H, 5462H, 54C5H, 5504H, 55D4H or 55E8H).

5202H - CMD"command": Run a DOS Command from BASIC

Entered from BASIC 57A5H when the CMD string is longer than one character and does not end in $. BASIC's CMD link 57ECH has evaluated the string, pushed its text pointer (57EFH), copied the string in upper case to SYS0/SYS's command buffer at 4225H (ending with 0DH) and pushed its length count at 57A4H; Register Pair HL holds 4225H. CMD"S=command" leaves BASIC and runs the DOS command; CMD"F=name" runs one of BASIC's functions POPS, POPR, POPN, ERASE, KEEP, SASZ, SWAP or SS (table at BASIC 592BH); any other string is a DOS command, first run as a MINI-DOS command (BASIC stays in memory). If the DOS answers 38H (ILLEGAL MINI DOS FUNCTION), BASIC's memory 5200H-70FFH is copied below the stack, the command runs as a full DOS command, the memory is copied back, and a checksum of everything from 7100H to the top of memory must be unchanged, or the result is error 23H MEMORY FAULT.

5271H - Back from the Command: Restore BASIC's Memory

5271H-527EH is executed in the saved copy below the stack (the DOS command has used 5200H-70FFH): it copies 5200H-70FFH back and jumps to 527FH in the restored SYS20/SYS. The operand at 5272H was set at 5236H; 5275H (5200H) and 5278H (1F00H) are also read as data at 5245H and 522FH.

529AH - The Memory Checksum

The 64-byte window (its address in the operand 52C9H) is filled with A5H, then every byte from 7100H to the top of memory (40B1H), except the window itself, is XORed into it, byte 0 of the window with byte 0, 64, 128 ... of memory, and so on. The second run (entry 52A4H, after the DOS command) XORs the same bytes into the window again; if memory is unchanged each byte cancels out and the window holds A5H in every byte again: the Z FLAG is set.

52E2H - CMD"S=" and CMD"F="

Register Pair DE points at the command's first character (4225H) and Register Pair HL at the = (4226H); Register C holds the length of the CMD string minus 1. S= leaves BASIC for the DOS; F= looks the name up in BASIC's function table at 592BH, whose entries are a length byte, the name and a 2-byte address, ending with a 00H length.

5316H - CMD"F=POPS", "F=POPR" and "F=POPN"

Three of the functions in the table at BASIC 592BH are here. POPS empties BASIC's stack of every GOSUB and FOR. POPR drops the latest GOSUB (and any FOR loops opened after it) without returning. POPN [var] drops a FOR loop (the latest, or the one of var) and any opened after it. Each continues with the next statement. On entry Register Pair HL holds BASIC's text pointer.

534AH - FN: Calling a User Function

Entered from BASIC 577FH through the ROM vector 4155H when an expression holds FN name(arguments). The function's variable entry (found by BASIC 5824H) holds a pointer to the DEF FN statement's text. For each parameter named in the DEF, the parameter variable's current value is saved on the stack, the matching argument of the call is evaluated and assigned to it (the separators of the call and the DEF must match), then the expression after = in the DEF is evaluated, the parameters get their old values back, and the result is converted to the function's type. Register Pair HL is BASIC's text pointer at the function's name on entry.

53F2H - INSTR

Entered from BASIC 5786H through the ROM vector 419DH. INSTR([start,]string1,string2) returns the position of string2 in string1, searching from the position start (1 if left out), or 0 if it is not there. Register Pair HL is BASIC's text pointer at the INSTR token on entry.

5462H - MID$ on the Left Side of an Assignment

Entered from BASIC 578BH through the ROM link 41D9H. MID$(var$,position[,length])=string replaces characters of var$ in place: from the position, as many as the length (the rest of var$ if left out) and the new string allow; var$ keeps its length. A string whose text lies in the program (a literal assigned earlier) is first copied to the string space so the program is not changed. Register Pair HL is BASIC's text pointer at the MID$ token on entry.

54C5H - &H and &O Constants

Entered from BASIC 5790H through the ROM vector 4194H when an expression holds &. &Hdigits is hexadecimal; &Odigits or &digits is octal. The value is built in Register Pair DE (16 bits, 0-65535) and returned as an integer in REG 1; more than 16 bits is OVERFLOW. Register Pair HL is BASIC's text pointer at the & on entry.

5504H - OPEN

Entered from BASIC 5795H through the ROM vector 4179H. OPEN "mode",file,"name"[,type][,record length]. The mode letter (I, O, E, R or D) gives the mode byte for 5700H and the open flags for BASIC 6087H: whether the file must exist, may be created, is emptied or is positioned at its end. The optional type is two letters: the first F or M, the second I, U or F (MI, MU, MF, FI, FF); the I types have no record length (7FFFH), the others take one up to 4095, and FF and MF need one. Without a type, a random file may have a record length of 1-256 (below 256 only when BASIC was started with the V option, 649FH = 2). The mode byte (5700H): bit 7 random, 6 writable, 5 readable, 3 set by the types U and F (and by every mode letter), 2 fixed-length records, 1 first letter F, 0 first letter M; the open flags (5701H after AND F8H): bit 7 the file may be extended, bit 2 it is emptied, bit 1 it starts at its end, bit 0 (open only) an existing file only. On entry Register Pair HL is BASIC's text pointer after OPEN.

55D4H - INPUT# and READ Items from a File

Entered from BASIC 579AH through the ROM link 41DCH, which the ROM's INPUT and READ code calls at 222DH for each item it reads. BASIC 6382H returns straight to the ROM unless an INPUT# is reading a file; otherwise the next item is read from the file into BASIC's input buffer (5621H) and the ROM's READ code assigns it to the variable.

55E8H - LINE INPUT

Entered from BASIC 579FH through the ROM vector 41A3H (the LINE token). LINE INPUT ["prompt";]var$ reads a whole line from the keyboard (BREAK stops the program); LINE INPUT#file,var$ reads a whole line from a file. Either way the line goes into var$ unchanged, commas and quotes included. On entry Register Pair HL is BASIC's text pointer after LINE.

5621H - Read an Item from a File

Reads characters through BASIC 60F2H (from the file open for input) into the input buffer (its address at 40A7H), at most 255. Register D holds the rules: bit 0 = skip leading spaces and line feeds, and a comma ends the item; bit 1 = quotes allowed (a quoted string may hold commas); bit 2 = a space ends the item; bit 3 = inside quotes (set here). A carriage return ends the item (one right after a line feed does not), and a line feed after it is taken with it. A character read one too far is given back (the FCB is moved back one byte with SYS0/SYS 4445H and an LRL of 1). The end of the file before the item starts is error 7CH INPUT PAST END; inside the item it ends the item (56ABH). The item is then made a string (the ROM's STRLIT at 2868H) or a number (the ROM's FIN at 0E6CH). Register Pair AF on entry holds the Z FLAG for a string item.