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

SYS10/SYS

Other Navigation

SYS10/SYS is a NEWDOS/80 v2.0 overlay module loaded into the SYS overlay area at 4D00H–51E7H (1,256 bytes, with 26 bytes of NOP padding at 51CEH–51E7H). It is loaded on demand when BASIC encounters PUT or GET statements for disk files.

What It Does:
SYS10 implements the complete PUT and GET statement processing for both sequential and random access disk files. This is the core data I/O module that enables BASIC programs to write formatted data to disk files and read it back.

PUT Processing (4D03H–4EBDH): Handles writing data to an open file. The PUT handler processes the file number, evaluates each expression in the PUT argument list, converts values to the appropriate format, and writes them through the FCB buffer. For random access files, it manages field positioning and record boundaries. Subcommands handled through special tokens include: position restore (#), alternate position ($), file close/reset (%), EOF marker write (&), and USING format (CFH token). Numeric values are converted between BASIC's floating-point format and disk integer formats using the CVI/CVS/CVD and MKI$/MKS$/MKD$ conversion logic at 4DE4H–4E16H.

GET Processing (4F18H–51CDH): Handles reading data from an open file. The GET handler parses the BASIC text for variable references, reads data from the file through the FCB buffer, converts between disk format and BASIC variable types, and stores results in the target variables. Supports string fields (with LSET/RSET trimming), numeric fields (integer, single-precision, double-precision), and special record-at-a-time mode for files opened with the special status flag.

Common Exit (518EH–51CDH): Both PUT and GET share a common exit path that advances the file position, updates FCB state, and loops back for additional data items separated by commas or semicolons.

Key ROM Routines Called: 09D6H (string block copy), 0A7FH (numeric evaluation), 0AF6H (numeric conversion), 1E5AH (expression evaluator), 1EC5H (numeric expression evaluator), 1F33H (PRINT handler), 260DH (string expression evaluator), 29E3H (string space allocator).

Key BASIC/CMD Routines Called: 6031H (position compare), 603EH (absolute position calc), 60EBH (store alt position), 610DH/6110H (position store), 6117H (store alternate), 6122H (load primary position), 6129H/612FH (load alternate + check), 6136H (record count), 614CH (FCB status reader), 615EH (position + dirty), 6190H (string expression + descriptor), 619CH (string expr evaluator), 61A3H (primary + write), 61A6H (DOS position write), 61ACH (current position loader), 61B3H (alternate position loader), 61C8H (record position validator), 61DFH (single-byte write), 621EH (common SVC dispatch), 6232H/6237H (DOS write/read + result), 6245H/6246H (position advance), 6258H (record advance), 626CH (record type decoder), 62C7H/62CEH (buffer position check), 62D0H (buffer pos alt), 62D8H (write mode + variable), 62FFH (buffer state logic), 6331H (position compare), 6346H (position-to-record), 635AH (clear work area), 6362H (zero-fill loop), 6368H (comma checker), 661CH (string expr + SYS10 dispatch), 6623H (string expression), 662CH (validation).

Variables Written by SYS10:

Variables Read by SYS10:

4D00H - STACK CLEANUP EXIT

Alternate exit point that discards the top return address from the stack, then returns to the grandparent caller. Used when a subroutine within SYS10 needs to abort and return directly past its caller's caller.

4D03H - PUT MAIN ENTRY AND FILE SETUP

Main entry point for PUT statement processing. This routine is entered after the SYS10 overlay is loaded. It sets the SVC post-operation flag, loads the FCB status, processes the file mode bits, checks for a comma or alternate entry, and sets up the file position for the write operation. IX points to the active FCB throughout.

4D5AH - PUT SUBCOMMAND DISPATCH

Dispatches PUT processing based on the subcommand token following the file number. The token in Register A determines the operation: CFH (USING), 23H (#, alternate position), 24H ($, restore position), 25H (%, close/reset), 26H (&, EOF marker), or 21H (!, numeric field). Any other character falls through to the default expression handler.

4DBCH - '!' NUMERIC FIELD HANDLER AND FLOAT-TO-INTEGER CONVERSION

Handles the '!' subcommand in PUT for numeric field output. Also contains the float-to-integer conversion routine used to convert BASIC floating-point numbers to the integer format stored in random access file fields. Detects the numeric type (integer, single-precision, double-precision) and routes to the appropriate conversion path. This section also handles the general expression dispatch at 4DE0H/4DE1H via BASIC/CMD's string expression + SYS10 dispatch at 661CH.

4E17H - RANDOM ACCESS POSITION CALCULATOR

Calculates the byte position within a random access file record using 25-bit multiplication. This routine is called when a PUT or GET operation needs to position to a specific field within a record. It multiplies the field offset by the record length and adds the byte-within-record offset, producing an absolute position for the DOS file I/O system.

4E48H - SEQUENTIAL ADVANCE HANDLER

Handles advancing through a sequential file when the current position is not aligned to a record boundary. This routine advances record-by-record until the position reaches the target, then stores the alternate position and continues with position setup.

4E5FH - DEFAULT EXPRESSION AND 25-BIT MULTIPLY

Handles PUT expressions that do not match any recognized subcommand token. Evaluates the expression via BASIC/CMD's string expression evaluator, validates the result, and performs a 25-bit multiplication to calculate the absolute byte position within the file for random access records. Also reached when the expression result needs to be converted to a file position.

4E9AH - STATUS-9 (DEVICE I/O) HANDLER

Handles files opened with the special status mode 09H (read + buffer, no write or random flags). This is a device I/O mode used for special file operations. Writes the current position to DOS, checks for special mode flags, and dispatches to either the record type decoder or a single-byte write path.

4EBEH - POST-WRITE COMPLETION

Handles completion processing after a PUT data item has been set up. Routes to either the sequential file path or the random access file path based on the FCB status flags. For sequential files, adjusts the position by adding the byte offset within the record. For random access files, dispatches to the GET handler at 4F18H.

4F18H - GET Main Entry (Random/Sequential File Input)

GET Main Entry for Random Access Files. This entry point handles the GET statement for reading data from random-access or sequential files. It begins by calling 6331H to calculate the total record count, stores the result as the record limit via self-modifying code at 4F8CH, then pops the saved HL (BASIC text pointer) and checks whether the statement has additional arguments (comma-separated variable list). The code routes to the line scanner at 4FC1H after setting up the record limit and print column state.

4F3DH - GET Special Mode Router

Special Mode Router. This section reads the FCB status flags and routes the GET handler based on whether the file is in special mode (bit 4 of IX+00H). Special mode files use a different I/O path that handles record-level positioning and direct buffer access. The code also checks whether the buffer dirty flag is set and whether the file is in read mode, adjusting its behavior accordingly.

4F87H - Record Limit Setup + Line Scanner Call

Record Limit Setup. This section clears the operation active flag, then falls through to the record limit setup at 4F8BH. The LD DE at 4F8BH is a self-modifying instruction whose operand at 4F8CH was written by either 4F1BH (record count from 6331H) or 4F77H (position difference from sequential advance). The loaded value is stored as the record limit at 61CAH, the print column state is initialized, and the line scanner at 4FC1H is called to begin parsing the GET variable list.

4F9CH - Separator Dispatch (Comma, Semicolon, Format Handler)

Separator Dispatch. After the line scanner returns, this section checks the character for comma or semicolon separators. A comma routes to 4FAAH (record type decode and position advance for the next variable). A semicolon decrements the print column counter and, if it reaches zero, routes to the end-of-data handler at 51A2H. Any other character routes to 4FDFH (the format handler for parenthesized expressions).

4FC1H - Line Scanner

Line Scanner. This routine scans the BASIC text for the next data item in the GET/PUT variable list. It fetches the next non-space character and checks for special cases: end-of-statement (00H), the USING keyword token (93H), and end-of-line (link pointer = 0000H). If a USING token is encountered, it is skipped over. If the line link pointer is zero, we have reached the end of the program text and an error is generated.

4FDFH - GET Format Handler

GET Format Handler. This section handles format expressions in the GET variable list. It checks for a parenthesized expression (opening parenthesis 28H), evaluates it as a string expression for a format specification, and checks for trailing separators. If the format specification includes a record count, it is evaluated as a numeric expression via ROM 0A7FH and stored at 5094H. The code then routes to the data output section based on the file mode.

500FH - GET/PUT Data Output Router

GET/PUT Data Output Router. This section checks the file mode (bit 4 of IX+00H for special mode) and routes to either the special-mode handler at 50F6H or the normal PUT data output at 5017H. For PUT (write mode), the code calls 62D8H to set up write mode and the target variable, then dispatches based on the data type: string output with LSET-style padding for close operations, numeric output with position advance for non-close operations, or hash-mark (#) handling for file-to-file operations.

5056H - Numeric Output / Expression PUT Handler

Numeric Output and Expression PUT Handler. This section handles non-close-mode PUT operations. It first checks the data type: if non-zero (a specific numeric type), it advances the file position and converts the position to a record number. If zero, it evaluates the expression at the BASIC text pointer and routes based on the result type (string vs. numeric) to the appropriate output handler.

506AH - '#' Handler (File-to-File Transfer) and String Expression PUT

'#' Handler for File-to-File Transfer. When a '#' appears in the PUT variable list, it indicates a file-to-file data transfer. This section loads the alternate buffer position via 62D0H and routes to the separator dispatch at 4FAAH. It also handles string expression PUT operations, where a string expression is evaluated via ROM 260DH and the result is written to the file with record type decoding and position advancing.

5099H - GET String Input with Field Handling

GET String Input with Field Handling. This section handles reading string data from a file into a BASIC string variable. It allocates string space via ROM 29E3H, manages the string descriptor, checks whether the string data is within the managed string space (via the 40D6H pointer comparison), and copies the field data with length adjustment. The result is a BASIC string variable updated with the file data.

50BFH - Numeric Type Determination

Numeric Type Determination. This section determines the specific numeric type of the expression (integer, single-precision, or double-precision) using the flags from RST 20H. It sets HL to point to the appropriate ROM BASIC accumulator: 4121H for single-precision (2+4 bytes) or 411DH for double-precision (8 bytes). The type size is loaded into B: 02H for integer, 04H for single, 08H for double. The variable type pointer at 40DFH is also updated.

50D9H - Buffer Position Check and Data Transfer

Buffer Position Check and Data Transfer. This section validates the buffer position via 62C7H, then checks whether data needs to be transferred (B > 0). If the byte count is non-zero, the DOS read routine at 6214H is called to transfer data from the file buffer to the variable. After the transfer, the file position is advanced and converted to a record number. The section then routes to the common loop at 518EH or to the PRINT handler at 1F33H for formatted output.

50F6H - GET Special Mode Handler

GET Special Mode Handler. Entry from the bit 4 check at 5013H. This section handles GET operations for files opened in special mode (bit 4 of IX+00H). It first calls 62D8H to set up write mode and the variable, then routes based on the data type: '#' handling with record write loops, or string/numeric input with byte-by-byte writing via 61C8H and space-fill padding.

511EH - Special Mode Expression Input

Special Mode Expression Input. This section handles expression evaluation in special mode. It evaluates the BASIC expression via RST 20H, checks the result type, and for string results, calls 619CH and then writes the data byte-by-byte using 61C8H with space-fill (20H) padding for any remaining field bytes.

5144H - Special Mode '#' Handler and Expression Evaluation

Special Mode '#' Handler. This section handles the '#' token in special-mode GET. It fetches the record count via 62CEH and 6136H, writes it byte-by-byte via 61C8H, then routes to the record write loop at 5111H. It also handles general expression evaluation for special mode, determining the type (string, integer, single, double) and writing the data byte-by-byte to the file.

518EH - Common Loop / Exit

Common Loop and Exit. This is the main loop return point for GET/PUT operations. It pops the saved HL, backs up the text pointer, calls the line scanner at 4FC1H to find the next data item, and dispatches based on the separator: comma routes to 4F95H (re-initialize print column and call line scanner), semicolon routes to 51A2H (end-of-data handler). After processing all items, the code updates the position via 610DH and 62FFH, then exits through 641EH or 635AH depending on the buffer flags.

51C3H - Close/Reset Exit Path

Close/Reset Exit Path. This alternate exit is taken when the '%' subcommand was used (bit 5 of IX+2DH is set). Instead of the normal position update and BASIC continuation, the code calls 635AH to perform the file close/reset operation, then returns to the caller.

51C8H - End-of-Statement Check

End-of-Statement Check. This short routine backs up the text pointer, fetches the next character, and validates that the statement has ended (character is 00H). If the statement has not ended, it generates a "Statement error".

51CEH - NOP Padding

NOP Padding. 26 bytes of NOP (00H) padding from 51CEH through 51E7H. This unused space at the end of the SYS10 overlay fills the remainder of the allocated block. It is not executable code and serves as dead space within the overlay module.