TRS-80 DOS - NEWDOS/80 v2.0 for the Model I - BASIC/CMD Disassembled

BASIC/CMD

Other Navigation

BASIC/CMD is NEWDOS/80 v2.0's Disk BASIC for the Model I. It loads at 5700H-684DH (load blocks 5700H-570CH, 572DH-64C4H, 64C7H-65AFH, 65C9H-66EEH and 66BCH-684DH; 66C7H-66EEH is overwritten by the last block) and starts at 66BEH. The entry code reads the options typed after BASIC, the start-up code at 64CAH sets the top of memory, displays the sign-on message, copies the link table 67BBH-684DH over the ROM's Disk BASIC links at 4152H-41E4H, clears the file areas and starts BASIC. The file areas then overwrite the entry code from 66BEH up. The file disassembled has NEWDOS/80's mandatory zaps applied.

The page was rebuilt on 2026-10-01. Every row's bytes match the file, every loaded byte is shown exactly once, and each row says what every register and address it uses holds at that moment.

Most of the work is done in overlays that BASIC/CMD loads with RST 28H through its loader at 576CH: SYS18 (the command line, RENUM/REF/RENEW entry), SYS19 (LOAD, RUN, MERGE, SAVE, CMD"F",DELETE), SYS20 (CMD strings, FN, INSTR, MID$=, &H/&O, OPEN, INPUT # items, LINE INPUT), SYS10 (GET and PUT), SYS13 (error messages, RENUM), SYS21 (CMD"O", ERASE, KEEP). BASIC/CMD itself holds:

• The links the ROM calls (vector table at 67BBH): CVI/CVS/CVD (58EFH), MKI$/MKS$/MKD$ (58D8H), DEF FN and DEF USR (5852H), USR (5892H), CMD (57FFH), TIME$ (58C4H), FIELD (5E63H), LSET/RSET (5908H), EOF/LOF/LOC (5EC5H), CLOSE (5FA1H), KILL (643CH), PUT/GET (6125H), and the hooks that send PRINT # and INPUT # through a file.
• One-letter CMD commands (57C3H): CMD"S" DOS, "F" SYS19, "C" program compression (59ADH), "J" date conversion (5A9DH), "O" array sort (SYS21), "E" last DOS error, "D" nothing, "R"/"T" interrupts on/off; and the CMD"F=" functions SWAP (598AH), SASZ (5C5BH) and SS single stepping (5BB6H, 63DDH).
• The file statement frame: 62BCH copies a file area's 2DH-byte header to the work area 5700H (Index Register IX = 5700H) and sets the flag 63A9H; 6445H copies it back at the end of the statement (or restores it after an error) and clears the work area. The file helpers at 6112H-6374H are shared with SYS10.
• Errors: the Disk BASIC error entries 5DC4H-5E03H and the DOS-to-BASIC error table 5E36H.

The work area and the variables in the file also have rows in the disassembly below.

Work Area (a copy of the current file area's header)

Address Size	Contents
5700H 1 byte	Mode Bit 7 random, bit 6 writable, bit 5 readable, bit 4 PUT in progress, bits 0-3 the type (MI 1, FI 2, MU 9, MF 0DH, FF 0EH).
5701H 1 byte	Flags Bit 7 the file may be extended, bit 6 the record start is known.
5702H-5703H 2 bytes	Record Length The record length of the file.
5704H-5706H 3 bytes	Last GET/PUT End Position where the last GET or PUT ended (low, middle, high).
5707H-5709H 3 bytes	Record Start Start of the current record (REMRA).
570AH-570CH 3 bytes	Last GET/PUT Start Position where the last GET or PUT statement started; in a PRINT # file 570AH is the print column.
570DH-572CH 32 bytes	FCB The file's FCB: 5712H NEXT low byte, 5715H EOF low byte, 5716H record length, 5717H NEXT middle/high, 5719H EOF middle/high.
572DH 1 byte	Statement Flags Bit 7 a work-area file (LOAD/RUN/MERGE/SAVE/KILL), bit 6 a length prefix was given (SYS10), bit 4 PUT at or past EOF, bit 2 format only (SYS10 %).

Other BASIC/CMD Variables

Address Size	Contents
576EH 1 byte	Overlay Loaded Last RST 28H code of the overlay loaded last (operand of CP 00H at 576DH).
57B6H-57B7H 2 bytes	SYS18 Command The RST 28H code and flag of RENEW, RENUM or REF, stored by SYS18.
57B8H-57B9H 2 bytes	Next Line Number Line number of the line after a trailing comma (5DADH).
57E5H 1 byte	Last DOS Error Last DOS error code OR C0H (5E19H), shown by CMD"E".
58B0H-58C3H 20 bytes	USR Addresses USR0-USR9 addresses (DEF USRn), 1E4AH until defined.
5A20H-5A21H 2 bytes	CMD"C" Line Number The line number of the line being compressed.
5A72H 1 byte	CMD"C" Space Opcode Opcode 28H (remove spaces) or FEH (keep).
5A95H 1 byte	CMD"C" Remark Opcode Opcode 00H (remove remarks) or 13H (keep).
5BA1H-5BADH 13 bytes	CMD"J" Month Lengths The month lengths; February at 5BA3H.
5BAEH-5BB5H 8 bytes	CMD"J" Result The result buffer of the date conversion.
5C25H, 5C2AH, 5C30H 1 byte each	Variable Name Operands Compare operands for a variable name (type, second and first character), set by 5BDDH for SYS21.
5C9EH, 5CB4H 2 bytes each	CMD"F=SASZ" Operands The new string area bottom and the new Stack Pointer.
5D51H-5D56H 6 bytes	Digit Buffer Decimal digit buffer (5D32H).
5D5FH 2 bytes	SYS10 Number A number set and displayed by SYS10.
5D6CH 1 byte	Printer Echo 24H when output also goes to the printer (SYS12 REF$), cleared at 6457H.
5E13H 1 byte	Error Code Error code for 5E09H.
5F89H 1 byte	File Area Count Number of file areas (stored at 652AH).
61F1H 2 bytes	Record Room Room left in the current record (SYS10).
624DH 1 byte	SYS10 Reload Non-zero when SYS10 must be reloaded after a DOS call.
6379H 2 bytes	Statement File Area Address of the file area used by the current statement.
63A9H 1 byte	File Statement Flag 00H (NOP) none, C9H (RET) running.
63BDH 1 byte	Saved Statement Flag Saved copy of 63A9H (links 41B5H/41B8H).
63DBH 1 byte	Single Step Switch 18H (JR) off, 20H (JR NZ) on.
63EBH 2 bytes	Single Step Start The line to start at (0 = every line).
6421H 1 byte	RUN ONLY Flag 43H during RUN ONLY (set by SYS19), else 00H.
644EH 2 bytes	Cleanup Hook Routine called at the end of a file statement (64BDH, or SYS19/SYS21's).
6482H 1 byte	Error Restore Switch 18H (JR) or 20H (JR NZ): whether an error restores the file area's control data.
64C5H-64C6H 2 bytes	File Area Size Size of one file area: 012DH, or 022DH with the V option.
66BEH 012DH each	File Areas First file area; area n is at 66BEH + (n - 1) x (64C5H).

ROM and DOS Addresses Used

Address Size	Contents
3C39H 6 bytes	Single Step Display Screen position of the single-step @nnnnn display.
4012H 1 byte	RST 38H Vector First byte of the interrupt vector: C3H (CMD"R") or C9H (CMD"T").
40A0H 2 bytes	String Area Bottom Bottom of the string area.
40A2H 2 bytes	Current Line Current line number (FFFFH in direct mode).
40A4H 2 bytes	Program Start Start of the program.
40A7H 2 bytes	Input Buffer Input buffer address.
40A9H 1 byte	Cassette Flag Set to 1 at 645BH.
40AFH 1 byte	Value Type 2 integer, 3 string, 4 single, 8 double.
40B1H 2 bytes	Top of Memory Top of BASIC memory.
40D6H 2 bytes	Lowest String Lowest string in use.
40DCH 1 byte	Function Name Flag 80H while a function name is looked up.
40F0H 2 bytes	ON ERROR Line ON ERROR GOTO line.
40F9H 2 bytes	Program End End of the program (start of the variables).
40FDH 2 bytes	Arrays End End of the arrays.
4101H 26 bytes	DEF Types DEF type of each letter.
4121H 8 bytes	Floating Accumulator The floating accumulator; 4124H its exponent.
4317H 1 byte	SYS0 Overlay Byte The overlay in 4D00H-51FFH (cleared by CMD"C").
4318H 80 bytes	SYS0 Command Buffer The command buffer (CMD strings).
4369H 1 byte	SYS0 Flags Bit 6 an overlay function is running, bit 5 chaining.

Disk BASIC Links (copied from 67BBH to 4152H-41E4H)

Address	Purpose
4152H / 4158H / 415EH	CVI 58F5H, CVS 58F2H, CVD 58EFH
4155H	FN 577FH (SYS20)
415BH	DEF 5852H
4161H / 4164H / 4167H	EOF 5EC5H, LOC 5ED1H, LOF 5EC9H
416AH / 416DH / 4170H	MKI$ 58DEH, MKS$ 58DBH, MKD$ 58D8H
4173H	CMD 57FFH
4176H	TIME$ 58C4H
4179H	OPEN 5795H (SYS20)
417CH	FIELD 5E63H
417FH / 4182H	GET 6126H, PUT 6125H (SYS10)
4185H	CLOSE 5FA1H
4188H / 418BH / 41A0H	LOAD 574AH, MERGE 572EH, SAVE 573BH (SYS19)
418EH	NAME 1E4AH (ILLEGAL FUNCTION CALL)
4191H	KILL 643CH
4194H	& 5790H (SYS20)
4197H / 419AH	LSET 5908H, RSET 5909H
419DH	INSTR 5786H (SYS20)
41A3H	LINE 579FH (SYS20)
41A6H	Errors: loads SYS13 (680FH)
41A9H	USR 5892H
41AFH / 41B2H	Line input 575DH, after tokenizing 5756H (SYS18)
41B5H / 41B8H	63B3H / 63BCH (save and restore 63A9H)
41BBH	Close all files 5FB6H
41BEH	After PRINT 6438H
41C1H	Character output 6076H
41C4H	Keyboard scan 63C0H
41C7H	RUN 5746H
41CAH	PRINT # 5F52H
41CDH	PRINT number 5F4BH
41D0H / 41E2H	5FA0H (RET)
41D3H	PRINT comma/TAB 5F3BH
41D6H	INPUT # 5EA8H
41D9H	MID$= 578BH (SYS20)
41DCH	INPUT # / READ item 579AH (SYS20)
41DFH	After INPUT / LIST 5EB9H

Main Routines

Address	Purpose
576CH	Overlay loader (Register A = RST 28H code, Register Pair BC = entry)
57C3H	One-letter CMD commands
5DC4H-5E03H	Disk BASIC error entries
5E16H	DOS error to BASIC error
5F7AH	Read a file number
609AH / 609DH	Open a file in the work area
62BCH	Set up a file statement
6445H	End a file statement
6245H	Call a DOS vector with the FCB 570DH
66BEH	Program entry

Each file area is 012DH bytes (022DH with the V option): a 2DH-byte header and a 256-byte buffer (plus a 256-byte record buffer with V). The areas start at 66BEH. The header has the same layout as the work area 5700H-572CH (see Variables): bytes +00H-+0CH are BASIC's control data and +0DH-+2CH the file's FCB. A closed area has 00H in byte +00H.

Offset	Contents
+00H	Mode (00H = not open)
+01H	Flags
+02H-+03H	Record length
+04H-+06H	Position where the last GET/PUT ended
+07H-+09H	Start of the current record
+0AH-+0CH	Position where the last GET/PUT statement started, or the print column
+0DH-+2CH	FCB
+2DH-	Buffer (256 bytes)

5700H - File Statement Work Area (Header Copy and FCB)

While a file statement runs, 62BCH copies the 2DH-byte header of the file area in use to 5700H-572CH and points Index Register IX at 5700H; 6445H copies it back and clears 5700H-572DH when the statement ends. Only 5700H-570CH is in the file (all 00H); 570DH-572CH, the FCB part, is not.

572DH - Busy Byte, LOAD/RUN/MERGE/SAVE Links and the Overlay Loader

572DH is cleared with the header at the end of each file statement and its bit 7 is tested at 646CH. The Disk BASIC links for MERGE (418BH), SAVE (41A0H), RUN (41C7H) and LOAD (4188H) open the file in the work area and load SYS19; the links 41B2H and 41AFH load SYS18. 576CH is the overlay loader: Register A = the RST 28H code, Register Pair BC = the entry to run.

577FH - Links That Load SYS20 (FN, INSTR, MID$=, &, OPEN, INPUT# Item, LINE INPUT, CMD String)

Each entry loads Register Pair BC with a SYS20 entry and joins 5782H, which loads Register A with 36H (SYS20) and goes to the overlay loader.

57AAH - CMD"F=ERASE", CMD"F=KEEP", CMD"O", RST 28H, Upper Case

57AAH and 57AEH are reached from SYS20's search of the function table at 5952H; they and CMD"O" run SYS21. 57B5H is the RST 28H used by the overlay loader. 57B6H-57B9H are work bytes. 57BAH converts a lower case letter to upper case.

57C3H - One-Letter CMD Commands

Reached from 582AH when the CMD string (copied to 4318H) is one character. Register Pair HL points at 4318H; the BASIC text pointer is on the stack. S returns to the DOS, F runs SYS19's CMD"F", C compresses the program, J converts a date, O sorts arrays (SYS21), E shows the last DOS error, D does nothing, R and T switch the RST 38H interrupt vector.

57FFH - CMD Statement

CMD link (4173H, JP 57FFH at 67DCH). The string after CMD (1 to 79 characters) is copied in upper case to SYS0's command buffer 4318H with a 0DH. One character: the letter commands at 57C3H. Ending in $: the text is the name of a string variable whose contents are the command. Otherwise SYS20 runs the command (5202H).

5837H - Function Name for DEF FN and FN

Reads a function name after FN: 40DCH = 80H tells PTRGET that a function name is being looked up (bit 7 set on the first character). Returns Register Pair DE = the entry and the Z FLAG set when it is a string function (value type 03H). 5844H is a second entry, used by SYS20's FN.

5852H - DEF Statement (DEF FN and DEF USR)

DEF link (415BH, JP 5852H at 67C4H) with Register A = the token after DEF. DEF FN name stores the text pointer (the start of the definition) in the function's entry and checks the parameter list; the rest of the statement is skipped like DATA. DEF USRn goes to 586FH.

586FH - DEF USRn Statement

DEF USRn = address stores the address in the USR table at 58B0H. Any other token after DEF is a syntax error.

5883H - USR Digit to Table Slot

Register Pair DE = 58B0H + 2 x n for USRn (n 0-9, 0 when no digit follows). Register Pair HL is the text pointer.

5892H - USR Function

Link 41A9H (JP 5892H at 6812H), called by the ROM for USR. The routine at the address in the slot for USRn is called with Register Pair HL = 4121H (the argument in the floating accumulator) and Register A = the value type; it returns to 5881H, which restores the text pointer.

58B0H - USR Address Table (USR0-USR9) and the TIME$ Entry

Ten addresses set by DEF USRn. Each starts as 1E4AH, so an undefined USR gives ILLEGAL FUNCTION CALL. 58C4H is the entry of the TIME$ link.

58C5H - TIME$ Function

Returns the 17-character string MM/DD/YY HH:MM:SS built by the SYS0 date and time routines.

58D8H - MKD$, MKS$ and MKI$ Functions

The Disk BASIC links for MKD$ (4170H, JP 58D8H at 67D9H), MKS$ (416DH, JP 58DBH at 67D6H) and MKI$ (416AH, JP 58DEH at 67D3H) enter here with the number in the floating accumulator. Register A is set to the length of the result, which is also the ROM's value type code: 08H double, 04H single, 02H integer. The number is converted to that type, a string of that length is reserved and the number's bytes are copied into it.

58EFH - CVD, CVS and CVI Functions

The Disk BASIC links for CVD (415EH, JP 58EFH at 67C7H), CVS (4158H, JP 58F2H at 67C1H) and CVI (4152H, JP 58F5H at 67BBH) enter with the string argument in the floating accumulator. Register A = 08H, 04H or 02H is the number of bytes needed and the value type of the result. A shorter string gives ILLEGAL FUNCTION CALL; otherwise its first bytes are copied into the floating accumulator.

5908H - LSET and RSET Statements

The Disk BASIC links for LSET (4197H, JP 5908H at 6800H) and RSET (419AH, JP 5909H at 6803H). LSET var$ = x$ copies x$ into the existing text of var$ from the left and pads with spaces; RSET pads first, so x$ ends at the right; a longer x$ is cut to the length of var$. A var$ whose text is a literal in the program is first copied to string space so the program is not changed.

5952H - CMD"F=" Function Table

Searched by SYS20 for CMD"F=name": each entry is a length byte, the name and the address of the routine; 00H ends the table. POPS 5316H, POPR 5324H and POPN 5334H are in SYS20 itself; ERASE 57AAH, KEEP 57AEH, SASZ 5C5BH, SWAP 598AH and SS 5BB6H are here.

598AH - CMD"F=SWAP",var1,var2

Exchanges the values of two variables of the same type; the number of bytes exchanged is the type code (2 integer, 3 string descriptor, 4 single, 8 double). Different types give ILLEGAL FUNCTION CALL.

59ADH - CMD"C" Program Compression: Options

CMD"C" removes spaces (outside strings) and remarks; CMD"C",S only spaces; CMD"C",R only remarks (manual 7.13). Allowed only as a direct command. The options set two bytes of code: 5A72H (28H JR Z removes spaces, FEH makes it CP 1EH) and 5A95H (00H NOP drops a remark, 13H INC DE keeps it). SYS0's overlay area 4D00H is used as a line buffer, so 4317H is cleared.

59EBH - CMD"C": Line Loop

Each line is copied to 4D00H (kept as the original), then compressed in place. A line that became empty (only a remark) is dropped. Otherwise the line is listed and tokenized again: if the result differs from the compressed line (for example IFFORDTHEN), the original is put back and the line number is displayed. At the end the line links are rebuilt and BASIC returns to READY.

5A6FH - CMD"C": Copy One Item

Copies from Register Pair HL to Register Pair DE: a space (removed when 5A72H is JR Z), a whole quoted string, or one character. After a colon or at a REM token (93H) the opcode at 5A95H decides whether the remark is copied (INC DE) or dropped (NOP, the destination stops advancing). Returns Z at the line's 00H.

5A9DH - CMD"J",date1,date2: mm/dd/yy to Day of the Year

date1 in mm/dd/yy form is converted to the 3-digit day of the year ddd; date1 starting with - (-yy/ddd) goes to 5B10H. The result string is assigned to the string variable date2 (manual CMD"J"). Bad values give ILLEGAL FUNCTION CALL. The year only decides February: 00 and years not divisible by 4 have 28 days.

5B10H - CMD"J": -yy/ddd to mm/dd/yy

The day of the year is turned into a month and day by subtracting month lengths; the result mm/dd/yy (8 characters) is built at 5BAEH and assigned to date2 through 5AF0H.

5B66H - CMD"J" Helpers

5B66H requires a /; 5B6EH reads a 2-digit number within Register B to Register B + Register C - 1; 5B80H reads the year and puts 28 or 29 into February's entry; 5B95H reads exactly Register B digits. All errors go to ILLEGAL FUNCTION CALL.

5BA1H - CMD"J" Month Lengths

5BA1H is 0 (so the sum at 5ACFH starts from nothing); 5BA2H-5BADH are January to December. February (5BA3H) is set to 28 or 29 by 5B91H.

5BAEH - CMD"J" Result Buffer

The result is built here: ddd in 5BAEH-5BB0H, or mm/dd/ in 5BAEH-5BB3H followed by yy in 5BB4H-5BB5H.

5BB6H - CMD"F=SS" Single Stepping

CMD"F=SS" turns single stepping on, CMD"F=SS",line from that line, CMD"F=SS",N off (manual 7.20). The line number goes into the operand at 63EBH; the opcode at 63DBH becomes 20H (JR NZ, stepping on) or 18H (JR, off).

5BDBH - Variable Name Parser (for SYS21)

Used by SYS21's ERASE/KEEP and CMD"O". Reads a variable name: the first letter goes into Register B, the second character (letter or digit, 00H if none) into Register C, and the type (suffix %, $, ! or #, else the DEF type of the first letter from the ROM table at 4101H) into Register D. They are stored as the compare operands at 5C25H (type), 5C2AH (second character) and 5C30H (first character). Returns Z when a ( follows (an array). 5BDBH steps back first; 5BDDH starts with the character in Register A.

5C21H - Variable Table Helpers (for SYS21)

5C21H compares the variable entry at Register Pair HL with the name stored by 5BDDH (Z = match, Register Pair HL unchanged). 5C34H steps to the next simple variable, 5C3FH to the next array. 5C48H skips a subscript in parentheses (Carry if the statement ends first).

5C5BH - CMD"F=SASZ",size

Changes the size of the string area without clearing variables (manual 7.16). The strings are compacted to the top of memory; the new bottom (top of memory minus size) must be below the lowest string (else OUT OF STRING SPACE) and at least 256 bytes above the arrays (else OUT OF MEMORY). The stack, which lies just below the string area, is moved with it.

5CB9H - String Helpers

5CB9H evaluates a string after a comma and leaves the text pointer on the stack (no caller in this file). 5CC0H/5CCBH take a string result: Register A = length, Register Pair DE = text, Register Pair HL = descriptor. 5CD3H creates a string of length A in the descriptor at Register Pair HL (used by SYS10). 5CDDH copies Register B bytes from Register Pair DE to Register Pair HL; 5CE3H stores Register C spaces. 5CEBH copies a string that lies in the program text to string space. 5CF3H steps to the end of a program line (SYS11, SYS13).

5CFCH - Read a Decimal Number

Reads decimal digits at Register Pair HL into Register Pair DE; Register C returns the number of digits read. 5CFCH allows any number of digits, 5CFEH at most Register B. Returns No Carry at the first non-digit, Carry if the value passes 65535.

5D27H - Number to Decimal Text

5D32H converts Register Pair DE (0-65535) to five digits at 5D51H-5D55H with ROM 132FH and returns Register Pair HL at the first digit that is not a leading zero and Register E (and D) = the number of digits left (at least 1). 5D27H also copies those digits to Register Pair BC.

5D51H - Digit Buffer

Six bytes: 5D51H-5D55H receive the five digits from 5D32H.

5D57H - Display Output (Screen and Printer)

5D66H displays the character in Register A (ROM 0033H) and also prints it when the operand at 5D6CH is 24H ($; set by SYS12 for REF$, cleared at 6457H). 5D57H outputs Register A spaces, 5D64H one space, 5D79H a carriage return, 5D5EH and 5D8EH a number in decimal, 5D7DH divides Register Pair HL by Register A.

5D9FH - Continue a Statement on the Next Line (SYS19, SYS21)

Called by SYS19 (MERGE) and SYS21 (ERASE/KEEP) after a trailing comma: the rest of the line must be empty, colons or a remark (5DB2H); the next line's number goes to 57B8H. No next line: SYNTAX ERROR.

5DB2H - Skip an Empty Rest of Line or a Remark

Returns at the line's 00H (Z). Colons are skipped; anything else must be the REM token, and the remark is skipped.

5DC4H - Disk BASIC Error Entries

One entry per Disk BASIC error: each loads Register A with the error code; the LD BC instructions only hide the next entry's LD A,n, so every entry falls through to 5E05H with its own code. The code in Register E selects the message (SYS13: codes 64H and up are Disk BASIC messages).

5E05H - Report a BASIC Error

Register A = the error code; ROM 19A2H reports it (ON ERROR GOTO, or the message through SYS13).

5E09H - Report an Error After Relinking (SYS11, SYS13)

Used by RENUM in SYS11 and SYS13: the program's line links are rebuilt before the error in Register A is reported.

5E16H - DOS Error to BASIC Error

Register A = a DOS error code. The code OR C0H is kept at 57E5H (for CMD"E"); the table at 5E36H gives the BASIC error, 72H DOS ERROR when the code is not listed. Without ON ERROR GOTO the DOS message is displayed first (57E4H).

5E36H - DOS to BASIC Error Table

Pairs of DOS error code and BASIC error code, ended by 00H. DOS codes not listed become 72H DOS ERROR.

5E63H - FIELD Statement

FIELD link (417CH, JP 5E63H at 67E5H). FIELD [#]n, w AS var$, ... points each string variable at the next w bytes of the file area's 256-byte buffer (area + 2DH). The file must be closed or a random file whose type bits 0-1 are 0; the widths may add up to 256 (else FIELD OVERFLOW).

5EA2H - Find a String Variable

ROM PTRGET finds the variable at Register Pair HL (Register Pair DE = its address); ROM 0AF4H then requires it to be a string.

5EA8H - INPUT # Link

Link 41D6H (JP 5EA8H at 683FH), called by the ROM's INPUT with Register A = the next character. INPUT # to a file (not #-, the cassette) checks the file area (readable) and continues at the ROM's INPUT code for a device.

5EB9H - Link 41DFH (After INPUT and LIST)

Link 41DFH (JP 5EB9H at 6848H), called by the ROM after INPUT assigns its variables (2278H) and in LIST (2B44H). Nothing to do unless a file statement is running (63A9H); then LIST continues at 2B4AH and INPUT # ends at ROM 2282H.

5EC5H - EOF Function Entry

Reached through the Disk BASIC link at 4161H (the JP 5EC5H at 67CAH is copied there). Register B = 01H selects EOF for the common routine at 5EE6H.

5EC9H - LOF Function Entry

Reached through the Disk BASIC link at 4167H (the JP 5EC9H at 67D0H). Register B = 02H selects LOF: 5FF0H returns the file's end position and 5EE6H divides it by the record length (5F08H), rounding up, so LOF returns a number of records.

5ECDH - LOC Suffix Characters

The four characters that may follow LOC(fan): $, %, ! and #. The loop at 5ED9H compares the character at the BASIC text pointer with them in this order. They are data: nothing executes 5ECDH-5ED0H (5ECBH jumps away and the LOC link enters at 5ED1H).

5ED1H - LOC Function Entry

Reached through the Disk BASIC link at 4164H (the JP 5ED1H at 67CDH). Looks for one of the suffixes $, %, ! or # (manual section 8.12) and sets Register B to the selector: 40H LOC(fan)$ (next record at or past EOF), 20H LOC(fan)% (EOF as a byte address), 10H LOC(fan)! (next record or current position), 08H LOC(fan)# (REMRA), 04H plain LOC(fan) (the previous record number).

5EE6H - Common EOF/LOF/LOC Routine

Register B is the selector from 5EC5H, 5EC9H or 5ED1H. 5FF0H reads the file number and returns a 24-bit value in Registers H:L:C (for LOF and LOC% it returns early at 6006H). For LOF (02H) and plain LOC (04H) the file area must have bit 2 of its byte +00H set (6660H) and the value is divided by the record length, rounded up (5F08H). The result is then converted to a single-precision number and returned through 637EH.

5F08H - Divide H:L:C by the Record Length (LOF, LOC)

Called from 5EEFH. Divides the 24-bit value in Registers H:L:C by the 16-bit record length at 5702H-5703H with 24 shift-and-subtract steps (counter in Register A', quotient bits collected in Register A and shifted up through Register Pair DE). The quotient is rounded up when there is a remainder; a quotient above FFFFFFH after rounding gives BASIC error 64 (5DD9H).

5F3BH - Link 41D3H (PRINT Comma and TAB to a File)

Link 41D3H (JP 5F3BH at 683CH), called by the ROM's PRINT comma (2108H) and TAB (2141H). During a file statement the file's print column (570AH) is used instead of the screen's.

5F4BH - Link 41CDH (PRINT a Number to a File)

Link 41CDH (JP 5F4BH at 6836H), called by the ROM after a number is converted for PRINT (20C6H). During a file statement the check whether the item fits on the screen line is skipped.

5F52H - Link 41CAH (PRINT #)

Link 41CAH (JP 5F52H at 6833H), called by the ROM's PRINT (206FH). PRINT # to a file (not #-, the cassette) needs a writable file. 5F5DH is the entry for INPUT # (readable).

5F5DH - Entry for INPUT # (Readable File)

Called from 5EB2H: the file must be readable.

5F5FH - Check the File for PRINT # and INPUT #

Register C = the mode bit that must be set (40H writable, 20H readable). Random files are not allowed.

5F7AH - Read a File Number

Reads [#]n at Register Pair HL. Register Pair BC returns the address of file area n (66BEH + (n - 1) x the area size at 64C5H), Register A its mode byte (Z if the file is not open). n above the file count (5F89H) is BAD FILE #. 5F84H starts with the number already evaluated.

5FA1H - CLOSE Statement

CLOSE link (4185H, JP 5FA1H at 67EEH). CLOSE alone closes all files (5FB6H); CLOSE n, m, ... closes the ones listed.

5FAFH - Close the Work Area File

Called at 6470H for a file that LOAD, RUN, MERGE, SAVE or KILL opened in the work area at 5700H.

5FB2H - Close One File Area

Register Pair BC = the file area.

5FB6H - Close All Files

Link 41BBH (JP 5FB6H at 6824H), called by the ROM for NEW and END, and by CLOSE without numbers. Nothing is done if no area is open. SYS19's RUN with the R option makes 5FCFH a RET so no file is closed; 6476H puts back the RET Z.

5FD5H - Close the Area in Register Pair BC

Writable files are closed through SYS0 4428H; the 2DH-byte header is cleared either way. Then the loop at 5FCEH goes on with the next area.

5FF0H - EOF, LOF and LOC: Read the File's Position

Called from 5EE6H with Register B = the selector (01H EOF, 02H LOF, 04H LOC, 08H LOC#, 10H LOC!, 20H LOC%, 40H LOC$). Returns the value as a 24-bit number in Registers H (high), L and C (low), or, for EOF and LOC$, finishes the function itself with -1 or 0.

6034H - EOF and LOC$ Results

EOF is -1 only exactly at the end of file; LOC$ is -1 at or past it (manual 8.12). Other selectors return the position.

604FH - LOC Without a Known Record

Plain LOC (04H) returns 0 when no record has been read or written; the others go on with the current position.

6058H - Compare a Position With EOF

6058H compares the current position NEXT, 605BH the position in Registers H, L and C, with the end of file: Z equal, Carry below.

6065H - Next Record Position

Registers H, L and C = the last record start (5707H-5709H) plus the record length (5702H-5703H).

6076H - Link 41C1H (Output a Character to a File)

Link 41C1H (JP 6076H at 682AH), called by the ROM's character output (032CH). During a file statement to a writable file the character in Register A goes to the file, and the print column (570AH) is kept: printable characters count, 0DH resets it.

609AH - Open a File in the Work Area

609AH opens for LOAD, RUN, MERGE and KILL with Register B = 01H (existing file only) and Register C = 20H (readable); 609DH takes the mode in Register Pair BC (SAVE: 8440H).

609DH - Open the File Named in the Statement

The work area 5700H is cleared and becomes the statement's file area; bit 7 of 572DH marks it as a work-area file (buffer 4200H, closed at 6470H). The filespec is copied to the FCB at 570DH and opened: Register B bit 0 set = existing file only (SYS0 4424H), else 4420H. Bit 2 of Register B sets EOF to 0, bit 1 starts at EOF. 5700H gets Register C (the mode), 5701H Register B AND F8H.

6112H - Set EOF

Stores Register A (low) and Register Pair HL (middle, high) as the end of file (FCB+8 at 5715H, FCB+12/13 at 5719H).

6119H - Read a Byte From the Work Area File

Used by SYS19 and SYS20 to read text files: ROM 0013H through the FCB at 570DH. Returns Z with the byte in Register A; at the end of file (DOS 1CH/1DH) NZ with Register A = the code (63A0H); other errors go to 5E16H.

6125H - PUT and GET Statements

The Disk BASIC links for PUT (4182H, JP 6125H at 67EBH) and GET (417FH, JP 6126H at 67E8H). The flag (NZ for PUT, Z for GET) is pushed, the file statement is set up, SYS10 is loaded and its GET/PUT code at 4D03H does the work.

6131H - Load SYS10 and Note the Position

RST 28H with code 2CH loads SYS10 (its 4D00H entry returns at once). 6134H stores the current position NEXT, 6137H the position in Registers C, L and H, at 5704H-5706H (where the last GET or PUT ended). Also called from 624FH to reload SYS10 after a DOS call.

613EH - Store the Record Start

Stores Registers C, L and H at 5707H-5709H and sets bit 6 of 5701H (the record start is known). Used by PRINT #/INPUT # (5F75H) and SYS10.

6149H - Read the Last GET/PUT End

Registers C, L and H = the position at 5704H-5706H.

6150H - Read the Record Start

Registers C, L and H = the record start at 5707H-5709H; BAD FILE MODE if bit 6 of 5701H is clear (no record yet). 6156H only makes the check (SYS10).

615DH - String Item Marker (SYS10)

Called from SYS10 when writing a string item with a length prefix. Register B = the string's length; the prefix n at 5094H (inside SYS10) limits it. Returns Register B = the length to write and Register A = the marker 80H + n; for 128 bytes or more the marker 71H is written first and Register A = n, the length byte.

6173H - Check the Mode for GET and PUT (SYS10)

The file must be random (bit 7 of 5700H) and readable for GET or writable for PUT (bit 4 marks a PUT); otherwise BAD FILE MODE. Returns with the Carry FLAG set when allowed.

6185H - PUT at or Past the End of File (SYS10)

Registers C, L and H = the position of the PUT. At or past EOF bit 4 of 572DH is set; past it the file must have fixed-length records (else BAD FILE POSITIONING PARAM), and an item file is filled with records of 00H bytes up to the position.

61ACH - Write 00H Bytes

Writes Register Pair HL bytes of 00H to the file (61AFH skips the zero test for the first byte).

61B7H - Evaluate an Expression, Text Pointer on the Stack

Used by CMD"J" and SYS10: evaluates the expression and leaves the text pointer on the stack under the return address. Returns NZ for a number; for a string Z with Register B = its length and Register Pair HL = its text.

61CAH - Position the File

61CAH positions the file to where the last GET or PUT ended (5704H-5706H); 61CDH to Registers C, L and H, through SYS0 444EH.

61D3H - Read NEXT

Registers C, L and H = the current position NEXT (FCB+5 at 5712H, FCB+10/11 at 5717H-5718H).

61DAH - Read EOF

Register A and Register Pair HL = the end of file (FCB+8 at 5715H, FCB+12/13 at 5719H-571AH).

61E1H - Read NEXT and EOF

Registers C, L and H = NEXT; Register Pair DE = the middle and high bytes of EOF and Register A its low byte. 61E4H reads only EOF into Register Pair DE and Register A.

61EAH - Read a Byte From the File

ROM 0013H through the FCB at 570DH (6245H).

61EFH - Write an Item Marker and Its Data (SYS10)

Register A = the marker, Register B = the number of data bytes at Register Pair HL. The room left in the record (operand 61F1H, set by SYS10) is reduced by B + 1; none left is RECORD OVERFLOW. With bit 2 of 572DH (the % format-only mode) nothing is written.

6206H - Write a Byte and Data Bytes

Writes the byte in Register A and then Register B bytes from Register Pair HL (6231H). Writing past EOF needs bit 7 of 5701H (the file may be extended), else ILLEGAL TO EXTEND FILE.

622CH - Write a Byte to the File

ROM 001BH through the FCB at 570DH (6245H).

6231H - Write or Read a Block in Record Mode

6231H writes Register A bytes from Register Pair HL unless 572DH bit 2 (format only) is set; 6236H writes them (SYS0 443CH, write with verify), 623BH reads them (SYS0 4436H). FCB+1 bit 7 (record mode) is set and the record length FCB+9 (5716H) is Register A.

623BH - Read a Block in Record Mode (SYS10)

Register Pair DE = 4436H (read).

6254H - Call a DOS Vector With the FCB

Pushes the vector in Register Pair DE as the return address and loads Register Pair DE with the FCB 570DH, so the RET jumps to the vector.

6259H - Read a Sector

SYS0 4436H with FCB+1 bit 7 cleared (sector mode). Used by SYS10.

625EH - Write a Sector

SYS0 443CH (write with verify) with FCB+1 bit 7 cleared. Used by SYS10.

6267H - Rewind

SYS0 443FH through the FCB. Used by SYS19.

626CH - Skip Bytes in the File

Moves NEXT forward by Register B (626CH) or Register A (626DH) bytes; past 24 bits is DOS error 1DH.

627FH - Skip One Item (SYS10)

Checks that the position is still inside the record (635BH), reads an item marker (6293H) and skips the item's data. Returns Z and Carry at a record start (70H), NZ otherwise.

6293H - Read an Item Marker

Returns Z and No Carry for 00H (a filler byte), Z and Carry for 70H (a record start); otherwise NZ with Register A = the type and Register B = the length: 71H n and 80H + n strings (type 3, length n), 72H integer (2), 73H single (4), 74H double (8). Any other byte is BAD FILE DATA.

62BCH - Set Up a File Statement

62BCH reads the file number first (5F7AH); 62BFH starts with the area in Register Pair BC. Only one file area per statement (63A9H must be 00H, else error A4H STMT USES 2 FILE AREAS). The area's address is kept at 6379H, 63A9H is set to C9H, Index Register IX = 5700H and the area's 2DH-byte header is copied to 5700H (572DH cleared). Returns Register A = the mode byte, Z if the file is not open.

62E4H - Copy an Area's Header to 5700H

Register Pair HL = the area (used at 6494H).

62E7H - Set Up a File Statement and Require a Comma

For PRINT # and INPUT # (and SYS20).

62EEH - Item Prefix Checks (SYS10)

Bit 6 of 572DH means a length prefix was given. 62EEH: a numeric item may not have one; 62F5H/62F7H: the item needs one (error 9EH BAD/ILLEGAL/MISSING IGEL ITEM PREFIX).

62FFH - Item Variable for a Type F File (SYS10)

Type M files return Z. Type F (mode bit 1) returns NZ with Register C = the prefix length (5094H) and either Register A = # or $ (Register Pair DE after it) or Register A = 00H with Register Pair HL = the variable's address (PTRGET); a string variable needs a prefix.

6326H - Fill the Rest of a Record After PUT (SYS10)

After a PUT (mode bit 4) to a record-segmented file (mode bit 3) the rest of the record is filled with 00H bytes where the type needs it: the room left (61F1H), or, for a type MU file not at EOF with 572DH bit 3, up to EOF.

6358H - Room Left in the Record (SYS10)

6358H: the record length minus the bytes from the record start (5707H) to the end of the last GET/PUT (5704H); 636DH: to NEXT. RECORD OVERFLOW if negative; returns Register Pair HL = the room.

636DH - Room Left, From NEXT (SYS10)

Uses the current position instead of 5704H.

6374H - Copy the Header Back to the File Area

5700H-572CH is copied to the area whose address is the operand at 6379H.

637EH - End a File Function

Pushed as the return for EOF, LOF and LOC: the header is copied back, the statement flag cleared and the work area 5700H-572DH cleared. 6381H only clears; 6389H clears Register B bytes at Register Pair HL.

638FH - End of Statement or a Comma

Z if the statement ends; otherwise a comma must follow and NZ is returned with Register A = the next character.

6397H - Read the Next Sector (SYS19)

SYS0 4436H through the FCB 570DH. Returns Z on success; at the end of file (DOS 1CH or 1DH, 63A0H is also used by 6119H) NZ with Register A = the code; other errors go to 5E16H.

63A9H - File Statement Flag

The byte at 63A9H is 00H (NOP) when no file statement is running and C9H (RET) while one is. The links call 63A9H first: with 00H the INC SP / INC SP / RET drops the call and returns straight to the ROM; with C9H the call just returns. 63ADH sets it, 63B3H (link 41B5H) saves it at 63BDH and clears it, 63BCH (link 41B8H) puts it back.

63ADH - Mark a File Statement Running

63A9H = C9H (called from 62CCH and SYS19).

63B3H - Link 41B5H: Save and Clear the Flag

Called by the ROM after the program's line table is rebuilt (1AECH).

63BCH - Link 41B8H: Restore the Flag

Called by the ROM after the line table and CLEAR (1AF2H).

63C0H - Link 41C4H (Keyboard Scan), File Statement End and Single Stepping

Link 41C4H (JP 63C0H at 682DH), called by the ROM's keyboard scan (0358H). When BASIC starts a new statement (the scan called from 1D21H) the file statement is ended (6445H); at the start of a line single stepping runs when 63DBH is JR NZ. During RUN ONLY (6421H) or chaining (4369H bit 5) the scan is skipped and no key is returned.

63DDH - Single Step

Before the next line runs its number is shown as @nnnnn at the top right of the screen (3C39H) and the program waits for ENTER (step) or BREAK. With a start line (63EBH) nothing happens until that line comes up.

642EH - Blank to the End of the Screen Line

Stores spaces from Register Pair BC up to the next 64-byte line boundary.

6438H - Link 41BEH (After PRINT)

Link 41BEH (JP 6438H at 6827H), called by the ROM when a PRINT ends (and from its error handling): the file statement is ended through 6447H with 6482H = JR NZ, so that on an error (called from 19B4H) the file area's control data is put back as it was (manual 8.13).

643CH - KILL Statement and the End of a File Statement

KILL link (4191H, JP 643CH at 67FAH): the file is opened in the work area and killed with SYS0 442CH, then the statement ends. 6445H ends a file statement (called at each new statement from 63D6H, by SYS10 and SYS18): 6482H becomes JR (always write the header back).

644AH - End the File Statement

Calls the cleanup hook at 644EH (a RET, or SYS19's/SYS21's while they run), clears the SYS10 reload flag (624DH), the printer echo (5D6CH), 65C9H and 4369H bit 6, sets 40A9H to 1. If a file statement ran: a work-area file (572DH bit 7) is closed; otherwise the header is copied back to the file area, except that after an error (called from ROM 19B4H with 6482H = JR NZ) the area's position and FCB+1 are put back as they were before the statement. Then 5700H-572DH is cleared.

64BEH - Restore the Cleanup Hook

Puts 64BDH (a RET) back into the operand at 644EH. Used by SYS19 and SYS21 when they finish.

64C5H - FCB Size Storage

Two bytes, not in the file, that hold the size of one file area: 012DH (301 bytes) stored by 6711H, or 022DH when 6730H sets the high byte to 02H.

64CAH - Initialization: Establish and Verify the Top of BASIC Memory

Execution arrives here from the JP 64CAH at 6759H, the last instruction of the program entry code at 66BEH. By this point the entry code has parsed the parameters typed after BASIC on the DOS command line and stored its results inside the code below: the number of file buffers in the operand at 6529H, the size of one file control block in 64C5H-64C6H, any requested top of memory in the operand at 64CBH-64CCH, and the address of the startup command text in the operand at 655EH-655FH. It has also copied the ROM's 39-byte division support table from 18F7H-191DH to 4080H-40A6H, as the ROM's own power-up code does. This routine decides where BASIC's memory ends, proves that RAM exists at that address, and sets MEMSIZ and STKTOP.

Everything from 64CAH through 65AFH runs only once. At 6502H this address becomes BASIC's keyboard input buffer, and every line BASIC reads afterward is stored over this code. The ROM line-input routine accepts up to 240 characters plus a 00H terminator, so the buffer occupies 64CAH-65BAH at most. The three bytes 3AH, 00H, 2CH at 64C7H-64C9H, immediately in front of it, are the same three bytes the ROM's power-up code places at 41E5H-41E7H in front of its own default buffer at 41E8H.

64F3H - Initialization: Sign-On Message, Line Number, Input Buffer and BREAK Vectors

With the memory pointers set, display the NEWDOS/80 Disk BASIC sign-on message, set the current line number, make 64CAH BASIC's keyboard input buffer, and set the vector at 4312H and the operand at 6421H according to bit 6 of the NEWDOS/80 flag byte at 436CH.

651CH - Initialization: Install the Disk BASIC Link Table

Copy BASIC/CMD's 147-byte link table from 67BBH-684DH over the link area at 4152H-41E4H. The ROM's power-up code fills the 28 Disk BASIC statement links at 4152H-41A5H with JP 012DH (?L3 ERROR) and the 21 DOS links at 41A6H-41E4H with RET. After this copy each slot holds a JP into BASIC/CMD or the ROM, except 41A6H, the error message link, which receives LD A,2FH / RST 28H. Two of the links matter later in this code: 41AFH, the keyboard line-input link called from 0368H inside INLIN, becomes JP 575DH, and 41BBH, the NEW/END close-files link, becomes JP 5FB6H. Interrupts stay disabled from here until the stack has been moved at 6530H.

652DH - Initialization: Clear the File Control Block Table

Zero one file control block per file buffer, starting at 66BEH. The program entry code at 66BEH has finished, so the table is written over it. Each block is the size held at 64C5H-64C6H: 012DH (301 bytes) as set by the entry code at 6711H, 022DH (557 bytes) when the file count on the command line was followed by V (set at 6730H), or the previous session's size, left unchanged, when BASIC is started with an asterisk. Register A holds the number of file buffers from 6528H.

6548H - Initialization: Set the Program Start, Check Workspace, and Perform NEW

Register Pair HL points one byte past the file control block table (66BEH when there are no file buffers). BASIC requires a 00H byte immediately in front of the first program line, so that byte goes here and the program text area begins at the next address. BASIC then requires at least 300 bytes between the program start and the top of memory, and calls the ROM's NEW code to set up an empty program and clear the variables.

655DH - Startup Command Dispatch

Decide what BASIC does first, from the text that followed BASIC and its numeric parameters on the DOS command line. If that text begins with an asterisk, BASIC was restarted with the previous session's program still in memory: the program's first link word and its end address, both saved by the entry code before NEW erased them, are put back, and the command text at 54E9H is queued. If there is any other text, it is queued as the first direct command. If the command line ended there (0DH), BASIC goes straight to READY. A queued command is delivered by placing 6589H in the vector at 5205H-5206H.

6589H - Startup Command Hook

Reached through the vector at 5205H-5206H installed at 6583H, on BASIC's direct-mode line-input path: the ROM command loop has called INLIN (0361H), INLIN has called its DOS link at 41AFH, and 575DH has verified the command loop's return address 1A7EH and dispatched SVC 34H to continue at 5202H. This code runs once. It restores the vector to 0033H, erases the READY message from the screen, copies the startup command into the input buffer at 64CAH, and leaves through INLIN's own exit code at 0379H, so the command loop receives the command exactly as if it had been typed and ENTER pressed.

65ACH - Screen Control String (Data)

The four-byte string displayed at 6594H through SYS0 routine 4467H. It is data, not code, and is the last part of the load block that begins at 64C7H. The load file contains nothing for 65B0H-65C8H.

65C9H - Flag Byte and Unreferenced Bytes (Data)

The first six bytes of the load block that begins at 65C9H. They are data, not code.

65CFH - Advance the Text Pointer and Test for an Equals Sign

Advances Register Pair HL by one byte and tests the character there for =. Entry: HL points one byte before the character to test. Exit: HL points to the character, Register A holds it, and the Z FLAG is set if it is =. No instruction in BASIC/CMD calls this routine.

65D4H - Fetch File Block Byte +12H With BC Preserved

Called from 6208H with Index Register IX pointing to a file's block. Calls 61E1H, which returns byte +12H of the block in Register C, the word at 5717H-5718H in HL, the word at 5719H-571AH in DE and the byte at 5715H in A, then moves byte +12H into Register A and restores Register Pair BC, which 61E1H would otherwise change.

65DBH - Get the File Control Block Size

Called from 5FC1H in the close-all-files routine at 5FB6H, which steps through the file control block table at 66BEH one block at a time.

65E0H - Set Bit 7 of File Block Byte +04H

Sets bit 7 of byte +04H of the block that Index Register IX points to. No instruction in BASIC/CMD calls this routine.

65E5H - Scan the 4200H Table for a Matching Word

If the caller's flags are NZ, report ?FC ERROR. Otherwise compare the word at +05H-+06H of the block that Index Register IX points to with the word at +05H-+06H of each 17H-byte (23-byte) entry of the table at 4200H, starting with the first entry when the byte at 5102H is 00H and with the second entry (4217H) otherwise, and set bit 6 of the block's byte +04H for each match. The scan continues while byte +00H of the next entry is less than Register C. No instruction in BASIC/CMD calls this routine.

6617H - Store Register A at 4F02H Unless File Block Byte +04H Bit 6 Is Set

Tests bit 6 of byte +04H of the block that Index Register IX points to (the bit set at 6606H). When it is clear, Register A is stored at 4F02H. No instruction in BASIC/CMD calls this routine.

6620H - Load File Block Byte +13H and, When Byte +04H Bit 6 Is Set, Add BC to HL

Loads Register E with byte +13H of the block that Index Register IX points to. If bit 6 of the block's byte +04H is set, it also discards the top word of the stack and adds Register Pair BC to HL before returning, so that when it was entered by CALL it returns to the caller's caller. No instruction in BASIC/CMD calls this routine.

662BH - Add DE to HL B Times Unless File Block Byte +04H Bit 6 Is Set

If bit 6 of byte +04H of the block that Index Register IX points to is clear, adds Register Pair DE to HL, Register B times (256 times when B is 00H), leaving B at 00H. No instruction in BASIC/CMD calls this routine.

6634H - Store H at File Block +0AH and Move a Block Downward in Memory

Stores Register H at byte +0AH of the block that Index Register IX points to. Then, unless bit 6 of the block's byte +04H is set, moves the BC bytes that end just below the entry value of DE so that they end just below the entry value of HL plus BC, working from the highest byte down. Entry: HL = destination start, DE = address just past the source, BC = byte count. Exit: A = 00H with the Z FLAG set, unless bit 6 was set. No instruction in BASIC/CMD calls this routine.

6648H - Evaluate a String Argument, Then Continue at 4DE4H and 4E17H

Evaluates the expression at the BASIC text pointer through 664FH, which passes control to 4DE4H; when 4DE4H returns, execution resumes at 664BH, which pushes HL and continues at 4E17H. 4DE4H and 4E17H are in the overlay area at 4D00H-51FFH. No instruction in BASIC/CMD calls 6648H.

664FH - Evaluate a String Argument and Continue at 4DE4H

Called from 6648H. Calls 61B7H, which evaluates the expression at the text pointer and, when the result is a string, returns with the Z FLAG set, the string length in Register B and the updated text pointer on the stack. This routine then moves the text pointer beneath its own return address and passes control to 4DE4H in the overlay area.

6658H - Test A, L and C for Zero

ORs Register L and Register C into Register A. If all three are zero, BASIC error 64 is reported through 5DD9H; otherwise the routine returns with Register A holding the value of C and the flags set from it. No instruction in BASIC/CMD calls this routine.

6660H - Require File Block Byte +00H Bit 2

Called from 5EECH when Register B has bit 1 or bit 2 set (tested at 5EEAH, after the CALL to 5FF0H). Reports BASIC error 55 unless bit 2 of byte +00H of the block that Index Register IX points to is set.

6668H - Unused Space

84 bytes of 00H between the last routine and the program entry area. No instruction in BASIC/CMD reads, writes or executes them.

66BCH - Unreferenced Bytes Before the Program Entry Point (Data)

The two bytes immediately below the program entry point at 66BEH. They are data, not code.

66BEH - Program Entry Point

The DOS transfers control here after loading BASIC/CMD; 66BEH is the load file's transfer address. Register Pair HL, as passed by the DOS, points into the DOS command line just past the program name BASIC. The code from here through 675BH reads the rest of that line, stores what it finds into the initialization code at 64CAH-6589H, and jumps to 64CAH. It runs only once: the file control block table that 653CH clears begins at 66BEH and is written over it.

Two forms of the command line are handled. BASIC followed by an asterisk restarts BASIC with the previous session's program and memory layout still in place. Otherwise BASIC may be followed by numbers separated by commas: 0-15 is the number of file buffers (optionally followed by V for 557-byte blocks), and 256 or more is the memory size. Text that does not begin with a digit, either directly after BASIC or after a comma, ends the parameters and becomes the first command BASIC executes.

670DH - Read the Numeric Parameters

BASIC was not started with an asterisk. Set the default file control block size, then read numbers separated by commas. A value of 0-15 is the number of file buffers and may be followed by V for 557-byte blocks; a value of 256 or more is the memory size; a value of 16-255 is rejected. A character that is not a digit, where a number could begin, ends the parameters; HL then points to the startup command, or to the 0DH at the end of the line. After a number, only a comma or the ending 0DH may follow; anything else sends BASIC back to DOS. Register Pair HL points to the first non-blank character after BASIC.

6747H - Store the Results and Enter Initialization

Reached from 6704H with the number of file buffers of a BASIC with an asterisk restart in Register A, or at 674BH from the parameter reader with Register Pair HL pointing to the startup command or to the 0DH at the end of the line.

675CH - Sign-On Message Text (Data)

The sign-on message displayed at 64F6H through the NEWDOS/80 SYS0 routine at 4467H, which stops at the 0DH at 67BAH. It reads: DISK BASIC. RADIO SHACK'S ROM ENHANCED WITH on one line and APPARAT'S NEWDOS80 EXTENDED AND DISK FEATURES. on the next.

67BBH - Disk BASIC Link Table (Copied to 4152H-41E4H)

Forty-nine three-byte entries, 67BBH-684DH, copied by the LDIR at 6526H over the ROM's link area at 4152H-41E4H. They execute there, not here: the name at the start of each description is the RAM slot the entry occupies at run time. The first 28 slots, 4152H-41A5H, are where the ROM sends each Disk BASIC statement and function; the other 21, 41A6H-41E4H, are the DOS links the ROM calls at fixed points. No entry jumps into this table, so each link below goes to the target's own address.