@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/z80/effects.js

@@ -1,563 +1,100 @@
-const FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity', 'carry'];
-const INC_DEC_FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity'];
-const ROTATE_SHIFT_FLAG_WRITES = [
-    'sign',
-    'zero',
-    'halfCarry',
-    'parity',
-    'carry',
+import { accumulatorRotateEffect, aluEffect, bitEffect, blockTransferEffect, callControl, controlEffect, exEffect, inEffect, incDecEffect, jumpControl, ldEffect, outEffect, popEffect, pushEffect, rotateShiftEffect, rstControl, stackControlEffect, } from './effect-groups.js';
+import { FLAG_WRITES, baseEffect, conditionFlagRead, concatUnique, expressionSymbol, reg16Units, unknownEffect, } from './effect-units.js';
+const BASE_EFFECT_MNEMONICS = ['nop', 'halt', 'di', 'ei', 'im'];
+const STACK_RETURN_MNEMONICS = ['reti', 'retn'];
+const ALU_MNEMONICS = ['add', 'adc', 'sbc', 'sub', 'and', 'or', 'xor', 'cp'];
+const ROTATE_SHIFT_MNEMONICS = [
+    'rlc',
+    'rrc',
+    'rl',
+    'rr',
+    'sla',
+    'sra',
+    'sll',
+    'sls',
+    'srl',
 ];
-const BIT_FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity'];
-const STACK_POINTER_UNITS = ['SPH', 'SPL'];
-const UNKNOWN_UNITS = [
-    'A',
-    'B',
-    'C',
-    'D',
-    'E',
-    'H',
-    'L',
-    'IXH',
-    'IXL',
-    'IYH',
-    'IYL',
-    'SPH',
-    'SPL',
-    'carry',
-    'zero',
-    'sign',
-    'parity',
-    'halfCarry',
+const ACCUMULATOR_ROTATE_MNEMONICS = ['rlca', 'rrca', 'rla', 'rra'];
+const BIT_MNEMONICS = ['bit', 'res', 'set'];
+const BLOCK_TRANSFER_MNEMONICS = [
+    'ldi',
+    'ldir',
+    'ldd',
+    'lddr',
+    'cpi',
+    'cpir',
+    'cpd',
+    'cpdr',
+    'ini',
+    'inir',
+    'ind',
+    'indr',
+    'outi',
+    'otir',
+    'outd',
+    'otdr',
 ];
-function baseEffect() {
-    return {
-        reads: [],
-        writes: [],
-        stack: { kind: 'none' },
-        control: { kind: 'fallthrough' },
-    };
-}
-function unknownEffect() {
-    return {
-        reads: UNKNOWN_UNITS,
-        writes: UNKNOWN_UNITS,
-        stack: { kind: 'unknown' },
-        control: { kind: 'unknown' },
-    };
-}
-function appendUnique(out, units) {
-    for (const unit of units) {
-        if (!out.includes(unit))
-            out.push(unit);
-    }
-}
-function concatUnique(...groups) {
-    const out = [];
-    for (const group of groups)
-        appendUnique(out, group);
-    return out;
-}
-function reg8Units(raw) {
-    const reg = raw.toLowerCase();
-    if (reg === 'a')
-        return ['A'];
-    if (reg === 'b')
-        return ['B'];
-    if (reg === 'c')
-        return ['C'];
-    if (reg === 'd')
-        return ['D'];
-    if (reg === 'e')
-        return ['E'];
-    if (reg === 'h')
-        return ['H'];
-    if (reg === 'l')
-        return ['L'];
-    return [];
-}
-function reg16Units(raw) {
-    const reg = raw.toLowerCase();
-    if (reg === 'bc')
-        return ['B', 'C'];
-    if (reg === 'de')
-        return ['D', 'E'];
-    if (reg === 'hl')
-        return ['H', 'L'];
-    if (reg === 'sp')
-        return ['SPH', 'SPL'];
-    if (reg === 'ix')
-        return ['IXH', 'IXL'];
-    if (reg === 'iy')
-        return ['IYH', 'IYL'];
-    if (reg === 'af')
-        return ['A', ...FLAG_WRITES];
-    return [];
-}
-function regHalfUnits(raw) {
-    const reg = raw.toLowerCase();
-    if (reg === 'ixh')
-        return ['IXH'];
-    if (reg === 'ixl')
-        return ['IXL'];
-    if (reg === 'iyh')
-        return ['IYH'];
-    if (reg === 'iyl')
-        return ['IYL'];
-    return [];
-}
-function expressionSymbol(expression) {
-    return expression.kind === 'symbol' ? expression.name : undefined;
-}
-function conditionFlagRead(condition) {
-    switch (condition) {
-        case 'z':
-        case 'nz':
-            return ['zero'];
-        case 'c':
-        case 'nc':
-            return ['carry'];
-        case 'm':
-        case 'p':
-            return ['sign'];
-        case 'pe':
-        case 'po':
-            return ['parity'];
-        default:
-            return [];
-    }
-}
-function operandReads(op) {
-    switch (op.kind) {
-        case 'reg8':
-            return reg8Units(op.register);
-        case 'reg16':
-        case 'reg-index16':
-            return reg16Units(op.register);
-        case 'reg-half-index':
-            return regHalfUnits(op.register);
-        case 'special8':
-            return [];
-        case 'reg-indirect':
-            return reg16Units(op.register);
-        case 'indexed':
-            return reg16Units(op.register);
-        case 'mem-abs':
-        case 'imm':
-            return [];
-        default:
-            return undefined;
-    }
-}
-function operandWrites(op) {
-    switch (op.kind) {
-        case 'reg8':
-            return reg8Units(op.register);
-        case 'reg16':
-            return reg16Units(op.register);
-        case 'reg-index16':
-            return reg16Units(op.register);
-        case 'reg-half-index':
-            return regHalfUnits(op.register);
-        default:
-            return undefined;
-    }
-}
-function callControl(target, conditional) {
-    return target === undefined
-        ? { kind: 'call', conditional }
-        : { kind: 'call', target, conditional };
-}
-function rstControl(vector) {
-    return vector === undefined ? { kind: 'rst' } : { kind: 'rst', vector };
-}
-function jumpControl(target, conditional) {
-    return target === undefined
-        ? { kind: 'jump', conditional }
-        : { kind: 'jump', target, conditional };
-}
-function controlEffect(control, reads = []) {
-    return {
-        ...baseEffect(),
-        reads,
-        control,
-    };
-}
-function stackControlEffect(control, reads = []) {
-    return {
-        ...controlEffect(control, reads),
-        writes: STACK_POINTER_UNITS,
-        stack: { kind: 'unknown' },
-    };
-}
-function ldEffect(instruction) {
-    const srcReads = operandReads(instruction.source);
-    if (srcReads === undefined)
-        return unknownEffect();
-    const dstWrites = operandWrites(instruction.target);
-    if (instruction.target.kind === 'reg8' || instruction.target.kind === 'reg16') {
-        if (dstWrites === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: srcReads,
-            writes: dstWrites,
-        };
-    }
-    if (instruction.target.kind === 'reg-index16' ||
-        instruction.target.kind === 'reg-half-index') {
-        if (dstWrites === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: srcReads,
-            writes: dstWrites,
-        };
-    }
-    if (instruction.target.kind === 'reg-indirect' || instruction.target.kind === 'indexed') {
-        const dstReads = operandReads(instruction.target);
-        if (dstReads === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: concatUnique(dstReads, srcReads),
-        };
-    }
-    if (instruction.target.kind === 'mem-abs') {
-        return {
-            ...baseEffect(),
-            reads: srcReads,
-        };
-    }
-    return unknownEffect();
-}
-function incDecEffect(instruction) {
-    const operand = instruction.operand;
-    if (operand.kind === 'reg8') {
-        const units = reg8Units(operand.register);
-        return {
-            ...baseEffect(),
-            reads: units,
-            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
-        };
-    }
-    if (operand.kind === 'reg16') {
-        const units = reg16Units(operand.register);
-        return {
-            ...baseEffect(),
-            reads: units,
-            writes: units,
-        };
-    }
-    if (operand.kind === 'reg-half-index') {
-        const units = regHalfUnits(operand.register);
-        return {
-            ...baseEffect(),
-            reads: units,
-            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
-        };
-    }
-    const reads = operandReads(operand);
-    if (reads === undefined)
-        return unknownEffect();
-    return {
-        ...baseEffect(),
-        reads,
-        writes: INC_DEC_FLAG_WRITES,
-    };
-}
-function aluEffect(instruction) {
-    if (instruction.mnemonic === 'add' &&
-        'target' in instruction &&
-        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
-        const targetReads = operandReads(instruction.target);
-        const sourceReads = operandReads(instruction.source);
-        if (targetReads === undefined || sourceReads === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: concatUnique(targetReads, sourceReads),
-            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
-        };
-    }
-    if (instruction.mnemonic === 'adc' &&
-        'target' in instruction &&
-        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
-        const targetReads = operandReads(instruction.target);
-        const sourceReads = operandReads(instruction.source);
-        if (targetReads === undefined || sourceReads === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: concatUnique(targetReads, sourceReads, ['carry']),
-            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
-        };
-    }
-    if (instruction.mnemonic === 'sbc' &&
-        'target' in instruction &&
-        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
-        const targetReads = operandReads(instruction.target);
-        const sourceReads = operandReads(instruction.source);
-        if (targetReads === undefined || sourceReads === undefined)
-            return unknownEffect();
-        return {
-            ...baseEffect(),
-            reads: concatUnique(targetReads, sourceReads, ['carry']),
-            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
-        };
-    }
-    if (!('source' in instruction))
-        return unknownEffect();
-    const source = instruction.source;
-    let sourceReads;
-    if (source.kind === 'reg8') {
-        sourceReads = reg8Units(source.register);
-    }
-    else if (source.kind === 'reg-indirect' || source.kind === 'indexed') {
-        sourceReads = operandReads(source) ?? [];
-    }
-    else if (source.kind === 'mem-abs' || source.kind === 'imm') {
-        sourceReads = [];
-    }
-    else if (source.kind === 'reg16' || source.kind === 'reg-index16') {
-        sourceReads = reg16Units(source.register);
-    }
-    else if (source.kind === 'reg-half-index') {
-        sourceReads = regHalfUnits(source.register);
-    }
-    else {
-        sourceReads = [];
-    }
-    const xorSelfZero = instruction.mnemonic === 'xor' &&
-        source.kind === 'reg8' &&
-        source.register === 'a';
-    const reads = xorSelfZero ? [] : concatUnique(['A'], sourceReads);
-    const carryReads = instruction.mnemonic === 'adc' || instruction.mnemonic === 'sbc' ? ['carry'] : [];
-    if (instruction.mnemonic === 'cp') {
-        return {
-            ...baseEffect(),
-            reads: concatUnique(reads, carryReads),
-            writes: FLAG_WRITES,
-        };
-    }
-    return {
-        ...baseEffect(),
-        reads: concatUnique(reads, carryReads),
-        writes: concatUnique(['A'], FLAG_WRITES),
-    };
-}
-function stackRegisterUnits(register) {
-    return reg16Units(register);
-}
-function pushEffect(register) {
-    const units = stackRegisterUnits(register);
-    return {
-        ...baseEffect(),
-        reads: units,
-        writes: STACK_POINTER_UNITS,
-        stack: { kind: 'push', units },
-    };
-}
-function popEffect(register) {
-    const units = stackRegisterUnits(register);
-    return {
-        ...baseEffect(),
-        writes: concatUnique(units, STACK_POINTER_UNITS),
-        stack: { kind: 'pop', units },
-    };
-}
-function rotateShiftEffect(instruction) {
-    const reads = operandReads(instruction.operand);
-    const writes = operandWrites(instruction.operand);
-    if (reads === undefined || writes === undefined)
-        return unknownEffect();
-    return {
-        ...baseEffect(),
-        reads,
-        writes: concatUnique(writes, ROTATE_SHIFT_FLAG_WRITES),
-    };
-}
-function bitEffect(instruction) {
-    const reads = operandReads(instruction.operand);
-    if (reads === undefined)
-        return unknownEffect();
-    if (instruction.mnemonic === 'bit') {
-        return {
-            ...baseEffect(),
-            reads,
-            writes: BIT_FLAG_WRITES,
-        };
-    }
-    const writes = operandWrites(instruction.operand);
-    if (writes === undefined)
-        return unknownEffect();
-    return {
-        ...baseEffect(),
-        reads,
-        writes,
-    };
-}
-function inEffect(instruction) {
-    const targetWrites = instruction.target?.kind === 'reg8' ? reg8Units(instruction.target.register) : undefined;
-    if (instruction.port.kind === 'imm') {
-        return {
-            ...baseEffect(),
-            reads: ['A'],
-            writes: targetWrites ?? [],
-        };
-    }
-    return {
-        ...baseEffect(),
-        reads: ['C'],
-        writes: concatUnique(targetWrites ?? [], BIT_FLAG_WRITES),
-    };
-}
-function outEffect(instruction) {
-    const valueReads = instruction.source.kind === 'reg8' ? reg8Units(instruction.source.register) : [];
-    if (instruction.port.kind === 'c') {
-        return {
-            ...baseEffect(),
-            reads: concatUnique(['C'], valueReads),
-        };
-    }
-    return {
-        ...baseEffect(),
-        reads: valueReads,
-    };
-}
-function blockTransferEffect() {
-    return {
-        ...baseEffect(),
-        reads: ['H', 'L', 'D', 'E', 'B', 'C'],
-        writes: ['H', 'L', 'D', 'E', 'B', 'C', 'halfCarry', 'parity'],
-    };
-}
-function exEffect(instruction) {
-    if (instruction.form === 'de-hl') {
-        return {
-            ...baseEffect(),
-            reads: ['D', 'E', 'H', 'L'],
-            writes: ['D', 'E', 'H', 'L'],
-        };
-    }
-    return unknownEffect();
-}
-function accumulatorRotateEffect(mnemonic) {
-    const reads = mnemonic === 'rla' || mnemonic === 'rra' ? ['A', 'carry'] : ['A'];
-    return {
+const EFFECT_HANDLERS = {
+    'ld-a-imm': () => ({ ...baseEffect(), writes: ['A'] }),
+    ld: (instruction) => ldEffect(instruction),
+    inc: (instruction) => incDecEffect(instruction),
+    dec: (instruction) => incDecEffect(instruction),
+    push: (instruction) => pushEffect(instruction.register),
+    pop: (instruction) => popEffect(instruction.register),
+    call: (instruction) => stackControlEffect(callControl(expressionSymbol(instruction.expression), false)),
+    'call-cc': (instruction) => {
+        const call = instruction;
+        return stackControlEffect(callControl(expressionSymbol(call.expression), true), conditionFlagRead(call.condition));
+    },
+    rst: (instruction) => stackControlEffect(rstControl(instruction.vector)),
+    ret: () => stackControlEffect({ kind: 'return', conditional: false }),
+    'ret-cc': (instruction) => stackControlEffect({ kind: 'return', conditional: true }, conditionFlagRead(instruction.condition)),
+    jp: (instruction) => controlEffect(jumpControl(expressionSymbol(instruction.expression), false)),
+    'jp-cc': (instruction) => {
+        const jump = instruction;
+        return controlEffect(jumpControl(expressionSymbol(jump.expression), true), conditionFlagRead(jump.condition));
+    },
+    'jp-indirect': (instruction) => controlEffect(jumpControl(undefined, false), reg16Units(instruction.register)),
+    jr: (instruction) => controlEffect(jumpControl(expressionSymbol(instruction.expression), false)),
+    'jr-cc': (instruction) => {
+        const jump = instruction;
+        return controlEffect(jumpControl(expressionSymbol(jump.expression), true), conditionFlagRead(jump.condition));
+    },
+    djnz: (instruction) => ({
         ...baseEffect(),
-        reads,
-        writes: ['A', 'carry', 'halfCarry'],
-    };
+        reads: ['B'],
+        writes: ['B'],
+        control: jumpControl(expressionSymbol(instruction.expression), true),
+    }),
+    scf: () => ({ ...baseEffect(), writes: ['carry', 'halfCarry'] }),
+    ccf: () => ({ ...baseEffect(), reads: ['carry'], writes: ['carry', 'halfCarry'] }),
+    cpl: () => ({ ...baseEffect(), reads: ['A'], writes: ['A', 'halfCarry'] }),
+    neg: () => ({ ...baseEffect(), reads: ['A'], writes: concatUnique(['A'], FLAG_WRITES) }),
+    out: (instruction) => outEffect(instruction),
+    in: (instruction) => inEffect(instruction),
+    ex: (instruction) => exEffect(instruction),
+};
+for (const mnemonic of BASE_EFFECT_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = () => baseEffect();
+}
+for (const mnemonic of STACK_RETURN_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = () => stackControlEffect({ kind: 'return', conditional: false });
+}
+for (const mnemonic of ALU_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = (instruction) => aluEffect(instruction);
+}
+for (const mnemonic of ROTATE_SHIFT_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = (instruction) => rotateShiftEffect(instruction);
+}
+for (const mnemonic of ACCUMULATOR_ROTATE_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = () => accumulatorRotateEffect(mnemonic);
+}
+for (const mnemonic of BIT_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = (instruction) => bitEffect(instruction);
+}
+for (const mnemonic of BLOCK_TRANSFER_MNEMONICS) {
+    EFFECT_HANDLERS[mnemonic] = () => blockTransferEffect();
 }
 export function getZ80InstructionEffect(instruction) {
-    switch (instruction.mnemonic) {
-        case 'nop':
-        case 'halt':
-        case 'di':
-        case 'ei':
-        case 'im':
-            return baseEffect();
-        case 'reti':
-        case 'retn':
-            return stackControlEffect({ kind: 'return', conditional: false });
-        case 'ld-a-imm':
-            return { ...baseEffect(), writes: ['A'] };
-        case 'ld':
-            return ldEffect(instruction);
-        case 'inc':
-        case 'dec':
-            return incDecEffect(instruction);
-        case 'add':
-        case 'adc':
-        case 'sbc':
-        case 'sub':
-        case 'and':
-        case 'or':
-        case 'xor':
-        case 'cp':
-            return aluEffect(instruction);
-        case 'push':
-            return pushEffect(instruction.register);
-        case 'pop':
-            return popEffect(instruction.register);
-        case 'call':
-            return stackControlEffect(callControl(expressionSymbol(instruction.expression), false));
-        case 'call-cc':
-            return stackControlEffect(callControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
-        case 'rst':
-            return stackControlEffect(rstControl(instruction.vector));
-        case 'ret':
-            return stackControlEffect({ kind: 'return', conditional: false });
-        case 'ret-cc':
-            return stackControlEffect({ kind: 'return', conditional: true }, conditionFlagRead(instruction.condition));
-        case 'jp':
-            return controlEffect(jumpControl(expressionSymbol(instruction.expression), false));
-        case 'jp-cc':
-            return controlEffect(jumpControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
-        case 'jp-indirect':
-            return controlEffect(jumpControl(undefined, false), reg16Units(instruction.register));
-        case 'jr':
-            return controlEffect(jumpControl(expressionSymbol(instruction.expression), false));
-        case 'jr-cc':
-            return controlEffect(jumpControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
-        case 'djnz':
-            return {
-                ...baseEffect(),
-                reads: ['B'],
-                writes: ['B'],
-                control: jumpControl(expressionSymbol(instruction.expression), true),
-            };
-        case 'rlc':
-        case 'rrc':
-        case 'rl':
-        case 'rr':
-        case 'sla':
-        case 'sra':
-        case 'sll':
-        case 'sls':
-        case 'srl':
-            return rotateShiftEffect(instruction);
-        case 'rlca':
-        case 'rrca':
-        case 'rla':
-        case 'rra':
-            return accumulatorRotateEffect(instruction.mnemonic);
-        case 'bit':
-        case 'res':
-        case 'set':
-            return bitEffect(instruction);
-        case 'scf':
-            return { ...baseEffect(), writes: ['carry', 'halfCarry'] };
-        case 'ccf':
-            return { ...baseEffect(), reads: ['carry'], writes: ['carry', 'halfCarry'] };
-        case 'cpl':
-            return { ...baseEffect(), reads: ['A'], writes: ['A', 'halfCarry'] };
-        case 'neg':
-            return { ...baseEffect(), reads: ['A'], writes: concatUnique(['A'], FLAG_WRITES) };
-        case 'out':
-            return outEffect(instruction);
-        case 'in':
-            return inEffect(instruction);
-        case 'ldi':
-        case 'ldir':
-        case 'ldd':
-        case 'lddr':
-        case 'cpi':
-        case 'cpir':
-        case 'cpd':
-        case 'cpdr':
-        case 'ini':
-        case 'inir':
-        case 'ind':
-        case 'indr':
-        case 'outi':
-        case 'otir':
-        case 'outd':
-        case 'otdr':
-            return blockTransferEffect();
-        case 'ex':
-            return exEffect(instruction);
-        default:
-            return unknownEffect();
-    }
+    return EFFECT_HANDLERS[instruction.mnemonic]?.(instruction) ?? unknownEffect();
 }

package/dist/src/z80/encode-core.d.ts

@@ -0,0 +1,2 @@
+import type { EncodedZ80Instruction, Z80CoreMnemonic } from './instruction.js';
+export declare function encodeCore(mnemonic: Z80CoreMnemonic): EncodedZ80Instruction;