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

EDTASM/CMD

Other Navigation

Program Overview

EDTASM/CMD on the NEWDOS/80 v2.0 Model I disk is the Radio Shack TRS-80 EDITOR/ASSEMBLER 1.1 (the banner at 5AC9H) combined with the APPARAT ASSEMBLER APPENDAGE, VERSION 3.0 (the banner at 74E8H). The editor/assembler is the cassette program: a line-numbered text editor with the commands A, B, D, E, F, H, I, L, N, P, R, T, W and the up and down arrows, and a three-pass Z80 assembler. The appendage (6F00H-72B5H with its messages and variables at 74E8H-765BH) is hooked into the cassette byte routines so that source text and object code can go to disk files, and it converts the assembler's cassette object records into a DOS /CMD load module.

This page was re-checked against the real EDTASM/CMD file in September 2026. Every row's bytes match the file, and every loaded byte from 5200H to 76FFH is shown exactly once.

Technical Specifications

Item	Value
Load blocks	5200H-52FEH (255 bytes), 5500H-72B5H (7,606 bytes), 74E8H-763CH (341 bytes), 764DH-76FFH (179 bytes): 8,381 bytes in all
Not loaded	52FFH-54FFH (editor/assembler variables and stack), 72B6H-74E7H (appendage FCB and 512-byte disk buffer), 763DH-764CH (symbol lister reference list)
Transfer address	6F00H
Text buffer	7700H up to the symbol table, which is built downward from the DOS high-memory pointer at 4049H
Stack	Grows down from 54FEH

What the Appendage Adds

• L D=filespec and W D=filespec load and save the source text on disk; L T=name and W T=name keep the cassette behavior.
• After the A command's switches, it asks OBJECT FILE TO DISK OR TAPE?. For disk it opens or creates the file and converts the cassette object stream (3CH data records and the 78H transfer record) into /CMD records (01H load records and an 02H transfer record).
• The BREAK key vector at 4312H is disabled while the program runs (6F00H) and restored by the B command (56F8H).
• Lower case letters are accepted and converted to upper case (7062H).
• After pass 2 it shows the free memory as nnnnn TEXT AREA BYTES LEFT (708FH).

Address Range	Contents
5200H-52FEH	Sorted symbol table and cross-reference lister, first part (entered from 6460H after pass 2)
52FFH-54FFH	Not loaded. Editor/assembler variables, 128-byte line buffer / object record, stack
5500H-56F7H	Symbol table and cross-reference lister, second part
56F8H-570EH	B command, prompt output, cassette-off exit
570FH-5833H	Dead code: unreferenced copies of the Level II ROM video driver, printer driver, DCB entry points, keyboard table and delay loop
5834H-5889H	Key input with filtering, BREAK/pause check, READY CASSETTE prompt, assembler switch table
588AH-596AH	Cold start, command loop, message display and character output
596BH-5B31H	Messages and the command table
5B32H-6106H	Line input, editor commands and the line editor
6107H-6DDEH	Assembler: file name handling, error reporting, operand parser, expression evaluator, instruction encoders, mnemonic table (6BD9H) and handler table (6DA7H)
6DDFH-6EE4H	End-of-line check, listing and object record output
6EE5H-72B5H	Apparat appendage code (entry point 6F00H)
72B6H-74E7H	Not loaded. Appendage FCB (72B6H) and disk buffer (72E8H)
74E8H-762BH	Appendage and lister messages
762CH-765BH	Appendage and lister variables (763DH-764CH not loaded)
765CH-76FFH	Unreferenced zero fill
7700H-	Text buffer (not part of the file)

Every variable in 52FFH-54FFH is listed with its users in the 52FFH storage section, and the appendage variables in the 762CH section. The most important ones:

Address Range	Purpose
5311H-5312H 2 bytes	Current text line pointer
5313H-5314H 2 bytes	Symbol table top (copied from 4049H)
5315H-5316H 2 bytes	End-of-text pointer (address of the FFH FFH end marker; 7700H when the buffer is empty)
5327H-53A6H 128 bytes	Line input buffer; in pass 3 the object record data
53A8H-53A9H 2 bytes	Input scan pointer used by 5BBBH/5BBEH
53AAH 1 byte	Input characters remaining
53B6H-53B7H 2 bytes	Assembler location counter
53BAH 1 byte	Output-to-file flag (character output goes through 710CH)
53BCH 1 byte	Printer flag (character output goes to the ROM printer routine)
53C0H 1 byte	Assembler pass: 1 = symbols, 2 = listing, 3 = object code
5876H-5886H 5 bytes	Switch flags NL, NO, LP, NS, WE (every fourth byte of the table at 5873H)
762CH 1 byte	Appendage disk-file-active flag
762DH 1 byte	Appendage file mode: 0 = read text, 1 = write text, 2 = object code
7658H-765BH 4 bytes	Appendage disk buffer position and end

Text Lines

Each line in the text buffer is stored as the line number (low byte, high byte), a length byte, and the text. The text ends with a line number of FFFFH, whose address is kept in 5315H.

Symbol Table Entries

The symbol table grows downward from the top of memory. Each entry is a flag byte, the name (1-6 characters) and the value (low byte, high byte). In the flag byte, the low bits hold the name length (5245H, 52BAH), bit 7 is set when the symbol is defined (set at 662FH, tested at 55D2H and 65ECH), bit 6 is set when it is multiply defined (set at 6624H, tested at 55EBH and 65F6H) and bit 5 is set when it was defined by DEFL (set at 6634H, tested at 661CH); only a DEFL symbol may be given a new value by another DEFL. A flag byte whose length bits are 0 ends the table. New entries are added below the current bottom (53C3H) by 65B2H-65DFH.

In operands, the register name C is also accepted as the condition C (carry): the condition parser at 67D7H turns register 1 (C) into condition 3, so JP C,nn, CALL C,nn, RET C and JR C,e work even though the register table (621AH) finds C as a register first.

Cassette Files and Their Disk Versions

Source text is written as D3H, a six-character name, then each line as five line-number digits with bit 7 set, a space, the text and 0DH, ending with 1AH. On disk the appendage writes the same bytes. Object code is written in the cassette SYSTEM format: 55H, the six-character name, 3CH data records (count, address, data, checksum) and a 78H transfer record. On disk the appendage drops the 55H and name, turns each 3CH record into a /CMD 01H load record (length = count + 2, address, data) without its checksum, and turns the 78H record into 02H 02H plus the transfer address.

Location	Written By	What Changes
550EH, 5513H	5204H, 5208H	Operands of the CP 00H instructions at 550DH and 5512H: the end-of-text address from 5315H, the stop point of the reference scan
5252H, 526DH	5223H, 522BH	Operands of CP instructions at 5251H and 526CH: the first character and the end of the previous symbol's name
5280H, 5292H	5239H, 5241H	Operands of CP instructions at 527FH and 5291H: the first character and the end of the current best candidate's name
5689H	52BDH	Operand of LD A,00H at 5688H: the end of the name being searched for
55EAH	52B7H	Operand of LD A,00H at 55E9H: the symbol's flag byte
5524H	52C2H, 5610H	The opcode of the jump at 5524H: 20H (JR NZ) or 18H (JR)
552FH	52C7H, 5615H, 563BH, 567BH	The opcode of the jump at 552FH: 28H (JR Z) or 18H (JR)
559EH	52CAH, 52F4H, 5636H	The opcode of the jump at 559EH: 28H (JR Z) or 20H (JR NZ)
4312H	6F02H, 56FAH	Not EDTASM code: the first byte of the DOS BREAK vector, set to C9H (RET) at start and back to C3H (JP) by the B command

Three Assembler Passes

1. Pass 1 (53C0H = 1) defines the labels in the symbol table.
2. Pass 2 (53C0H = 2) produces the listing (6EE5H/6E03H), unless NL is given or listing is turned off.
3. After pass 2, 6427H shows the error total and the free memory, then prints the sorted symbol table with references (5200H) unless NS is given.
4. Pass 3 (53C0H = 3) runs only when NO is not given. It writes the 55H header and name (6491H) and collects object bytes into records of up to 128 bytes (6E65H), written by 6EC3H. END writes the last record and the 78H transfer record (6BAFH-6BC0H).

Expression Evaluator

62A0H evaluates operands made of numbers (decimal by default or with a D suffix, octal with O or Q, hexadecimal with H; see 635AH), symbols and character constants, combined with the operators handled at 63BAH (subtraction), 63C0H (addition) and 63C9H (AND), and <, which shifts left by the value of the term (right if it is negative). Terms are combined left to right with no precedence, and a term may have a leading + or -.

Sorted Symbol Listing

5200H repeatedly scans the whole symbol table for the next name in alphabetical order after the previous one (the dummy entries at 7654H and 7656H supply starting values that sort below and above every name), prints it with its value, UNDEF*** or MULTIPLY DEFINED AT, and scans the text for the lines that refer to it.

1. 6F00H: writes RET over the DOS BREAK vector at 4312H and jumps to 588AH.
2. 588AH: empties the text buffer at 7700H, sets the symbol table top from 4049H, sets the line increment to 10, clears the screen and shows TRS-80 EDITOR/ASSEMBLER 1.1.
3. 58DAH: the command loop. It resets the stack, lets the appendage finish any disk file (71D5H), shows the * prompt, reads a line (5B41H) and dispatches through the command table at 5B05H.
4. L, W and A first go through the appendage (6F08H, 6F14H, 6F22H), which shows its banner once and sets up a disk file when asked.
5. B (56F8H) restores the BREAK vector and returns to the DOS through 402DH.

Routine	Entry	Exit
592FH	HL = message ending with a bit-7 character	Message and a carriage return displayed; HL past the message
5937H	None	Carriage return output (enters 5939H with A = 0DH)
5939H	A = character	Character sent to the screen, the printer (53BCH) or the file (53BAH); tabs expanded; all registers preserved
5834H	None	A = key (upper case; unaccepted control codes are ignored); DE and HL preserved
5856H	None	Z = no key; BREAK aborts to 58DAH; shift-@ pauses
5BBBH / 5BBEH	Input at 53A8H, count at 53AAH	A = next character (5BBBH skips spaces); Z and CARRY at the end of the line
5D75H	HL = number	Five decimal digits and a space displayed
5DC2H	HL, DE	Flags from comparing HL with DE (Z = equal)
56BEH	HL = text ending with 03H	Text output
6F34H / 6F3FH	Appendage register save / restore	6F3FH returns A with the Z FLAG set
710CH / 70C6H	A = byte / none	Byte written to / read from tape or the appendage disk file

5200H - Symbol Table Listing: Start

Entered by the JP 5200H at 6460H after assembler pass 2 (unless the NS switch was given). Prints every symbol in alphabetical order with its value (or UNDEF***), the line number of its definition and the line numbers of every line that refers to it. The symbols are not sorted in place: for each line of output, 521CH-52A5H scan the whole symbol table for the smallest name that is greater than the one printed last. 7650H points to the name printed last; it starts at the dummy entry at 7654H-7655H (name 00H), which is lower than any real name. The text scan loop at 550CH is set up here to stop at the end of the text.

521CH - Symbol Table Listing: Find the Next Name in Order

Walks the symbol table from its bottom (53C3H) to the entry with a zero length. An entry is a flag byte (bits 0-2 = name length), the name, and a 2-byte value. The best candidate so far (7650H) starts as the dummy entry at 7656H-7657H (name FFH), which sorts above every real name. For each entry the name is compared with the name printed last (skip it if it is not greater) and with the candidate (take it if it is smaller). The first character and the end address of both names are patched into CP instructions so the compares are fast.

52A7H - Symbol Table Listing: Print the Chosen Symbol

Reached at the end of the table. If the candidate is still the FFH dummy entry, every symbol has been printed and the listing ends at 6486H. Otherwise the chosen symbol's flag byte and name end are patched into the printing and compare code, the scan controls are reset, and the text scan at 550CH starts from the first line (7700H) to find the symbol's definition and references. An undefined symbol (flag bit 7 clear) has no definition line, so its heading is printed first through 559CH.

52EAH - Symbol Table Listing: End of a Text Scan

Reached from 5514H when the scan passes the end of the text. Normally the symbol is finished and the next one is chosen (5211H). For a multiply defined symbol the first scan only collected the line numbers of its definitions (559EH = 20H); a second scan then lists its references, starting at the first definition line (7652H).

52FFH - Working Storage (Not in the File)

Not Loaded
EDTASM/CMD has no load record for 52FFH-54FFH: its first load block ends at 52FEH and the next starts at 5500H. The bytes here are whatever was in memory before; EDTASM sets each variable before it reads it (at 588AH-58B7H, 58E4H-58EDH, 63E3H-63FCH and 6427H-643BH). The rows below list each variable with the code that sets and reads it. There are no bytes to show, so the rows have no opcode column.

5500H - Symbol Table Listing: Text Scan

Scans the text line by line for the symbol being listed (Register C = its first character; its flag byte and name end are patched in by 52B5H-52BDH). Each line is a line number (2 bytes), a length byte and the text; 7634H holds the address of the current line and Register B counts the characters left in it. The label field is compared at 5522H while 5524H holds 20H (JR NZ); the operand field is compared at 5564H. A semicolon starts a comment and ends the line; an apostrophe (a character constant) also ends the scan of the line. Entry at 5500H is the second scan of a multiply defined symbol, which starts at its first definition line (7652H).

559CH - Symbol Table Listing: Label Match

Called when the symbol is found in a label field (and from 52E1H for an undefined symbol). With 559EH = 28H (JR Z) the heading is printed (55A9H). After a multiply defined heading, 559EH = 20H (JR NZ) and each further definition line only has its line number added to the heading line (55A0H). Registers HL and BC are preserved.

5646H - Symbol Table Listing: Record a Reference

Called from 5573H when the symbol appears in an operand field. After the heading (5524H = 18H) the line number is printed at once. Before the heading, up to eight line addresses are kept in the list at 763DH. A ninth reference saves the scan position (7637H, 7639H, 7636H) and switches to label-only scanning until the definition is found; 5618H then resumes from the saved position.

5684H - Symbol Table Listing: Compare the Name at HL

Register HL points to a character in the text that equals the symbol's first character, Register B = characters left in the line. Returns the Z FLAG set if the symbol's name follows and is not immediately followed by a letter or digit. If the line ends during the compare, the line is abandoned (56B2H).

56B6H - Symbol Table Listing: Output Helpers

Small output routines used by the listing. All output goes through 5939H (screen, or printer when 53BCH is set).

56EEH - Assembler: Index Displacement Range Check

Called from 66F9H with Register DE = an (IX+d) or (IY+d) displacement. Adds 80H: the result's high byte is 00H only when the displacement is -128 to +127. 6672H reports FIELD OVERFLOW when it is not.

56F8H - B Command: Return to DOS

The B entry of the command table. Puts the JP opcode (C3H) back into the DOS BREAK key vector at 4312H (6F00H replaced it with RET) and exits to the DOS.

5700H - Display Character, Then Turn the Cursor On

Called from the command loop at 58F3H to display the * command prompt (Register A = 2AH). It sends the character in Register A through the common output routine at 5939H and then sends 0EH, the Level II video control code that turns the cursor on.

5708H - Cassette-Only Cleanup on Return to the Command Loop

Reached from 71DAH when no disk file is active (762CH = 00H). It clears the appendage's DOS-error flag at 762EH and then jumps to the ROM routine that turns the cassette motor off.

570FH - Unreferenced Copy of the ROM Video Driver (Dead Code)

Dead Code
Nothing in EDTASM/CMD jumps to, calls, or points at any address from 570FH to 57A9H (verified against every branch and every 16-bit operand in the file). These bytes have the same instruction sequence as parts of the Level II ROM video driver: the 32/64 character mode switch (OUT (FFH),A), the control-code dispatcher for codes 08H and 0AH-1FH, the screen scroll (a 03C0H-byte LDIR from 3C40H down to 3C00H), and the erase-to-end-of-line and erase-to-end-of-screen loops. The 16-bit operands that referred to Level II RAM have been changed (for example the ROM's port FFH image at 403DH, whose bit 3 marks 32 character mode, appears here as 5228H, which is the AND 07H instruction in EDTASM's symbol search), and several JR targets fall outside this block into unrelated EDTASM code, sometimes in the middle of an instruction. Because the block is never executed, those targets are shown but not linked, and the comments below describe what each instruction would do.

57AAH - Unreferenced Copy of the ROM Printer Driver (Dead Code)

Dead Code
Nothing in EDTASM/CMD reaches 57AAH-57F5H. This block has the same instruction sequence as the Level II ROM printer driver at 058DH-05D8H, with only the internal JR offsets changed: Register C holds the character, Register IX points to a printer Device Control Block (IX+03H = lines per page, IX+04H = line counter), and 37E8H is the memory-mapped printer port. EDTASM itself prints by calling the ROM at 003BH (see 5954H), so this copy is never used.

57F6H - Unreferenced Copy of the ROM DCB, Keyboard, and Delay Routines (Dead Code)

Dead Code
Nothing in EDTASM/CMD reaches 57F6H-5833H; the only reference into this block (the CALL 5805H at 5817H) is inside it. The bytes have the same form as the Level II ROM routines at 0013H-0064H: the device-call entry points that set B = 01H (input), 02H (output) or 04H (control) before dispatching through a Device Control Block, the keyboard/video/printer entry points that load DE with a DCB address, the wait-for-key loop at 0049H, the 16-byte keyboard special-key table at 0050H, and the BC delay loop at 0060H. The DCB and dispatcher addresses were changed from the ROM's 4015H, 401DH, 4025H and 03C2H to 5500H, 5508H, 5510H and 55CEH, which are EDTASM code (55CEH is the last byte of the CALL 56C8H at 55CCH), so none of this could run correctly.

5834H - Get a Key (Wait, Filter, and Force Upper Case)

Waits for a key through the ROM keyboard routine at 0049H and returns it in Register A. Six control keys are returned as-is (the table at 5850H). Any other code below 1AH is ignored and the routine waits for another key. Everything else goes through the appendage routine at 7062H, which converts lower case a-z to upper case. Registers DE and HL are preserved. Called by the command-line input routine (5B49H), the line editor (5FE7H, 6052H, 608CH, 60E4H), and the pause handler at 5866H.

5856H - Check the Keyboard for BREAK or Pause

Scans the keyboard once without waiting (ROM 002BH). Returns at once with Z set if no key is down, or with the key in Register A if it is not special. BREAK (01H) abandons the current command and goes to the command loop at 58DAH. Shift-@ (60H) pauses output: 5866H waits for another key and that key is tested the same way. Called during listing and assembly (5E48H, 6464H, 6499H). Register DE is preserved.

586BH - Prompt READY CASSETTE (Cassette Only) and Wait

Called before a cassette read (5F50H) or write (6121H). When the appendage has a disk file open (762CH non-zero), 7046H skips both the message and the wait and returns to this routine's caller.

5873H - Assembler Switch Table and Flags

Table searched by the assembler command at 6419H (via 627CH) when parsing A command switches that follow a slash. Each entry is a length byte (02H), the two-letter switch name, and a flag byte that 6424H increments when the switch is given. The flags are cleared at 63EEH-63FCH before each assembly.

588AH - Cold Start: Initialize the Editor/Assembler

Reached from the program entry point at 6F00H. Empties the text buffer, sets the symbol table top from the DOS high-memory pointer, sets default values, clears the screen and shows the TRS-80 EDITOR/ASSEMBLER 1.1 banner, then falls into the command loop at 58DAH.

58DAH - Command Loop

The editor's main loop, reached after every command, error and BREAK. It resets the stack, lets the appendage finish any disk file (71D5H), pushes 58DAH so a command handler's RET comes back here, shows the * prompt and reads a command line into 5327H. The first non-space character is looked up in the command table at 5B05H and the handler is entered by a RET with its address on the stack.

592FH - Display a Message

Prints the characters at HL through 5939H until one with bit 7 set has been printed, then prints a carriage return (it falls into 5937H). HL is left after the message.

5939H - Output a Character

Sends Register A to the tape or disk file when the output-to-file flag (53BAH) is set (the W command); otherwise displays it (ROM 0033H) or prints it (ROM 003BH when 53BCH is set). Keeps the output column at 53BBH and expands a tab (09H) to spaces up to the next multiple of 8. All registers and flags are preserved.

596BH - Editor and Assembler Messages (Data)

Data
Text displayed by 592FH, which prints characters until it has printed one with bit 7 set and then prints a carriage return. The last character of each message therefore has bit 7 set (for example C4H is "D" + 80H). The error messages are shown by 592BH, which also pushes 58DAH so the display returns to the command loop; assembler errors pass the message address in DE to 614BH instead. The NONAME default file name at the end has no terminator because it is used as a fixed 6-byte name.

5B05H - Command Table (Data)

Data
Searched by the command loop at 58FFH-5926H: 15 entries (B = 0FH at 5902H), each a command character followed by the handler address (low byte first). The matching handler address is pushed and reached by a RET at 5916H or 5920H. When the text buffer is empty, only the last three entries (L, I, B, which leave Register B below 04H) are allowed; the others give NO TEXT IN BUFFER. The W, L and down-arrow entries point into the Apparat appendage.

5B32H - Read a Line from the Keyboard

Reads keys through 5834H into the buffer at 5327H (53A8H is set to point there) and echoes them. ENTER ends the line; the count goes to 53AAH. Backspace (08H) erases one character, shift left arrow (18H) erases the whole line (5B32H), BREAK goes back to the command loop. At most 128 characters are accepted. With Register C non-zero, an up arrow (5BH) or down arrow (0AH) typed as the first key ends the line at once as a one-character command. Register D counts the characters typed.

5B89H - Erase the Last Character

Used by line input (5B54H) and the line editor (609AH, 6104H). Register HL = the position after the last character, Register D = characters before it. Moves HL back one and erases the character on the screen. A tab cannot be erased by backspacing, so the whole screen line is erased and the remaining characters are displayed again from 5327H.

5BBBH - Get the Next Input Character (Two Entry Points)

Reads the next character of the line being scanned: the pointer is at 53A8H and the count of characters left is at 53AAH. Tabs (09H) are returned as spaces.
Entry 5BBBH
Skips spaces: Register B = 20H, and every character equal to B is passed over.
Entry 5BBEH
Returns the very next character: 5BBEH is the second byte of the CP AFH instruction at 5BBDH, so execution starts with AFH = XOR A, which makes Register B = 00H (no character is skipped).
Exit
At the end of the line: A = 0DH, the Z FLAG and the CARRY FLAG are set. Otherwise A = the character, with the Z FLAG clear and the CARRY FLAG set by 5BE4H only when the character is not a digit (0-9). Registers BC and HL are preserved.

5BE4H - Test for a Digit

Register A = a character. Returns the CARRY FLAG clear if it is 0-9 and set if it is not. The Z FLAG is always clear on return from the compare path, and Register A is unchanged. Called from 5BDEH, 5FEAH (line editor repeat count) and 637FH (number evaluation). 5BEDH shares the ending at 5BE9H.

5BEDH - Test for a Letter

Register A = a character. Returns the CARRY FLAG clear if it is A-Z and set if it is not. Register A is unchanged. Called from 61E5H and 620EH (operand classification).

5BF4H - Put Back the Last Input Character

Undoes one 5BBBH/5BBEH read: moves the scan pointer at 53A8H back one character and adds one to the count of characters left at 53AAH, so the same character is read again. All registers are preserved (the flags are changed by the INC).

5C02H - N Command: Renumber the Text

N start,increment. Renumbers every line from the first (7700H), giving the first line the start number (the current line's number if none is typed) and adding the increment (5317H) for each following line. The text is walked twice: the first pass (CARRY FLAG set) only checks that no number reaches FFFAH; the second pass (CARRY FLAG clear) writes the numbers.

5C41H - I Command: Insert Lines

I start,increment. Inserts lines typed from the keyboard, numbering them from the start number (the current line's number if none is typed) in steps of the increment. If a line with the start number exists, insertion starts at the next number after it. Insertion continues until BREAK (which leaves through 5B41H) or an error.

5C5CH - Insert One Line

Inserts a line with the number in the caller's stack slot before the line at 531DH (set by the last line search). Two entries:
5C5CH
With the CARRY FLAG set (from 5C56H): the number is displayed and the line is read from the keyboard into 5327H.
5C60H
The second byte of the LD B,B7H at 5C5FH, so it runs B7H = OR A, which clears the CARRY FLAG: the text already in 5327H (length in 53AAH) is used. The line editor (6041H) and the R command reach this through 5ED6H.
The number must be lower than that of the following line, otherwise NO ROOM BETWEEN LINES. The rest of the text is moved up to open a gap of length + 3 bytes, the pointers 5315H, 531DH and 5311H are updated, and the line (number, length, text) is stored in the gap.

5CC7H - Read a Line Number and Increment, and Find the Line

Parses number,increment after the command (5D09H with , as the delimiter, then 5D07H). A typed increment of 0 is BAD PARAMETER(S); a typed increment is stored in 5317H. Then falls into the line search at 5CDAH.

5D07H - Read a Line Number

Reads a line number from the command line. Entry 5D07H ends it at the end of the line (B = 0DH); entry 5D09H takes the delimiter in Register B. Besides decimal digits (values above 65529 are refused by the check at 5D34H), # means the first line, . the current line and * the last line. Returns HL = the number. With nothing typed, HL = the current line's number and the Z FLAG is set; the Z FLAG is also set when the delimiter was found, and clear when the line ended after a number. Register D counts what was typed; Register E is set after #, . or *. Anything else gives BAD PARAMETER(S).

5D75H - Print a 5-Digit Decimal Number

Prints HL as five decimal digits followed by a space, and sets the output column (53BBH) so that the text after a line number starts at column 0 for tab stops. Each digit is sent with bit 7 set (B0H-B9H): the screen and printer show it normally (5939H clears bit 7), and a source file written by W keeps bit 7, which the load code expects. Registers HL, DE and BC are preserved.

5DA9H - Check for Memory Full

Compares the end of the text (5315H) with the symbol table top (5313H) minus 256 bytes. If there is not enough room, BUFFER FULL is displayed and the command ends. Registers HL and DE are preserved.

5DC2H - Compare HL with DE

Sets the flags as for HL - DE: Z if equal, CARRY if HL is lower. Only Register A is changed.

5DC8H - F Command: Find a String

F text. Stores up to 16 characters as the find string (5300H = length, 5301H = text); with no text, the previous string is used. Searches from the line after the current line to the end of the text and displays the first line that contains the string, which becomes the current line. Otherwise STRING NOT FOUND.

5E1CH - P, H and T Commands: Display or Print Lines

Three entries:
5E1CH (T)
Sets 53C5H so the lines are printed without line numbers, then continues as H.
5E20H (H)
Shows READY PRINTER, waits for a key (5866H) and prints the lines.
5E2AH (P)
The second byte of the LD B,AFH at 5E29H, so it runs AFH = XOR A: Register A = 00H, and the lines go to the screen.
Register A (the key from 5866H, or 00H for P) becomes the printer flag (53BCH). With a range (start:end, 5E9BH) every line in it is shown; with nothing typed, 16 lines from the current line. BREAK stops and shift-@ pauses (5856H). The last line shown becomes the current line.

5E72H - Up Arrow and Down Arrow Commands

Up arrow (5BH) enters at 5E72H with the CARRY FLAG set and shows the line before the current one. Down arrow enters through the appendage at 705AH, which jumps to 5E74H: the second byte of the LD B,AFH at 5E73H, so it runs AFH = XOR A (NO CARRY) and shows the line after the current one. At the first or last line the current line is shown again. The line shown becomes the current line.

5E9BH - Read a Line Range

Reads start:end (either may be #, ., * or a number; with nothing typed the current line is used). Returns HL = the address of the first line of the range, DE = the address of the line after the last, Register B non-zero if a start was typed. Without an end number the start line must exist (NO SUCH LINE); an end lower than the start gives BAD PARAMETER(S).

5ECDH - R Command and Line Deletion

5ECDH (R)
R line,increment deletes the line and then continues as the I command at 5C56H: the line is typed again with the same number, followed by new lines.
5ED6H
Deletes the line found by the last search (531BH up to 531DH) and returns to the address in BC (5C56H for R, 5C60H for the line editor).
5EE3H (D)
D start:end deletes a range of lines.
The text after the deleted lines is moved down and the end-of-text pointer is updated. When the deletion reaches the end of the text, the line before the deleted block becomes the current line.

5F1FH - W Command: Write the Text to Tape

Reached from the appendage at 6F1FH (with a disk file already open when D= was used). Writes the header (D3H and the six-character name) through 6121H, then lists the whole text with line numbers through 5E4FH while the output-to-file flag (53BAH) is set, so every character goes to 710CH instead of the screen, and ends with 1AH. On tape each line is five digits with bit 7 set, a space, the text and 0DH.

5F47H - L Command: Load Text from Tape

Reached from the appendage at 6F11H. Finds the source file header (D3H and the name; the name is compared only as far as the name typed, and not at all for a disk file), then reads the lines and appends them after the existing text, blinking the indicator at 3C3FH once per line. Each line is five digits with bit 7 set, a space, the text and 0DH; 1AH ends the file.

5FC1H - E Command: Edit a Line

E line (the current line if no number is typed). Copies the line's text into 5327H with a 00H terminator, displays its number, and reads edit subcommands. Throughout the editor: Register HL = the edit position in the copy, Register D = characters before the cursor, Register E = the line length, Register B = the repeat count typed before a subcommand (1 if none), and 5FE5H is pushed so each subcommand returns for the next key. The line number stays on the stack under it. Subcommands handled here: A (start again from the original line), L (show the edited line and start again at its beginning) and space (move right). The rest are at 6030H-6106H.

6030H - Edit Subcommands: ENTER and E (Keep the Edited Line)

Part of the line editor started by the E command at 5FC1H. The line being edited is a 00H-terminated copy in the buffer at 5327H. Throughout the editor: Register HL = the edit position in that copy, Register D = the number of characters before the cursor, Register E = the length of the edited line, Register B = the repeat count typed before the subcommand (1 if none), and the top of the stack holds 5FE5H so each subcommand's RET goes back for the next key. ENTER shows the rest of the line first; E does not. Both then replace the original line in the text with the edited copy.

6047H - Edit Subcommands E, C, D, Q, I, X, H, S, K and Backspace

Continues the subcommand tests begun at 6005H. Register A = the subcommand key, Register B = the repeat count, HL = edit position, D = characters before the cursor, E = line length.

6107H - Read a File Name

Used by W, L (5F1FH, 5F47H) and the assembler command (63FDH). Clears the name length (53ADH), then takes the next word on the command line as the file name if it is an identifier (type 00H from 61D6H) of at most six characters: 53ABH = its address, 53ADH = its length. Anything else is put back for the caller to reject; seven or more characters give BAD PARAMETER(S).

6121H - Write a File Header

Register C = the header byte (D3H for source text, 55H for object code). Shows READY CASSETTE and waits (cassette only), writes the cassette leader (7079H, cassette only), then writes the header byte, the file name and spaces up to six characters. Every byte goes through 710CH (tape, or the appendage's disk file).

614BH - Report an Assembler Error

Register DE = the message. Adds one to the error count (53B8H) and, in pass 2 only, displays the message (and prints it when LP is set) and sets 53BFH (the WE switch pauses on it).
614BH
Also displays the source line and then abandons it: 6496H (the next source line) is pushed as the return address, and Register A = AFH selects printing the line.
6150H
The second byte of the LD A,AFH at 614FH, so it runs AFH = XOR A: the message only, and the routine returns to its caller so assembly of the line continues. Registers BC and HL are preserved.

617FH - Display on the Screen, and Print When LP Is Set

617FH
Loads DE with 592FH (display a message) and continues at 6182H.
6182H
Calls the routine whose address is in DE with HL and BC as given. Then, unless the NL switch is set, and if the LP switch is set, turns the printer flag (53BCH) on, calls the routine a second time and turns the flag off again.

61A8H - Operand Classification

Reads the next word of an operand and reports what it is. Register DE returns its address, Register C its length, Register A its type, Register B the register number for types 03H-09H. The Z FLAG is set only when the line has ended.
Types
00H = an identifier that is not a register name (a symbol), 01H = a word starting with a digit (a number), 02H = any other single character (for example (, ', $, +), 03H = 8-bit register, 04H = register pair, 05H = IX or IY, 06H = condition, 07H = AF, 08H = I or R, 09H = ON or OFF (see the table at 621AH).
Entries
61A8H skips spaces first (5BBBH). 61D6H does not. 61B5H, 61B3H, 61B0H and 61ADH also check the type against an expected value (in A, or 03H, 04H, 05H) and return the Z FLAG if it matches; a missing operand gives MISSING INFORMATION.

6274H - Table Search

Searches a table of entries [length byte (bits 0-4)][name][B data bytes] for the word at DE whose length is in Register C. Returns NO CARRY with HL at the matching entry's data bytes, or the CARRY FLAG with HL at the 00H end byte. Used for the register names (621AH), the assembler switches (5873H) and the mnemonics (6BD9H). Registers BC and DE are preserved.

6293H - Evaluate an Expression

Returns the value of the operand expression in Register DE (Registers BC and HL are preserved).
62A0H
The normal entry: classifies the first term itself.
6293H
Used when the caller has already called 61D6H (Register A = the type, DE = the word): END (6B9CH).
A term is a symbol (its value from 65A6H), a number (635AH), a character constant 'c' (63A0H) or $ (the location counter, 53B6H); a term may be preceded by + or -. Terms are combined left to right, with no precedence, by +, -, & (AND) and < (shift left by the term, or right if it is negative). The result is kept in 53C1H. The expression ends at a space, tab, the end of the line, or (put back for the caller) at ;, , or ). Anything else is EXPRESSION ERROR.

635AH - Number and Character Constants

635AH
A number. The last character selects the base: H = 16, O or Q = 8, D or a digit = 10. Each character must be a digit (0-9, A-F) below the base, otherwise EXPRESSION ERROR. Register DE = the word, Register C = its length.
63A0H
A character constant: exactly one character between apostrophes; its value is the character code.

63BAH - Expression Operators

Each is reached from 6321H-632DH with HL = the new term; each returns to 63D4H. 63BAH subtracts, 63C0H adds and 63C9H ANDs, working on the result at 53C1H. 63D4H reads the character after a term: the end of the line finishes the expression; otherwise it becomes the pending operator after the delimiter check at 62E8H.

63E3H - A Command: Assemble

A name /switch/switch.... Empties the symbol table (bottom = top = 5313H, with a 00H end byte), clears the pass number and the five switch flags, reads the object file name (default NONAME) and then each / switch (NL, NO, LP, NS, WE; table at 5873H). When the command line has been used up, the appendage (6F22H) asks where the object code goes and starts pass 1 at 6427H. An unknown switch gives BAD PARAMETER(S).

6427H - Start the Next Assembler Pass, or Finish After Pass 2

Reached when a pass ends: from the appendage at 6F31H when the A command line has been parsed, from the END handler at 6B8BH, and from 6B86H when the text ends without END. It resets the source line pointer and the per-line variables and increments the pass number at 53C0H. Passes 1 and 2 continue at 6496H. When the pass number reaches 03H, the error total and free memory are displayed, the symbol table (with cross-references) is listed unless the NS switch was given, and pass 3 (object code) starts through 6486H.

6463H - Unreferenced Code: Old Symbol Table Listing

Nothing in EDTASM/CMD jumps or calls into 6463H-6485H. The block is a loop that lists the symbol table in stored order, one symbol per line with its name, a tab and its value in hexadecimal; it would have been reached from the CALL 5937H at 645DH, where the JP 5200H at 6460H now sends the assembler to the sorted lister and cross-reference instead. The byte 53H at 6463H is left over from the instruction that the JP 5200H replaced.

6486H - Start Pass 3 (Object Code)

Reached from the sorted symbol lister at 52B2H, and from 6452H when the NS switch skips the listing. Turns the printer flag off. If the NO switch was given there is no object code, so the assembly ends at 58D7H; otherwise the object file header (55H and the name) is written and the pass continues with the first source line at 6496H.

6496H - Assemble the Next Source Line

The top of the assembler's per-line loop, used by all three passes. Every line handler returns here: 6496H is pushed below the handler's return address, and the error routine at 614BH pushes it too. It resets the stack, checks the keyboard, pauses after an error line if the WE switch is set, and moves the location counter past the bytes of the previous line.
WE Pause
53BFH is set to 01H by the error routine. When it counts down to 00H here and the WE switch is set, the assembler waits for a key. C clears the WE switch (SUB 43H gives 00H), so the assembly then continues without stopping at errors; any other key leaves it set.

64D0H - Get the Next Source Line and Look at Its First Word

Takes the text line at 531DH as the current line (5311H), sets the input scan pointer (53A8H) and count (53AAH) to its text, and advances 531DH to the line after it. When the end-of-text marker is reached, the pass ends at 6B80H. The first word decides the kind of line:
Empty Line or ;
Listed only (6DF1H).
Identifier
A label (6539H).
Space or Tab
No label: the opcode follows (654CH).
*
A listing directive (6508H).
Anything Else
BAD LABEL (6533H).

6508H - *L ON / OFF: Listing Directive

A line starting with *, a word starting with L (only the first letter is checked, so *LIST works) and ON or OFF. The line itself is listed, and then 53BDH is set to 00H (ON) or 01H (OFF): a non-zero value stops 6E03H from listing later lines. For ON the flag is cleared before the line is listed, so both directive lines appear in the listing.

652DH - Comment Line, or Bad Label

Continues 64D0H for a first character that is not a space, tab, * or letter. A ; starts a comment line, which is only listed. Anything else gives BAD LABEL.
652FH
Also reached with the Z FLAG set from 64F5H (empty line) and 6557H/655BH (a line with no label and no opcode).
6533H
Also reached from 653CH and 654AH (a bad label), and from the ORG and END handlers at 6B72H and 6B91H (a label is not allowed there).

6539H - Check the Label

The first word is an identifier in column 1, so it is a label. Its length (Register C) must be 6 characters or fewer, and it must be followed by a space (or tab) or a colon. A label with nothing after it gives MISSING INFORMATION.

654CH - Look Up the Opcode

Reads the opcode word (skipping spaces) and finds it in the mnemonic table at 6BD9H. Register C holds the label length (00H if there is no label). On a line with no label, a ; or the end of the line in place of the opcode means the line is only listed. An unknown word, or a mnemonic followed by anything other than a space, ; or the end of the line, gives ILLEGAL OPCODE.

657CH - Call the Opcode Handler

Positions the input at the first operand, stores the base opcode into 53B1H and fetches the handler for the mnemonic's type from the dispatch table at 6DA7H. The stack is arranged as handler, 6DDFH (end-of-line check and listing), 6496H (next line), so the handler's RET goes to the listing routine and the listing's RET to the next line.
Label Handling
With no label the handler is entered at once (Register A = the type). For types 18H and above (ORG, END, EQU, DEFL) the handler is entered with Register A = 01H, Register HL = the location counter and Register DE/C = the label, and deals with the label itself. For every other type the label is defined first as the location counter by falling into 65A6H with Register A = 01H; the RET at the end of 65A6H then enters the handler.

65A6H - Look Up or Define a Symbol

Register DE = the symbol name, Register C = its length, Register HL = the value (when defining), Register A = the mode: 00H looks the symbol up (from the expression evaluator at 6305H), 01H defines it (labels, from 657CH, and EQU), 02H defines it as a DEFL symbol (6BC6H). A symbol that is not in the table is added first, below the current bottom (53C3H), with a flag byte holding only the length and a value of 0000H.
Lookup (Mode 0)
Returns Register HL = the value and Register DE = the HL passed in. A symbol that has never been defined gives UNDEFINED SYMBOL, and one that was defined twice gives MULTIPLY DEFINED SYMBOL; both are reported through 6150H, so the line is still assembled.
Define (Modes 1 and 2)
Sets bit 7 of the flag byte (and bit 5 for DEFL) and stores the value. If the symbol is already defined with a different value, it is only changed when it was defined by DEFL and this is DEFL again; otherwise bit 6 is set and MULTIPLE DEFINITION is reported. The same value again (every label in pass 2) is not an error.
Symbol Table Overflow
If a new entry would reach the end of the text (5315H), SYMBOL TABLE OVERFLOW is shown through 592BH and the assembly is abandoned.

663DH - ADD, ADC and SBC: Check for the A, Prefix

Called by the ADC/SBC handler (6714H) and the ADD handler (6735H). Classifies the first operand (61B5H) and requires a comma after it, else ILLEGAL ADDRESSING MODE. If the first operand is not an 8-bit register, it returns with Register A = its type and Register B = its number, for the 16-bit forms. If it is a register it must be A: the return address is discarded and execution falls into 6654H, so ADD A,s, ADC A,s and SBC A,s are encoded like the single-operand arithmetic group (base 80H, 88H, 98H).

6660H - Immediate Operand and Field Overflow Check

The operand is a value. XOR 46H turns the register form of the opcode at 53B1H into its immediate form: A0H (AND r) becomes E6H (AND n), 80H (ADD A,r) C6H, 88H CEH, 90H D6H, 98H DEH, A8H EEH, B0H F6H, B8H FEH, and 40H+r<<3 (LD r,r') becomes 06H+r<<3 (LD r,n). The value goes into 53B2H and the length becomes 2.
6669H
Also entered from 6A1CH (LD (HL),n and LD (IX+d),n) with Register HL = the byte before the one to fill.
6671H
Reports FIELD OVERFLOW through 6150H (the line is still assembled) when Register D is not 00H. Register DE is preserved. Called from 6690H, 68C8H, 68FAH and 6B5CH; 56F5H jumps to 6672H with Register A already set.

667CH - BIT, SET and RES; 6696H - CB-Prefixed Group

667CH
Type 03H (BIT 40H, RES 80H, SET C0H). Evaluates the bit number; 8 or more forces Register D = 01H so that 6671H reports FIELD OVERFLOW. The bit number goes into bits 3-5 of the base opcode, a comma is required, and execution continues at 6696H.
6696H
Type 02H (RL 10H, RLC 00H, RR 18H, RRC 08H, SLA 20H, SRA 28H, SRL 38H). Moves the opcode to 53B2H, stores CBH at 53B1H, sets the length to 1, classifies the operand and falls into 66A4H, which ORs the register into the second byte.

66A4H - Encode an 8-Bit Register, (HL) or (IX+d) Operand

Register A = the operand type from 61B5H, Register B = the register number, Register DE = the word. Adds one to the length at 53B4H and ORs the register number into the last instruction byte so far (53B0H + length). (HL), (IX+d) and (IY+d) use register number 6.
Entries
66A4H clears the CARRY FLAG, so the register goes into bits 0-2. 66A5H is entered from the INC/DEC handler (678AH) with the CARRY FLAG set, so the register goes into bits 3-5.
Memory Operands
Any type other than 03H must start with ( and be followed by HL (66DCH then requires )) or by IX or IY (66E8H). Anything else goes to 66E2H.

66E2H - Illegal Addressing Mode

Points Register DE to ILLEGAL ADDRESSING MODE and jumps to 614BH, which counts and reports the error and goes on to the next source line. About forty operand checks jump here.

66E8H - (IX+d) and (IY+d) Operands

Sets the DDH or FDH prefix and adds 2 to the length (66FEH), evaluates the displacement, stores it at 53B2H, checks that it is -128 to +127 (56EEH) and requires ). When the length has become 4 the instruction is a CB-prefixed one (DD CB d op), so the opcode is first moved from 53B2H to 53B3H to make room for the displacement. Also called from LD at 69F0H.

66FEH - Set the DDH or FDH Prefix; 670BH - Add 2 to the Length

66FEH
Register B = 00H for IX or 01H for IY. Stores DDH or FDH at 53B0H and sets Register B = 02H, the HL position that IX and IY replace in the opcode, then continues at 670BH. Returns with HL = 53B0H.
670BH
Adds 2 to the length at 53B4H and returns the new length in Register A. Used for a prefix, an immediate byte (666EH), a second opcode byte (67B4H) and DEFW (6B6DH).

6714H - ADC and SBC Handler

Type 04H (ADC 88H, SBC 98H). The 8-bit forms (ADC A,s and SBC A,s) are passed to 6654H by 663DH. Otherwise the first operand must be HL, and the instruction is EDH followed by 4AH (ADC) or 42H (SBC) ORed with the second register pair in bits 4-5. Length 2.

6735H - ADD Handler

Type 05H (ADD 80H). ADD A,s is passed to 6654H by 663DH. ADD HL,ss gives 09H ORed with the pair in bits 4-5, length 1. ADD IX,pp and ADD IY,pp are handled at 675DH.

674DH - Register Pair into Bits 4-5

674DH
Requires the next operand to be a register pair (61B0H), else ILLEGAL ADDRESSING MODE, and falls into 6752H.
6752H
Rotates Register B (the pair number: BC 0, DE 1, HL 2, SP 3, AF 3) into bits 4-5 and ORs it into the opcode at 53B1H. Many handlers end here, and PUSH/POP push 6752H as their return address.
6753H
The same with the number already in Register A (from 6B02H).

675DH - ADD IX,pp and ADD IY,pp

Sets the prefix. The second operand may be BC, DE or SP, or the same index register as the first (ADD IX,IX gives 29H). HL, the other index register and anything else give ILLEGAL ADDRESSING MODE.

677DH - INC and DEC Handler

Type 06H (INC 04H, DEC 05H). A register pair gives 03H (INC) or 0BH (DEC) ORed with the pair in bits 4-5, length 1. IX and IY get the prefix as well (DD 23H, DD 2BH). Any other operand goes to 66A5H with the CARRY FLAG set, so the register (or number 6 for (HL), (IX+d) and (IY+d)) goes into bits 3-5 of 04H or 05H.

679EH - IM Handler; 67B0H - Second Byte; 67B7H - ED Group

679EH
Type 07H (IM, base EDH). Evaluates the mode: 0 gives 46H, 1 gives 56H and 2 gives 5EH; 3 or more is ILLEGAL ADDRESSING MODE.
67B0H
Stores Register A at 53B2H and adds 2 to the length. Used by IM, the ED group, JR, DJNZ, IN and OUT.
67B7H
Type 08H (CPD, CPDR, CPI, CPIR, IND, INDR, INI, INIR, LDD, LDDR, LDI, LDIR, NEG, OTDR, OTIR, OUTD, OUTI, RETI, RETN, RLD, RRD). Moves the base opcode to the second byte and stores EDH as the first. Also used for LD A,I/R and LD I/R,A.

67BFH - CALL Handler

Type 09H (CALL CDH). With a condition (67D7H) the opcode becomes C4H ORed with the condition in bits 3-5 and a comma is required. The address is evaluated (62A0H, or 6293H when 67D7H has already classified the word) and stored at 53B2H-53B3H with a length of 3.
67C2H
Also the JP cc,nn path (681DH).
67CCH / 67CFH
67CCH evaluates an already classified word if the Z FLAG is clear; 67CFH stores Register DE after 53B1H (HL = 53B1H) and sets the length to 3. Both are also used by JP and LD.

67D7H - Condition Operand

Classifies the operand (61B5H; 67DAH uses the type already in Register A, from RET). A condition (type 06H) is put into the opcode at 53B1H: it is ANDed with C6H (which clears bits 0 and 3-5) and ORed with the condition number in bits 3-5, and the routine returns with the Z FLAG set. Register C (type 03H, number 1) is taken as condition 3, carry, because the register table finds C first. Anything else returns with the Z FLAG clear and the word still classified, for the caller to evaluate as an address. Register HL returns at 53B1H.

67F8H - Require a Comma; 6801H/6804H - Test for (

67F8H
Reads the next character; anything other than a comma is ILLEGAL ADDRESSING MODE.
6801H
Classifies the next operand (61B5H) and continues at 6804H.
6804H
Tests whether the word at Register DE starts with (: the Z FLAG is set if it does. Registers A and BC are preserved.

680CH - RET Handler

Type 0AH (RET C9H). Length 1. With no operand the opcode stays C9H; a condition gives C0H ORed with the condition in bits 3-5. Anything else is put back (5BF4H) so that the end-of-line check at 6DDFH reports it as ILLEGAL ADDRESSING MODE.

681AH - JP Handler

Type 0BH (JP C3H). JP cc,nn becomes C2H ORed with the condition and continues as CALL at 67C2H. JP nn is evaluated and stored with a length of 3. JP (HL) gives E9H, length 1. JP (IX) and JP (IY) give DD/FD E9H.

6839H - JR and DJNZ Handlers

6839H
Type 0CH (JR 18H). A condition must be NZ, Z, NC or C (numbers 0-3); PO, PE, P and M give ILLEGAL ADDRESSING MODE. The opcode becomes 20H, 28H, 30H or 38H and a comma is required before the target.
6850H
Type 0DH (DJNZ 10H). Evaluates the target.

6853H - Relative Jump Offset

Computes the offset target - (location counter + 2). If it is outside -128 to +127, BRANCH OUT OF RANGE is reported through 6150H and the offset FEH (a jump to itself) is used. The offset is stored by 67B0H with a length of 2. The seven bytes at 6867H-686DH are never executed.

6879H - RST Handler; 688DH - Length 1

6879H
Type 0EH (RST C7H). The value must be 00H, 08H, ... 38H, else ILLEGAL ADDRESSING MODE; it is ORed into C7H.
688DH
Type 00H (CCF, CPL, DAA, DI, EI, EXX, HALT, NOP, RLA, RLCA, RRA, RRCA, SCF): sets the length at 53B4H to 1. Many handlers call it.

6893H - IN Handler

Type 0FH (IN DBH). The first operand must be a register, followed by a comma and (. IN r,(C) gives EDH and 40H ORed with the register in bits 3-5. IN A,(n) keeps DBH and stores the port, which 6671H checks. A closing ) is required.

68CEH - OUT Handler

Type 10H (OUT D3H). The first operand must start with (. OUT (C),r gives EDH and 41H ORed with the register in bits 3-5. OUT (n),A keeps D3H and stores the port, which 6671H checks. Any register other than A after (n), is ILLEGAL ADDRESSING MODE.

690FH - EX Instruction Handler

Operand handler for the EX mnemonic. The opcode table entry for EX (type 11H) points here through the dispatch table at 6DC9H and has already stored EBH (EX DE,HL) in 53B1H. The handler accepts EX (SP),HL (E3H), EX (SP),IX / EX (SP),IY (DDH/FDH E3H), EX DE,HL (EBH) and EX AF,AF' (08H). Anything else goes to 66E2H (ILLEGAL ADDRESSING MODE) through 697DH.
The operand classifier (61D6H) returns a type in Register A and a register number in Register B: type 03H = 8-bit register, 04H = register pair (BC=0, DE=1, HL=2, SP=3), 05H = index register (IX=0, IY=1), 07H = AF.

6964H - PUSH and POP Handler

Type 12H (PUSH C5H, POP C1H). Pushes 6752H as the return address, so the pair number ends up ORed into bits 4-5. IX and IY set the prefix and use the HL position (DD/FD E5H and E1H). AF uses pair number 3 (F5H, F1H). BC, DE and HL give a length of 1. SP and anything else are ILLEGAL ADDRESSING MODE.

6980H - LD Handler: 8-Bit Register Destination

Type 13H (LD, base 40H). Register HL stays at 53B1H throughout the handler. When the destination is a register r, 40H is ORed with r in bits 3-5 and a comma is required. For any destination other than A the source is handled by 6654H: a register gives 40H+r<<3+r', (HL), (IX+d) and (IY+d) use number 6, and a value is turned into 06H+r<<3 n by the XOR 46H at 6665H.
Destination A
I and R give EDH 57H or 5FH. (HL), (IX+d) and (IY+d) are read again through 66A4H (7EH). (BC) and (DE) give 0AH and 1AH. (nn) gives 3AH nn. Everything else goes to 6657H as for the other registers.

69E3H - LD Handler: Destination in Brackets

(IX+d) and (IY+d): with a register source DD/FD 70H+r d (length 3), with a value DD/FD 36H d n (length 4). (HL): 70H+r, or 36H n. (BC) and (DE): the source must be A, giving 02H or 12H. Any other bracketed destination is an address, handled at 6A3AH. A destination that is not in brackets goes to 6A78H.

6A3AH - LD (nn),Source

The address is stored at 53B2H-53B3H (67CCH, length 3) and ) and a comma are required. (nn),HL gives 22H. (nn),BC, (nn),DE and (nn),SP give EDH 43H+pair<<4 with a length of 4. (nn),A gives 32H. (nn),IX and (nn),IY give DD/FD 22H with a length of 4.

6A78H - LD Handler: 16-Bit and I/R Destinations

A destination that is not an 8-bit register and not in brackets. The opcode is first set to 2AH.
IX, IY
LD IX,nn gives DD/FD 21H nn; LD IX,(nn) gives DD/FD 2AH nn (length 4).
I, R
LD I,A and LD R,A give EDH 47H or 4FH.
SP
SP,HL gives F9H and SP,IX/IY gives DD/FD F9H; any other source continues at 6ADDH as LD SP,nn or LD SP,(nn).
Other register pairs continue at 6AD9H. Anything else is ILLEGAL ADDRESSING MODE.

6AD9H - LD rr,nn and LD rr,(nn)

Register B = the destination pair (BC, DE, HL; SP arrives at 6ADDH from 6ACFH). LD rr,nn gives 01H+pair<<4 nn. LD HL,(nn) gives 2AH nn. LD BC,(nn), LD DE,(nn) and LD SP,(nn) give EDH 4BH+pair<<4 nn with a length of 4.

6B0BH - DEFS Directive Handler

Type 14H in the opcode table (dispatch entry 6DCFH). Reserves space: the location counter advances by the operand value and no code is produced. 62A0H evaluates the operand and returns its value in Register DE.

6B1AH - DEFM Directive Handler

Type 15H in the opcode table (dispatch entry 6DD1H). Emits the characters between the apostrophes one byte at a time: each character is stored as the instruction byte in 53B1H and passed through the pass-dependent output routine at 6DF4H, then the address advances by one. The loop ends at the closing apostrophe or the end of the line. The loop test was changed by the Apparat appendage: 6B56H jumps to 7292H, where pass 2 (listing) advances the address for each further character without listing it, so a DEFM produces one listing line; passes 1 and 3 handle every character through 6B30H.

6B59H - DEFB Directive Handler

Type 16H in the opcode table (dispatch entry 6DD3H). Produces one byte from the operand expression.

6B66H - DEFW Directive Handler

Type 17H in the opcode table (dispatch entry 6DD5H). Produces a 16-bit word, low byte first.

6B70H - ORG Directive Handler

Type 18H in the opcode table (dispatch entry 6DD7H). Sets the location counter. A label on an ORG line is not allowed.

6B80H - End of Text Without END

Reached from 64DAH when the assembler runs out of source lines before an END statement. Reports NO END STATEMENT. Passes 1 and 2 continue with the next pass; pass 3 falls into the END handler so the object file is finished with a transfer address of 0000H.

6B8EH - END Directive Handler

Type 19H in the opcode table (dispatch entry 6DD9H). Records the transfer address (the operand, or 0000H if there is none) and lists the line. Passes 1 and 2 then start the next pass. In pass 3 the last object record is written, followed by the 78H transfer record: 78H, address low byte, address high byte. Each byte goes through 710CH, which writes to tape or, when the appendage has a disk object file open, converts the tape format to a /CMD transfer record.

6BC6H - DEFL and EQU Directive Handlers

Two entries. DEFL (type 1BH, dispatch entry 6DDDH) starts at 6BC6H; EQU (type 1AH, dispatch entry 6DDBH) starts at 6BC7H. When a line has a label and a type of 18H or more, the dispatcher at 659EH-65A5H enters the handler with Register A = 01H, so Register B holds 01H for EQU and 02H for DEFL. That is the mode passed to 65A6H: mode 1 defines the symbol, mode 2 also marks it as set by DEFL (bit 5 of its flag byte) so that it can be given a new value later. Both require a label.

6BD9H - Mnemonic Table

One entry per mnemonic and directive, in alphabetical order except that END comes before EI: the length byte, the name, the type (the handler number in the dispatch table at 6DA7H) and the base opcode, which 6585H stores at 53B1H. Searched by 627CH from 6563H with Register B = 02H. The table ends with 00H at 6DA6H. Directives have a base of 00H.

6DA7H - Handler Dispatch Table

28 handler addresses, two bytes each, indexed by the type from the mnemonic table (6588H-6592H). 657CH pushes the selected address as the return address, with 6DDFH (end-of-line check and listing) and 6496H (next line) below it.

6DDFH - End of the Line, Then List It

Every opcode handler returns here (657CH pushes 6DDFH under the handler's address). After the operands only spaces, a ; comment or the end of the line may follow; anything else is ILLEGAL ADDRESSING MODE.
6DF0H
Loads Register A with AFH: the listing shows the address.
6DF1H
The second byte of that instruction, so it runs AFH = XOR A: no address. Used for comment lines, empty lines and *L directives (6526H, 6530H).

6DF4H - Route the Line by Pass

Register A = 00H (no address) or non-zero (show the address); Register C bit 0 is set for a DEFM continuation line (the call from 6B36H). Pass 1 produces no output and returns. Pass 2 goes through 6EE5H to the listing at 6E03H. Pass 3 goes to the object output at 6E65H.

6E01H - Listing Line (Pass 2)

6E01H-6E02H are two NOPs that are never executed. 6E03H is entered from 6EEBH with Register HL = 53BDH (the listing off flag), Register A = the NL switch and Register B = the address flag. It returns without listing when either flag is set. Otherwise it copies the LP switch into the printer flag (53BCH), prints the address from 53AEH-53AFH as four hex digits and a space (6E42H) or five spaces, then the code bytes (the prefix at 53B0H if non-zero, then 53B1H onward, 53B4H bytes in all) padded with spaces to nine characters, and then the source line through 5E4FH. For a DEFM continuation (Register C bit 0 set) only a carriage return is printed after the bytes. The printer flag is cleared at the end.

6E42H - Print the Line Address

Entered from 6E10H with Register HL = 53AFH. Prints 53AFH and then 53AEH as four hexadecimal digits and continues at 6E14H with Register B = 01H for one space.

6E4EH - Print a Byte as Two Hex Digits

Prints the byte at Register HL as two hexadecimal digits through 5939H. It first decrements Register B, because the code field loop at 6E26H-6E2EH counts two character positions for each byte. 6E58H prints the low four bits of Register A as one digit. Also called from the symbol lister (55C5H, 55C9H).

6E65H - Pass 3: Add the Line's Bytes to the Object Record

Reached from 6DFCH in pass 3. Each byte of the assembled instruction (prefix at 53B0H if non-zero, then 53B1H onward; the count is at 53B4H) is added to an object record kept in memory in cassette SYSTEM-tape form: checksum at 5323H, byte count at 5324H, load address at 5325H-5326H and up to 128 data bytes from 5327H. A byte whose address does not follow the last byte output (531FH), or a 129th byte, first causes the current record to be written by 6EC3H.

6EC3H - Write the Object Record

Writes the record built at 5323H-53A6H in cassette SYSTEM-tape form: 3CH, byte count, load address low, load address high, the data bytes, and the checksum. Every byte goes through 710CH: to the cassette, or, when the appendage has a disk object file open, into its tape-to-/CMD converter. Registers BC and HL are preserved.

6EE5H - Pass 2: Listing Hook

Reached by the JP 6EE5H at 6DFEH in pass 2 (Register HL = 53C0H, Register B = the value passed to 6DF4H). It performs the three DEC HL and the load of the NL switch that the listing routine at 6E03H expects, then jumps there. The two bytes at 6E01H-6E02H (NOP, NOP) that lie between 6DFEH and 6E03H are never executed.

6EEEH - Unreferenced Bytes

Nothing in EDTASM/CMD refers to 6EEEH-6EFFH. The loaded bytes are eleven 00H bytes followed by 54H 49H 4EH 45H 82H 2DH 0EH; the first four are the ASCII letters "TINE". The program entry point 6F00H is the byte after them.

6F00H - Program Entry Point

The transfer address of EDTASM/CMD. It writes a RET opcode over the first byte of the DOS BREAK key vector (4312H-4314H holds a JP instruction), so the BREAK key no longer enters the DOS while the editor/assembler is running, and then starts the editor/assembler at 588AH. The B command (56F8H) puts the JP opcode (C3H) back before returning to the DOS.

6F08H - L Command (Load Text) Entry

The L entry in the command table at 5B05H points here. Syntax handled by the appendage: L D=filespec loads source text from a disk file; L T=name loads from cassette through the original handler at 5F47H.

6F14H - W Command (Write Text) Entry

The W entry in the command table points here. W D=filespec writes the text to a disk file; W T=name writes to cassette through the original handler at 5F1FH.

6F22H - A Command: End of Switches

Called at 6410H from the assembler command's switch loop, after 5BBBH has read the next non-space character. If the command line is used up, the appendage takes over (6F27H). Otherwise it returns Z if the character is / (another switch follows) and NZ otherwise (6413H then reports BAD PARAMETER(S)).

6F34H - Save Registers, Point IX at the FCB

Pushes HL, DE, BC and IX under the caller's return address and loads IX with 72B6H, the appendage's File Control Block. The matching exit is 6F3FH, which must be reached with one extra return address on the stack (the routines that end at 6F3FH are always CALLed after a CALL 6F34H).

6F3FH - Restore Registers and Return with A

The common exit of the appendage's disk routines. Returns the value in Register A with the Z FLAG set, and restores HL, DE, BC and IX from the frame built by 6F34H.

6F4EH - L: Keep or Clear the Text in the Buffer

Called from 6F0EH. If the text buffer is not empty, asks TEXT IN BUFFER. ARE YOU CONCATENATING???? (Y OR N). Y keeps the text (the loaded file is added after it); N empties the buffer. Then falls into 6F71H with file mode 0 (read).

6F72H - Parse D=filespec or T=name

Entered with Register A = the file mode: 00H (read, from 6F71H) or 01H (write text, from 6F1CH). Looks at the rest of the command line (pointer at 53A8H, count at 53AAH). The first non-space character and the = after it are replaced by spaces so the original cassette code later sees only the name. D continues at 6FB0H to copy the filespec into the FCB and open the file. T exits through 6F3FH so the original cassette code runs. Anything else is BAD PARAMETER(S).

7046H - Show a Cassette Prompt Unless a Disk File Is Open

Called from 586EH with HL pointing to READY CASSETTE. For cassette it displays the message and returns to 5871H, which waits for a key. For disk it drops its own return address and returns straight to the caller of 586BH, so there is no prompt and no wait.

704FH - Header Name Compare Setup for L

Called at 5F63H with Register A = the length of the name typed after L T=. The load code compares that many header characters with the name and then skips the rest of the header. For a disk file the compare count is set to zero so any name in the file header is accepted.

705AH - Down Arrow Command

The down arrow (0AH) entry of the command table points here. It sends 1BH (the video code that moves the cursor up one line) through the ROM display routine at 0033H, then jumps into the up/down arrow line display at 5E74H. 5E74H is the second byte of the LD B,AFH at 5E73H, so it runs AFH = XOR A (NO CARRY), which selects the next line instead of the previous one.

7062H - Convert Lower Case to Upper Case

Called from 5849H with a key code of 1AH or more in Register A. Codes below 61H are returned unchanged; 61H-7AH (a-z) are returned as 41H-5AH (A-Z). For 7BH-7FH the routine does not return: it jumps back to the key loop at 5836H to wait for another key.

706DH - Cassette Read Start (Skipped for Disk)

Called at 5F53H before a load. For cassette it turns interrupts off and jumps to the ROM routine at 0293H, which starts the cassette and finds the leader and sync byte. For disk it returns at once.

7079H - Cassette Write Start (Skipped for Disk)

Called at 6130H before a file header is written. For cassette it turns interrupts off and jumps to the ROM routine at 0284H, which starts the cassette and writes the leader and sync byte. For disk it returns at once.

7086H - Blink the Load Indicator

Called at 5FA2H once for each line loaded. Changes the character at 3C3FH (top line of the screen) between 2AH (*) and 20H (space), the way the ROM cassette routines blink an asterisk there; it runs for disk loads as well.

708FH - Display Free Memory and Return the NS Flag

Called at 644EH after pass 2. Displays the number of bytes between the end of the text and the bottom of the symbol table, followed by TEXT AREA BYTES LEFT, then returns Register A = the NS switch flag from 5882H.

70A9H - Store the Object Record Pointer and Read the FDC Status

70A9H is reached only from 728CH, which the object output calls at 6EB9H. 70ACH is also called from 71A5H. The status value is discarded by both callers.

70B6H - L: Read the Header Byte

Called at 5F56H in the load code, which looks for the D3H byte that starts a source file. For cassette it reads bytes (70C6H) until the load code finds D3H. For disk it reads the first byte: if it is D3H it returns normally; otherwise it goes straight to the line reader at 5F79H with that byte, so a disk file without a header is accepted.

70C6H - Read One Byte (Tape or Disk)

Replaces the ROM cassette read. Returns the next byte in Register A. For cassette it jumps to the ROM at 0235H; for disk it reads from the buffer through 70D4H with all other registers preserved.

70D4H - Fetch a Byte from the Disk Buffer

Returns the next byte from the 512-byte buffer at 72E8H, reading two more sectors when it is used up. Register IX = 72B6H, the FCB. Exits through 6F3FH.

710CH - Write One Byte (Tape or Disk)

Replaces the ROM cassette write. Every byte that EDTASM sends to tape comes here: the source text during W (5F41H and 5939H), the file headers (6135H-6144H), and the object code (6BB8H-6BC0H, 6ED5H, 6EDBH). For cassette it jumps to the ROM at 0264H. For disk it saves the registers and passes the byte to 711FH.

711FH - Store a Byte, Converting Object Code to /CMD Format

Register A = the byte. In file mode 1 (text) the byte is stored unchanged. In file mode 2 (object code) the cassette SYSTEM-tape stream from EDTASM is converted, one byte at a time, into DOS load-module (/CMD) records. 762FH holds the state and 7630H a count:
Bit 0
Skip bytes. Set with a count of 7 by 7262H-7269H to drop the 55H header byte and the six-character name; later set with a count of 1 to drop a record checksum.
Bit 1
Expect a record type. 3CH (data record) is written as 01H (load record); 78H (transfer record) is written as 02H, 02H.
Bit 2
Expect the data record's byte count. It is written increased by 2, because a /CMD load record's length includes the two address bytes.
Bit 7
Copy the address and data bytes.
Bit 6
Copy the two transfer address bytes.
A byte that does not fit the current state stops with INTERNAL ERROR.

71ABH - Put a Byte in the Disk Buffer

Stores Register B at the buffer position (7658H). When the buffer reaches 74E8H (512 bytes), both sectors are written with the DOS WRITE call and the position goes back to 72E8H.

71D5H - Close the Disk File on Return to the Command Loop

Called at 58DDH every time the command loop starts (after each command, error or BREAK). With no disk file open it jumps to 5708H (clear the error flag, turn the cassette off). Otherwise 71E4H writes any buffered bytes and closes the file.

71E4H - Finish and Close the Disk File

After a DOS error (762EH non-zero) or a read (mode 0) the flags are simply cleared. After writing, the bytes left in the buffer are written (the last sector with its byte count in FCB+05H), the file is read back from the start until the DOS reports end of file, and then it is closed.

723BH - A: Object Code to Disk or Tape

Called from 6F2EH. Sets file mode 2. Unless the NO switch was given, asks OBJECT FILE TO DISK OR TAPE? (D OR T). T leaves the object code going to cassette. D asks OBJECT FILESPEC?, reads the filespec straight into the FCB, arms the /CMD converter to skip the 7-byte tape header, and opens or creates the file through 6FF4H.

726FH - DOS Error Handler

Reached from every appendage DOS call that returns NZ, with Register A = the DOS error code. Sets the DOS error flag (so 71E4H will not try to finish the file), sets bits 7 and 6 of the code, calls the DOS error display at 4409H and, when it returns, jumps to the command loop.

727AH - Display a Prompt and Read a Reply

Register HL = the prompt message (bit-7 terminated), Register BC = where the reply goes. Displays the prompt, reads a line of up to 31 characters with the ROM line input at 0040H, and returns the first character typed in Register A. BREAK goes back to the command loop. Register DE is preserved.

728BH - Object Record Pointer Hook

Called at 6EB9H in place of a store into 5321H. Keeps Register A and the flags.

7292H - DEFM: End Test and Pass 2 Shortcut

Reached from 6B56H with the Z FLAG set if the character in Register A is the closing apostrophe. Pass 2 goes back to 6B39H (advance the address only); passes 1 and 3 go back to 6B30H to emit the character.

72A0H - Clear the Output-to-File Flag

Clears 53BAH so that character output goes to the screen again. Register A and the flags are preserved. Called before the appendage shows an error message (6FAAH, 7199H).

72A7H - Show the Appendage Banner Once

Called at the start of L, W and A. The first time, displays APPARAT ASSEMBLER APPENDAGE, VERSION 3.0; 7632H remembers that it has been shown.

72B6H - Appendage FCB and Disk Buffer (Not in the File)

Not Loaded
EDTASM/CMD has no load record for 72B6H-74E7H; the second load block ends at 72B5H and the next starts at 74E8H. The appendage uses this space for its one File Control Block and a two-sector disk buffer. IX = 72B6H inside the disk routines (set by 6F34H).

74E8H - Appendage Messages (Data)

Data
Messages used by the appendage and by the symbol table lister. Most end with a character that has bit 7 set and are displayed by 592FH (through 727AH for the questions); the two cross-reference texts end with 03H and are printed by 56BEH.

762CH - Appendage and Symbol Lister Variables

Loaded as 00H bytes. 762CH-7632H belong to the appendage; 7633H-763CH are used by the symbol table and cross-reference lister at 5200H-56EDH.

763DH - Reference List (Not in the File)

Not Loaded
EDTASM/CMD has no load record for 763DH-764CH (the third load block ends at 763CH and the fourth starts at 764DH).

764DH - Symbol Lister Work Area and Disk Buffer Pointers

Loaded. 7654H-7657H hold two constant one-character dummy symbol entries used by the sorted listing at 5200H: a length byte of 01H followed by the name 00H (lower than any symbol) and by the name FFH (higher than any symbol). 7658H-765BH are the appendage's disk buffer position and end. The rest is unreferenced zero fill. The text buffer starts right after this block at 7700H (588AH).