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

BASIC/CMD

Other Navigation

BASIC/CMD is the core Disk BASIC extension module for NEWDOS/80 v2.0 on the TRS-80 Model I. This file provides the essential interface between Level II BASIC and the DOS file system. It handles:

• CMD Commands: Processing CMD"O" (open), CMD"S" (system), CMD"F" (format/filespec), CMD"C" (copy), CMD"J" (jump table), CMD"E" (enable/disable), CMD"R" (repeat), CMD"T" (timer), and CMD"D" (debug).
• File I/O Statements: OPEN, CLOSE, GET, PUT, PRINT#, INPUT#, LINE INPUT#, and related file handling.
• Extended Functions: LOF (length of file), LOC (location in file), EOF (end of file), DATE$, TIME$.
• Memory Management: CLEAR statement extensions, string space handling.
• Program Control: RUN, LOAD, SAVE, MERGE support for disk operations.

The module loads at 5700H-684BH and integrates with both ROM BASIC (0000H-2FFFH) and SYS0 (4000H-4CFFH) through supervisor calls (RST 28H).

Program Entry Point: 66BEH (BASIC initialization)

NOTE: This disassembly is on the UNPATCHED/AS SHIPPED version of BASIC/CMD.

FCB Work Area (5700H-572CH)

Address	Bytes	Purpose
5700H-5701H	2	File Control Block (FCB) flags/status word
5702H-5704H	3	File position (24-bit: low word + high byte)
5705H-5706H	2	Saved file position (low word)
5707H-5709H	3	End-of-file position (24-bit)
570AH	1	Character count / column position
570DH-5716H	10	Filename buffer (8 chars + extension)
5717H-5719H	3	Current record position
572DH	1	FCB status flags (bit 7 = file open)

Other BASIC/CMD Variables

576EH	1	Self-modifying code: SVC return value
57B8H-57B9H	2	Pointer storage for string operations
58B0H-58C3H/td>	20	PDevice vector table (10 entries × 2 bytes)
5A20H-5A21H	2	Line number storage for COMPRESS
5A72H	1	COMPRESS: space handling flag (self-mod)
5A95H	1	COMPRESS: REM handling flag (self-mod)
5BA1H-5BADH	13	DATE$ calculation table (days per month)
5BAEH-5BB5H	8	DATE$ string buffer
5BB4H-5BB5H	2	Year storage for DATE$ calculation
5C25H	1	Variable type byte (self-modifying)
5C2AH	1	Variable name modifier (self-modifying)
5C30H	1	Variable first char (self-modifying)
5D51H-5D56H	6	Numeric conversion buffer
5E13H	1	Error code storage (self-modifying)
5F89H	1	Number of open file buffers
6379H-637AH	2	Current FCB pointer
637EH	1	Return value buffer for functions
63A9H	1	File operation status (C9H=RET or 00H=NOP)
63DBH	1	LPRINT width setting
63EBH-63ECH	2	TRON line number filter
64C5H-64C6H	2	FCB block size
655EH-655FH	2	Command line continuation pointer
65C9H	1	Initialization flag

DOS Variables Used

4012H	Interrupt vector (C3H=enabled, C9H=disabled)
4040H	Timer tick counter
4121H	BASIC string descriptor
4317H	Line counter (COMPRESS)
4369H	DOS system flags (bit 6 = output in progress)
40A2H	Variable area start
40A4H	BASIC program start
40AFH	Device type byte
40DCH	Current device byte
40F9H	String space pointer

Self-Modifying Code Variables

576EH	SVC return value storage (modified by 5774H)
5A72H	COMPRESS space handling flag (set by 59D4H)
5A95H	COMPRESS REM handling flag (set by 59D8H)
5C25H	Variable type byte
5C2AH	Variable name modifier
5C30H	Variable first char
5E13H	Error code storage

CMD Entry Points

572EH	CMD"S" entry (System - returns to DOS)
5736H	CMD"F" entry (Filespec)
573BH	Special open mode entry
57C3H	CMD command character router
57C9H	CMD"S" handler (JP 402DH)
59ADH	CMD"C" (COMPRESS) entry
5A9DH	CMD"J" (DATE$) entry

SVC Dispatchers

5746H	Conditional return
574AH	File buffer setup
5752H	Common entry (SVC 35H)
5756H	Push AF/BC entry
575DH	Stack cleanup
576AH	Entry with SVC 34H
576CH	Main SVC Dispatcher
57AAH	SVC 57H with B=28H
57AEH	SVC 57H with B=20H
57B0H	SVC 57H executor
57B3H	SVC 37H executor
57B5H	Main SVC executor (RST 28H)

Utility Routines

57BAH	Lowercase to uppercase converter
57FFH	NAME statement handler
5837H	File device setup
5844H	Direct device type setup
584CH	Device type check
5852H	OPEN statement
586FH	CLOSE statement
5883H	Device number parser
5892H	PRINT# handler
58C5H	TIME$ function
58D8H	INPUT# type 1
58DDH	INPUT# type 2
58EFH	INPUT# alternate
5908H	MID$ assignment
598AH	SWAP statement

Data Areas

58B0H	Device vector table (20 bytes)
5952H	Keyword token table

FCB Table starts at 66BEH. FCB block size stored at 64C5H.

Offset	Size	Purpose
+00H	1	Status byte (bit 0=open, bit 1=write mode)
+01H	1	Flags (bit 3=write, 4=dirty, 5=modified, 7=valid)
+02H	3	Current file position (24-bit)
+05H	2	Saved position (for record ops)
+07H	3	EOF position (24-bit)
+0AH	1	Column counter
+0BH	1	Reserved
+0CH	1	Reserved
+0DH	10	Filename buffer
+17H	3	Record position
+1AH+	...	Additional fields
+2DH	1	FCB flags byte

5700H - FCB WORK AREA AND RESERVED SPACE: File Control Block Work Area

This area (5700H-570CH) serves as the active File Control Block (FCB) work area. When a file is opened, the 45-byte FCB structure is copied here from the FCB table at 66BEH. The NOPs represent uninitialized storage that gets populated with file status, position pointers, and buffer addresses during file operations.

572DH - CMD COMMAND DISPATCHER ENTRY POINTS: CMD"S" Entry Point (System Command)

This section contains entry points for various CMD commands. Each entry point sets up Register BC with a return address, loads Register A with an SVC code, and jumps to the common dispatcher at 576CH. The CMD dispatcher at 57C3H examines the character following CMD" to route to the appropriate handler.

577FH - More CMD Command Entry Points

These entry points handle additional CMD commands. Each loads BC with a specific return address and A with SVC code 36H, then uses the common dispatcher. SVC 36H is used for extended disk operations including KILL, RENAME, and directory functions.

57AAH - SVC Wrapper Routines

These routines provide wrappers for executing supervisor calls (RST 28H) and include a lowercase-to-uppercase conversion function used when parsing filenames and commands.

57C3H - CMD Command Character Router

This is the main CMD command dispatcher. When BASIC encounters CMD"X" where X is any character, this routine examines X and routes to the appropriate handler. It supports: S (system), F (filespec), C (copy/compress), J (jump), O (open device), E (enable/disable interrupts), D (debug), R (reset/repeat), and T (timer).

57FFH - BASIC NAME Statement (Rename File)

This routine handles the BASIC NAME statement which renames files on disk. Syntax: NAME "oldname" AS "newname". It parses both filenames, validates them, and calls the DOS rename function.

5837H - FILE DEVICE HANDLER AND OPEN ROUTINES: File Device Setup

These routines handle file device setup, including setting the device type byte and calling ROM routines for file operations. They interface with both the BASIC file handling and DOS file operations.

5852H - BASIC OPEN Statement

This routine handles the BASIC OPEN statement (token BEH). Syntax: OPEN "mode",#n,"filename" where mode is "I" (input), "O" (output), or "R" (random). It parses the parameters and sets up the file control block.

586FH - BASIC CLOSE Statement

This routine handles the BASIC CLOSE statement (token C1H). Syntax: CLOSE #n or CLOSE #n,#m,... It parses file numbers and closes each specified file buffer.

5883H - Parse Device/File Number

This routine parses a device number (0-9) from the BASIC line and returns a pointer to the corresponding entry in the device vector table at 58B0H. Each entry is 2 bytes, so the number is doubled to get the offset.

5892H - PRINT# Statement Handler

This routine handles the PRINT# statement, which outputs data to a file device. It retrieves the device number, evaluates the expression to print, and sends the data to the appropriate file buffer. The routine begins by restoring flags from a previous operation and then calls the device parser to determine which file device to use.

58B0H - Device Vector Table

This is a data table containing 10 two-byte addresses for device handlers. Each entry corresponds to a device number (0-9) used with file I/O statements like PRINT#, INPUT#, etc. Device 0 is typically the keyboard/display, and devices 1-9 are disk files. The table is accessed by the device parser at 5883H which calculates an offset based on the device number.

58C5H - TIME$ Function

This routine implements the TIME$ function which returns the current system time as a string in "HH:MM:SS" format. It calls the SYS0 time routine to get the current time values, formats them with a colon separator, and returns the result as a BASIC string. The routine allocates an 11-character string space for the result.

58D8H - INPUT# / LINE INPUT# Entry Points

These are the entry points for the INPUT# and LINE INPUT# statements, which read data from file devices. The INPUT# statement reads formatted data (comma or carriage-return delimited), while LINE INPUT# reads an entire line including commas. The routines share common code but differ in how they handle the data type (string vs numeric, fixed vs variable length).

58EFH - LINE INPUT# Statement Handler

This routine handles the LINE INPUT# statement, which reads an entire line from a file device into a string variable. Unlike regular INPUT#, LINE INPUT# reads all characters including commas until a carriage return is encountered. It uses the string handling routines to allocate space and copy the data.

5908H - MID$ Assignment Statement

This routine handles the MID$ assignment statement (MID$(string$,start,length)=replacement$), which replaces a portion of an existing string with new characters. It's different from the MID$ function which extracts a substring. The routine must validate the start position and length, locate the target string in memory, and perform the character replacement without changing the original string's length.

5952H - Keyword Token Table (Partial)

This area contains a keyword token table used by the BASIC tokenizer and detokenizer. Each entry consists of a length byte followed by the keyword text and a token value. The table maps keyword strings to their internal token numbers used in the tokenized BASIC program. This is a portion of the larger keyword table for DISK BASIC extensions.

598AH - SWAP Statement Handler

This routine implements the SWAP statement which exchanges the values of two variables. The statement syntax is SWAP var1, var2. Both variables must be of the same type (both strings, both integers, etc.). The routine parses both variable references, validates type compatibility, and then exchanges their contents byte by byte.

59ADH - COMPRESS (CMD"C") Command Handler

This routine implements the CMD"C" command which compresses a BASIC program by removing unnecessary spaces and optionally REM statements. The compression reduces program size and can improve execution speed slightly. Options include: CMD"C" (default compression), CMD"C",R (remove REM statements), and CMD"C",S (keep spaces). The routine uses self-modifying code to control the compression behavior.

59EBH - COMPRESS Main Loop

This is the main processing loop for the COMPRESS command. It iterates through each line of the BASIC program, copying bytes from the source position (HL) to the destination position (DE). The loop handles the compression by selectively skipping spaces and REM statements based on the self-modifying code set up earlier. It uses a line buffer at 4D00H for processing each line.

5A6FH - Space Compression Handler

This routine handles space character compression in the COMPRESS command. It uses self-modifying code at 5A72H to either skip spaces (default) or keep them (with S option). The byte at 5A72H is either 28H (JR Z opcode to skip spaces) or 00H (NOP to keep spaces).

5A9DH - DATE$ Function (CMD"J")

This routine handles the DATE$ function through the CMD"J" command. It can both read and set the system date. When reading, it returns the date as a string in MM/DD/YY format. When setting, it parses the date string and converts it to the internal day-of-year format. The routine includes leap year calculations and month-day validation.

5BA1H - Days Per Month Table

This is a data table containing the number of days in each month. It's used by the DATE$ routine for converting between MM/DD/YY format and day-of-year format. The table has 13 entries: a placeholder at index 0, then months 1-12. Note that February (index 2) at address 5BA3H is modified by the leap year routine to be either 28 or 29 days.

5BAEH - DATE$ Result Buffer and Work Area

This is a work area used by the DATE$ function to build and store the date string result. It contains 8 bytes for the formatted date string plus additional temporary storage for day-of-year calculations.

5B66H - DATE$ Helper Routines

These are helper routines used by the DATE$ function for parsing date components, validating values, and handling leap years. They include the slash/dash separator checker, numeric range validator, and leap year detector.

5BA1H - DAYS PER MONTH TABLE (DATA)

This 13-byte table stores the number of days in each month, indexed 0-12 where index 0 is unused and 1-12 correspond to January through December. The DATE$ function (CMD"J") uses this table to convert between MM/DD/YY format and day-of-year format. Critical: Address 5BA3H (February) is self-modifying - it gets changed from 1CH (28) to 1DH (29) for leap years by the leap year handler at 5B91H.

5BAEH - DATE$ WORK BUFFERS (DATA)

These 8 bytes at 5BAEH-5BB5H serve as work buffers for the DATE$ function. The first 6 bytes (5BAEH-5BB3H) hold the formatted date result string in MM/DD/YY format. The last 2 bytes (5BB4H-5BB5H) store the day-of-year value as a 16-bit integer during calculations. These buffers are populated by the DATE$ helpers and read by the main DATE$ function when constructing the return string.

5BB6H - TRON/LPRINT WIDTH STATEMENT

This routine handles the LPRINT WIDTH statement, which sets the line width and tab spacing for LPRINT output. The statement syntax is LPRINT WIDTH n where n is the line width, or LPRINT WIDTH n,N to also set tab spacing to 24 (18H) instead of the default 32 (20H). The routine parses the width value, stores it at 63EBH (printer line width), and sets the tab/zone width at 63DBH based on whether the "N" option was specified.

5BDBH - VARIABLE TYPE PARSER

This critical routine parses variable names and determines their type based on suffix characters. BASIC variables can be: Integer (suffix %), String (suffix $), Single precision (suffix !), or Double precision (suffix #). If no suffix is given, the type defaults based on the first letter of the variable name using the DEFINT/DEFSNG/DEFDBL/DEFSTR settings stored in a 26-byte table at 0041H (one byte per letter A-Z). The routine also counts characters in the variable name and stores key information in self-modifying code locations for later use.

5C21H - TYPE CHECKING HELPERS

This section contains several helper routines for type checking and variable structure navigation. The first routine (5C21H) contains self-modifying code locations that store the variable type, name length, and first character as set by the Variable Type Parser at 5BDBH. Other routines here help skip over variable entries in memory and count parentheses for array dimension parsing.

5C5BH - CLEAR EXTENSION

This routine implements the CLEAR statement's memory management functionality. CLEAR deallocates all variables and resets the stack, optionally setting new memory limits. The syntax is CLEAR ,<top-of-memory>. This routine calculates how much memory to reserve for strings, validates that sufficient memory exists, and relocates the stack to the new location. It uses self-modifying code at 5C9EH and 5CB4H to store intermediate values during the complex memory calculations.

5CB9H - STRING OPERATIONS

This section contains several string manipulation helper routines. These include routines to parse string expressions, extract string descriptors (pointer and length), copy strings to temporary storage, and pad strings with spaces. These are fundamental building blocks used by BASIC's string handling functions like LEFT$, RIGHT$, MID$, and string assignment.

5CFCH - NUMBER PARSING (DECIMAL STRING TO DE)

This routine converts an ASCII decimal number string to a 16-bit binary integer in the DE register pair. It processes digits from the string at HL, multiplying by 10 and adding each digit's value. The routine tracks the number of digits parsed in C and sets the carry flag if overflow occurs (value > 65535). This is a fundamental routine used by many BASIC statements that need to parse numeric arguments.

5D27H - NUMBER TO STRING CONVERSION

This section contains routines to convert binary numbers to ASCII string representation. The main routine at 5D32H converts a 16-bit value in DE to a decimal ASCII string stored at 5D51H, stripping leading zeros. A wrapper at 5D27H copies the result to a buffer pointed to by BC. These routines are used for PRINT, STR$, and other numeric output operations.

5D51H - NUMERIC CONVERSION BUFFER (DATA)

This 6-byte buffer at 5D51H-5D56H is used by the number-to-string conversion routine at 5D32H. It stores the ASCII representation of converted numbers. A 16-bit unsigned integer can have at most 5 digits (65535) plus a possible terminator byte, hence the 6-byte size. The buffer is populated by the ROM routine at 132FH and read by the number output routines.

5D57H - OUTPUT ROUTINES

This section contains several utility routines for outputting characters and numbers to the screen or printer. These include routines to print spaces, print numbers with or without leading spaces, and a general character output routine. The routines interact with the ROM's character output vector at 0033H and handle printer status checking via 003BH. A 16-bit division routine at 5D7DH is also included for numeric formatting.

5D9FH - GOSUB Line Number Lookup

This routine locates a line number for GOSUB statements. It skips to the next statement, reads the pointer stored at the line, validates it, and stores the target address at 57B8H for later use. This enables GOSUB to jump to a computed or stored line number.

5DB2H - Skip Statement (SKIPST)

This routine skips past BASIC statements to find the next statement or line. It handles statement separators (colon) and the ELSE token (93H). Used by control flow statements to navigate through the program text.

5DC4H - Error Code Table

This is a data table containing Disk BASIC error codes and their associated error numbers. Each entry consists of 3 bytes: a LD A,nn instruction (3EH) followed by LD BC,nnnn (01H) which encodes the error number. The error handler at 5E05H extracts the error code from Register A and jumps to the ROM error generator.

5E05H - Error Dispatch Handler

This routine takes an error code in Register A (or derived from the error table) and dispatches to the ROM error handler at 19A2H. It extracts the error code and passes it in Register E as required by the ROM routine.

5E09H - Error Handler with State Setup

This error handler stores the error code using self-modifying code, finalizes the current BASIC program state, resets BASIC pointers, then dispatches to the error handler. Used for recoverable errors during program execution.

5E16H - DOS Error to BASIC Error Translator

This routine translates DOS error codes (returned by SVC calls) into BASIC error codes. It looks up the DOS error in a translation table at 5E36H to find the corresponding BASIC error number. If no translation exists, it uses error 72H (114 decimal) as the default.

5E36H - DOS to BASIC Error Translation Table

This is a lookup table that maps DOS error codes to BASIC error codes. Each entry is 2 bytes: [DOS error code, BASIC error code]. The table is terminated by a 00H byte.

5E63H - FIELD Statement Handler

This routine handles the BASIC FIELD statement which defines the structure of a random access file buffer. It parses the file number, validates the file is open for random access, and processes field variable assignments. Syntax: FIELD #n, width AS variable$, ...

5EA2H - Parse Variable for FIELD

This helper routine parses a variable name for use in FIELD or similar statements. It calls the ROM variable parser and then evaluates the string expression.

5EA8H - USR Function File Channel Check

This routine checks if the current input is from a file channel (indicated by # prefix). It's used by the USR function to determine if input should come from a file or the keyboard.

5EB9H - PRINT# Position Handler

This routine handles position specifiers for PRINT# statements, determining whether TAB or SPC function was used.

5EC5H - LOC Function Entry

Entry point for the LOC (location) function which returns the current record position in a random access file.

5EC9H - LOF Function Entry

Entry point for the LOF (length of file) function which returns the size of a file in bytes.

5ECDH - EOF Function Signature

Data signature ("$%") used to identify binary file functions.

5ECFH - EOF Function Entry

Entry point for the EOF (end of file) function which returns -1 (true) if at end of file, 0 (false) otherwise.

5EE6H - Common File Function Handler (LOC/LOF/EOF)

Common entry point for LOC, LOF, and EOF functions. Parses the file number, validates the file, and dispatches to the appropriate calculation routine.

5F10H - Calculate File Position (Division)

This routine calculates the current record position by performing a 24-bit by 16-bit division. It divides the byte position by the record length to get the record number.

5F3BH - LPOS Function Handler

Handles the LPOS function which returns the current print position on the line printer.

5F4BH - POS Function Handler

Handles the POS function which returns the current cursor position.

5F52H - INPUT Channel Check

Checks if input should come from a file channel by looking for the USR token (CEH).

5F5DH - OUTPUT Channel Setup

Entry point for setting up an output channel to a file.

5F5FH - File Channel Validation

Validates and sets up a file channel for I/O operations. Checks for # prefix, parses file number, and validates file mode.

5F7AH - Parse File Number and Get FCB Pointer

This routine parses a file number from the BASIC program text, validates it against the maximum allowed files, and returns a pointer to the corresponding File Control Block (FCB). It's called by many disk I/O statements like FIELD, INPUT#, PRINT#, etc. to identify which file the operation applies to. On entry, HL points to the BASIC text. On exit, BC contains the FCB pointer, A contains the FCB status byte, and HL is advanced past the parsed file number.

5FA1H - CLOSE Statement Handler

This routine handles the BASIC CLOSE statement. It can close a single file (CLOSE #n) or all open files (CLOSE with no arguments). When closing a file, it flushes any buffered data, calls DOS to close the file, then marks the FCB as unused. The routine at 5FB6H handles closing all files, while 5FA1H handles closing a specific file number.

5FAFH - Initialize Dummy FCB

This entry point sets BC to 5700H (the work FCB area) for operations that need a temporary FCB.

5FB2H - Close Single File (Common Entry)

Close a single file. BC must contain the FCB pointer. This is the common close logic.

5FB6H - CLOSE All Files

[CLOSE with no arguments] Close all currently open files.

5FD5H - Execute File Close

Common close logic. BC = FCB pointer. Flush buffer if dirty, then call DOS CLOSE.

5FF0H - Get FCB and Validate File Open

This routine is called before file operations to validate that a file is properly open. It parses the file number, retrieves the FCB, and checks that the file is open for the correct mode. Returns the FCB status and position information.

6034H - Check File Mode and Return Status

Check if file is in correct mode for the requested operation.

604FH - Handle Unpositioned Random File

File position not valid - check if random access mode and initialize position.

6058H - Compare File Positions

This routine compares the current file position with the target position to determine if more data needs to be read or if we're at/past the target location.

6065H - Calculate Next Record Position

For random access files, this routine calculates the position of the next record by adding the record length to the current position.

6076H - Character Output to File

This routine outputs a single character to a file. It handles printer position tracking and calls the appropriate DOS write routine. The character to output is passed in A.

609AH - File OPEN Entry Points

These are the entry points for opening files in different modes. The OPEN statement in BASIC calls one of these depending on the mode (FOR INPUT, FOR OUTPUT, FOR RANDOM, FOR APPEND). Each entry sets up mode flags in BC before calling the common OPEN handler.

609DH - Common OPEN Handler

[COMMON ENTRY] All OPEN modes converge here. BC contains mode flags.

6112H - Store Initial Random Position

For random files, store the initial position in the alternate position fields.

6119H - Check Filename in FCB

This routine compares a filename with the one stored in the work FCB to see if they match.

6125H - PUT Statement Entry Point

This is the entry point for the PUT statement (PUT #n, record). It sets a flag byte indicating PUT mode (with bit 7 and bits 0-2,5 set via OR AFH), then shares common code with GET for parsing and executing the file record operation.

6131H - Parse Record Number with Comma

This routine expects a comma followed by a record number expression. It parses the record number and stores it in the FCB position fields. Called by both GET and PUT statements.

613EH - Update Alternate File Position

Stores position information in the alternate position fields of the FCB and sets a flag indicating the alternate position is valid.

6149H - Get Primary File Position

Retrieves the primary file position from FCB offset +04H and memory location 5705H.

6150H - Get Alternate File Position

Retrieves the alternate file position from FCB offset +07H and memory 5708H. Checks if alternate position is valid; if not, jumps to error.

615DH - Record Length Validation

Validates that a requested byte count does not exceed the record length, adjusting if necessary. Also checks for position overflow.

6173H - File Status Check

Checks the file status flags at 5700H to determine if the file is in an error state or specific mode. Returns via error handler if invalid.

6185H - File Buffer Operation Handler

Handles reading/writing data to/from the file buffer. Checks buffer flags and manages the dirty bit for write operations.

61ACH - Record Count Loop

Decrements the record count in HL and loops until zero. Used for processing multiple records.

61B7H - String Expression for File Operation

Evaluates a string expression and retrieves the string descriptor for file I/O operations.

61CAH - Get Primary Position and Update

Retrieves the primary file position and calls the DOS position update routine.

61D3H - Get Current File Position

Returns the current file position from the FCB work area.

61DAH - Get Alternate Position Data

Retrieves the alternate file status and position from the FCB work area at 5715H and 5719H.

61E1H - Get Both Position Values

Retrieves both the current position and alternate position, returning them for comparison or calculation.

61EAH - SVC Call with Offset 13H

Sets up an SVC call with DE=0013H and jumps to the common handler.

61EFH - Position Bounds Check

Validates that a file position calculation won't overflow. If adding the increment (in BC) to the current position would overflow, generates an error. Also stores the calculated position for later use.

6206H - Process Single Record

Core routine for processing a single record. Handles position validation, buffer management, and DOS calls for reading or writing data.

622CH - SVC Call with Offset 1BH

Sets up an SVC call with DE=001BH for record-level file operations.

6231H - Buffer Check After Record Operation

After a record operation, checks buffer flags to determine if more processing is needed.

623BH - Alternative SVC Entry with 4436H

Entry point for SVC calls using parameter 4436H.

6254H - Setup Filename Pointer for SVC

Pushes DE (SVC parameter) and sets DE to point to the filename buffer at 570DH for DOS calls.

6259H - SVC Call with 4436H and Clear Flag

Entry point for SVC calls using parameter 4436H that clears bit 7 of FCB byte +0EH.

625EH - SVC Call with 443CH and Clear Flag

Entry point for SVC calls using parameter 443CH that clears bit 7.

6267H - SVC Call with 443FH

Entry point for SVC calls using parameter 443FH.

626CH - Add Bytes to Current Position

Adds a byte count (in B) to the current file position. Checks for overflow and updates the position through a DOS call. Used for sequential file operations.

627FH - File Buffer Management

Manages file buffer operations by calculating position from L and C registers, calling the buffer routine, and handling the result.

6293H - Buffer Status Check

Checks the buffer status after a DOS operation and returns appropriate flags and values.

62BCH - Parse File Number and Setup FCB

This is a key routine called by GET, PUT, and other file operations. It parses the "#n" file number from the BASIC statement, validates that the file is open, and copies the FCB to the work area at 5700H. Also sets a guard flag to prevent re-entry.

62E4H - Push HL and Setup FCB

Alternate entry point that saves HL before setting up the FCB work area.

62E7H - Parse File Number with Required Comma

Parses a file number preceded by a comma. Uses RST 08H to require the comma.

62EEH - Check Buffer Position Valid

Tests bit 6 of FCB byte +2DH for buffer position validity.

62FFH - Check Write Mode and Variable

Checks write mode flag and handles variable or file reference.

6326H - File Status Validation

Validates file status flags at 5700H for specific operations.

6358H - Position Comparison

Compares file positions from 5704H and 5707H.

636DH - Position from Current

Gets current position and calculates buffer offset.

6374H - Setup Work Area Pointer

Saves HL and points HL to FCB work area at 5700H, DE to 0.

637EH - Return Handler for File Functions

Common return point for LOC/LOF/EOF functions. Cleans up FCB and resets guard flag.

638FH - Check for Comma or End

Decrements HL, gets next character, checks for comma or end of statement.

6397H - DOS File Open Call

Calls DOS to open a file using the filename at 570DH.

63A9H - Guard Flag and FCB Cleanup

Contains the re-entry guard flag at 63A9H and routines to set/clear it. The guard prevents recursive FCB operations. When set to C9H (RET opcode), calls to this address return immediately.

63ADH - Set Guard Flag

Sets the guard flag at 63A9H to C9H (RET opcode), preventing re-entry into FCB operations.

63B3H - Copy Guard to Another Location

Copies the guard flag from 63A9H to 63BDH, then clears it.

63BCH - Clear Guard with Default

Clears the guard flag using a default value of 00H.

63C0H - PRINT# Output Handler

Handles output for PRINT# statement. Checks for end of buffer, compares current position against buffer limits, and handles file writes.

63DDH - Line Number Display

Displays a BASIC line number during execution. Used for error reporting and debugging.

642EH - Clear Display Line

Clears a portion of the video display by writing spaces.

63A9H - Guard Flag and FCB Cleanup

Contains the re-entry guard flag at 63A9H and routines to set/clear it. The guard prevents recursive FCB operations. When set to C9H (RET opcode), calls to this address return immediately.

63ADH - Set Guard Flag

Sets the guard flag at 63A9H to C9H (RET opcode), preventing re-entry into FCB operations.

63B3H - Copy Guard to Another Location

Copies the guard flag from 63A9H to 63BDH, then clears it.

63BCH - Clear Guard with Default

Clears the guard flag using a default value of 00H.

63C0H - PRINT# Output Handler

Handles output for PRINT# statement. Checks for end of buffer, compares current position against buffer limits, and handles file writes.

63DDH - Line Number Display

Displays a BASIC line number during execution. Used for error reporting and debugging.

642EH - Clear Display Line

Clears a portion of the video display by writing spaces.

6438H - Set Default Print Width (32)

Sets the printer tab/zone width to 32 (20H) for normal formatting.

643CH - File OPEN with Width Setup

Opens a file and sets up print width handling.

644AH - File Cleanup and Guard Reset

Main cleanup routine called when BASIC file operations complete. Saves registers, processes pending file operations, clears buffers, and resets the guard flag.

64BEH - Store Return Address

Stores the address 64BDH into 644EH, setting up a callback location.

64C5H - FCB Size Storage

Data area storing the FCB size (typically 012DH = 301 bytes) used during file operations.

64CAH - BASIC Initialization Entry

This is called during BASIC startup. It initializes memory pointers, checks high memory availability, and sets up the BASIC environment. The actual PROGRAM ENTRY is at 66BEH which jumps here after FCB table setup.

6589H - Startup Command Processor

This routine is called via the callback mechanism after BASIC displays its startup message. It returns from a subroutine on the stack to reach 658AH, then displays additional startup text and processes any command line that was passed to BASIC at startup (such as RUN "filename" or direct commands).

65ADH - Control Code Data

This 3-byte sequence contains cursor control codes used by the startup message display routine at 6595H. These are TRS-80 screen control characters.

65C9H - Reserved/NOP Space

This area contains NOP bytes (00H) that serve as padding or reserved space between routines. They may have been used during development or reserved for future patches.

65CDH - Check for Assignment Statement

This small utility routine checks if the current BASIC statement is an assignment (contains an = sign). It's used by the command parser to distinguish between variable assignments and other statements.

65D4H - Get Position with BC Preserved

This utility routine calls the position fetching routine at 61E1H while preserving the BC register pair. It returns the position status in Register A.

65DBH - Get FCB Size

This short utility routine retrieves the FCB (File Control Block) size value from the storage location at 64C5H. This is used when calculating FCB table offsets.

65E0H - Reserved/NOP Area (FCB Workspace)

This large block of 00H bytes from 65E0H to 66BDH is reserved space that may be used for FCB table overflow or as workspace. It contains 222 bytes of zeros.

66BEH - PROGRAM ENTRY POINT

This is the main entry point for BASIC/CMD. When NEWDOS/80 loads and executes BASIC, execution begins here. This routine processes any startup parameters, handles the * auto-run command, determines the FCB size for multiple files, and then jumps to the main initialization at 64CAH. The code handles the BASIC command line format: BASIC [*filename] [,n[V]] where n=number of files and V=verify mode.

675CH - Startup Message Text

This area contains the ASCII text strings displayed when BASIC starts up. The text includes cursor control codes and the NEWDOS/80 copyright/enhancement message. Control codes: 1CH = cursor control, 1FH = clear screen/position, 0AH = line feed, 0DH = carriage return.

67BBH - BASIC Jump Table

This is the BASIC statement/function jump table. It contains 49 JP (Jump) instructions that provide entry points for various DISK BASIC statements and functions. During initialization, this entire table (147 bytes = 49 entries × 3 bytes) is copied from here to RAM at 4152H. The entries provide hooks into BASIC/CMD's disk I/O routines, file handling, and extended statements.