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

[IDENTIFY COMMAND TYPE]
Check the command letter: 'R' for RUN, 'V' for saVe, anything else defaults to LOAD/MERGE.

[SAVE COMMAND - 'V']
User specified CMD"V" for SAVE. Set up SAVE-specific parameters.

[RUN COMMAND - 'R']
User specified CMD"R" for RUN. Set execution flag.

[LOAD/MERGE/DELETE COMMAND]
Default path for CMD"L", CMD"M", CMD"D" or just CMD with no letter.

[STORE COMMAND FLAGS]
Save the identified command parameters into memory locations for later use.

[DISK FILE PATH] - For regular disk files, we check if the "R" (Read-only) modifier was specified. The DOS override flag at 436CH controls whether read-only protection is enforced.

DOS override is NOT active, so if the user specified the "R" modifier, we need to install a patch that blocks write operations. We'll set up a RET (C9H) instruction to immediately return from write operations.

[DEVICE FILE PATH] - For device files (printer, screen, etc.), different handling is needed.

This is specifically the printer device (device 6). Check if the "V" (Verify) modifier was specified, which was stored earlier at 5315H.

A modifier WAS specified on the printer device. For the printer, the "V" modifier requests character echo verification. We need to adjust the device code in the FCB to enable bi-directional printer mode, then install a JP (Jump) patch instead of RET.

Now install the patch bytes into the ROM hook locations. The code at 6421H and 4312H are RAM locations that shadow ROM routines - they'll be patched with either RET (to block operation) or JP (to redirect to new code).

[OPEN EXISTING FILE PATH] - An existing file was found. Need to set up the file pointers and read the file header to initialize the buffer structure.

[CREATE NEW FILE PATH] - No existing file was found, so we're creating a new file. Need to initialize an empty buffer structure.

Now set up for reading BASIC program lines. The system will read from the console (or input stream) and parse statements to be added to the file buffer. The pointer at 644EH will be set to point to the statement parsing routine.

After setting up the parser, get the first input line from the user. The routine at 4436H returns with status in flags and possibly a character in A.

Calculate how much space remains in the buffer by comparing the buffer start address (40A4H) with the end of this statement.

Check if there's enough stack space remaining. The code compares the stack pointer with a safety margin.

There's enough memory to continue. Now prepare to move the existing buffer contents to make room for the new statement.

Update the system memory pointers to reflect the new buffer layout.

Save the buffer start address for later use in the line copying loop.

The line link was zero, meaning this is either an unnumbered direct command or special case. Set BC to FFFFH to mark it as having no valid line number.

Continue with processing this statement, whether it has a valid line number or not.

Now check if there's an existing file buffer in memory that needs to be merged with the new lines. Address 4200H contains a marker byte that indicates buffer status.

[NEW FILE PATH] - The buffer is empty (FFH marker), so this is a completely new file. We'll copy lines directly into the buffer without merge logic.

Begin copying bytes from the parsed statement in the parse buffer to the destination buffer. The loop will copy lines byte by byte, checking for certain boundary conditions.

The bytes were not both zero, so continue reading more data from the current line structure.

Now copy the statement text byte by byte until we reach the null terminator.

[INNER LOOP END] - The null terminator has been copied. Go back to read the next line from the source buffer.

A modifier WAS specified (A is non-zero). Need to perform additional processing based on the modifier type.

The modifier was 02H (V modifier for verify mode on printer output). Need to perform verification operations.

A valid file IS open (pointer is not FFFFH). Need to process it appropriately.

This IS the printer device (6). The earlier code may have decremented the device code to 5 for bi-directional mode, so increment it back to restore the original state.

[NO FILE PATH] - The file pointer was FFFFH, indicating no file is currently open or an invalid state.

Set up to read a line of input from the user/console. E is loaded with a buffer size counter.

[INPUT LOOP START] - Read characters from the console one by one until Enter is pressed or buffer is full.

A character was received in A. Check what kind of character it is.

The character was not Enter. Check if it's a line feed character that should be ignored.

It IS a line feed character. Check if this is the first character in the buffer (E still equals F0H), in which case ignore it.

The character is acceptable (not a leading line feed). Store it and continue.

[INPUT COMPLETE] - Either Enter was pressed or the buffer is full. Null-terminate the line and process it.

The line appears valid. Now call the BASIC line parser to tokenize it.

After tokenizing, trim trailing spaces from the line. Work backwards from the end of the line to find the last non-space character.

[TRIM LOOP] - The last character was a space. Continue scanning backwards to remove all trailing spaces.

HL now points to where the null terminator should be placed (right after the last meaningful character). Now process the tokenized line.

Now copy the tokenized statement text byte by byte into the destination buffer.

Now check if the new line will fit in the remaining buffer space. The comparison is between the line's expected size and the space available.

There IS sufficient space. Copy the 4-byte line header (link pointer + line number) into the destination buffer.

Write the 4-byte line header: 2 bytes for line link pointer (both set to H=00H initially), followed by 2 bytes for the line number from BC.

[SPECIAL CASE - EXACT MATCH] - HL exactly equals BC, which might indicate the buffer is exactly full or a boundary condition.

BC was not FFFFH. Check the modifier flag to determine how to proceed.

Normal processing continues. Need to scan through the existing buffer to count lines and find the proper insertion point.

[LINE COUNTING LOOP] - Scan through the buffer counting complete lines by looking for null terminators.

Found the end of a line. HL now points to the start of the next line (or the end marker). Process this line's information.

The line link pointer WAS zero (00 00), indicating this is the last line or end of buffer. Handle this special case.

Still not enough space after initial expansion. Need to allocate a larger buffer area.

Initialize BC as a counter starting at 5 (the size of a line header: 4 bytes plus 1).

[STATEMENT COPY LOOP] - Copy the statement text byte by byte, counting bytes as we go.

The entire line has been copied. BC now contains the total line length. Update the self-modifying code location and continue.

Now move the variables area if needed.

Now move the string space if needed.

All memory areas have been moved. Now perform final cleanup and return to the system.

Check if we're approaching memory limits. Compare the current position with a safety threshold.

[VARIABLE PROCESSING LOOP] - Scan through each variable in the variables area.

This IS an array variable. Arrays need special processing to relocate string pointers.

[SIMPLE VARIABLE PATH] - This is a simple (non-array) variable.

Calculate the size of this variable and advance to the next one.

[STRING SPACE PROCESSING LOOP] - Scan through the string space area.

This IS a string. Process each character or element in the string.

[STRING ELEMENT LOOP] - Process each element in this string descriptor.

All elements of this string processed. Continue to next string descriptor.

Need to relocate this pointer. Load the offset and perform the calculation.

The pointer is in the valid range for relocation. Add the adjustment offset.

[SPECIAL CASE HANDLING] - Handle cases where the pointer needs different treatment.

Write the relocated pointer back to the variable descriptor.

The syntax is valid. Continue parsing the command parameters.

Processing complete. Close any open files and proceed.

Check if there's sufficient stack space for the operation.

Insufficient space. This appears to be incomplete code or an error condition.

Set up for reading input lines.

[INPUT LOOP] - Read and process input lines until complete.

Input processing complete. Finalize and return.