@jhlagado/azm 0.2.6 → 0.2.8

package/dist/src/z80/parse-instruction.js

@@ -1,161 +1,61 @@
-import { parseExpression } from '../syntax/parse-expression.js';
+import { splitInstructionOperands } from './operand-split.js';
+import { aluImm8RangeError, halfIndexFamilyFromRegister, indexedBracketError, parseAluOperand, parseBitIndex, parseCbOperand, parseIncDecOperand, parseIndexHalfRegister, parseIndexRegister16, parseRegister16Operand, parseRegister8Operand, parseStackRegister, } from './parse-operands.js';
+import { parseCallInstruction, parseJumpInstruction, parseRelativeBranchInstruction, } from './parse-branch.js';
+import { parseNoOperandCoreInstruction, parseNopInstruction, parseRetInstruction, } from './parse-basic.js';
+import { parseExchangeInstruction } from './parse-exchange.js';
+import { parseInputInstruction, parseInterruptModeInstruction, parseOutputInstruction, parseRstInstruction, } from './parse-io-control.js';
+import { parseLdInstruction } from './parse-ld.js';
+const INSTRUCTION_PARSERS = [
+    parseNopInstruction,
+    parseRetInstruction,
+    parseNoOperandCoreInstruction,
+    parseInputInstruction,
+    parseOutputInstruction,
+    parseInterruptModeInstruction,
+    parseRstInstruction,
+    parseExchangeInstruction,
+    parseIncDecInstruction,
+    parseStackInstruction,
+    parseLdInstruction,
+    parseBitLikeInstruction,
+    parseRotateShiftInstruction,
+    parseAccumulatorAluInstruction,
+    parseUnaryAluInstruction,
+    parseJumpInstruction,
+    parseCallInstruction,
+    parseRelativeBranchInstruction,
+];
 export function parseZ80Instruction(text) {
-    const nop = /^NOP(?:\s+(.*))?$/i.exec(text);
-    if (nop) {
-        return nop[1] === undefined
-            ? { instruction: { mnemonic: 'nop' } }
-            : { error: 'nop expects no operands' };
-    }
-    const ret = /^RET(?:\s+(.*))?$/i.exec(text);
-    if (ret) {
-        const operandText = ret[1] ?? '';
-        if (operandText.trim().length === 0) {
-            return { instruction: { mnemonic: 'ret' } };
-        }
-        const parts = splitInstructionOperands(operandText);
-        if (parts.length !== 1) {
-            return { error: 'ret expects no operands or one condition code' };
-        }
-        const condition = parseCondition(parts[0] ?? '');
-        return condition
-            ? { instruction: { mnemonic: 'ret-cc', condition } }
-            : { error: 'ret cc expects a valid condition code' };
-    }
-    const noOperandCore = /^(DI|EI|SCF|CCF|CPL|DAA|EXX|HALT|RLCA|RRCA|RLA|RRA|NEG|RRD|RLD|LDI|LDIR|LDD|LDDR|CPI|CPIR|CPD|CPDR|INI|INIR|IND|INDR|OUTI|OTIR|OUTD|OTDR|RETI|RETN)(?:\s+(.*))?$/i.exec(text);
-    if (noOperandCore) {
-        const mnemonic = (noOperandCore[1] ?? '').toLowerCase();
-        return noOperandCore[2] === undefined
-            ? { instruction: { mnemonic } }
-            : { error: `${mnemonic} expects no operands` };
-    }
-    const input = /^IN(?:\s+(.*))?$/i.exec(text);
-    if (input) {
-        const operandText = input[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length > 2) {
-            return { error: 'in expects one or two operands' };
-        }
-        if (parts.length === 1) {
-            const port = parsePortOperand(parts[0] ?? '');
-            return port?.kind === 'c'
-                ? { instruction: { mnemonic: 'in', port } }
-                : { error: 'in (c) is the only one-operand in form' };
-        }
-        const target = parseRegister8Operand(parts[0] ?? '');
-        if (!target) {
-            return parseIndexHalfRegister(parts[0] ?? '')
-                ? { error: 'in destination must use plain reg8 B/C/D/E/H/L/A' }
-                : { error: 'in expects a reg8 destination' };
-        }
-        const port = parsePortOperand(parts[1] ?? '');
-        if (!port) {
-            return { error: 'in expects a port operand (c) or (imm8)' };
-        }
-        if (port.kind === 'imm' && target.register !== 'a') {
-            return { error: 'in a,(n) immediate port form requires destination A' };
-        }
-        return { instruction: { mnemonic: 'in', target, port } };
-    }
-    const output = /^OUT(?:\s+(.*))?$/i.exec(text);
-    if (output) {
-        const operandText = output[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length !== 2) {
-            return { error: 'out expects two operands' };
-        }
-        const port = parsePortOperand(parts[0] ?? '');
-        if (!port) {
-            return { error: 'out expects a port operand (c) or (imm8)' };
-        }
-        const source = parseRegister8Operand(parts[1] ?? '');
-        if (source) {
-            if (port.kind === 'imm' && source.register !== 'a') {
-                return { error: 'out (n),a immediate port form requires source A' };
-            }
-            return { instruction: { mnemonic: 'out', port, source } };
-        }
-        if (parseIndexHalfRegister(parts[1] ?? '')) {
-            return { error: 'out source must use plain reg8 B/C/D/E/H/L/A' };
-        }
-        const zero = parseConstantExpression(parts[1] ?? '');
-        if (zero !== undefined && port.kind === 'c') {
-            return zero === 0
-                ? { instruction: { mnemonic: 'out', port, source: { kind: 'zero' } } }
-                : { error: 'out (c), n immediate form supports n=0 only' };
-        }
-        return { error: 'out expects a reg8 source' };
-    }
-    const im = /^IM(?:\s+(.*))?$/i.exec(text);
-    if (im) {
-        const operandText = im[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length !== 1) {
-            return { error: 'im expects one operand' };
-        }
-        const mode = parseConstantExpression(parts[0] ?? '');
-        if (mode !== 0 && mode !== 1 && mode !== 2) {
-            return { error: 'im expects 0, 1, or 2' };
-        }
-        return { instruction: { mnemonic: 'im', mode } };
-    }
-    const rst = /^RST(?:\s+(.*))?$/i.exec(text);
-    if (rst) {
-        const operandText = rst[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length !== 1) {
-            return { error: 'rst expects one operand' };
-        }
-        const vector = parseConstantExpression(parts[0] ?? '');
-        if (!isRstVector(vector)) {
-            return { error: 'rst expects an imm8 multiple of 8 (0..56)' };
-        }
-        return { instruction: { mnemonic: 'rst', vector } };
-    }
-    const exchange = /^EX\s+(.+)$/i.exec(text);
-    if (exchange) {
-        const operandText = exchange[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (parts.length !== 2) {
-            return { error: 'ex expects two operands' };
-        }
-        const left = (parts[0] ?? '').toLowerCase();
-        const right = (parts[1] ?? '').toLowerCase();
-        if ((left === 'af' && right === "af'") || (left === "af'" && right === 'af')) {
-            return { instruction: { mnemonic: 'ex', form: 'af-af' } };
-        }
-        if (left === 'de' && right === 'hl') {
-            return { instruction: { mnemonic: 'ex', form: 'de-hl' } };
-        }
-        if (left === '(sp)' && right === 'hl') {
-            return { instruction: { mnemonic: 'ex', form: 'sp-hl' } };
-        }
-        if ((left === '(sp)' && right === 'ix') || (left === 'ix' && right === '(sp)')) {
-            return { instruction: { mnemonic: 'ex', form: 'sp-ix' } };
-        }
-        if ((left === '(sp)' && right === 'iy') || (left === 'iy' && right === '(sp)')) {
-            return { instruction: { mnemonic: 'ex', form: 'sp-iy' } };
-        }
-        return {
-            error: `ex supports "AF, AF'", "DE, HL", "(SP), HL", "(SP), IX", and "(SP), IY" only`,
-        };
+    for (const parser of INSTRUCTION_PARSERS) {
+        const result = parser(text);
+        if (result)
+            return result;
     }
+    return undefined;
+}
+function parseIncDecInstruction(text) {
     const incDec = /^(INC|DEC)(?:\s+(.*))?$/i.exec(text);
     if (incDec) {
         const mnemonic = (incDec[1] ?? '').toLowerCase();
-        const operandText = incDec[2] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length !== 1) {
-            return { error: `${mnemonic} expects one operand` };
-        }
-        const indexedBracket = indexedBracketError(parts[0] ?? '');
-        if (indexedBracket) {
-            return { error: indexedBracket };
-        }
-        const operand = parseIncDecOperand(parts[0] ?? '');
-        return operand
-            ? { instruction: { mnemonic, operand } }
-            : { error: `${mnemonic} expects r8/rr/(hl) operand` };
+        return parseIncDecOperands(mnemonic, incDec[2] ?? '');
     }
+    return undefined;
+}
+function parseIncDecOperands(mnemonic, operandText) {
+    const parts = splitInstructionOperands(operandText);
+    if (operandText.trim().length === 0 || parts.length !== 1) {
+        return { error: `${mnemonic} expects one operand` };
+    }
+    const indexedBracket = indexedBracketError(parts[0] ?? '');
+    if (indexedBracket) {
+        return { error: indexedBracket };
+    }
+    const operand = parseIncDecOperand(parts[0] ?? '');
+    return operand
+        ? { instruction: { mnemonic, operand } }
+        : { error: `${mnemonic} expects r8/rr/(hl) operand` };
+}
+function parseStackInstruction(text) {
     const stack = /^(PUSH|POP)(?:\s+(.*))?$/i.exec(text);
     if (stack) {
         const mnemonic = (stack[1] ?? '').toLowerCase();
@@ -169,900 +69,214 @@ export function parseZ80Instruction(text) {
             ? { instruction: { mnemonic, register } }
             : { error: `${mnemonic} supports BC/DE/HL/AF/IX/IY only` };
     }
-    const ld = /^LD\s+(.+)$/i.exec(text);
-    if (ld) {
-        const operandText = ld[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (parts.length !== 2) {
-            return { error: 'ld expects two operands' };
-        }
-        const indexedBracket = indexedBracketError(parts[0] ?? '') ?? indexedBracketError(parts[1] ?? '');
-        if (indexedBracket) {
-            return { error: indexedBracket };
-        }
-        const leftText = parts[0] ?? '';
-        const rightText = parts[1] ?? '';
-        if (/^AF$/i.test(leftText) || /^AF$/i.test(rightText)) {
-            return { error: 'ld does not support AF in this form' };
-        }
-        const target = parseLdOperand(leftText);
-        const source = parseLdOperand(rightText);
-        if (!target || !source) {
-            const operandDiagnostics = [
-                ...invalidLdOperandDiagnostics(leftText),
-                ...invalidLdOperandDiagnostics(rightText),
-            ];
-            if (operandDiagnostics.length > 0) {
-                const error = operandDiagnostics[operandDiagnostics.length - 1];
-                return {
-                    error,
-                    diagnostics: operandDiagnostics,
-                };
-            }
-            return { error: 'ld expects a supported register/memory/immediate transfer form' };
-        }
-        if (target.kind === 'reg8' &&
-            target.register !== 'a' &&
-            source.kind === 'reg-indirect' &&
-            source.register !== 'hl') {
-            return { error: 'ld r8, (bc/de) supports destination A only' };
-        }
-        if (target.kind === 'reg-indirect' &&
-            source.kind === 'reg8' &&
-            source.register !== 'a' &&
-            target.register !== 'hl') {
-            return { error: 'ld (bc/de), r8 supports source A only' };
-        }
-        if (target.kind === 'reg-half-index' && source.kind === 'reg-indirect') {
-            return {
-                error: `ld ${target.register.toUpperCase()}, source expects (ix+disp)`,
-            };
-        }
-        const unsupportedReason = unsupportedLdReason(target, source);
-        if (unsupportedReason) {
-            return { error: unsupportedReason };
-        }
-        if (!isSupportedLd(target, source)) {
-            return { error: 'ld expects a supported register/memory/immediate transfer form' };
-        }
-        return { instruction: { mnemonic: 'ld', target, source } };
-    }
+    return undefined;
+}
+function parseBitLikeInstruction(text) {
     const bitLike = /^(BIT|RES|SET)(?:\s+(.*))?$/i.exec(text);
     if (bitLike) {
         const mnemonic = (bitLike[1] ?? '').toLowerCase();
-        const operandText = bitLike[2] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0 || parts.length < 2) {
-            return {
-                error: mnemonic === 'bit'
-                    ? 'bit expects two operands'
-                    : `${mnemonic} expects two operands, or three with indexed source + reg8 destination`,
-            };
-        }
-        if (mnemonic === 'bit' && parts.length !== 2) {
-            return { error: 'bit expects two operands' };
-        }
-        if (mnemonic !== 'bit' && parts.length > 3) {
-            return {
-                error: `${mnemonic} expects two operands, or three with indexed source + reg8 destination`,
-            };
-        }
-        const bit = parseBitIndex(parts[0] ?? '');
-        if (bit === undefined) {
-            return { error: `${mnemonic} expects bit index 0..7` };
-        }
-        const operand = parseCbOperand(parts[1] ?? '');
-        if (!operand) {
-            return { error: `${mnemonic} expects reg8 or (hl)` };
-        }
-        if (parts.length === 2) {
-            return { instruction: { mnemonic, bit, operand } };
-        }
-        if (operand.kind !== 'indexed') {
-            return { error: `${mnemonic} b,(ix/iy+disp),r requires an indexed memory source` };
-        }
-        const destination = parseRegister8Operand(parts[2] ?? '');
-        if (destination) {
-            return { instruction: { mnemonic, bit, operand, destination } };
-        }
-        const halfDestination = parseIndexHalfRegister(parts[2] ?? '');
-        if (halfDestination) {
-            return halfIndexFamilyFromRegister(halfDestination) === operand.register
-                ? {
-                    error: `${mnemonic} indexed destination must use plain reg8 B/C/D/E/H/L/A`,
-                }
-                : {
-                    error: `${mnemonic} indexed destination family must match source index base`,
-                };
-        }
-        return { error: `${mnemonic} b,(ix/iy+disp),r expects reg8 destination` };
-    }
-    const rotateShift = /^(RLC|RRC|RL|RR|SLA|SRA|SLL|SLS|SRL)(?:\s+(.*))?$/i.exec(text);
-    if (rotateShift) {
-        const mnemonic = (rotateShift[1] ?? '').toLowerCase();
-        const operandText = rotateShift[2] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0) {
-            return {
-                error: `${mnemonic} expects one operand, or two with indexed source + reg8 destination`,
-            };
-        }
-        if (parts.length > 2) {
-            return {
-                error: `${mnemonic} expects one operand, or two with indexed source + reg8 destination`,
-            };
-        }
-        if (parts.length === 2) {
-            const operand = parseCbOperand(parts[0] ?? '');
-            if (operand?.kind !== 'indexed') {
-                return { error: `${mnemonic} two-operand form requires (ix/iy+disp) source` };
-            }
-            const destination = parseRegister8Operand(parts[1] ?? '');
-            if (destination) {
-                return { instruction: { mnemonic, operand, destination } };
-            }
-            const halfDestination = parseIndexHalfRegister(parts[1] ?? '');
-            if (halfDestination) {
-                return halfIndexFamilyFromRegister(halfDestination) === operand.register
-                    ? {
-                        error: `${mnemonic} indexed destination must use plain reg8 B/C/D/E/H/L/A`,
-                    }
-                    : {
-                        error: `${mnemonic} indexed destination family must match source index base`,
-                    };
-            }
-            return { error: `${mnemonic} (ix/iy+disp),r expects reg8 destination` };
-        }
-        if (parts.length !== 1) {
-            return {
-                error: `${mnemonic} expects one operand, or two with indexed source + reg8 destination`,
-            };
-        }
-        const operand = parseCbOperand(parts[0] ?? '');
-        return operand
-            ? { instruction: { mnemonic, operand } }
-            : { error: `${mnemonic} expects reg8 or (hl)` };
-    }
-    const accumulatorAlu = /^(ADD|ADC|SBC)(?:\s+(.*))?$/i.exec(text);
-    if (accumulatorAlu) {
-        const mnemonic = (accumulatorAlu[1] ?? '').toLowerCase();
-        const operandText = accumulatorAlu[2] ?? '';
-        if (operandText.trim().length === 0) {
-            return {
-                error: mnemonic === 'add'
-                    ? 'add expects two operands'
-                    : `${mnemonic} expects one operand, two with destination A, or HL,rr form`,
-            };
-        }
-        const parts = splitInstructionOperands(operandText);
-        if (parts.length !== 2) {
-            return {
-                error: mnemonic === 'add'
-                    ? 'add expects two operands'
-                    : `${mnemonic} expects one operand, two with destination A, or HL,rr form`,
-            };
-        }
-        const target = parseRegister8Operand(parts[0] ?? '');
-        if (target?.register === 'a') {
-            const source = parseAluOperand(parts[1] ?? '');
-            if (!source) {
-                return { error: `invalid ${mnemonic.toUpperCase()} operand: ${parts[1] ?? ''}` };
-            }
-            const imm8Error = source.kind === 'imm' ? aluImm8RangeError(source.expression, mnemonic) : undefined;
-            if (imm8Error) {
-                return { error: imm8Error };
-            }
-            return { instruction: { mnemonic, source } };
-        }
-        const target16 = parseRegister16Operand(parts[0] ?? '');
-        if (target16?.register === 'hl') {
-            const source = parseRegister16Operand(parts[1] ?? '');
-            return source
-                ? { instruction: { mnemonic: mnemonic, target: target16, source } }
-                : { error: `${mnemonic} HL, rr expects BC/DE/HL/SP` };
-        }
-        const targetIndex16 = parseIndexRegister16(parts[0] ?? '');
-        if (mnemonic === 'add' && targetIndex16) {
-            const target = { kind: 'reg-index16', register: targetIndex16 };
-            const source16 = parseRegister16Operand(parts[1] ?? '');
-            if (source16 && source16.register !== 'hl') {
-                return { instruction: { mnemonic, target, source: source16 } };
-            }
-            const sourceIndex16 = parseIndexRegister16(parts[1] ?? '');
-            if (sourceIndex16 === targetIndex16) {
-                return {
-                    instruction: {
-                        mnemonic,
-                        target,
-                        source: { kind: 'reg-index16', register: sourceIndex16 },
-                    },
-                };
-            }
-            return {
-                error: `add ${targetIndex16.toUpperCase()}, rr supports BC/DE/SP and same-index pair only`,
-            };
-        }
-        return mnemonic === 'add'
-            ? { error: 'add expects destination A, HL, IX, or IY' }
-            : { error: `${mnemonic} expects destination A or HL` };
-    }
-    const alu = /^(SUB|AND|OR|XOR|CP)(?:\s+(.*))?$/i.exec(text);
-    if (alu) {
-        const mnemonic = (alu[1] ?? '').toLowerCase();
-        const operandText = alu[2] ?? '';
-        if (operandText.trim().length === 0) {
-            return { error: `${mnemonic} expects one operand, or two with destination A` };
-        }
-        const parts = splitInstructionOperands(operandText);
-        if (parts.length === 2) {
-            const target = parseRegister8Operand(parts[0] ?? '');
-            if (target?.register === 'a') {
-                const source = parseAluOperand(parts[1] ?? '');
-                if (!source) {
-                    return { error: `invalid ${mnemonic.toUpperCase()} operand: ${parts[1] ?? ''}` };
-                }
-                const imm8Error = source.kind === 'imm' ? aluImm8RangeError(source.expression, mnemonic) : undefined;
-                if (imm8Error) {
-                    return { error: imm8Error };
-                }
-                return { instruction: { mnemonic, source } };
-            }
-            return { error: `${mnemonic} two-operand form requires destination A` };
-        }
-        if (parts.length !== 1) {
-            return { error: `${mnemonic} expects one operand, or two with destination A` };
-        }
-        const source = parseAluOperand(parts[0] ?? '');
-        if (!source) {
-            return { error: `invalid ${mnemonic.toUpperCase()} operand: ${operandText}` };
-        }
-        const imm8Error = source.kind === 'imm' ? aluImm8RangeError(source.expression, mnemonic) : undefined;
-        if (imm8Error) {
-            return { error: imm8Error };
-        }
-        return { instruction: { mnemonic, source } };
-    }
-    const jump = /^JP(?:\s+(.*))?$/i.exec(text);
-    if (jump) {
-        const operandText = jump[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0) {
-            return {
-                error: 'jp expects one operand (nn/(hl)/(ix)/(iy)) or two operands (cc, nn)',
-            };
-        }
-        if (parts.length === 2) {
-            const condition = parseCondition(parts[0] ?? '');
-            if (!condition) {
-                return { error: 'jp cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M' };
-            }
-            const targetText = parts[1] ?? '';
-            if (/^\(.*\)$/.test(targetText.trim())) {
-                return { error: 'jp cc, nn does not support indirect targets' };
-            }
-            const expression = parseAbsoluteBranchTarget(targetText);
-            return expression
-                ? { instruction: { mnemonic: 'jp-cc', condition, expression } }
-                : { error: 'jp cc, nn expects imm16' };
-        }
-        if (parts.length !== 1) {
-            return {
-                error: 'jp expects one operand (nn/(hl)/(ix)/(iy)) or two operands (cc, nn)',
-            };
-        }
-        const single = parts[0] ?? '';
-        const condition = parseCondition(single);
-        if (condition) {
-            return { error: 'jp cc, nn expects two operands (cc, nn)' };
-        }
-        const indirect = parseJumpIndirect(single);
-        if (indirect) {
-            return { instruction: { mnemonic: 'jp-indirect', register: indirect } };
-        }
-        if (/^\(.*\)$/.test(single.trim())) {
-            return { error: 'jp indirect form supports (hl), (ix), or (iy) only' };
-        }
-        if (isRegisterName(single)) {
-            if (/^(HL|IX|IY)$/i.test(single.trim())) {
-                return { error: 'jp indirect form requires parentheses; use (hl), (ix), or (iy)' };
-            }
-            return { error: 'jp does not support register targets; use imm16' };
-        }
-        const expression = parseExpression(single);
-        return expression
-            ? { instruction: { mnemonic: 'jp', expression } }
-            : { error: `invalid JP target: ${single}` };
-    }
-    const call = /^CALL(?:\s+(.*))?$/i.exec(text);
-    if (call) {
-        const operandText = call[1] ?? '';
-        const parts = splitInstructionOperands(operandText);
-        if (operandText.trim().length === 0) {
-            return { error: 'call expects one operand (nn) or two operands (cc, nn)' };
-        }
-        if (parts.length === 2) {
-            const condition = parseCondition(parts[0] ?? '');
-            if (!condition) {
-                return { error: 'call cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M' };
-            }
-            const targetText = parts[1] ?? '';
-            if (/^\(.*\)$/.test(targetText.trim())) {
-                return { error: 'call cc, nn does not support indirect targets' };
-            }
-            const expression = parseAbsoluteBranchTarget(targetText);
-            return expression
-                ? { instruction: { mnemonic: 'call-cc', condition, expression } }
-                : { error: 'call cc, nn expects imm16' };
-        }
-        if (parts.length !== 1) {
-            return { error: 'call expects one operand (nn) or two operands (cc, nn)' };
-        }
-        const single = parts[0] ?? '';
-        const condition = parseCondition(single);
-        if (condition) {
-            return { error: 'call cc, nn expects two operands (cc, nn)' };
-        }
-        if (/^\(.*\)$/.test(single.trim())) {
-            return { error: 'call does not support indirect targets; use imm16' };
-        }
-        if (isRegisterName(single)) {
-            return { error: 'call does not support register targets; use imm16' };
-        }
-        const expression = parseExpression(single);
-        return expression
-            ? { instruction: { mnemonic: 'call', expression } }
-            : { error: `invalid CALL target: ${single}` };
-    }
-    const relativeBranch = /^(JR|DJNZ)(?:\s+(.*))?$/i.exec(text);
-    if (relativeBranch) {
-        const mnemonic = (relativeBranch[1] ?? '').toLowerCase();
-        const operandText = (relativeBranch[2] ?? '').trim();
-        if (operandText.length === 0) {
-            return {
-                error: mnemonic === 'djnz'
-                    ? 'djnz expects one operand (disp8)'
-                    : 'jr expects one operand (disp8) or two operands (cc, disp8)',
-            };
-        }
-        const parts = splitInstructionOperands(operandText);
-        if (mnemonic === 'djnz') {
-            if (parts.length !== 1) {
-                return { error: 'djnz expects one operand (disp8)' };
-            }
-            const targetText = parts[0] ?? '';
-            const targetError = relativeDispTargetError(targetText, {
-                indirect: 'djnz does not support indirect targets; expects disp8',
-                register: 'djnz does not support register targets; expects disp8',
-            });
-            if (targetError) {
-                return { error: targetError };
-            }
-            const expression = parseExpression(targetText);
-            return expression
-                ? { instruction: { mnemonic: 'djnz', expression } }
-                : { error: 'djnz expects disp8' };
-        }
-        if (parts.length === 1) {
-            const targetText = parts[0] ?? '';
-            const targetError = relativeDispTargetError(targetText, {
-                indirect: 'jr does not support indirect targets; expects disp8',
-                register: 'jr does not support register targets; expects disp8',
-            });
-            if (targetError) {
-                return { error: targetError };
-            }
-            if (parseRelativeCondition(targetText)) {
-                return { error: 'jr cc, disp expects two operands (cc, disp8)' };
-            }
-            const expression = parseExpression(targetText);
-            return expression
-                ? { instruction: { mnemonic: 'jr', expression } }
-                : { error: 'jr expects disp8' };
-        }
-        if (parts.length === 2) {
-            const condition = parseRelativeCondition(parts[0] ?? '');
-            if (!condition) {
-                return { error: 'jr cc expects valid condition code NZ/Z/NC/C' };
-            }
-            const targetText = parts[1] ?? '';
-            const targetError = relativeDispTargetError(targetText, {
-                indirect: 'jr cc, disp does not support indirect targets',
-                register: 'jr cc, disp does not support register targets; expects disp8',
-            });
-            if (targetError) {
-                return { error: targetError };
-            }
-            const expression = parseExpression(targetText);
-            return expression
-                ? { instruction: { mnemonic: 'jr-cc', condition, expression } }
-                : { error: 'jr cc, disp expects disp8' };
-        }
-        return { error: 'jr expects one operand (disp8) or two operands (cc, disp8)' };
+        return parseBitLikeOperands(mnemonic, bitLike[2] ?? '');
     }
     return undefined;
 }
-function parseLdOperand(text) {
-    const trimmed = text.trim();
-    const indexed = parseIndexedOperand(trimmed);
-    if (indexed) {
-        return indexed;
-    }
-    const memory = /^\((BC|DE|HL)\)$/i.exec(trimmed);
-    if (memory) {
-        return {
-            kind: 'reg-indirect',
-            register: (memory[1] ?? '').toLowerCase(),
-        };
+function parseBitLikeOperands(mnemonic, operandText) {
+    const parts = splitInstructionOperands(operandText);
+    const arityError = bitLikeArityError(mnemonic, operandText, parts.length);
+    if (arityError)
+        return { error: arityError };
+    const bit = parseBitIndex(parts[0] ?? '');
+    if (bit === undefined) {
+        return { error: `${mnemonic} expects bit index 0..7` };
     }
-    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
-        const expression = parseExpression(trimmed.slice(1, -1).trim());
-        return expression ? { kind: 'mem-abs', expression } : undefined;
-    }
-    if (/^(A|B|C|D|E|H|L)$/i.test(trimmed)) {
-        return { kind: 'reg8', register: trimmed.toLowerCase() };
-    }
-    const index16 = parseIndexRegister16(trimmed);
-    if (index16) {
-        return { kind: 'reg-index16', register: index16 };
-    }
-    const half = parseIndexHalfRegister(trimmed);
-    if (half) {
-        return { kind: 'reg-half-index', register: half };
-    }
-    if (/^(BC|DE|HL|SP)$/i.test(trimmed)) {
-        return parseRegister16Operand(trimmed);
-    }
-    const special8 = parseSpecialRegister8(trimmed);
-    if (special8) {
-        return { kind: 'special8', register: special8 };
-    }
-    const expression = parseExpression(trimmed);
-    return expression ? { kind: 'imm', expression } : undefined;
+    return parseBitLikeTarget(mnemonic, bit, parts);
 }
-function invalidLdOperandDiagnostics(text) {
-    const trimmed = text.trim();
-    if (trimmed === '?') {
-        return ['Invalid imm expression: ?', 'Unsupported operand: ?'];
+function parseBitLikeTarget(mnemonic, bit, parts) {
+    const operand = parseCbOperand(parts[1] ?? '');
+    if (!operand) {
+        return { error: `${mnemonic} expects reg8 or (hl)` };
     }
-    if (trimmed.startsWith("'") && parseExpression(trimmed) === undefined) {
-        return [`Invalid imm expression: ${trimmed}`];
-    }
-    return [];
+    return parts.length === 2
+        ? { instruction: { mnemonic, bit, operand } }
+        : parseIndexedBitDestination(mnemonic, bit, operand, parts[2] ?? '');
 }
-function aluImm8RangeError(expression, mnemonic) {
-    const value = constantExpressionValue(expression);
-    if (value === undefined) {
-        return undefined;
+function bitLikeArityError(mnemonic, operandText, partCount) {
+    if (operandText.trim().length === 0 || partCount < 2) {
+        return bitLikeOperandCountError(mnemonic);
     }
-    if (value < -128 || value > 255) {
-        return `${mnemonic} expects imm8`;
+    if (mnemonic === 'bit' && partCount !== 2) {
+        return 'bit expects two operands';
     }
-    return undefined;
+    return mnemonic !== 'bit' && partCount > 3 ? bitLikeOperandCountError(mnemonic) : undefined;
 }
-function parseRelativeCondition(text) {
-    const trimmed = text.trim().toLowerCase();
-    return /^(nz|z|nc|c)$/.test(trimmed) ? trimmed : undefined;
+function bitLikeOperandCountError(mnemonic) {
+    return mnemonic === 'bit'
+        ? 'bit expects two operands'
+        : `${mnemonic} expects two operands, or three with indexed source + reg8 destination`;
 }
-function relativeDispTargetError(text, messages) {
-    const trimmed = text.trim();
-    if (/^\(.*\)$/.test(trimmed)) {
-        return messages.indirect;
+function parseIndexedBitDestination(mnemonic, bit, operand, destinationText) {
+    if (operand.kind !== 'indexed') {
+        return { error: `${mnemonic} b,(ix/iy+disp),r requires an indexed memory source` };
     }
-    if (isRegisterName(trimmed)) {
-        return messages.register;
+    const destination = parseRegister8Operand(destinationText);
+    if (destination) {
+        return { instruction: { mnemonic, bit, operand, destination } };
     }
-    const expression = parseExpression(trimmed);
-    if (expression?.kind === 'symbol' && isRegisterName(expression.name)) {
-        return messages.register;
+    const destinationError = indexedDestinationError(mnemonic, destinationText, operand.register);
+    return { error: destinationError ?? `${mnemonic} b,(ix/iy+disp),r expects reg8 destination` };
+}
+function parseRotateShiftInstruction(text) {
+    const rotateShift = /^(RLC|RRC|RL|RR|SLA|SRA|SLL|SLS|SRL)(?:\s+(.*))?$/i.exec(text);
+    if (rotateShift) {
+        const mnemonic = (rotateShift[1] ?? '').toLowerCase();
+        return parseRotateShiftOperands(mnemonic, rotateShift[2] ?? '');
     }
     return undefined;
 }
-function parseAluOperand(text) {
-    const trimmed = text.trim();
-    const indexed = parseIndexedOperand(trimmed);
-    if (indexed) {
-        return indexed;
-    }
-    const memory = /^\(HL\)$/i.exec(trimmed);
-    if (memory) {
-        return { kind: 'reg-indirect', register: 'hl' };
-    }
-    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+function parseRotateShiftOperands(mnemonic, operandText) {
+    const parts = splitInstructionOperands(operandText);
+    const arityError = rotateShiftArityError(mnemonic, operandText, parts.length);
+    if (arityError)
+        return { error: arityError };
+    if (parts.length === 2) {
+        return parseIndexedRotateShift(mnemonic, parts[0] ?? '', parts[1] ?? '');
+    }
+    const operand = parseCbOperand(parts[0] ?? '');
+    return operand
+        ? { instruction: { mnemonic, operand } }
+        : { error: `${mnemonic} expects reg8 or (hl)` };
+}
+function rotateShiftArityError(mnemonic, operandText, partCount) {
+    const message = `${mnemonic} expects one operand, or two with indexed source + reg8 destination`;
+    return operandText.trim().length === 0 || partCount < 1 || partCount > 2 ? message : undefined;
+}
+function parseIndexedRotateShift(mnemonic, operandText, destinationText) {
+    const operand = parseCbOperand(operandText);
+    if (operand?.kind !== 'indexed') {
+        return { error: `${mnemonic} two-operand form requires (ix/iy+disp) source` };
+    }
+    const destination = parseRegister8Operand(destinationText);
+    if (destination) {
+        return { instruction: { mnemonic, operand, destination } };
+    }
+    const destinationError = indexedDestinationError(mnemonic, destinationText, operand.register);
+    return { error: destinationError ?? `${mnemonic} (ix/iy+disp),r expects reg8 destination` };
+}
+function indexedDestinationError(mnemonic, destinationText, sourceIndex) {
+    const halfDestination = parseIndexHalfRegister(destinationText);
+    if (!halfDestination) {
         return undefined;
     }
-    const register = parseRegister8Operand(trimmed);
-    if (register) {
-        return register;
-    }
-    const half = parseIndexHalfRegister(trimmed);
-    if (half) {
-        return { kind: 'reg-half-index', register: half };
-    }
-    const expression = parseExpression(trimmed);
-    return expression ? { kind: 'imm', expression } : undefined;
-}
-function parseCbOperand(text) {
-    const trimmed = text.trim();
-    const indexed = parseIndexedOperand(trimmed);
-    if (indexed) {
-        return indexed;
-    }
-    if (/^\(HL\)$/i.test(trimmed)) {
-        return { kind: 'reg-indirect', register: 'hl' };
-    }
-    return parseRegister8Operand(trimmed);
-}
-function parseRegister8Operand(text) {
-    const trimmed = text.trim();
-    if (/^(A|B|C|D|E|H|L)$/i.test(trimmed)) {
-        return { kind: 'reg8', register: trimmed.toLowerCase() };
-    }
-    return undefined;
+    return halfIndexFamilyFromRegister(halfDestination) === sourceIndex
+        ? `${mnemonic} indexed destination must use plain reg8 B/C/D/E/H/L/A`
+        : `${mnemonic} indexed destination family must match source index base`;
 }
-function parseRegister16Operand(text) {
-    const trimmed = text.trim();
-    if (/^(BC|DE|HL|SP)$/i.test(trimmed)) {
-        return { kind: 'reg16', register: trimmed.toLowerCase() };
+function parseAccumulatorAluInstruction(text) {
+    const accumulatorAlu = /^(ADD|ADC|SBC)(?:\s+(.*))?$/i.exec(text);
+    if (accumulatorAlu) {
+        const mnemonic = (accumulatorAlu[1] ?? '').toLowerCase();
+        return parseAccumulatorAluOperands(mnemonic, accumulatorAlu[2] ?? '');
     }
     return undefined;
 }
-function parseIncDecOperand(text) {
-    const trimmed = text.trim();
-    const indexed = parseIndexedOperand(trimmed);
-    if (indexed) {
-        return indexed;
-    }
-    if (/^\(HL\)$/i.test(trimmed)) {
-        return { kind: 'reg-indirect', register: 'hl' };
-    }
-    const register8 = parseRegister8Operand(trimmed);
-    if (register8) {
-        return register8;
-    }
-    const register16 = parseRegister16Operand(trimmed);
-    if (register16) {
-        return register16;
-    }
-    const index16 = parseIndexRegister16(trimmed);
-    if (index16) {
-        return { kind: 'reg16', register: index16 };
-    }
-    const half = parseIndexHalfRegister(trimmed);
-    return half ? { kind: 'reg-half-index', register: half } : undefined;
-}
-function parseIndexRegister16(text) {
-    const trimmed = text.trim();
-    return /^(IX|IY)$/i.test(trimmed) ? trimmed.toLowerCase() : undefined;
-}
-function parseIndexHalfRegister(text) {
-    const trimmed = text.trim();
-    return /^(IXH|IXL|IYH|IYL)$/i.test(trimmed)
-        ? trimmed.toLowerCase()
-        : undefined;
-}
-function halfIndexFamilyFromRegister(register) {
-    return register.startsWith('ix') ? 'ix' : 'iy';
-}
-function parseSpecialRegister8(text) {
-    const trimmed = text.trim();
-    return /^(I|R)$/i.test(trimmed) ? trimmed.toLowerCase() : undefined;
-}
-function parseStackRegister(text) {
-    const trimmed = text.trim();
-    return /^(BC|DE|HL|AF|IX|IY)$/i.test(trimmed)
-        ? trimmed.toLowerCase()
-        : undefined;
-}
-function parseIndexedOperand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-        return undefined;
-    }
-    const inner = trimmed.slice(1, -1).trim();
-    const match = /^(IX|IY)(?:\s*([+-])\s*(.+))?$/i.exec(inner);
-    if (!match) {
-        return undefined;
-    }
-    const register = (match[1] ?? '').toLowerCase();
-    const sign = match[2];
-    const displacementText = match[3] ?? '0';
-    const parsed = parseExpression(sign === '-' ? `-${displacementText}` : displacementText);
-    if (!parsed) {
+function parseAccumulatorAluOperands(mnemonic, operandText) {
+    const arityError = accumulatorAluArityError(mnemonic, operandText);
+    if (arityError)
+        return { error: arityError };
+    const parts = splitInstructionOperands(operandText);
+    if (parts.length !== 2)
+        return { error: accumulatorAluOperandCountError(mnemonic) };
+    return parseAccumulatorAluTarget(mnemonic, parts[0] ?? '', parts[1] ?? '');
+}
+function accumulatorAluArityError(mnemonic, operandText) {
+    return operandText.trim().length === 0 ? accumulatorAluOperandCountError(mnemonic) : undefined;
+}
+function accumulatorAluOperandCountError(mnemonic) {
+    return mnemonic === 'add'
+        ? 'add expects two operands'
+        : `${mnemonic} expects one operand, two with destination A, or HL,rr form`;
+}
+function parseAccumulatorAluTarget(mnemonic, targetText, sourceText) {
+    for (const parser of ACCUMULATOR_ALU_TARGET_PARSERS) {
+        const result = parser(mnemonic, targetText, sourceText);
+        if (result)
+            return result;
+    }
+    return mnemonic === 'add'
+        ? { error: 'add expects destination A, HL, IX, or IY' }
+        : { error: `${mnemonic} expects destination A or HL` };
+}
+const ACCUMULATOR_ALU_TARGET_PARSERS = [
+    parseAccumulatorRegisterAlu,
+    parseHlRegisterAlu,
+    parseIndexRegisterAdd,
+];
+function parseAccumulatorRegisterAlu(mnemonic, targetText, sourceText) {
+    const target = parseRegister8Operand(targetText);
+    return target?.register === 'a' ? parseAccumulatorAluSource(mnemonic, sourceText) : undefined;
+}
+function parseHlRegisterAlu(mnemonic, targetText, sourceText) {
+    const target16 = parseRegister16Operand(targetText);
+    if (target16?.register !== 'hl')
         return undefined;
-    }
-    return { kind: 'indexed', register, displacement: parsed };
-}
-function parsePortOperand(text) {
-    const trimmed = text.trim();
-    if (/^\(C\)$/i.test(trimmed)) {
-        return { kind: 'c' };
-    }
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-        return undefined;
-    }
-    const expression = parseExpression(trimmed.slice(1, -1).trim());
-    return expression ? { kind: 'imm', expression } : undefined;
-}
-function indexedBracketError(text) {
-    const match = /^\(?\s*((IX|IY)\s*\[\s*.+?\s*\])\s*\)?$/i.exec(text.trim());
-    return match
-        ? `Indexed memory operands use (ix+disp)/(iy+disp), not ${match[1]?.toLowerCase().replace(/\s+/g, '')}.`
+    const source = parseRegister16Operand(sourceText);
+    return source
+        ? { instruction: { mnemonic: mnemonic, target: target16, source } }
+        : { error: `${mnemonic} HL, rr expects BC/DE/HL/SP` };
+}
+function parseIndexRegisterAdd(mnemonic, targetText, sourceText) {
+    const targetIndex16 = parseIndexRegister16(targetText);
+    return mnemonic === 'add' && targetIndex16
+        ? parseIndexedAdd(targetIndex16, sourceText)
         : undefined;
 }
-function parseAbsoluteBranchTarget(text) {
-    const trimmed = text.trim();
-    if (/^\(.*\)$/.test(trimmed) || isRegisterName(trimmed)) {
-        return undefined;
+function parseAccumulatorAluSource(mnemonic, sourceText) {
+    const source = parseAluOperand(sourceText);
+    if (!source) {
+        return { error: `invalid ${mnemonic.toUpperCase()} operand: ${sourceText}` };
     }
-    return parseExpression(trimmed);
-}
-function parseCondition(text) {
-    const trimmed = text.trim();
-    return /^(NZ|Z|NC|C|PO|PE|P|M)$/i.test(trimmed)
-        ? trimmed.toLowerCase()
-        : undefined;
-}
-function parseJumpIndirect(text) {
-    const indirect = /^\((HL|IX|IY)\)$/i.exec(text.trim());
-    return indirect ? (indirect[1] ?? '').toLowerCase() : undefined;
+    const imm8Error = source.kind === 'imm' ? aluImm8RangeError(source.expression, mnemonic) : undefined;
+    return imm8Error ? { error: imm8Error } : { instruction: { mnemonic, source } };
 }
-function isRegisterName(text) {
-    return /^(A|B|C|D|E|H|L|I|R|AF|BC|DE|HL|SP|IX|IY|IXH|IXL|IYH|IYL)$/i.test(text.trim());
-}
-function parseConstantExpression(text) {
-    const expression = parseExpression(text);
-    return expression ? constantExpressionValue(expression) : undefined;
-}
-function isRstVector(value) {
-    return (value === 0 ||
-        value === 8 ||
-        value === 16 ||
-        value === 24 ||
-        value === 32 ||
-        value === 40 ||
-        value === 48 ||
-        value === 56);
-}
-function parseBitIndex(text) {
-    const value = parseConstantExpression(text);
-    return isBitIndex(value) ? value : undefined;
-}
-function isBitIndex(value) {
-    return (value === 0 ||
-        value === 1 ||
-        value === 2 ||
-        value === 3 ||
-        value === 4 ||
-        value === 5 ||
-        value === 6 ||
-        value === 7);
-}
-function constantExpressionValue(expression) {
-    switch (expression.kind) {
-        case 'number':
-            return expression.value;
-        case 'unary':
-            return constantUnaryExpressionValue(expression);
-        case 'binary':
-            return constantBinaryExpressionValue(expression);
-        case 'symbol':
-        case 'current-location':
-            return undefined;
-    }
-}
-function constantUnaryExpressionValue(expression) {
-    const value = constantExpressionValue(expression.expression);
-    if (value === undefined) {
-        return undefined;
-    }
-    switch (expression.operator) {
-        case '+':
-            return value;
-        case '-':
-            return -value;
-        case '~':
-            return ~value;
-    }
-}
-function constantBinaryExpressionValue(expression) {
-    const left = constantExpressionValue(expression.left);
-    const right = constantExpressionValue(expression.right);
-    if (left === undefined || right === undefined) {
-        return undefined;
-    }
-    switch (expression.operator) {
-        case '+':
-            return left + right;
-        case '-':
-            return left - right;
-        case '*':
-            return left * right;
-        case '/':
-            return Math.trunc(left / right);
-        case '%':
-            return left % right;
-        case '&':
-            return left & right;
-        case '^':
-            return left ^ right;
-        case '|':
-            return left | right;
-        case '<<':
-            return left << right;
-        case '>>':
-            return left >> right;
-    }
-}
-function splitInstructionOperands(text) {
-    const values = [];
-    let depth = 0;
-    let quote;
-    let escaped = false;
-    let start = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\' && quote) {
-            escaped = true;
-            continue;
-        }
-        if ((char === '"' || char === "'") &&
-            !(char === "'" && quote === undefined && /[A-Za-z0-9_]/.test(text[index - 1] ?? ''))) {
-            quote = quote === char ? undefined : (quote ?? char);
-            continue;
-        }
-        if (quote) {
-            continue;
-        }
-        if (char === '(') {
-            depth += 1;
-        }
-        else if (char === ')') {
-            depth -= 1;
-        }
-        else if (char === ',' && depth === 0) {
-            values.push(text.slice(start, index));
-            start = index + 1;
-        }
-    }
-    values.push(text.slice(start));
-    return values.map((value) => value.trim());
-}
-function isSupportedLd(target, source) {
-    if (isSupportedSpecialRegisterLd(target, source)) {
-        return true;
-    }
-    if (isSupportedHalfIndexLd(target, source)) {
-        return true;
-    }
-    if (target.kind === 'reg8' && (source.kind === 'reg8' || source.kind === 'imm')) {
-        return true;
-    }
-    if (target.kind === 'reg8' && source.kind === 'indexed') {
-        return true;
-    }
-    if (target.kind === 'indexed' && (source.kind === 'reg8' || source.kind === 'imm')) {
-        return true;
-    }
-    if (target.kind === 'reg16' && source.kind === 'imm') {
-        return true;
-    }
-    if (target.kind === 'reg16' &&
-        source.kind === 'reg16' &&
-        isLegacyReg16ByteTransferPair(target.register, source.register)) {
-        return true;
+function parseIndexedAdd(targetIndex16, sourceText) {
+    const target = { kind: 'reg-index16', register: targetIndex16 };
+    const source16 = parseRegister16Operand(sourceText);
+    if (source16 && source16.register !== 'hl') {
+        return { instruction: { mnemonic: 'add', target, source: source16 } };
     }
-    if (target.kind === 'reg-index16' && source.kind === 'imm') {
-        return true;
-    }
-    if (target.kind === 'reg16' &&
-        target.register === 'sp' &&
-        (source.kind === 'reg16' || source.kind === 'reg-index16') &&
-        (source.register === 'hl' || source.register === 'ix' || source.register === 'iy')) {
-        return true;
-    }
-    if ((target.kind === 'reg8' || target.kind === 'reg16' || target.kind === 'reg-index16') &&
-        source.kind === 'mem-abs' &&
-        (target.kind !== 'reg8' || target.register === 'a')) {
-        return true;
-    }
-    if (target.kind === 'mem-abs' &&
-        (source.kind === 'reg16' ||
-            source.kind === 'reg-index16' ||
-            (source.kind === 'reg8' && source.register === 'a'))) {
-        return true;
-    }
-    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'reg-indirect') {
-        return true;
-    }
-    if (target.kind === 'reg-indirect' && source.kind === 'reg8' && source.register === 'a') {
-        return true;
-    }
-    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'reg8') {
-        return true;
-    }
-    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'imm') {
-        return true;
+    const sourceIndex16 = parseIndexRegister16(sourceText);
+    if (sourceIndex16 === targetIndex16) {
+        return {
+            instruction: {
+                mnemonic: 'add',
+                target,
+                source: { kind: 'reg-index16', register: sourceIndex16 },
+            },
+        };
     }
-    return target.kind === 'reg8' && source.kind === 'reg-indirect' && source.register === 'hl';
+    return {
+        error: `add ${targetIndex16.toUpperCase()}, rr supports BC/DE/SP and same-index pair only`,
+    };
 }
-function unsupportedLdReason(target, source) {
-    if (isMemoryOperand(target) && isMemoryOperand(source)) {
-        return 'ld does not support memory-to-memory transfers';
-    }
-    if (hasHalfIndexRegister(target, source)) {
-        if (!isSameIndexHalfFamily(target, source)) {
-            return 'ld between IX* and IY* byte registers is not supported';
-        }
-        if (usesPlainHlCounterpart(target, source)) {
-            return 'ld with IX*/IY* does not support plain H/L counterpart operands';
-        }
-    }
-    if (target.kind === 'reg-index16' &&
-        source.kind === 'reg-index16' &&
-        target.register !== source.register) {
-        return 'ld rr, rr supports SP <- HL/IX/IY only';
-    }
-    if (target.kind === 'reg16' &&
-        source.kind !== 'imm' &&
-        (source.kind === 'reg16' || source.kind === 'reg-index16')) {
-        if (target.register === 'sp' &&
-            (source.register === 'hl' || source.register === 'ix' || source.register === 'iy')) {
-            return undefined;
-        }
-        if (source.kind === 'reg16' &&
-            isLegacyReg16ByteTransferPair(target.register, source.register)) {
-            return undefined;
-        }
-        return 'ld rr, rr supports SP <- HL/IX/IY only';
+function parseUnaryAluInstruction(text) {
+    const alu = /^(SUB|AND|OR|XOR|CP)(?:\s+(.*))?$/i.exec(text);
+    if (alu) {
+        const mnemonic = (alu[1] ?? '').toLowerCase();
+        return parseUnaryAluOperands(mnemonic, alu[2] ?? '');
     }
     return undefined;
 }
-function isLegacyReg16ByteTransferPair(target, source) {
-    return ((target === 'hl' && source === 'de') ||
-        (target === 'bc' && source === 'de'));
-}
-function isSupportedSpecialRegisterLd(target, source) {
-    return ((target.kind === 'special8' && source.kind === 'reg8' && source.register === 'a') ||
-        (target.kind === 'reg8' && target.register === 'a' && source.kind === 'special8'));
-}
-function isMemoryOperand(operand) {
-    return (operand.kind === 'reg-indirect' || operand.kind === 'indexed' || operand.kind === 'mem-abs');
-}
-function isSupportedHalfIndexLd(target, source) {
-    if (!hasHalfIndexRegister(target, source)) {
-        return false;
-    }
-    if (!isSameIndexHalfFamily(target, source) || usesPlainHlCounterpart(target, source)) {
-        return false;
+function parseUnaryAluOperands(mnemonic, operandText) {
+    const parts = splitInstructionOperands(operandText);
+    if (operandText.trim().length === 0 || (parts.length !== 1 && parts.length !== 2)) {
+        return { error: `${mnemonic} expects one operand, or two with destination A` };
     }
-    return isHalfIndexCompatibleByteOperand(target) && isHalfIndexCompatibleByteOperand(source);
-}
-function hasHalfIndexRegister(target, source) {
-    return target.kind === 'reg-half-index' || source.kind === 'reg-half-index';
-}
-function isSameIndexHalfFamily(target, source) {
-    const targetFamily = indexHalfFamily(target);
-    const sourceFamily = indexHalfFamily(source);
-    return !targetFamily || !sourceFamily || targetFamily === sourceFamily;
-}
-function indexHalfFamily(operand) {
-    if (operand.kind !== 'reg-half-index') {
-        return undefined;
-    }
-    return operand.register.startsWith('ix') ? 'ix' : 'iy';
-}
-function usesPlainHlCounterpart(target, source) {
-    return ((target.kind === 'reg-half-index' && isPlainHlReg8(source)) ||
-        (source.kind === 'reg-half-index' && isPlainHlReg8(target)));
-}
-function isPlainHlReg8(operand) {
-    return operand.kind === 'reg8' && (operand.register === 'h' || operand.register === 'l');
+    return parts.length === 2
+        ? parseTwoOperandUnaryAlu(mnemonic, parts[0] ?? '', parts[1] ?? '')
+        : parseAccumulatorAluSource(mnemonic, parts[0] ?? '');
 }
-function isHalfIndexCompatibleByteOperand(operand) {
-    return (operand.kind === 'reg-half-index' ||
-        (operand.kind === 'reg8' && operand.register !== 'h' && operand.register !== 'l'));
+function parseTwoOperandUnaryAlu(mnemonic, targetText, sourceText) {
+    const target = parseRegister8Operand(targetText);
+    return target?.register === 'a'
+        ? parseAccumulatorAluSource(mnemonic, sourceText)
+        : { error: `${mnemonic} two-operand form requires destination A` };
 }