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

DISASSEM/CMD

Other Navigation

NEWDOS/80 v2.0 DISASSEM/CMD Disassembly - The Apparat Disassembler 3.0 (Model I)

DISASSEM/CMD (manual section 6.2) disassembles Z-80 code from main memory or from a load module on disk, to the display or the printer. For a disk object it can also build a location reference table (a cross reference of every address an instruction names), list it, write it to a file (RTD), and write the disassembly as EDTASM source text with generated names (STD). The program identifies itself as APPARAT DISASSEMBLER 3.0.

The file is one load block 55E4H-6E7BH (6,296 bytes in 25 load records), transfer address 5614H. 55E4H-5613H are the variables, 5614H-681BH the code, 681CH-6DDFH the mnemonic tables, source text lines and messages, 6DE0H-6DE6H a small routine and 6DE7H-6E7BH unused zero bytes. Everything above the file is work space: the stack below 6F60H, the reference table's search index at 6F60H-6F9FH and the table itself from 6FA0H up to HIMEM - 6. Below the file are the buffers at 5200H-55E3H.

The page shows every byte of the file once, in address order. Each row says what every register and address it uses holds at that moment.

Questions and Options

The Passes of a Disk Disassembly

The Output Line

The Location Reference Table

STD Source Text

Notes From the Code

55E4H - Variables

Data. The program's variables are loaded with the file (the first load record starts here) and most are set again at 5614H for every disassembly. The work buffers below 55E4H (5200H object buffer, 5300H input sector buffer, 5400H output sector buffer, 5500H input FCB, 5532H output FCB, 5564H input line, 55A4H output line) and the reference table from 6F60H up are not in the file.

5614H - Start: Title, Variables and the Reference Table

DISASSEM's transfer address; ANOTHER DISASSEMBLY? answered Y also comes back here (5D06H). The stack is put below the reference table index at 6F60H, the title is shown, the per-run variables are reset and an empty reference table is built at 6FA0H with its 16-entry search index at 6F60H-6F9FH. Then the object source (M or D) is asked for.

5677H - Memory Object: Questions

For an object in main memory the virtual base address (where the code is considered to run) and the real base address (where it is now, by default the same) are asked; then the options. NIP, RTD and STD need a disk object; PTR also asks for a byte count. Then the disassembly runs at 5748H until the byte count runs out or the operator stops it.

56B9H - Disassembly Loop: STD Labels Inside the Last Instruction

The loop is entered at 5748H (a new screen) or 5755H (the keyboard check) and returns from 56FDH or 570EH. When STD source text is being written, a byte inside the instruction just written that is referenced elsewhere cannot have a label on a line of its own, so an EQU line name EQU $-n is written after the instruction for every such byte, n being the bytes from it to the end of the instruction. The bytes are taken from bits 2-0 of the reference mark at 55F1H (bit 3, the first byte, gets its label on the instruction itself).

56F8H - Disassembly Loop: Next Instruction

Stops when the byte count is used up, or for a disk object when the object buffer has been decoded up to 55FFH. Otherwise one instruction is decoded into the output line (60EDH); STD writes it to the source file, and unless the reference table is being built the line is shown, with a pause when the screen is full.

5748H - Disassembly Loop: New Screen, Keyboard Check and Pause

5748H is the entry of the disassembly loop: it clears the screen unless the table is being built and allows 16 lines on it. 5755H checks the keyboard after every instruction: X ends the disassembly, P pauses. The pause (5765H/576BH) waits for ENTER, X, or for a memory object V, which asks for a new VIRTUAL RESTART LOCATION and moves the real pointer by the same amount.

579AH - Start the Output of a Pass

During the build pass only BUILDING CROSS-REFERENCE TABLE is displayed. Otherwise the pause flag (bit 7 of 55F0H) is set unless BFSP is set, and with PTR the output is switched to the printer.

57B7H - Disk Object: Questions and Opening the File

For a load module on disk the filespec, the offset to add to the load addresses and the virtual restart location are asked, the reference types are all enabled, and the options are asked. 57E3H is also where the second pass starts (from 5A2CH): the file is opened again and read from its first record.

5807H - Disk Object: Read the Load Records

Each record starts with a type byte. Type 01H (a load block) has a length byte (the bytes after it, address included; 00H means 256), a two-byte load address and the data, which is collected in the object buffer at 5200H. A block that does not start where the previous one ended begins a new run: the previous run is decoded to its end (58D5H) and for STD an ORG line is written. Type 02H is the transfer record (591FH); other types are skipped (590EH). Register B is the sector byte counter of 58BAH throughout, Register C the bytes left in the record and Register Pair DE the store position in the object buffer.

58BAH - Disk Object: Read One Byte of the File

Returns the next byte of the object file in Register A. Register B counts down the bytes left in the sector buffer at 5300H; when it runs out the next sector is read with SYS0 4436H. Register Pair DE is preserved.

58D5H - Disk Object: End of a Run

Called when a load block starts a new run and for the transfer record. The bytes of the run that are still in the object buffer are decoded: the byte count at 560BH is set to the bytes between the virtual location and the end of the run, so decoding stops exactly there. Then the output pauses and, when printing, up to three blank lines mark the break.

590EH - Disk Object: Other Records and the Transfer Record

A record of a type other than 01H and 02H is skipped. The transfer record 02H ends the run and gives the entry point: for STD its address gets a name, it is shown as nnnn = PROGRAM ENTRY POINT, and at the end of the listing pass the EQU lines for the names that are not on an instruction and the END line are written to the source file.

59C9H - Disk Object: End of the Build Pass

The object file is closed. With RTD the reference table is written to a new file, a sector at a time straight from memory starting with the C0H marker at 6FA0H. The flags then switch from the build pass (bit 0) to the listing pass (bit 1); NIP goes straight to the reference table listing. Otherwise the search index is rebuilt, which also numbers the names, the STD output file is opened, and the file is read again from 57E3H.

5A2FH - Open an Output File

Asks the question at Register Pair DE (an answer is required), copies the answer into the FCB at 5532H and opens the file with SYS0 4420H (new or existing), the buffer at 5400H and the record length 256. Returns with Register Pair DE = 5532H and Register Pair HL = 5400H.

5A49H - Disk Object: Read a Load Address

Reads two bytes of the file (low byte first) into Register Pair HL, takes 2 off Register C (the bytes left in the record) and adds the offset at 55F9H, giving the virtual address. Register Pair DE is preserved.

5A5BH - STD: Write the Source Line of an Instruction

Writes the instruction just decoded to the source text file: the line number, the label field (55B5H, the location's name if it has one) and a TAB, the mnemonic field (55BDH) and a TAB, the operand field (55C5H) and a carriage return. Spaces end each field.

5A6EH - STD: Count and Write the Line Number

The line number at 6987H-698BH is five digits with bit 7 set (B0H-B9H), as EDTASM source files keep them. It is counted up by 1 from the last digit and then written with the space after it (698CH). Going past 99999 gives SEQUENCE # OVERFLOW.

5A91H - STD: Write Fields and Characters to the Output File

5A91H writes an 8-character field up to its first space, steps Register Pair HL to the next field and writes a TAB. 5A9DH writes characters from Register Pair HL until a space, at most Register B of them. 5AA8H puts one character in the output sector buffer at 5400H; when the buffer is full (the pointer's low byte wraps to 00H) the sector is written with SYS0 443CH. 5ABEH ends a line at Register Pair HL with a carriage return and writes it, with a line number, from Register Pair DE; 5AC5H writes a line up to and including its carriage return.

5ADAH - Questions and Their Answers

Every question goes through 5CC5H, which displays it, reads a line into 5564H and keeps the question and its own return address on the stack. A bad answer displays BAD REPLY (5B18H) and asks the same question again by going back into 5CC5H; a good one leaves through 5B03H, which drops those two words and returns Register A = Register C with the flags of OR A. Register B is the number of characters typed, Register Pair HL the start of the answer. 5AE4H accepts only ENTER; 5AEBH needs any answer; 5AF2H Y (NZ), N or ENTER (Z); 5B08H D or ENTER (A = 01H, NZ), M (A = 00H, Z); 5B22H a hexadecimal number (required) and 5B29H one with the default 0 (Z for an empty answer); 5B52H a decimal number. Numbers come back in Register Pair HL.

5B7DH - ANY OPTIONS?

Each answer is one option, looked up in the table at 5C8EH; its handler sets a flag and asks the question again (through 5B1EH). An empty answer ends the options (5C1DH). The name must be typed exactly; NCR, NIP, RTD, STD, PTR and BFSP must stand alone, RE and RI take one more letter, FGN= three letters.

5BB3H - Option Handlers

5BB3H (PTR, BFSP) sets the mask in Register C in the output flags at 55F0H, 5BB8H (NCR, NIP, RTD, STD) in the flags at 55EFH; nothing may follow the name. 5BC4H handles RE and RI: one letter must follow, A for every reference type or one of S T U V W X P L R. 5BCDH enables (Register C bit 0 set) or disables those types in the flags at 60E2H. 5BF6H reads FGN=xxx, three letters, into the first name number at 5FC1H. Every handler asks ANY OPTIONS? again through 5B1EH.

5C1DH - ANY OPTIONS?: Settle the Flags

After the empty answer the options are made consistent: RTD and STD need the reference table, so they cancel NCR; NCR cancels the build pass; STD cancels NIP and turns on BFSP; PTR turns on BFSP. With PTR the page size, the margins, the printer's top of page and its highest character code are asked.

5C8EH - Option Table

Data. Searched by 5B7DH: each entry is the option's name in ASCII, a byte with bit 7 set whose low bits are the mask the handler sets (Register C), and the handler's address. A 00H in place of a name ends the table.

5CC5H - Ask a Question and Read the Answer

Called first by every question routine. 5CC5H takes its own return address (the asking routine) off the stack and pushes it back with the question's address in Register Pair DE and the return address once more, so that 5B18H can ask the same question again after BAD REPLY and 5B03H can drop both words. It displays the question, reads the answer into 5564H and returns Register Pair HL = 5564H, Register A = the first character, Register B = the characters typed, Register C = 00H and the Z FLAG for an empty answer.

5CD2H - Keyboard: Wait for a Key, Scan the Keyboard

5CD2H waits for a key with ROM 0049H, 5CE0H only scans with ROM 002BH (Register A = 00H if no key is pressed). Both turn a lower case letter into upper case (5CD7H, also used by 5DB8H) and keep Register Pair DE.

5CE6H - End of a Disassembly: Errors, Cancel and Another Disassembly?

5CE6H displays a DOS error (Register A = its code) through SYS0 4409H with bits 7 and 6 set, so the message is displayed and 4409H returns, and then reports FUNCTION CANCELLED. 5CF2H (X, or the up-arrow while answering) and 5CF7H (BAD MAIN MEMORY) display their message; 5CFDH switches the output back to the display and asks ANOTHER DISASSEMBLY?: Y starts again at 5614H, N or ENTER goes to DOS READY.

5D0CH - Output: Messages and Characters

5D0CH switches to the display and shows a message with three blank lines after it. 5D17H shows the text at Register Pair DE up to its 00H and a carriage return; 5D1AH outputs one carriage return, 5D1CH Register B of them; 5D24H outputs text up to its 00H; 5D2DH clears the screen (1CH home, 1FH clear to the end of the frame); 5D3AH/5D3FH output Register B characters from Register Pair DE (with a carriage return after them for 5D3AH). All go through 5D47H, one character at a time.

5D47H - Output One Character

Outputs Register A through 5E63H (to the display or the printer) and keeps the column count at 5605H: a printable character uses a column and a full line is ended automatically; 08H gives one back; 1CH-1FH start the count again. 0AH-0DH end the line: an empty line gets a space first, the carriage return is output, the page count is updated (5E20H) and, if BREAK is held down, the output waits until ENTER is pressed. All registers are kept.

5DA6H - Read an Answer Line

Reads a line of up to 64 characters into 5564H with ROM 0040H. Holding down the up-arrow key while pressing ENTER cancels the disassembly (FUNCTION CANCELLED). The line is turned into upper case. Returns Register Pair HL = 5564H, Register B = the characters typed, Register A = the first character and the Z FLAG if the line is empty.

5DC6H - Output Device and Page Handling

5DC6H switches the output to the printer: the JR at 5E67H gets displacement 00H so 5E63H prints, the line width comes from 5608H, and before the first printed page the top margin is printed (5E34H). 5DD8H switches back to the display (displacement 18H, width from 5607H). Both first end a line that is not empty. 5E07H prints carriage returns up to the top of the next page; 5E10H returns the Z FLAG on the display or at the top of a page; 5E20H counts every printed line and prints the bottom and top margins at the end of a page; 5E48H prints up to Register C blank lines; 5E53H prints Register B lines of one space.

5E63H - Send a Character to the Display or the Printer

The JR at 5E67H is set by 5DEAH: with displacement 18H it goes straight to the display code (5E81H), with 00H it runs the printer code at 5E69H first. The printer gets printable characters, 0AH and 0DH through ROM 003BH; other control codes are dropped. The display code (ROM 0033H) leaves out the carriage return after a line of exactly 64 characters, because the display has already moved to the next line. All registers are kept.

5E9CH - Utilities: Clear the Line Buffer, Compare

5E9CH fills the 64 bytes at 5564H with spaces (the reference table listing builds its lines there) and returns Register Pair HL = 5564H. 5EA9H subtracts Register Pair DE from Register Pair HL; 5EACH tests Register Pair HL: both return the Z FLAG only when Register Pair HL is (or becomes) 0000H, with Register Pair HL = the difference.

5EB2H - Reference Table: Record a Reference

Called for every operand value during the build pass only (bits 1 and 2 of 55EFH clear): Register Pair DE = the referenced location, 55EBH = the location of the referencing instruction, 55F8H = the reference type. The table at 6FA1H is kept in ascending order of the referenced locations; each referencee entry (location high, low, 40H) is followed by its referencer entries (location high, low, type), also in ascending order. A new referencee takes 6 bytes (with its first referencer), a further referencer 3. After every 64 new referencees (32 the first time) the search index is rebuilt.

5F02H - Reference Table: Make Room for New Entries

Moves everything from the entry whose control byte is at Register Pair HL up to the end marker up by Register A bytes and updates the search index entries after the one the last search used (5F2EH). INSUFFICIENT MEMORY ends the disassembly if the end marker would pass HIMEM - 12. Returns Register Pair HL = the room made and Register Pair DE as it was.

5F4DH - Reference Table: Find a Location

Looks the location in Register Pair DE up among the referencee entries. The search index at 6F60H-6F9FH (16 entries: a table pointer and the name number of the referencee it points at) is read from the last entry down until one points at a location not above Register Pair DE (the first entry is always used), and the table is searched from there. Found: the Z FLAG, Register Pair HL at the entry's control byte and Register Pair BC = its name number. Not found: the CARRY FLAG and the NZ FLAG, with Register Pair HL at the control byte of the next higher referencee (or the end marker), where a new one goes. The index entry used is left at 5F2EH for 5F02H.

5F93H - Reference Table: Rebuild the Search Index

Counts the referencee entries, divides the count by 16 (rounded up) and points the 16 index entries at every so many referencees, with the name number of each (5FC1H, the first name, plus the referencees before it). Index entries past the last referencee point at the end marker. Called after every 64 new referencees during the build pass and once before the listing pass (5A19H), when the name numbers are needed. The counting uses the alternate register set.

5FECH - Location Reference Table Listing

The last phase of a disk disassembly (skipped with NCR). After the heading with the type definitions (6B1CH) the types turned off by RI are named. Then every referencee is listed in ascending order: its location, then the location and type letter of each referencing instruction of a listed type, six columns each, continued on further lines indented by six columns. The lines are built in the buffer at 5564H. X ends the listing, P pauses it. A referencer of a type that is not listed still moves the position on by two columns (60CDH jumps to 609BH).

603EH - Listing: Output the Line, Keys

Outputs the line built in 5564H up to Register Pair HL (nothing if it is empty) and a carriage return, then checks the keyboard: X ends the disassembly, P waits for ENTER (or X). The buffer is filled with spaces again and Register Pair HL = 5564H. Register Pair DE is kept.

6066H - Listing: A Referencee

Outputs the line of the previous referencee and, unless this is the end marker, starts a new line with the referencee's location if at least one of its referencers is of a listed type (referencers of other types at the start are passed over). A referencee followed by no referencer at all, such as the entry point added at 5943H, is listed alone.

60ADH - Listing: Next Entry, a Referencer

Reads the next table entry through Index Register IX into Register Pair DE (its location) and its control byte. A referencer of a listed type is written as its location and type letter.

60D7H - Reference Type Letters and Flags

Data. 60D7H holds the eleven type letters in type number order (types 6 and 7 are not used and hold spaces); 60E2H holds the enabled-type flags, a type's letter when it is listed and a space when not, all spaces in the file and set by 5BCDH (REA by default, then RE and RI).

60EDH - Decode One Instruction

Builds the output line for the instruction at the virtual location 55E5H. The 64-character line at 55A4H-55E3H is: 55A4H-55A5H the reference mark (count and byte mask), 55A6H the location (four hexadecimal digits), 55ABH the instruction's bytes (two digits each), 55B5H the label (the location's name, STD only), 55BDH the mnemonic, 55C5H the operands, 55D3H the bytes as ASCII. The state (virtual location, real pointer, byte count, table scan pointer) is saved on the stack first; an opcode that is not valid, an index prefix left unused, or the byte count running out inside the instruction makes 618AH restore it and decode the first byte again as DEFB (55F1H = FFH). 60EDH starts with 55F1H = 00H; 60EEH is entered from 619FH with Register A = FFH.

618AH - Decode Again as DEFB

Reached when the instruction cannot be decoded: an opcode that is not valid (64E0H, 645EH), a second index prefix (63B7H), a prefix no operand used (6150H), or the byte count running out inside the instruction (6598H). The saved state is restored, so the virtual location, the real pointer, the byte count and the table scan pointer are back at the instruction's first byte, and it is decoded again with 55F1H = FFH, which makes 61A2H show that one byte as DEFB.

61A2H - Opcode Decoder: First Byte

Register Pair HL = the operand field (55C5H) throughout the decoder. With 55F1H not 00H the byte is shown as DEFB (626DH). Otherwise the opcode is fetched (6592H) and kept at 560DH; its bit fields are read with 6727H (bits 5-4), 673BH (bits 5-3) and 6743H (bits 2-0). 40H-7FH are LD r,r' and HALT, 80H-BFH the arithmetic and logic group; 00H-3FH and C0H-FFH are sorted by testing their bits. Each path writes the mnemonic (67A6H, into 55BDH) and the operands, and ends in a helper whose RET goes back to 614CH.

61EAH - Opcode Decoder: 00H-3FH

Sorted by bits 0, 1, 2, 5 and 3 of the opcode in Register A. With all of them clear the opcode is 00H (NOP) or 10H (DJNZ); bit 5 alone gives JR cc (20H-38H), bit 3 alone 08H (EX AF,AF') or 18H (JR). A relative jump's target is computed from the location after the offset byte and written as a word with reference type R (0AH).

624BH - Opcode Decoder: 00H-3FH, Bit 1 Set and Bit 0 Clear

x2H, x6H, xAH and xEH, all loads: LD (BC)/(DE),A and LD A,(BC)/(DE), LD (nn),HL/A and LD HL/A,(nn) with reference types W, X, S and T, LD r,n with type V. 626DH writes a byte as DEFB, also with type V.

62A9H - Opcode Decoder: 00H-3FH, Odd Opcodes

x1H LD rr,nn (type U), x3H/xBH INC rr and DEC rr, x5H/xDH DEC r, x7H/xFH the accumulator and flag instructions, x9H ADD HL,rr. HL as an operand becomes IX or IY after a DD or FD prefix (67F5H, 67FCH).

62F3H - Opcode Decoder: C0H-FFH

x0H/x8H RET cc, x2H/xAH JP cc,nn (type P), x4H/xCH CALL cc,nn (type L), x6H/xEH the arithmetic and logic operations with a byte (type V); the odd opcodes from 6342H. The condition comes from bits 5-3 of the opcode (66FFH).

6342H - Opcode Decoder: C0H-FFH, Odd Opcodes

x1H POP, x5H PUSH, C9H RET, D9H EXX, E9H JP (HL), F9H LD SP,HL, CDH CALL nn, DDH/FDH the index prefixes, EDH the extended group, and from 63BAH the x3H/x7H/xBH/xFH opcodes. POP and PUSH use bits 5-4 with AF for 3.

63BAH - Opcode Decoder: C0H-FFH, x3H x7H xBH xFH

C3H JP nn, D3H OUT (n),A (type X), E3H EX (SP),HL, F3H DI, x7H/xFH RST, CBH the bit group, DBH IN A,(n) (type T), EBH EX DE,HL, FBH EI.

641FH - Opcode Decoder: The Bit Group (CBH)

After a DD or FD prefix the displacement comes before the opcode (DD CB d op), so it is fetched first into 5611H and the prefix state becomes 03H. 00H-3FH are the rotates and shifts (30H-37H are not valid and give DEFB), 40H-7FH BIT, 80H-BFH RES, C0H-FFH SET, with the bit number from bits 5-3 written as a byte (e.g. 03H) and the register from bits 2-0.

646DH - Opcode Decoder: The Extended Group (EDH)

A0H-BFH with bit 2 clear are the block instructions (table 68E6H, 16 mnemonics). 40H-7FH: x0H/x8H IN r,(C) (70H is IN (C)), x1H/x9H OUT (C),r (71H is not valid), x2H/xAH SBC/ADC HL,rr, x3H/xBH LD (nn),rr and LD rr,(nn) (types W and S), and RRD, RLD, NEG, RETN, RETI, LD I,A, LD A,I, LD R,A, LD A,R, IM 0, IM 1, IM 2. Every other second byte is not valid and gives DEFB.

6559H - Operand: A Register, (HL), (IX+d) or (IY+d)

6559H takes the register number from bits 2-0 of the opcode, 655CH from Register A (0-7: B C D E H L (HL) A). Number 6 is written as (HL), or (IX+d)/(IY+d) after a prefix: the displacement is the byte fetched now, or the one already saved at 5611H for the DD CB d op form, written as + or - and two hexadecimal digits with H. The prefix state is then cleared.

6592H - Fetch the Next Object Byte

Returns the byte at the real pointer (55E7H) in Register A and moves the real pointer and the virtual location on. The byte count at 560BH is counted down; if it is already 0 the instruction does not fit and 618AH makes it a DEFB. The byte is written as two hexadecimal digits into the byte column (5609H). In the listing pass with a reference table (bit 1 of 55EFH) the byte's location is looked up from the scan pointer 55F6H: if it is a referencee, its referencers are counted (but not 8-bit values, types V, aimed at a location below 0100H) and the count and this byte's mask bit are added into the reference mark at 55F1H. Register Pair HL and Register Pair DE are kept; Index Register IY is changed.

663AH - Operands: Addresses, Values and Names

663AH (type in Register A, plus 1 when bit 4 of the opcode is set) and 6646H write (nnnn) for a 16-bit address, 664FH writes nnnn, 665CH writes Register Pair DE (a computed jump target), 6672H writes (nn) and 667BH nn. The value is stored as the reference type at 55F8H, recorded in the table (5EB2H, build pass only) and written in hexadecimal with a trailing H and a leading 0 when it starts with a letter. When STD source text is being written (66B6H) the value's name from the table is written instead.

669BH - Hexadecimal Digits

669BH writes Register Pair DE as four hexadecimal digits at Register Pair HL, 66A0H writes Register A as two; Register Pair HL ends after them, Register A and Register Pair BC are kept.

66B6H - Names

66B6H returns at once unless STD source text is being written; then it drops its caller's return address and writes the name of the value in Register Pair DE (it must be in the table). 66C1H looks Register Pair DE up: Register A bit 0 set means a missing name is an error (BAD MAIN MEMORY), bit 1 set marks the name as used on an instruction (bit 5 of the control byte). The name is written at the Register Pair HL saved on entry as three letters (66DAH: the name number in base 26, AAA = 0) and Register Pair HL returns after it.

66FFH - Operands: Conditions and Opcode Fields

66FFH writes the condition of a jump, call or return from bits 5-3 of the opcode in Register A (NZ Z NC C PO PE P M; 6703H is used by JR for NZ Z NC C). 6727H returns bits 5-4 of the opcode at 560DH, 673BH bits 5-3, 6743H bits 2-0, 6730H the high four bits of Register A.

674EH - Operands: Single Characters

Each writes one or two characters at Register Pair HL and moves it on; Register A and the flags are kept: 674EH comma, 6752H A and comma, 6757H (C), 6760H comma and A, then N, Z, C, M, P, E, O, minus, plus, opening and closing parenthesis, A, 0 and H, and 679DH Register B.

67A0H - Mnemonics and Register Names

67A6H copies mnemonic number Register A (4 characters) of the table at Register Pair DE into the mnemonic field at 55BDH; 67CEH copies the one at Register Pair DE itself, and 67A0H-67CBH load a table or mnemonic first (67A0H the operation in bits 5-3 of the opcode). 67D1H writes register Register A (one letter from 681CH). 6803H writes register pair Register A (two letters from 6824H: BC DE HL SP IX IY AF); 67D9H/67E0H put one in parentheses, 67E8H DE, 67ECH HL, 67F0H the pair in bits 5-4, 67F5H the same but HL as the index register after a prefix, 67FCH HL, IX or IY (5610H), which clears the prefix state.

681CH - Register and Pair Names

Data. 681CH: one letter per register number for 67D1H (6, (HL), is never taken from here). 6824H: two letters per register pair number for 6803H.

6832H - Mnemonic Tables

Data. Four characters per mnemonic, padded with spaces, copied into the output line's mnemonic field (55BDH) by 67A6H. 6832H, 68A6H, 68C6H, 68E6H and 692BH are tables indexed by a number from the opcode; the single mnemonics between them are used with 67CEH.

6957H - Source Text Lines and the Line Number

Data. The lines STD writes besides the instructions, each ending with 0DH and filled in before they are written: an EQU line for a name that is not on an instruction, the EQU line for a referenced byte inside an instruction, the ORG line, the END line. 6987H-698CH is the line number written before every source line, 698DH its starting value.

6992H - Messages

Data. The title, the questions and the messages; each ends with 00H (5D24H outputs up to it). The heading at 6B1CH has its lines separated by 0DH. 6C92H-6C97H is the operand text AF,AF', not a message.

6DE0H - RTD: Set Up the Write

Called by the RTD write at 59E2H: Index Register IX = the FCB in Register Pair DE (5532H), so the loop can set its buffer address, and Register Pair HL = 6FA0H, the first byte of the reference table (its C0H marker).

6DE7H - Unused Bytes

The end of the file. No instruction in DISASSEM reaches or reads these 149 zero bytes; the reference table index and table start above them at 6F60H.