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

When execution reaches 4D00H, the DOS command processor has set up: Register A = command module identifier (expected F1H for SYS15), Register C = sub-command number (1 = FORMS, 2 = SETCOM), and Register Pair HL = pointer to the remainder of the command line after the command name.

If execution falls through to here, neither FORMS nor SETCOM was identified. This means the sub-command index in Register C was neither 1 nor 2, indicating an invalid command code.

When execution arrives here from the dispatcher at 4D05H, Register Pair HL points to the user's command line text following the FORMS command name. Register C has been decremented to 0 (confirming FORMS). The code first checks whether there are any parameters at all.

The command line has parameters. Before invoking the keyword parser, the code saves the current WIDTH value into the self-modifying instruction at 4D42H. This is done so that if the user only specifies one parameter (e.g., only WIDTH or only LINES), the other parameter retains its current value.

The keyword parser at 4EE7H processes the command line and, when it matches a keyword, calls the handler routine associated with that keyword. For the FORMS WIDTH keyword, the handler returns to 4D22H with the parsed numeric value in Register A. For the FORMS LINES keyword, the handler returns to 4D27H.

The LINES keyword handler entry point follows. When the keyword parser matches LINES and parses its numeric value, execution arrives at 4D27H with the parsed value in Register A.

Fall through to 4D30H to continue parsing for more keywords.

If execution falls through (Z flag set with Carry clear: no keyword matched but not end of line), the code below applies the parsed parameter values to the DOS system variables and then displays the results.

[DISPLAY SECTION] The parameter values have been applied (or no changes were made if the user typed bare FORMS). Now display the current printer settings by reading the live values from the DOS variables and formatting them for output.

When execution arrives here from the dispatcher at 4D09H, Register Pair HL points to the user's command line text following the SETCOM command name. The code first checks whether parameters were provided.

Parameters were provided. Before invoking the keyword parser, the code copies the current RS-232 configuration from the DOS system variables into the self-modifying code locations. This preserves any parameters the user does not explicitly change.

SETCOM WORD= Keyword Handler (4D8AH): Execution arrives here when the keyword parser has matched the WORD keyword and parsed the numeric value. Register A contains the parsed WORD length value. Valid values are 5, 6, 7, or 8, representing the number of data bits per transmitted byte. The value must be converted into the RS-232 configuration bit field encoding used by the Model III hardware: the word length is stored in bits 5-6 of the configuration byte at 4DFAH. The encoding maps 5→00, 6→01, 7→10, 8→11 in the bit field, but with an XOR adjustment for the parity/overflow flag behavior.

SETCOM BAUD= Keyword Handler (4DA6H): Execution arrives here when the keyword parser has matched the BAUD keyword and parsed the numeric value. Register Pair DE contains the parsed baud rate value (e.g., 300, 9600, 19200). The code must look up this value in the baud rate table at 4EC7H to find the corresponding baud rate index (0-15) for the RS-232 hardware register.

[LOOP START — Baud rate table search] This loop scans the baud rate table, comparing each entry against the user's requested baud rate in Register Pair DE. Register A is the index counter (incremented by 11H each iteration to encode the baud rate index in the RS-232 config format).

[LOOP END — Baud rate found] The matching baud rate was found. Register A contains the encoded baud rate index (multiples of 11H: 00H, 11H, 22H, ... FFH for the 16 entries).

SETCOM STOP= Keyword Handler (4DC3H): Execution arrives here when the keyword parser has matched the STOP keyword and parsed the numeric value. Register A contains the parsed stop bits value. Valid values are 1 (one stop bit) or 2 (two stop bits). The stop bit setting is stored in bit 4 of the configuration byte at 4DFAH: bit 4 clear = 1 stop bit, bit 4 set = 2 stop bits.

SETCOM PARITY= Keyword Handler (4DD1H): Execution arrives here when the keyword parser has matched the PARITY keyword and parsed the numeric value. Register A contains the parsed parity value: 1 = odd parity, 2 = even parity, 3 = no parity. The parity setting uses two bits of the configuration byte at 4DFAH: bit 3 (parity enable) and bit 7 (even/odd select).

Common Keyword Handler Exit (4DE7H): All SETCOM keyword handlers (WORD, BAUD, STOP, PARITY, WAIT, NOWAIT) jump here after successfully processing their parameter. This restores the command line pointer and continues parsing.

SETCOM WAIT Keyword Handler (4DEAH): Execution arrives here when the keyword parser has matched the WAIT keyword (a keyword with no "=value" parameter). The WAIT flag is stored as FFH at 4E02H (the operand byte of the self-modifying instruction at 4E01H).

SETCOM NOWAIT Keyword Handler (4DEEH): Execution arrives here when the keyword parser has matched the NOWAIT keyword.

Keyword Parse Loop Continuation (4DF2H): After each keyword handler stores its value, execution arrives here to check for more keywords on the command line.

Apply RS-232 Configuration (4DF8H): All keyword parameters have been parsed. The self-modifying code locations now contain the final configuration values. The code reads them, performs final adjustments, and writes the configuration to the DOS system variables and hardware.

SETCOM OFF Keyword Handler (4E08H): Execution arrives here when the keyword parser has matched the OFF keyword. The OFF keyword disables the RS-232 interface entirely. The code calls the SYS0 parser once more to confirm no additional keywords follow (OFF must be the only parameter), then sets the RS-232 state to "off" (configuration = 0, flag = 0).

Display Section Entry (4E0FH): This is the common entry point for displaying the RS-232 state. When reached from the bare SETCOM path (no parameters), it loads the current configuration high byte from 41F9H. When reached from the OFF handler, Register A is already 00H.

Display RS-232 Parameters (4E1DH): The RS-232 is active. The code now decodes and displays each parameter value: WORD length, BAUD rate, STOP bits, PARITY, and WAIT/NOWAIT. Register A contains the configuration high byte (from 41F9H) with the packed settings.

Now display the BAUD rate. The baud rate index is stored in bits 0-3 of the configuration low byte at 41F8H. The index is used to look up the actual baud rate value from the table at 4EC7H.

Now display the STOP bits. The stop bit setting is in bit 4 of the configuration high byte (saved on the stack). Value 1 = one stop bit (bit 4 clear), value 2 = two stop bits (bit 4 set).

Now display the PARITY setting. The parity is encoded in bits 3 and 7 of the configuration high byte (saved on the stack). The decoding is: bit 3=1 = no parity (value 3), bit 3=0 and bit 7=1 = even parity (value 2), bit 3=0 and bit 7=0 = odd parity (value 1).

Finally, display the WAIT or NOWAIT state. The WAIT/NOWAIT flag is stored at 41FAH: FFH (non-zero) = WAIT, 00H = NOWAIT.

RS-232 Defaults Reset Subroutine (4E79H): Called when the RS-232 interface is being turned off or when a bare SETCOM is issued with the interface unconfigured. Stores a zeroed configuration word and FFH WAIT flag to the system variables, then reinitializes the hardware.

Fall through to 4E7EH to store the values and reinitialize the hardware.

Baud Rate Table — 16 entries, 2 bytes each (little-endian):

When execution arrives here, Register Pair BC points to the keyword table (4D5BH for FORMS, 4E87H for SETCOM) and Register Pair HL points to the current position in the command line. Register D is loaded with the maximum number of keyword scan passes.

The keyword requires a numeric parameter. The code now calls the numeric value parser to convert the ASCII number string following the "=" sign into a binary value.

Bit 6 is clear, so this is an 8-bit parameter. Validate that the high byte of DE is zero (the value fits in 8 bits), then pass the low byte in Register A to the handler.

[LOOP START — Keyword scan loop] Each iteration calls the SYS0 scanner for the current keyword. If no match, the code skips to the next table entry. Register D was loaded with 03H at 4EE7H, meaning 3 bytes must be skipped after each NUL terminator (1 flags byte + 2 handler address bytes).

The keyword did not match. Skip past the remaining bytes of the current keyword name (scan to the NUL terminator), then skip the 3 record bytes (flags + handler address) to reach the next keyword entry.

BC now points to the byte after the NUL terminator (the flags byte). Skip past the 3 record bytes (flags + 2-byte handler address) to reach the start of the next keyword entry.

BC now points to the first byte of the next keyword entry. Check if this is the end-of-table marker (00H).

[LOOP END — no match found] The end-of-table marker was reached without finding a matching keyword. Report a parse error.

The character following the decimal number is in the range A-H, which suggests this might be a hexadecimal number (e.g., "1AH" or "FFH"). Re-parse from the beginning with hex mode enabled.

[LOOP START — Digit parsing loop] Each iteration reads one character from the command line, validates it as a digit, multiplies the accumulator by the base (10 or 16), and adds the new digit value.

The character is not a decimal digit. Check if hex mode is enabled and if the character is a valid hex digit A-F.

Register A now contains the binary value of the current digit (0-9 for decimal, 0-15 for hex). The code below multiplies the accumulator (DE) by the base and adds the new digit. The multiplication uses a shift-and-add technique that differs depending on whether decimal or hex mode is active.

At this point HL = original_value * 4. The next step differs based on mode: in hex mode (bit 0 set), two more shifts give *16; in decimal mode (bit 0 clear), ADD HL,DE gives *5, then one more shift gives *10.

[HEX PATH] Hex mode: need value * 16. Currently HL = value * 4. One more shift gives * 8.

[DECIMAL PATH] Decimal mode: HL = value * 4. Add the original value (in DE) to get value * 5.

Now add the new digit value (saved in Register C) to the multiplied accumulator.

[LOOP START — String print loop] Print each character of the NUL-terminated label string pointed to by Register Pair HL.

Binary-to-Decimal Conversion (4F99H): Converts the 16-bit value in Register Pair DE to decimal ASCII and prints each digit. Uses repeated subtraction with negative divisors from the table at 4FC3H. Register B counts 4 divisor passes (ten-thousands, thousands, hundreds, tens), then the remainder is the ones digit. Register C is used as a leading-zero suppression flag: starts at 0, and is incremented when the first non-zero digit is encountered.

[LOOP START — Digit extraction loop] For each divisor, the code repeatedly adds the negative divisor to the value until it overflows (carry), counting how many times the addition succeeded. The count is the digit value.

[INNER LOOP START — Repeated subtraction] Each iteration adds the negative divisor (subtracts the divisor) and increments the ASCII digit counter.

[INNER LOOP END] The last subtraction underflowed. Undo it by adding the divisor back (via SBC), and Register A contains the ASCII digit.

Register A contains the ASCII digit for this position. Check for leading-zero suppression: if the digit is "0" and no significant digit has been printed yet (C = 0), skip printing this digit.

[LOOP END] All four divisor passes are complete. The remainder in Register E is the ones digit (0-9). Print it unconditionally (the ones digit is always printed, even if zero).