Z80 Disassembler

This program implements a complete Z80 CPU disassembler, accepting a start and end address plus an optional offset, then decoding memory contents into human-readable Z80 assembly mnemonics. It handles all major Z80 instruction prefixes including CB (bit operations), DD (IX-indexed), ED (extended), and FD (IY-indexed), with proper multi-byte instruction decoding. Output can be displayed in either hexadecimal or decimal address format, and a printer output option triggers screen-copy pagination via COPY. The disassembler works by extracting the binary bit-field pattern of each opcode (bits broken into groups for x, y, and z fields) and matching them against a large DATA table of mnemonic templates starting at line 3000, using variable substitution characters within the template strings to fill in register names, immediate values, and displacement operands.

---

Program Analysis

Program Structure

The program is organized into a main loop and a collection of subroutines, with the instruction database encoded in DATA statements. The high-level flow is:

1. Initialization and user prompts (line 420): start address, end address, hex/decimal display mode, printer option, and address offset.
2. Main decode loop (lines 440–810): fetch one byte at a time, handle prefix bytes, extract opcode bit-fields, look up the mnemonic template, perform variable substitution, and print.
3. Output/pagination subroutine (lines 820–880): handles COPY for printer output and page-break counting.
4. Subroutines for byte-to-hex conversion (lines 120–180), 16-bit address formatting (lines 200–220), displacement decoding (lines 240–340), and V-type operand substitution (lines 360–400).
5. DATA tables (lines 3000–3345): mnemonic templates indexed by prefix and opcode bit-fields.

Opcode Bit-Field Extraction

Lines 600–620 implement a software bit-unpacker. The opcode byte is converted into an 8-character binary string stored in D$ (LSB first, stored at index 1). Four derived values are then computed:

• A(1): bits 7–6 (the x field, value 0–3), used as the primary table index.
• A(2): bits 2–0 (the z field, value 0–7), the secondary index.
• A(3): bits 5–3 (the y field, value 0–7), used for register/condition selection.
• A(4): bits 4–3 (the p sub-field, value 0–3), used for register-pair selection.

These map directly to the standard Z80 opcode decoding matrix (x, y, z, p, q fields).

DATA Table Indexing

The mnemonic templates are addressed by the formula RESTORE 3000 + (100*CL + 10*A(1) + A(2)) at line 660, where CL encodes the active prefix (0 = unprefixed, 1 = CB, 2 = ED). This creates a sparse table: line 3000 covers unprefixed x=0,z=0; line 3100 covers CB-prefix x=1,z=0; line 3200 covers ED-prefix x=2,z=0; and so on. Each DATA line holds one or more "pattern","mnemonic" pairs. The pattern string is three characters matching against A$(1) (y-field digit), A$(2) (bit 3), and A$(3) (p sub-field digit), with "-" acting as a wildcard.

Mnemonic Template Variable Substitution

Lines 740–800 scan the matched mnemonic template character by character, replacing placeholder characters with actual operand text. The substitution codes are:

Character	Meaning	Data line
!–$	Register/condition codes indexed by A(3)	3333–3336
%	Register indexed by A(2)	3337
&	Register pair, two variants indexed by A(4) and prefix	3338–3339
'	Push/pop register pair (AF variant)	3339
*	(HL)/(IX+d)/(IY+d) depending on IN prefix	3342
-	HL/IX/IY depending on IN prefix	3345
.	Inline immediate byte (calls subroutine at 360)	—
/	Index displacement (calls subroutine at 240)	—
..	16-bit immediate address via GO SUB 240 path	—
#	Condition code (part of template literal)	—

The substitution loop at lines 740–800 replaces each placeholder in D$ in-place, expanding the string as needed, then continues scanning from the same position to handle chained substitutions.

Prefix Handling

Lines 550–560 detect prefix bytes before dispatching through the decode matrix. CL records CB (value 1) or ED (value 2) prefix state, while IN records DD (value 1) or FD (value 2) for IX/IY indexing. When both IN>0 and CL>0 (i.e., DDCB or FDCB prefix pair), line 580 pre-fetches the displacement operand before reading the actual opcode, which is correct Z80 behavior for the DDCB/FDCB instruction group where the displacement precedes the final opcode byte.

Hex Conversion Subroutine

The subroutine at line 180 converts a byte value in X into a two-character hex string in X$. It uses arithmetic on the AND operator’s precedence behavior: (48 + digit AND digit <= 9) + (55 + digit AND digit > 9) selects either the ASCII digit (48+) or the uppercase letter (55+, since 55+10=65=’A’). This avoids any IF/THEN branching.

Displacement and Relative Jump Decoding

Line 270 converts the raw displacement byte into a signed integer using the expression (X AND X<128) + (X-256 AND X>127), correctly handling two’s complement sign extension from 8 to full integer. Lines 280–340 compute the absolute target address for JR/DJNZ instructions by adding the displacement to the current program counter (M+1+X+MX), and display both the raw displacement and the resolved address.

Output and Pagination

The output subroutine (lines 820–880) implements a simple three-screen page counter in PC. When printer output is selected, after every three screen-fulls it emits eight blank lines via LPRINT to advance the paper. When printer output is not selected, it prompts the user whether to invoke COPY before clearing the screen and continuing.

Notable Techniques

• POKE 23658,8 at line 70 sets the system FLAGS2 byte to enable lowercase input, useful for the y/n prompts.
• DIM A$(PI) at line 100 exploits the fact that INT(PI)=3 to allocate a 3-character string array without writing the literal 3.
• The sparse DATA table layout (line numbers as lookup keys via RESTORE) avoids any explicit search loop over instruction encodings.
• The binary string representation in D$ uses STR$ (X+.5 - INT X) to extract the fractional part of successive halvings—a compact way to read individual bits without bitwise operators.
• The MX offset variable allows the disassembler to display relocated addresses, useful when disassembling code that has been copied to a different memory location for inspection.

Bugs and Anomalies

• Line 250 references variable Z$ before it is ever assigned in a fresh run; on the first DDCB/FDCB instruction encountered, Z$ may be uninitialized. In practice this is only reached after line 580 has already set Z$, so it functions correctly in the normal decode path.
• The prompt text at line 420 spells “HEXADECIMAL” as “HEXADECIMAL” in the source but the DATA string reads "<H>EXADECIMAL"—the leading H is part of the angle-bracket option, not a typo in the word itself.
• Line 3036 encodes arithmetic/logic instructions as "$.", which combines a register-group substitution ($ → one of ADD A, ADC A, SUB, etc.) with an immediate byte fetch (.). The SUB template in DATA line 3336 includes a spurious comma ("SUB,") that would produce output like SUB,42 rather than the standard SUB 42.
• Instructions with undefined or illegal opcodes will fall through the DATA search loop without finding a match, potentially causing a BREAK or reading garbage from adjacent DATA lines.