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

EDTASM/CMD

Other Navigation

Program Overview

EDTASM is a sophisticated Z80 assembler for the TRS-80 running NEWDOS/80 v2.0. Developed by Apparat, Inc., this is Version 3.0 of their assembler "appendage" - an enhancement to the system's editing and assembly capabilities. The program provides full Z80 assembly language support with macro capabilities, conditional assembly, and comprehensive error checking.

Technical Specifications

• Address Range: 5200H - 76FFH
• Program Size: 9,472 bytes (9.25 KB)
• Total Lines: ~5,062 lines of assembly code
• Entry Point: 6F00H
• Load Address: 5200H

Key Features

• Full Z80 instruction set support including undocumented opcodes
• Symbol table management with alphabetic sorting
• Macro definition and expansion capabilities
• Conditional assembly (IF/ELSE/ENDIF)
• Multi-pass assembly for forward references
• Comprehensive error detection and reporting
• Disk and tape I/O for source and object files
• Cross-reference table generation
• Listing output with pagination control

Major Program Sections

Address Range	Section	Description
5200H-53FFH	Symbol Table Handler	Lookup, insertion, comparison routines, sorting, and pass control initialization.
5300H-54FFH	Symbol Table Data Structures	Contains pointers, counters, and configuration data.
5400H-57FFH	Assembly Engine	Opcode parsing, instruction encoding, expression evaluation, and scanner.
5500H-56FFH	Source Scanner & Symbol Mgmt	Token recognition, symbol table updates, and cross-reference tracking.
5700H-58FFH	Screen & I/O Dispatch	Character output, screen scrolling, and control character processing.
5800H-5FFFH	File I/O & Expression Evaluator	Disk/tape operations (NEWDOS/80 system calls) and numeric/symbolic parsing.
6000H-67FFH	Assembler Core Pass 1	First pass logic: label resolution, address calculation, and symbol collection.
6800H-6EFFH	Assembler Core Pass 2	Second pass logic: code generation, opcode lookup, and Intel HEX/Listing output.
6F00H-72FFH	Main Entry & Command Dispatch	Program initialization, user interface, and command processing loop.
7300H-76FFH	Error Handling & Runtime Data	Error messages, prompts, runtime variables, and work buffers.

High Memory Workspace (7600H-76FFH)

This area contains runtime work buffers and temporary storage populated during execution:

7600H-762BH	Error message strings
762CH-764CH	Uninitialized buffer area
764DH-7652H	Runtime variables
7653H-76FFH	Additional work buffers and stack space

The following tables detail the runtime variables and pointers used for program state and buffer management.

Symbol Table & Pass Control

Address	Size	Description
5315H	2b	Symbol Table Base (Low byte to 5513H, High to 550EH)
53C3H	2b	Current Symbol Entry Pointer
550EH	1b	Current Pass Number (01H = Pass 1, 02H = Pass 2)
5513H	1b	Pass Configuration Flags
559EH	1b	Conditional Nesting Counter (Init to 28H)
7652H	2b	Symbol Table Base Address (Search start)

I/O & Buffer Management

Address	Size	Description
7650H	2b	Source Symbol Name / Line Buffer Pointer
764EH	2b	Symbol Compare Save / Source Line Backup
7634H	2b	Symbol String / Entry Working Pointer
763BH	2b	Cross-Ref / Output Buffer Pointer
7655H	-	Input Buffer Base Address
7700H	-	Extended Work Area

Additional Runtime Counters & Flags

Address	Description
3840H	Keyboard Flags (System)
4312H	Display/Printer Control (System)
552FH	Assembly Status Flag
55EAH	Symbol Attributes Byte
7633H	Output Column Counter
7636H	Line Number / Multi-Define Flag
763BH	Cross-Ref Write Pointer
764DH	Page Counter / Cross-Ref Entry Count

EDTASM uses variable-length entries: [Length/Flags (1b)][Symbol Name (1-7b)][Value (2b)][Type (1b)].

Bit 7 of Attribute byte: External/Local; Bits 0-6: Length and type.

EDTASM employs self-modifying code for performance optimization. This allows the program to change comparison values and branch logic dynamically without the overhead of extra conditional jumps.

Location	Source/Modifier	Target Purpose
5252H	5223H-5225H	Quick compare: Stores 1st char of source symbol into CP operand.
526DH	5228H-522AH	Boundary check: Stores computed end position for name length.
5280H	5238H-523BH	Quick compare: Stores 1st char of table symbol into CP operand.
5292H	523EH-5240H	Hash/End check: Stores computed end position for table symbol.
5689H	52BAH-52BDH	Output limit: Stores symbol length limit for printer routine.
5524H	52C5H, 5610H	Scanning Mode: Switches between 18H (JR) and 20H (JR NZ) for label/opcode fields.
552FH	Various	Comment Logic: Switches between 18H (JR) and 28H (JR Z) for comment recognition.
559EH	52CAH, 5636H	Conditionals: Switches JR Z/NZ to control the IF/ENDIF state machine.
55EBH	55E9H	Flag Testing: Modifies a LD A,00H instruction to test dynamic flag values.

Symbol Table Search (5200H-52A5H)

1. Extract length from low 3 bits of flags byte.
2. Patch 1st character and end position into search loop (Self-Modification).
3. Compare 1st characters for fast rejection.
4. Full name character-by-character comparison.
5. On match, return Z flag; otherwise, advance HL by (name_length + 3).

Two-Pass Assembly Process

Expression Evaluator & Scanner

The evaluator supports full arithmetic (+, -, *, /, MOD) and logical operators (AND, OR, XOR, NOT, SHL, SHR) with precedence and parentheses. The scanner at 5500H identifies fields by column and delimiters (Space, Tab, Semicolon, Apostrophe).

Entry point and main program flow from startup through assembly completion.

Entry Point (6F00H):

The program is entered at 6F00H where it:

1. Displays the program banner "APPARAT ASSEMBLER APPENDAGE, VERSION 3.0"
2. Initializes the symbol table pointers
3. Sets up I/O vectors and buffer pointers
4. Prompts for source and object file specifications
5. Enters the main assembly loop

Main Assembly Loop:

1. Initialize for Pass 1 (5200H entry)
2. Process all source lines, collecting symbols
3. Check for errors; if any, report and optionally continue
4. Initialize for Pass 2 (via 52EAH)
5. Re-process source, generating code and listing
6. Output object file in Intel HEX format
7. Display statistics and return to DOS or prompt for another file

Symbol Table Initialization (5200H-520EH):

At the start of each assembly:

1. Load configuration from (5315H) into pass control variables
2. Initialize buffer pointer 7650H to 7655H (input buffer)
3. Call I/O initialization at 5937H
4. Check for break key at (3840H)
5. Begin source line processing loop

Standard register assignments used throughout the assembler code.

General Conventions:

Registers

Flags

Subroutine Conventions:

5684H	Symbol Compare: HL=source, DE=(7650H), B=length	Returns: Z if match, NZ if different
559CH	Add Symbol Reference: HL=source line position	Updates cross-reference table, preserves HL and BC
56B6H	Output Symbol Name: HL=symbol, B=length	Outputs B characters starting at HL
56BEH	Output Message: HL=string address	Outputs until 03H terminator found
5937H	Initialize I/O: No parameters	Sets up buffers and pointers
5939H	Output Character: A=character	Sends character to current output device

5200H - Symbol Table Handler Entry Point

This is the main entry point for symbol table operations. It initializes pass control variables from configuration data, sets up buffer pointers for symbol name storage, checks for user break request, and prepares for symbol table searching. The code at 5200H-5210H runs at the beginning of each assembly pass.

521CH - Source Symbol Extraction

This section extracts the symbol name from the source line and prepares comparison parameters. It reads the symbol's first character and length, then stores these as self-modifying operands for the fast comparison loop that follows.

522EH - Table Symbol Setup and Search Loop Entry

This section initializes the table symbol comparison parameters similar to how the source symbol was set up. It then enters the main search loop that iterates through all symbol table entries looking for a match.

5244H - Symbol Entry Length Check

This section reads the symbol table entry's length byte to determine entry size and check for end-of-table. A length of zero indicates the end of the symbol table has been reached.

5250H - First Character Quick Comparison

This section performs a quick first-character comparison between the source symbol and table symbol. This optimization avoids full name comparison for entries that cannot possibly match.

525CH - Character Comparison Loop

This is the main character-by-character comparison loop. It compares each character of the source symbol against the table symbol, handling matches and mismatches appropriately.

526BH - End of Symbol Name Check

After matching a character, this section checks if we've reached the end of the source symbol name. If all characters have been compared and matched, we have found the symbol.

5279H - Alternate Comparison Path

This section handles cases where the first comparison path found a mismatch. It reloads pointers and attempts comparison from the alternate (table symbol's perspective) to properly determine ordering.

528AH - Alternate Character Comparison Loop

This is the alternate comparison loop that checks symbols from the table entry's perspective. It handles cases where the symbol lengths differ or ordering needs verification.

52A7H - Symbol Not Found / End of Table Handler

This section handles the case where the symbol was not found in the table (end-of-table reached) or processes a found symbol. It checks the result and either adds a new symbol or processes the existing one.

52B5H - Symbol Processing Setup

When a symbol is found or needs to be added, this section prepares the symbol attributes and initializes self-modifying code locations that control subsequent line processing.

52CDH - Cross-Reference Initialization

This section initializes the cross-reference table tracking variables and prepares for adding references to the current symbol.

52DAH - External Reference Check and Line Processing Entry

This section checks if the symbol is an external reference and, if not, adds it to the cross-reference table. It then transfers control to the main line processing loop.

52EAH - Pass Completion Check

This section is reached at the end of processing. It checks if we've completed both passes and either starts Pass 2 or continues to final output.

5300H - Data Section: Variables and Working Storage

This memory region (5300H-54FFH) contains no executable code. It is used for variable storage, configuration data, pointers, counters, and the system stack. The disassembler skipped this area because it contains data, not instructions. Below are all identified variables with their purposes, organized by functional group.

53A8H - Buffer Pointers and State Variables

These variables track buffer positions and parsing state during source line processing.

53C6H - Reserved/Unused Area

The area from 53C6H to 54FDH appears to be reserved space or used as scratch storage. No direct references were found in the code to specific addresses in this range.

54FEH - System Stack

The top of the data area is used as the system stack. The stack grows downward from 54FEH.

5500H - Source Line Scanner Entry

This is the main entry point for source line scanning. It initializes I/O, loads the symbol table base pointer, and enters the main scanning loop. The scanner processes source lines character by character, identifying labels, opcodes, operands, and comments.

550CH - Main Line Processing Loop

This section checks if we've reached the end of source and processes each line. It validates the current position, saves it for reference tracking, and begins field parsing.

5522H - Label Field Recognition

This section checks if the current character matches a symbol and processes label definitions. It handles the self-modifying branch that controls whether we're in label or opcode scanning mode.

552DH - Comment and Whitespace Detection

This section checks for comment markers and whitespace to determine field boundaries. It handles semicolons, tabs, and spaces that separate assembly language fields.

553EH - Whitespace Skip Loop

This section skips over whitespace (spaces and tabs) between fields. It continues until it finds a non-whitespace character or reaches end of line.

5552H - Operand Field Scanner

This section scans the operand field, checking for whitespace that would indicate the end of the operand and start of a comment field.

5564H - Symbol Character Validation

This section validates characters that can appear in symbol names (A-Z, 0-9). It distinguishes between letters, digits, and symbol terminators to properly parse identifiers.

5584H - Digit Check in Symbol Names

This section checks if a character is a digit (0-9), which is valid in symbol names after the first character but cannot start a symbol.

559CH - Cross-Reference Entry Handler

This subroutine adds a cross-reference entry for the current symbol occurrence. It preserves registers, checks the current mode, and either prints the reference or records it in the cross-reference table.

55A9H - Symbol Definition Output

This section handles the first definition of a symbol, outputting the symbol name, its value, and setting up for cross-reference tracking. It formats the symbol table listing output.

55CFH - External Symbol Check and Output

This section checks if the symbol is external (bit 7 of attributes set) and outputs appropriate text - either "UNDEF***" for undefined symbols or the symbol's value.

55E9H - Multiply Defined Check

This section checks if the symbol has been multiply defined and processes the cross-reference list. It outputs all line references for the symbol.

55FFH - Cross-Reference Output Loop

This loop iterates through all cross-reference entries for the current symbol and outputs each line number reference.

560EH - Reset Self-Modifying Code

After processing a symbol's references, this section resets the self-modifying code locations to their default values for the next symbol.

562EH - Multiply Defined Error Output

This section outputs the "MULTIPLY DEFINED AT" error message when a symbol has been defined more than once.

5646H - Add Cross-Reference Entry

This subroutine adds a new cross-reference entry for the current symbol. It checks if there's room in the table and handles overflow conditions.

566CH - Cross-Reference Overflow Handler

When the cross-reference table for a symbol is full (8 entries), this section saves the overflow information for later output on a continuation line.

5684H - Symbol Name Comparison

This subroutine compares a symbol name in the source with the current symbol being searched. It performs character-by-character comparison and validates that names match completely.

5699H - End of Symbol Validation

When we've matched all characters of the search symbol, this section validates that the source symbol also ends (isn't longer than the search symbol).

56B6H - Output Symbol Name

This subroutine outputs a symbol name character by character. It outputs B characters starting at address HL.

56BEH - Output Message String

This subroutine outputs a null-terminated (03H) message string starting at address HL.

56C8H - Output Spaces

These subroutines output one or more space characters for formatting purposes.

56D3H - Output Line Reference

This subroutine outputs a cross-reference line number with proper column tracking and line wrapping.

56E7H - Output 16-bit Value in Hex

This subroutine loads a 16-bit value from memory and outputs it in hexadecimal format.

56EEH - Offset Calculation Helper

This helper routine calculates an offset by adding 80H to DE and returning the high byte result.

56F8H - DOS Vector Patching

This section patches the NEWDOS/80 jump vector to intercept system calls and redirect to the assembler's command processor.

5700H - Character Output Wrapper

This section contains character output routines that handle special control characters and formatting. It outputs a character followed by an optional control code for cursor positioning or formatting.

5708H - Exit to NEWDOS/80

This routine clears the error flag and returns control to the NEWDOS/80 operating system via the warm start vector.

570FH - Display Control and Memory Banking

This section handles Model III memory banking via port FFH and cursor position calculations for screen output.

5719H - Control Character Dispatcher

This routine dispatches control characters to their appropriate handlers. It checks for various control codes (backspace, linefeed, carriage return, cursor controls) and jumps to the corresponding handler routine.

575EH - Write Character to Video RAM

This routine writes a character to video RAM at the current cursor position and advances the cursor, handling screen wrap and scrolling.

5770H - Screen Scroll Up

This routine scrolls the screen up by one line using the LDIR block move instruction to copy video memory upward.

5781H - Line Feed / Carriage Return Handler

This routine handles line feed (0AH) and carriage return (0DH) by moving the cursor to the start of the next line, scrolling if necessary.

5790H - Clear to End of Line

This routine clears from the current cursor position to the end of the current line by filling with spaces.

5799H - Clear Screen

This routine clears the entire screen by filling video RAM with spaces (20H).

57AAH - Printer Output Handler

This section handles output to the printer, including form feed detection and page formatting.

57D1H - Normal Printer Character Output

This routine outputs a normal character to the printer and tracks line position for page formatting.

57EEH - Check Printer Ready

This routine checks if the printer is ready to receive data by reading the printer status port.

57F6H - File Output Setup Routines

These routines set up different output destinations (disk files) with varying buffer sizes.

58DAH - Error/Abort Handler Entry

This is the main error and abort handling entry point. It resets the stack, performs cleanup, and prepares for new user input.

592FH - Display Message with High-Bit Terminator

This routine displays a message string pointed to by HL. The string is terminated by a character with its high bit set. Entry: HL points to the start of the message string. Exit: Message is displayed, HL points past the terminator.

5939H - Character Output with Column Tracking

This routine outputs a character to the display while tracking column position and handling special characters like TAB (09H). Entry: A contains the character to display. Exit: Character is displayed, column counter updated.

596BH - Editor Error and Status Messages

This section contains the error and status messages used by the editor. Each message is terminated by a character with its high bit set (bit 7 = 1), which signals the end of the string to the display routine at 592FH.

5B05H - Command Dispatch Table

This is a command dispatch table used by the command parser at 58FEH. Each entry consists of a single ASCII command letter followed by a 2-byte jump address (little-endian). The parser searches this table for matching commands and jumps to the corresponding handler routine. The table contains 15 entries (0FH entries as indicated by the LD B,0FH at 5902H).

5B32H - Command Input Handler

This routine handles command line input from the user. It initializes the input buffer, processes keystrokes including special keys (backspace, enter, break), and manages cursor position. The routine uses 53BBH as a tab/column counter, 53A8H as the buffer pointer, and 53AAH to store the final character count.

5B89H - Backspace Handler

This routine handles the backspace key during input. It decrements the buffer position, erases the character from the display, and handles tab characters specially by erasing multiple spaces. Register D contains the character count, HL points to the current buffer position.

5BBBH - Skip Spaces / Get Next Non-Space Character

This routine skips over space characters (20H) in the input buffer and returns the next non-space character. Entry at 5BBBH sets A=20H as the delimiter, entry at 5BBDH uses the existing value in A. Entry at 5BBEH (the main entry point) is used by most callers. Register B is set to the delimiter character, and the routine returns with A containing the next non-space character, Z flag set if end of line (0DH) reached.

5BE4H - Validate Alphanumeric Character

This routine checks if the character in Register A is alphanumeric (0-9 or A-Z). Entry: A = character to test. Exit: Carry flag set if character is alphanumeric (digit or uppercase letter), Carry flag clear if not alphanumeric. The Z flag is affected but secondary to the Carry flag result.

5BEDH - Validate Uppercase Letter

This routine checks if the character in Register A is an uppercase letter (A-Z). Entry: A = character to test. Exit: Carry flag set if character is uppercase letter, Carry flag clear if not. Falls through to 5BE9H for final flag manipulation.

5BF4H - Unget Character (Push Back to Input Buffer)

This routine "pushes back" one character to the input buffer by decrementing the buffer pointer and incrementing the remaining character count. This allows re-reading the last character consumed. Entry: None required. Exit: HL preserved, buffer pointer (53A8H) decremented, character count (53AAH) incremented.

5C02H - Edit Line with Line Number Range

This routine handles editing operations with a line number range specified. It parses line number parameters, validates memory bounds, and iterates through source lines. Entry: Command line parsed with potential line number range. Exit: Lines processed according to edit operation, or error displayed if bounds exceeded.

5C41H - Delete Lines in Range

This routine deletes source lines within a specified line number range. It validates memory bounds and repeatedly calls the line deletion routine until all lines in range are removed. Entry: Command line with line number range parsed. Exit: Lines deleted from source buffer, memory compacted.

5C5CH - Delete Single Source Line

This routine deletes a single line from the source buffer by moving all subsequent lines up to fill the gap. It updates memory pointers and validates that sufficient memory remains. Entry: Line to delete identified via 531DH pointer. Exit: Line removed, source buffer compacted, pointers updated.

5CC7H - Parse Line Number Range

This routine parses a line number range from the command line in the format "start,end" or just "start". It handles special symbols like # (end of file), . (current line), and * (all lines). Entry: Command line in input buffer. Exit: 5317H = end line number, 5319H = current search position, 531BH/531DH = line pointers.

5D07H - Parse Number with CR Delimiter / 5D09H - Parse Number with Custom Delimiter

These routines parse a decimal number or special symbol from the input buffer. 5D07H uses carriage return (0DH) as delimiter, 5D09H uses the delimiter specified in Register B. Entry: B = delimiter character (5D09H only), input buffer set up. Exit: HL = parsed value, DE indicates if value was found (D non-zero = found), Z flag set if no number found.

5D75H - Display Line Number

This routine displays a line number in decimal format. It uses a powers-of-10 table at 5D9FH to convert the binary value in HL to ASCII digits. Each digit is output via the character output routine at 5939H. After output, the tab counter at 53BBH is set to FFH and a trailing space is printed.

5D9FH - Powers of 10 Table (Negated)

This table contains negated powers of 10 in little-endian format, used by the line number display routine. The values are stored as two's complement negatives so ADD can be used for subtraction. Table entries: -10000 (D8F0H), -1000 (FC18H), -100 (FF9CH), -10 (FFF6H), -1 (FFFFH), terminator (FFH).

5DA9H - Check Memory Full

This routine checks if memory is full by comparing the symbol table top (5313H) minus 100H against the program text end (5315H). If there is insufficient space, it displays a "FULL" error message. Returns with CARRY clear if OK, displays error if full.

5DC2H - Compare HL with DE

This utility routine compares the 16-bit value in HL against DE. Returns: Z flag set if HL equals DE. CARRY flag set if HL is less than DE. This is used extensively for bounds checking and address comparisons throughout the editor.

5DC8H - Collect Search String

This routine collects a search string from the input buffer into the search buffer at 5301H. The string length is stored at 5300H. Maximum string length is 16 characters. After collection, it initiates a search through the program text to find matching lines.

5E1CH - List Command Handler

This routine implements the LIST command, displaying program lines. It prompts for parameters, then lists lines starting from the specified line number. The listing can be limited to a count or continue to the end. Uses print flag at 53C5H to control output destination.

5E72H - Symbol Value Retrieval Entry Point (Alternate)

This is an alternate entry point for symbol value retrieval. It sets the carry flag before falling through to the main routine at 5E75H. The carry flag indicates a specific retrieval mode. Entry: None explicit. Exit: BC=0001H, HL=value from 5319H or 531BH depending on carry state.

5E9BH - Symbol Lookup with Colon Delimiter

This routine searches for a symbol name followed by a colon character (3AH). It is used for label definitions in the assembler. If the symbol is not found or is undefined, an error is generated. Entry: Symbol name in input buffer. Exit: HL=symbol table entry address, DE=end pointer, BC=length.

5ECDH - Symbol Table Entry Creation/Update

This routine creates or updates a symbol table entry. It first validates the symbol via 5CC7H, then manages memory allocation by moving existing entries to make room for new data. Uses pointers at 531DH, 531BH, 5311H, 5315H, and 5319H. Entry: Symbol information set up by previous calls. Exit: Memory reorganized, pointers updated.

5F1FH - File Write Command Handler

This routine handles writing the source file to disk. It initializes file I/O via 6107H, skips any parameters via 5BBEH, sends a D3H marker byte, then outputs all source lines from memory starting at 5315H to address 7700H. The file is terminated with a 1AH (EOF) character. Entry: Command line parsed. Exit: File written to disk, 53BAH flag cleared.

5F47H - File Load Command Handler (Entry)

This routine handles loading a source file from disk. It initializes file I/O, reads the D3H format marker, then parses the file content including 5-digit line numbers and source text. Lines are stored in memory with a 2-byte line number followed by a length byte and text. Entry: Filename parsed from command line. Exit: Source file loaded into memory at 7700H and below, pointers updated.

5FC1H - Interactive Line Editor Entry

This routine provides interactive editing of source lines. It validates the line exists via 5D07H and 5CDAH, then displays the line and accepts keyboard input. Supports commands: 'A' (abort edit), 'L' (list remaining), SPACE (advance cursor), ENTER (accept changes). The edit buffer is at 5327H with a maximum of 128 characters. Entry: Line number or context from previous operation. Exit: Line updated in source buffer or edit aborted.

6030H - Space Command Handler / Character Display Loop

This section handles the SPACE command in the line editor, which advances the cursor through the line displaying characters. It also contains the ENTER command handler (0DH) which commits the edited line, and the backspace handler (08H) which moves back one character. Entry: B=count of characters to advance, HL=current position in edit buffer, D=display position. Exit: Characters displayed, HL advanced, or line committed.

6041H - Edit Command Dispatcher

This routine dispatches edit subcommands based on the character in A. It checks for 'E' (edit), 'C' (change), 'D' (delete), 'Q' (quit), 'I' (insert), 'X' (exit), 'H' (help or home), 'S' (search), 'K' (kill), and backspace (08H). Entry: A=command character, HL=buffer position, B=count, D=display position, E=buffer offset. Exit: Varies by command.

6046H - Additional Edit Command Checks

Continuation of edit command dispatcher checking for additional commands.

6107H - File I/O Initialization

This routine initializes file I/O operations. It clears the file flag at 53ADH, then calls 61A8H to parse the filename and set up the FCB. On return, it validates the result and checks for valid drive specification (0-7). The filename is stored at 53ABH. Entry: Command line contains filename. Exit: A=result code, HL=53ABH if successful, or jumps to error handler.

6121H - File Output Byte Handler

This routine outputs a byte to the file. It calls 586BH to handle the actual I/O, retrieves the file column count from 53ADH, calculates remaining space (6 - column), then formats and outputs the data through 7079H. Entry: C=byte to output. Exit: Byte written to file output stream.

614BH - Error Message Output Setup

This routine sets up for error message output. It pushes return address 6496H onto the stack twice, then loads A with AFH (XOR A opcode) before continuing. This creates a chain that will execute cleanup code after the error is displayed. Entry: DE=error message address. Exit: Jumps to error display routine.

617FH - Error Message Display Routine

This routine displays an error message. It sets up the stack to return through 618CH for cleanup, then calls the message output routine at (DE). Uses a trampoline technique with stack manipulation. Entry: DE=message output routine address, HL=error message. Exit: Message displayed, returns through cleanup code.

61A8H - Filename Parser Entry

This routine parses a filename from the command line. It skips leading spaces via 5BBBH, then calls 5BBEH to parse the filename. Returns the parsed position in DE and validates the result. Entry: Command line at input buffer. Exit: DE=position after filename, A=result code, Z flag set if successful.

61ADH - Register Operand Parser (Register A = 05H)

Entry points for parsing register operands with different register codes loaded into A. These are used by the assembler to validate and encode register references in instructions.

61D6H - Skip Delimiter and Parse

This routine skips delimiters and parses the next token. It calls 5BBEH to skip the delimiter, then returns the parsed position. Entry: Input buffer positioned at delimiter. Exit: DE=position after token, A=first character, Z flag set if end of input.

6206H - Token Length Counter

This routine counts the length of a token (identifier or keyword) by scanning characters until a delimiter is found. It increments C for each valid character and calls 5BBEH to get the next character. Entry: DE=input position, C=initial count. Exit: C=token length, A=01H, Z flag clear.

621AH - Register Name Lookup Table

This is a lookup table for Z80 register names used by the assembler. Each entry consists of a length byte (in low 5 bits), the register name characters, and a code byte. The table includes single registers (A, B, C, D, E, H, L), register pairs (BC, DE, HL, SP, IX, IY), and condition codes (NZ, Z, NC, C, PO, PE, P, M). Format: [length+flags] [char1] [char2...] [code]

6274H - Table Search Mismatch Handler

This routine handles a mismatch during table search. It calculates the skip distance to move to the next table entry by adding the entry length to HL, then continues the search. Entry: HL=current table position, A=entry length, C=search length. Exit: HL advanced to next entry.

627CH - Table Search Main Loop

This is the main table search routine. It scans a table looking for a match against the string at (DE) with length C. Each table entry has a length byte (in bits 0-4), followed by the characters, followed by a code byte. Returns with Carry set if no match found (end of table). Entry: HL=table start, DE=search string, C=string length, B=entry count. Exit: HL=matching entry (or past end), Carry set if not found.

6293H - Expression Evaluator Entry (with CR check)

This routine initializes expression evaluation with a check for carriage return. It saves registers, initializes HL to 0000H as the accumulator, pushes it, then checks if the current character is CR (0DH). Entry: A=expression type, DE=input position. Exit: Jumps to 62AEH for main evaluation.

62A0H - Expression Evaluator Main Entry

This is the main entry point for expression evaluation. It initializes the accumulator at 53C1H to 0000H, sets up registers, and begins parsing the expression. Used for assembly-time expression calculation. Entry: None specific. Exit: Result in HL and at 53C1H.

62E8H - Operator/Delimiter Check

This routine checks if the current character is an operator or delimiter. It pops the return address, checks for space (20H), TAB (09H), semicolon (3BH), comma (2CH), or close parenthesis (29H). If a delimiter is found, it backs up the input pointer and returns to the expression end handler. Entry: Stack has return address. Exit: A=character, or jumps to delimiter handler.

6305H - Symbol Reference Handler

This routine handles symbol references in expressions. It calls 65A6H to look up the symbol value, then continues expression processing. Entry: DE=symbol name position. Exit: HL=symbol value.

635AH - Numeric Constant Parser

This routine parses a numeric constant from the input. It handles decimal (default), hexadecimal (H suffix), octal (O or Q suffix), and binary (B suffix, but 'B' also checked for hex). Initializes HL to 0, sets default base to 10, then scans digits. Entry: DE=input position. Exit: HL=parsed value, continues at 6308H.

63A0H - Character Constant Parser

This routine parses a single-quoted character constant (e.g., 'A'). It extracts the ASCII value of the character between quotes and returns it in HL. Entry: DE points to opening quote. Exit: HL contains character value, continues at 6308H.

63BAH - Subtraction Operator Handler

This routine handles the subtraction operator (-). It negates the value in HL (two's complement), then falls through to the addition handler to subtract by adding the negative. Entry: HL=right operand. Exit: Result stored in accumulator at 53C1H.

63C0H - Addition Operator Handler

This routine handles the addition operator (+). It adds the value in HL to the accumulator at 53C1H and stores the result. Also serves as entry point for subtraction (after negation). Entry: HL=operand to add. Exit: Sum stored at 53C1H.

63C9H - Bitwise AND Operator Handler

This routine handles the bitwise AND operator (&). It ANDs the value in HL with the accumulator at 53C1H byte-by-byte and stores the result. Entry: HL=mask operand. Exit: Result stored at 53C1H.

63D4H - Expression Continuation Handler

This routine continues expression parsing after an operand has been processed. It checks for additional operators and either continues parsing or returns the result. Entry: After operand processing. Exit: Either continues with next operator or returns to caller.

63E3H - Assembly Initialization

This routine initializes the assembler for a new assembly operation. It clears working variables, resets file flags, and prepares the symbol table pointer. Called at the start of assembly to ensure clean state.

6400H - Assembly Pass Setup

This routine handles pass initialization and the main assembly loop entry. It checks and initializes pass-related variables, sets up buffer pointers, and begins processing source lines.

6427H - Working Variable Initialization

This routine initializes the working variable block at 53B4H-53BFH (12 bytes) to zero, sets up memory pointers, and prepares for assembly pass execution. Called when starting a new assembly pass.

6463H - Symbol Table Output Loop

This routine outputs the symbol table after assembly is complete. It iterates through symbols, displaying each name and value. Part of the post-assembly symbol listing.

6486H - Assembly Completion Handler

This routine handles assembly completion. It clears the output flag, checks if assembly was in progress, and either returns to command mode or outputs the final status byte. Called when assembly finishes or encounters an unrecoverable error.

6496H - Main Assembly Loop Entry

This is the main entry point for processing source lines during assembly. It resets the stack, calls file handling, and manages the pass counter. This routine is called repeatedly for each source line.

64D0H - Source Line Fetch and Parse

This routine fetches the next source line from memory and parses its structure. It compares memory boundaries, extracts line length, and sets up pointers for line processing.

6508H - Comment/Directive Line Handler

This routine handles lines beginning with asterisk (*) which may be comments or special directives like *LIST. It parses the directive and takes appropriate action.

652DH - Label/Comment Line Check

This routine checks if the current line is a comment (beginning with semicolon) or continues to process the label. Also handles label error reporting when an invalid label is detected.

6539H - Short Label Validation

This routine validates labels that are 6 characters or shorter. It checks for proper delimiters (space or colon) after the label and handles the transition to opcode field parsing.

654CH - Opcode Field Parser Entry

This routine begins parsing the opcode/mnemonic field after the label. It saves the label length, parses the opcode mnemonic, checks for empty opcodes (label-only lines), and dispatches to the instruction lookup table at 6BD9H.

6569H - Opcode Not Found Error

This routine handles the case when an opcode mnemonic is not found in the lookup table. It reports an "OPCODE" error and returns to the error handler.

656FH - Opcode Found - Operand Check

This routine is called after a valid opcode is found. It checks for operand delimiters and prepares for operand parsing. Validates that operands follow proper syntax.

657CH - Opcode Dispatch Setup

This routine sets up for opcode dispatch. It skips spaces, classifies operands, loads the dispatch table entry, and prepares for instruction encoding. The opcode handler address is loaded from table at 6DA7H. Uses a PUSH/RET trick to call the handler.

65A6H - Symbol Table Lookup for Label

This routine looks up a label in the symbol table. If the symbol exists, it retrieves its value. If not found and this is Pass 1, it creates a new symbol table entry. Handles forward references and multiple definition detection.

65E0H - Symbol Entry Processing

This routine processes a symbol table entry after lookup. It calculates the position of the flags byte, checks for multiple definition warnings, and handles symbol attribute flags for external references and phase errors.

6605H - Symbol Redefinition Handler

This routine handles symbol redefinition cases. It checks if this is a legitimate redefinition (like EQU) or an error, manages the external and phase flags, and either updates the symbol value or reports an error.

662FH - Set Symbol Definition Flags

This routine sets the appropriate flags for a new symbol definition. It marks the symbol as defined (bit 7) and optionally sets the external flag (bit 5) based on the definition context.

6637H - Store Symbol Value

This routine stores a 16-bit value to a symbol table entry. It handles the final step of symbol definition by writing the low and high bytes of the value.

663DH - Parse Comma-Separated Operand

This routine advances past the current operand, checks for a comma separator, and validates the operand type. Used for instructions with multiple operands like LD r,r or ADD A,n.

6660H - Immediate Operand Handler

This routine handles immediate operand encoding. It toggles the opcode type flag, evaluates the expression, and sets up the instruction bytes for immediate mode operations.

667CH - Bit Operation Handler

This routine handles bit manipulation instructions (BIT, SET, RES). It evaluates the bit number expression, validates the range (0-7), encodes the bit position, and processes the register operand.

66A4H - Register Operand Encoder

This routine encodes register operands into instruction bytes. It handles both source and destination register encoding, with special handling for rotated positions in the opcode byte.

66E2H - Operand Syntax Error Handler

This routine handles operand syntax errors. It loads the address of the "OPERAND" error message and jumps to the error display routine.

66E8H - Indexed Addressing Offset Handler

This routine handles the offset portion of indexed addressing modes (IX+d, IY+d). It sets up the index prefix, evaluates the displacement expression, and encodes the offset byte.

66FEH - Index Register Prefix Setup

This routine sets up the prefix byte for IX or IY indexed addressing. It stores DDH for IX or FDH for IY at 53B0H and updates the instruction length.

670BH - Add Bytes to Instruction Length

This routine adds additional bytes to the instruction length counter at 53B4H. Used when encoding multi-byte instructions with prefixes or immediate values.

6714H - EX Instruction Handler

This routine handles the EX (exchange) instruction encoding. It validates the operand combination and generates the appropriate opcode for EX DE,HL, EX AF,AF', or EX (SP),HL/IX/IY.

6735H - ADD/ADC/SBC Register Pair Handler

This routine handles ADD, ADC, and SBC instructions with register pair operands (e.g., ADD HL,BC or ADC HL,DE). It validates operand types and encodes the appropriate opcode with register pair bits.

674DH - Register Pair Operand Parser

This routine parses the second register pair operand and encodes its bits into the opcode. It rotates the register code into position and ORs it with the base opcode. Used by ADD HL,rr and similar instructions.

675DH - Index Register Pair ADD Handler

This routine handles ADD IX,rr and ADD IY,rr instructions. It sets up the index prefix, validates that the second operand matches the first (can't mix IX and IY), and encodes the instruction.

677DH - INC/DEC Register Pair Handler

This routine handles INC and DEC instructions with register pair operands. It checks for both simple register pairs (BC, DE, HL, SP) and index registers (IX, IY), setting appropriate prefixes.

679EH - RST Instruction Handler

This routine handles the RST (restart) instruction. It evaluates the restart address expression, validates it's a valid RST vector (0, 8, 10H, 18H, 20H, 28H, 30H, 38H), and encodes the opcode.

67B0H - Store Opcode Byte 2 and Update Length

This routine stores a computed opcode byte at 53B2H and jumps to update the instruction length. Used as a common endpoint for many instruction encoders.

67B7H - ED-Prefixed Instruction Setup

This routine sets up ED-prefixed instructions. It moves the current opcode to byte 2 and stores EDH in byte 1, then continues with length update.

67BFH - JP/CALL Instruction Handler

This routine handles JP and CALL instructions. It determines if this is a conditional or unconditional jump, handles register indirect forms (JP (HL), JP (IX), JP (IY)), and encodes the 16-bit target address.

67D7H - Condition Code / Operand Type Check

This routine checks the operand type and handles condition codes for conditional JP/CALL/RET instructions. It identifies condition codes (NZ, Z, NC, C, PO, PE, P, M) and encodes them into the opcode.

67F8H - Require Comma Separator

This routine checks that the next character is a comma and reports an operand error if not. Used to enforce proper syntax between operands.

6801H - Advance and Get Operand Type

This routine advances the source pointer, then checks if the next character is an open parenthesis (for indirect addressing). Returns with Z flag reflecting the parenthesis check.

680CH - DEFB/DEFM Directive Handler

This routine handles DEFB (define byte) and DEFM (define message) directives. It sets up for byte definition, parses the content, and handles both numeric values and string literals.

681AH - JP (HL)/(IX)/(IY) Handler

This routine handles JP with register indirect addressing: JP (HL), JP (IX), and JP (IY). It checks for the indirect form and encodes the appropriate opcode with any needed prefix.

6839H - JR Instruction Handler

This routine handles JR (jump relative) instructions, both conditional (JR Z, JR NZ, JR C, JR NC) and unconditional. It evaluates the target address, calculates the relative offset, and checks for range errors.

6853H - JR Relative Offset Calculator

This routine calculates the relative offset for JR and DJNZ instructions. It subtracts the current PC from the target, adjusts for the instruction length, validates the range (-128 to +127), and reports errors if out of range.

6879H - RST Instruction Handler

Encodes the RST (Restart) instruction. RST takes a single operand that must be a multiple of 8 (00H, 08H, 10H, 18H, 20H, 28H, 30H, 38H) and encodes it into a single-byte opcode C7H + (n*8).

6893H - IN Instruction Handler

Handles the IN instruction which reads from an I/O port. Supports both IN A,(n) (port in immediate) and IN r,(C) (port in register C) forms.

68CEH - OUT Instruction Handler

Handles the OUT instruction which writes to an I/O port. Supports both OUT (n),A (port out immediate) and OUT (C),r (port out to register C address) forms.

690FH - JP Instruction Handler

Handles the JP (jump) instruction. Supports unconditional JP nn, conditional JP cc,nn, and indirect JP (HL)/(IX)/(IY) forms.

6964H - CALL Instruction Handler

Handles the CALL instruction. Supports unconditional CALL nn and conditional CALL cc,nn forms.

6980H - LD Instruction Handler (Main Entry)

Main handler for the LD (load) instruction. This is the most complex handler as LD has many forms: register-to-register, immediate, memory access, 16-bit loads, special registers (I, R), and indexed addressing.

69E3H - LD Instruction Handler (Memory Destination)

Handles LD instructions where the destination is a memory location: LD (nn),A, LD (nn),HL, LD (BC),A, LD (DE),A, and indexed forms.

6A3AH - LD (nn),source Handler

Handles LD instructions with direct memory address destination: LD (nn),A, LD (nn),HL, LD (nn),rr forms.

6A78H - LD 16-bit Register Handler

Handles 16-bit register pair loads: LD rr,nn, LD rr,(nn), LD SP,HL/IX/IY forms.

6AD9H - LD rr,source Handler (BC/DE/HL)

Handles LD BC/DE/HL with various source operands including immediate values and memory addresses.

6B0BH - ORG Directive Handler

Handles the ORG (Origin) directive which sets the assembly address counter to a specified value. This directive changes where subsequent code will be assembled without generating any object code bytes.

6B1AH - DEFM/DEFB Character String Handler

Handles character string constants within DEFB/DEFM directives. Processes single-quoted strings character by character, outputting each byte to the object code.

6B59H - DEFB Numeric Expression Handler

Handles numeric expressions in DEFB directive, evaluating and storing single-byte values.

6B66H - DEFW Directive Handler

Handles the DEFW (Define Word) directive which stores 16-bit values in standard Z80 low-byte-first order.

6B70H - DEFS Directive Handler

Handles the DEFS (Define Storage) directive which reserves a specified number of bytes without initializing them. Advances the assembly address counter without generating object code.

6B80H - END Directive Handler

Handles the END directive which terminates assembly. Optionally accepts an expression specifying the program execution entry point address which is written to the object file.

6BC6H - EQU Directive Handler

Handles the EQU (Equate) directive which assigns a constant value to a symbol. The symbol must be defined as a label on the same line. Unlike labels on regular instructions, EQU symbols can be given any value, not just the current address.

6BD9H - Opcode/Directive Mnemonic Lookup Table

This table contains all Z80 mnemonics and assembler directives in a packed format. Each entry consists of: length byte, ASCII mnemonic string, type/flags byte, and handler index or base opcode. The table is searched sequentially by the opcode parser at 627CH. The disassembler incorrectly interprets these data bytes as Z80 instructions.

6DA7H - Opcode Handler Dispatch Address Table

This table contains 2-byte handler addresses (low-high order) indexed by the type code from the mnemonic table. Used by opcode dispatch at 657CH to jump to the appropriate encoding routine.

6DDFH - End-of-Line Verification Routine

Called after processing an instruction or directive to verify the source line ends properly. Accepts carriage return (0DH) or semicolon (3BH for comments) as valid terminators. Generates an operand syntax error if unexpected characters remain on the line.

6DF4H - Assembly Pass Output Router

Routes output processing based on the current assembly pass number. Pass 1 calculates addresses, Pass 2 generates listing, Pass 3 generates object code. The pass number is stored at 53C0H.

6E01H - Listing Line Output Entry Point

Entry point for listing line generation during pass 2. Formats and outputs the address, object code bytes, and source line to the listing device.

6E42H - Alternate Listing Format Handler

Handles alternate listing format when address field needs to be displayed. Outputs the 4-digit hex address before the object code bytes.

6E4EH - Output Byte as Two Hex Digits

Converts a byte pointed to by HL to two hexadecimal ASCII characters and outputs them to the listing. Uses standard nibble-to-hex conversion.

6E65H - Object Code Output Routine (Pass 3)

Generates object code output during pass 3. Writes instruction bytes to the object file in the system-specific format with load addresses and checksums.

6EC3H - Flush Object Record to File

Writes the current object code record to the output file. Outputs the record type marker (3CH), load address, data bytes, and checksum.

6EE5H - Pass 2 Listing Setup

Entry point for pass 2 listing generation. Adjusts pointers and loads control flags before calling the main listing output routine.

6EEEH - Reserved/Unused Area

Unused memory area, filled with NOPs. May be reserved for future expansion or patch space.

6EF9H - Copyright/Version String (DATA)

Embedded identification string containing version or copyright information.

6F02H - Store Result and Return to DOS

This short routine stores a value to the DOS filename buffer area (4478H) and jumps to the file close/return routine at 588AH. This appears to be an exit point that saves state before returning control.

6F08H - Assembly Entry Point (Object File Mode)

Entry point for assembly with object file output. Saves registers via 6F34H, initializes source input via 7293H, prompts for symbol table overflow confirmation via 6F4EH, then jumps to main assembly routine at 5F47H.

6F14H - Assembly Entry Point (Listing Mode)

Entry point for assembly with listing output. Similar setup to 6F08H but sets A=01H before calling 6F72H to enable listing mode, then jumps to alternate assembly entry at 5F1FH.

6F22H - Source Line End Check

Checks if current character indicates end of source input. If Z flag is set on entry, jumps to 6F27H. Otherwise compares A against 2FH (slash character) and returns with result in flags. This is used to detect end-of-file or special line markers.

6F27H - End of Source Handler

Handles end of source input. Pops return address (discarding it), saves registers, initializes source, reads next line, then jumps to working variable initialization at 6427H to continue assembly.

6F34H - Save Registers and Setup Return Context

Saves all main registers (HL, DE, BC, IX) onto the stack and sets IX to point to the return handler at 72A2H. This establishes a clean return context for assembly operations. On entry, the return address is on stack; on exit, IX points to 72A2H and all registers are preserved on stack.

6F3FH - Restore Registers and Return

Restores all registers saved by 6F34H and returns. Stores A temporarily at 75F5H, restores IX, BC, DE, HL from stack, then retrieves A and returns. The Z flag state is preserved based on the stored A value.

6F4EH - Symbol Table Overflow Check and User Prompt

Compares the current symbol table pointer (5315H) against a limit stored at 588BH. If they differ, prompts user with a message at 7520H asking whether to continue. Accepts Y to continue, N to reset the symbol table pointer to the limit value. Any other response re-prompts.

6F72H - Initialize Listing Mode and Parse Source Line

Stores the listing mode flag to 75F1H, then parses the source line from the input buffer (53A8H). Scans for spaces, handles the 'D=' directive for disk file specification. Copies characters to the output buffer at 72A2H. If the first character after a label is 'D' followed by '=', processes the disk file specification.

6F9FH - Copy Character from Source to Destination

Copies a single character from (HL) to (DE), increments both pointers, and checks if the character is a space (20H). Returns with NZ if not a space, Z if space. This is a helper routine for copying filename characters.

6FA6H - Clear Flags and Return to Line Parser

Clears the 53BAH flag via 728CH, then jumps to 5D24H to continue line parsing. This is the common exit point when source line parsing is complete or when an empty/invalid line is encountered.

6FACH - Process D= Disk File Specification

Parses a disk file specification following a D= directive. Copies up to 6 alphanumeric characters for the filename to the buffer at 72A2H, validating that each character is 0-9 or A-Z. If fewer than 6 valid characters, adjusts the count. Then copies up to 15 more characters for extension/path, terminating with CR (0DH).

6FE7H - Confirm File Overwrite

Called when a file already exists. Displays a prompt via 7266H and waits for user response. If user presses 'Y' (59H), jumps to 703AH to proceed with overwrite. Otherwise returns to 6FA6H to abort.

6FF0H - Initialize File Buffers for Disk Output

Sets up the file buffers for disk output. Initializes the buffer pointers at 761CH and 761EH to point to 72D4H. If listing mode (75F1H) is non-zero, adjusts the end buffer pointer by adding 200H and attempts to open the file. Handles file exists (error 18H) by prompting user, other errors jump to error handler at 725BH.

7042H - Check Disk File Active for Output

Checks if disk file output is active (75F0H). If not active (zero), jumps to 592FH to use standard output. If active, pops AF and returns to caller, allowing disk output to proceed.

704BH - Set Output Column Width

Saves character in C and sets B=07H for column width. If disk file is active (75F0H non-zero), clears C to 00H before returning. This adjusts output formatting based on whether output goes to screen or disk.

7056H - Send Escape Character to Display

Outputs an escape character (1BH) to the display via ROM routine 0033H, then jumps to 5E74H for further processing. This is used for terminal control sequences.

705EH - Convert Lowercase to Uppercase

Converts lowercase letter in Register A to uppercase. If A is less than 'a' (61H), returns unchanged. Subtracts 20H to convert to uppercase, then checks if result is less than '[' (5BH). If still lowercase after conversion check, jumps to error handler at 5836H.

7069H - Write Cassette Leader (If Not Disk Mode)

Checks if disk file mode is active. If so, returns immediately. Otherwise, calls 7081H for initialization, disables interrupts, and jumps to ROM routine 0296H to write cassette leader tone.

7075H - Read Cassette Byte (If Not Disk Mode)

Checks if disk file mode is active. If so, returns immediately. Otherwise, calls 7081H for initialization, disables interrupts, and jumps to ROM routine 0287H to read a byte from cassette.

7081H - Cassette Motor Control Jump

Jumps to cassette motor control routine at 3042H. This is a relay jump for cassette operations.

7084H - Toggle Video Cursor

Toggles bit 1 and bit 3 of the cursor character stored at 3C3FH by XORing with 0AH. This creates a blinking cursor effect by alternating the cursor character appearance.

708DH - Calculate and Display Symbol Table Size

Calculates the size of the symbol table by subtracting the base pointer (5315H) from the current pointer (53C3H). Converts the result to a displayable format via 6182H and outputs a message at 75DAH via 617FH. Returns the file status from 5882H in Register A.

70A7H - Store HL and Read FDC Status

Stores HL to 5321H, then reads the FDC status register at 37ECH and masks bit 7 (not ready). Returns with result in A.

70B0H - Write to FDC Drive Select Latch

Writes the value in Register A to the FDC drive select latch at 37E1H. Used to select the active disk drive.

70B4H - Cassette Motor Off with Disk Check

If disk file mode is active, calls 70C4H to turn off cassette motor. Checks if result is D3H; if so returns. Otherwise pops BC and jumps to 5F79H for alternate handling.

70C4H - Cassette Motor Off Handler

If disk file mode is not active, jumps to ROM routine 0235H to turn cassette motor off. If disk mode is active, saves registers via 6F34H, calls 70D2H to read from disk buffer, and returns.

70D2H - Read Byte from Disk Buffer

Reads the next byte from the disk input buffer. Compares current buffer pointer (761CH) against buffer end (761EH/761FH). If at end of buffer, reads next sector from disk via 4436H. Returns the byte in A and updates the buffer pointer.

710AH - Write Byte to Cassette or Disk

Writes a byte to cassette or disk depending on mode. If disk file mode is not active, jumps to ROM routine 0264H for cassette output. If disk mode is active, saves registers via 6F34H, calls 711DH to write to disk buffer, and returns.

711DH - Write Byte to Disk Buffer with Encoding

Writes a byte to the disk output buffer with special encoding for object file format. The byte in A is saved to B. Checks listing mode (75F1H); if less than 2, writes directly. Otherwise implements a state machine using flags at 75F3H to handle Intel HEX record encoding with escape sequences for special bytes (3CH, 78H).

71A0H - Write Byte B to Disk Buffer

Writes the byte in Register B to the disk buffer via 71A9H, then calls 70AAH to check FDC status, and returns via 6F3FH.

71A9H - Store Byte to Buffer and Flush if Full

Stores the byte in Register B to the current buffer position (761CH), increments the pointer, and checks if buffer is full by comparing against 761EH. If buffer is full, writes buffer to disk via 4439H and resets pointer to 72D4H.

71D3H - Check Keyboard and Close File

Enables interrupts, checks if disk file mode is active. If not active, jumps to 5708H for keyboard check. If disk mode is active, saves registers via 6F34H and calls 71E2H to close the file properly.

71E2H - Close Disk Output File

Closes the disk output file. Checks error flag (75F2H) and listing mode (75F1H). If no errors and listing mode active, flushes remaining buffer to disk via 4439H, then closes file via 443FH and waits for completion. Finally clears the disk file active flags and returns.

7239H - Initialize Source File Input

Sets up for reading source from disk file. Sets listing mode to 02H, checks if assembly is in progress (587AH). If not in progress, displays prompt at 74FFH, initializes encoding state, and sets up file buffers via 6FF0H.

725BH - Disk Error Handler

Handles disk errors. Stores error code to 75F2H, ORs with C0H to create DOS error code, calls 4409H to display error, then jumps to 58DAH for cleanup.

7266H - Display Message and Get Single Character Input

Displays a message by calling 592FH, then gets single character input via 5B47H. Preserves the original character count at 53AAH. Returns with the input character in Register A.

727EH - Conditional Assembly Pass Check

Returns immediately if Z flag is set. Otherwise saves A in B, loads the assembly pass number from 53C0H, and compares against 02H. If pass 2, jumps to 6B39H. Otherwise restores A from B and jumps to 6B30H. This routes processing based on which assembly pass is active.

728CH - Clear Assembly Flag 53BAH

Clears the assembly flag at 53BAH while preserving the value in Register A. This flag controls various assembly state conditions.

7293H - Initialize Source Input (One-Time)

Initializes source input, but only once per assembly session. Checks flag at 75F6H; if already initialized (non-zero), returns immediately. Otherwise sets the flag, points HL to the startup message at 74D4H, and displays it via 592FH.

74D4H - Message Strings Data Area

This section contains ASCII message strings used by EDTASM. Messages are delimited by A0H (high-bit set space) or 0DH (carriage return). Some messages contain embedded control codes (03H).

75F0H - Working Variables and Buffers

This section contains working variables used by the disk file I/O routines. These are initialized to zero at load time and are modified during program execution.

7618H - FCB Template and Disk Buffers

This section contains an FCB template initialized with default values, followed by buffer pointers and the main disk I/O buffers.

72A2H - File Control Block (FCB)

The FCB at 72A2H is used for disk file operations. This 50-byte area holds the filename, file attributes, and current file position. Referenced throughout the disk I/O code.

72D4H - Primary Disk I/O Buffer

The primary 256-byte disk buffer starting at 72D4H. Used for reading and writing disk sectors. A second 256-byte buffer at 73D4H may be used for double-buffering, and a third at 74D4H overlaps with the message area (which is read-only after loading).

76A2H - Extended Buffer Area

Additional buffer space from 76A2H to 76FFH (94 bytes). This may be used as overflow for the FCB or as temporary workspace.