@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/z80/encodeBitOps.js

@@ -1,123 +0,0 @@
-const BIT_LIKE_OPS = {
-    bit: { base: 0x40, allowIndexedDestination: false },
-    res: { base: 0x80, allowIndexedDestination: true },
-    set: { base: 0xc0, allowIndexedDestination: true },
-};
-const ROTATE_SHIFT_OPS = {
-    rlc: 0x00,
-    rrc: 0x08,
-    rl: 0x10,
-    rr: 0x18,
-    sla: 0x20,
-    sra: 0x28,
-    sll: 0x30,
-    srl: 0x38,
-};
-function indexedCbDestinationCode(node, diagnostics, ctx, idxPrefix, operand, mnemonic, invalidDestinationMessage) {
-    const dstIndexed = ctx.indexedReg8(operand);
-    if (dstIndexed) {
-        ctx.diag(diagnostics, node, dstIndexed.prefix !== idxPrefix
-            ? `${mnemonic} indexed destination family must match source index base`
-            : `${mnemonic} indexed destination must use plain reg8 B/C/D/E/H/L/A`);
-        return undefined;
-    }
-    const dstReg = ctx.regName(operand);
-    const dstCode = dstReg ? ctx.reg8Code(dstReg) : undefined;
-    if (dstCode === undefined) {
-        ctx.diag(diagnostics, node, invalidDestinationMessage);
-        return undefined;
-    }
-    return dstCode;
-}
-function checkedIndexedDisp(node, diagnostics, ctx, disp, mnemonic) {
-    if (disp < -128 || disp > 127) {
-        ctx.diag(diagnostics, node, `${mnemonic} (ix/iy+disp) expects disp8`);
-        return undefined;
-    }
-    return disp;
-}
-function encodeCbRegOrHl(node, diagnostics, ctx, operand, opcodeBase, mnemonic) {
-    if (ctx.isMemHL(operand))
-        return Uint8Array.of(0xcb, opcodeBase + 0x06);
-    const reg = ctx.regName(operand);
-    const code = reg ? ctx.reg8Code(reg) : undefined;
-    if (code === undefined) {
-        ctx.diag(diagnostics, node, `${mnemonic} expects reg8 or (hl)`);
-        return undefined;
-    }
-    return Uint8Array.of(0xcb, opcodeBase + code);
-}
-function encodeBitLike(node, env, diagnostics, ctx, base, mnemonic, allowIndexedDestination = false) {
-    const ops = node.operands;
-    if (ops.length !== 2 && !(allowIndexedDestination && ops.length === 3))
-        return undefined;
-    const bit = ctx.immValue(ops[0], env);
-    if (bit === undefined || bit < 0 || bit > 7) {
-        ctx.diag(diagnostics, node, `${mnemonic} expects bit index 0..7`);
-        return undefined;
-    }
-    const src = ops[1];
-    const idx = ctx.memIndexed(src, env);
-    if (idx) {
-        const disp = checkedIndexedDisp(node, diagnostics, ctx, idx.disp, mnemonic);
-        if (disp === undefined)
-            return undefined;
-        if (ops.length === 3) {
-            const dstCode = indexedCbDestinationCode(node, diagnostics, ctx, idx.prefix, ops[2], mnemonic, `${mnemonic} b,(ix/iy+disp),r expects reg8 destination`);
-            if (dstCode === undefined)
-                return undefined;
-            return Uint8Array.of(idx.prefix, 0xcb, disp & 0xff, base + (bit << 3) + dstCode);
-        }
-        return Uint8Array.of(idx.prefix, 0xcb, disp & 0xff, base + (bit << 3) + 0x06);
-    }
-    if (ops.length === 3) {
-        ctx.diag(diagnostics, node, `${mnemonic} b,(ix/iy+disp),r requires an indexed memory source`);
-        return undefined;
-    }
-    return encodeCbRegOrHl(node, diagnostics, ctx, src, base + (bit << 3), mnemonic);
-}
-function encodeCbRotateShift(node, env, diagnostics, ctx, base, mnemonic) {
-    const ops = node.operands;
-    if (ops.length !== 1 && ops.length !== 2)
-        return undefined;
-    const operand = ops[0];
-    const idx = ctx.memIndexed(operand, env);
-    if (idx) {
-        const disp = checkedIndexedDisp(node, diagnostics, ctx, idx.disp, mnemonic);
-        if (disp === undefined)
-            return undefined;
-        if (ops.length === 1) {
-            return Uint8Array.of(idx.prefix, 0xcb, disp & 0xff, base + 0x06);
-        }
-        const dstCode = indexedCbDestinationCode(node, diagnostics, ctx, idx.prefix, ops[1], mnemonic, `${mnemonic} (ix/iy+disp),r expects reg8 destination`);
-        if (dstCode === undefined)
-            return undefined;
-        return Uint8Array.of(idx.prefix, 0xcb, disp & 0xff, base + dstCode);
-    }
-    if (ops.length === 2) {
-        ctx.diag(diagnostics, node, `${mnemonic} two-operand form requires (ix/iy+disp) source`);
-        return undefined;
-    }
-    return encodeCbRegOrHl(node, diagnostics, ctx, operand, base, mnemonic);
-}
-export function encodeBitOpsInstruction(node, env, diagnostics, ctx) {
-    const head = node.head.toLowerCase();
-    const ops = node.operands;
-    const bitLike = BIT_LIKE_OPS[head];
-    if (bitLike) {
-        const encoded = encodeBitLike(node, env, diagnostics, ctx, bitLike.base, head, bitLike.allowIndexedDestination);
-        if (encoded)
-            return encoded;
-        if (ops.length === 2 || (bitLike.allowIndexedDestination && ops.length === 3))
-            return undefined;
-    }
-    const rotateShiftBase = ROTATE_SHIFT_OPS[head];
-    if (rotateShiftBase !== undefined) {
-        const encoded = encodeCbRotateShift(node, env, diagnostics, ctx, rotateShiftBase, head);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeContext.d.ts

@@ -1,29 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { AsmInstructionNode, AsmOperandNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-type EncodeDiag = (diagnostics: Diagnostic[], node: {
-    span: AsmInstructionNode['span'];
-}, message: string) => void;
-type IndexedReg8 = {
-    prefix: number;
-    code: number;
-    display: 'IXH' | 'IXL' | 'IYH' | 'IYL';
-};
-export type EncoderRegisterContext = {
-    diag: EncodeDiag;
-    regName: (op: AsmOperandNode) => string | undefined;
-    indexedReg8: (op: AsmOperandNode) => IndexedReg8 | undefined;
-    reg8Code: (name: string) => number | undefined;
-};
-export type EncoderImmContext = {
-    immValue: (op: AsmOperandNode, env: CompileEnv) => number | undefined;
-    fitsImm8: (value: number) => boolean;
-};
-export type EncoderMemContext = {
-    isMemHL: (op: AsmOperandNode) => boolean;
-    memIndexed: (op: AsmOperandNode, env: CompileEnv) => {
-        prefix: number;
-        disp: number;
-    } | undefined;
-};
-export {};

package/dist/legacy-root-azm/src/z80/encodeContext.js

@@ -1 +0,0 @@
-export {};

package/dist/legacy-root-azm/src/z80/encodeControl.d.ts

@@ -1,26 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { AsmInstructionNode, AsmOperandNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-type ControlEncodeContext = {
-    diag: (diagnostics: Diagnostic[], node: {
-        span: {
-            file: string;
-            start: {
-                line: number;
-                column: number;
-            };
-        };
-    }, message: string) => void;
-    immValue: (op: AsmOperandNode, env: CompileEnv) => number | undefined;
-    registerTokenName: (op: AsmOperandNode) => string | undefined;
-    conditionName: (op: AsmOperandNode) => string | undefined;
-    symbolicImmBaseName: (op: AsmOperandNode, env: CompileEnv) => string | undefined;
-    fitsImm16: (value: number) => boolean;
-    isMemRegName: (op: AsmOperandNode, reg: string) => boolean;
-    retConditionOpcode: (name: string) => number | undefined;
-    callConditionOpcode: (name: string) => number | undefined;
-    jpConditionOpcode: (name: string) => number | undefined;
-    jrConditionOpcode: (name: string) => number | undefined;
-};
-export declare function encodeControlInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: ControlEncodeContext): Uint8Array | undefined;
-export {};

package/dist/legacy-root-azm/src/z80/encodeControl.js

@@ -1,180 +0,0 @@
-function encodeConditionalAbs16(node, target, env, diagnostics, ctx, opcode, messages) {
-    if (opcode === undefined) {
-        ctx.diag(diagnostics, node, messages.badCondition);
-        return undefined;
-    }
-    if (target.kind === 'Mem') {
-        ctx.diag(diagnostics, node, messages.indirectTarget);
-        return undefined;
-    }
-    const n = ctx.immValue(target, env);
-    if (n === undefined || !ctx.fitsImm16(n)) {
-        ctx.diag(diagnostics, node, messages.badTarget);
-        return undefined;
-    }
-    return Uint8Array.of(opcode, n & 0xff, (n >> 8) & 0xff);
-}
-function rejectUnsupportedDirectTarget(node, target, env, diagnostics, ctx, messages) {
-    if (target.kind === 'Mem') {
-        ctx.diag(diagnostics, node, messages.indirect);
-        return true;
-    }
-    if (ctx.registerTokenName(target) !== undefined && ctx.immValue(target, env) === undefined) {
-        ctx.diag(diagnostics, node, messages.register);
-        return true;
-    }
-    return false;
-}
-function encodeRelativeDisp8(node, target, env, diagnostics, ctx, opcode, badTarget) {
-    const n = ctx.immValue(target, env);
-    if (n === undefined || n < -128 || n > 127) {
-        ctx.diag(diagnostics, node, badTarget);
-        return undefined;
-    }
-    return Uint8Array.of(opcode, n & 0xff);
-}
-export function encodeControlInstruction(node, env, diagnostics, ctx) {
-    const head = node.head.toLowerCase();
-    const ops = node.operands;
-    if (head === 'ret' && ops.length === 0)
-        return Uint8Array.of(0xc9);
-    if (head === 'ret' && ops.length === 1) {
-        const cc = ctx.conditionName(ops[0]);
-        const opcode = cc ? ctx.retConditionOpcode(cc) : undefined;
-        if (opcode === undefined) {
-            ctx.diag(diagnostics, node, `ret cc expects a valid condition code`);
-            return undefined;
-        }
-        return Uint8Array.of(opcode);
-    }
-    if (head === 'ret') {
-        ctx.diag(diagnostics, node, `ret expects no operands or one condition code`);
-        return undefined;
-    }
-    if (head === 'call' && ops.length === 1) {
-        if (rejectUnsupportedDirectTarget(node, ops[0], env, diagnostics, ctx, {
-            indirect: 'call does not support indirect targets; use imm16',
-            register: 'call does not support register targets; use imm16',
-        })) {
-            return undefined;
-        }
-        const cc = ctx.conditionName(ops[0]) ?? ctx.symbolicImmBaseName(ops[0], env);
-        if (cc && ctx.callConditionOpcode(cc) !== undefined) {
-            ctx.diag(diagnostics, node, `call cc, nn expects two operands (cc, nn)`);
-            return undefined;
-        }
-        const n = ctx.immValue(ops[0], env);
-        if (n === undefined || !ctx.fitsImm16(n)) {
-            ctx.diag(diagnostics, node, `call expects imm16`);
-            return undefined;
-        }
-        return Uint8Array.of(0xcd, n & 0xff, (n >> 8) & 0xff);
-    }
-    if (head === 'call' && ops.length === 2) {
-        const cc = ctx.conditionName(ops[0]);
-        return encodeConditionalAbs16(node, ops[1], env, diagnostics, ctx, cc ? ctx.callConditionOpcode(cc) : undefined, {
-            badCondition: 'call cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M',
-            indirectTarget: 'call cc, nn does not support indirect targets',
-            badTarget: 'call cc, nn expects imm16',
-        });
-    }
-    if (head === 'call') {
-        ctx.diag(diagnostics, node, `call expects one operand (nn) or two operands (cc, nn)`);
-        return undefined;
-    }
-    if (head === 'djnz' && ops.length === 1) {
-        if (rejectUnsupportedDirectTarget(node, ops[0], env, diagnostics, ctx, {
-            indirect: 'djnz does not support indirect targets; expects disp8',
-            register: 'djnz does not support register targets; expects disp8',
-        })) {
-            return undefined;
-        }
-        return encodeRelativeDisp8(node, ops[0], env, diagnostics, ctx, 0x10, 'djnz expects disp8');
-    }
-    if (head === 'djnz') {
-        ctx.diag(diagnostics, node, `djnz expects one operand (disp8)`);
-        return undefined;
-    }
-    if (head === 'jp' && ops.length === 1) {
-        if (ops[0].kind === 'Mem') {
-            if (ctx.isMemRegName(ops[0], 'HL'))
-                return Uint8Array.of(0xe9);
-            if (ctx.isMemRegName(ops[0], 'IX'))
-                return Uint8Array.of(0xdd, 0xe9);
-            if (ctx.isMemRegName(ops[0], 'IY'))
-                return Uint8Array.of(0xfd, 0xe9);
-            ctx.diag(diagnostics, node, `jp indirect form supports (hl), (ix), or (iy) only`);
-            return undefined;
-        }
-        const jpReg = ctx.registerTokenName(ops[0]);
-        const jpImm = ctx.immValue(ops[0], env);
-        if (jpReg !== undefined && jpImm === undefined) {
-            if (jpReg === 'HL' || jpReg === 'IX' || jpReg === 'IY') {
-                ctx.diag(diagnostics, node, `jp indirect form requires parentheses; use (hl), (ix), or (iy)`);
-                return undefined;
-            }
-            ctx.diag(diagnostics, node, `jp does not support register targets; use imm16`);
-            return undefined;
-        }
-        const cc = ctx.conditionName(ops[0]) ?? ctx.symbolicImmBaseName(ops[0], env);
-        if (cc && ctx.jpConditionOpcode(cc) !== undefined) {
-            ctx.diag(diagnostics, node, `jp cc, nn expects two operands (cc, nn)`);
-            return undefined;
-        }
-        const n = jpImm;
-        if (n === undefined || !ctx.fitsImm16(n)) {
-            ctx.diag(diagnostics, node, `jp expects imm16`);
-            return undefined;
-        }
-        return Uint8Array.of(0xc3, n & 0xff, (n >> 8) & 0xff);
-    }
-    if (head === 'jp' && ops.length === 2) {
-        const cc = ctx.conditionName(ops[0]);
-        return encodeConditionalAbs16(node, ops[1], env, diagnostics, ctx, cc ? ctx.jpConditionOpcode(cc) : undefined, {
-            badCondition: 'jp cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M',
-            indirectTarget: 'jp cc, nn does not support indirect targets',
-            badTarget: 'jp cc, nn expects imm16',
-        });
-    }
-    if (head === 'jp') {
-        ctx.diag(diagnostics, node, `jp expects one operand (nn/(hl)/(ix)/(iy)) or two operands (cc, nn)`);
-        return undefined;
-    }
-    if (head === 'jr' && ops.length === 1) {
-        if (rejectUnsupportedDirectTarget(node, ops[0], env, diagnostics, ctx, {
-            indirect: 'jr does not support indirect targets; expects disp8',
-            register: 'jr does not support register targets; expects disp8',
-        })) {
-            return undefined;
-        }
-        const cc = ctx.conditionName(ops[0]) ?? ctx.symbolicImmBaseName(ops[0], env);
-        if (cc && ctx.jrConditionOpcode(cc) !== undefined) {
-            ctx.diag(diagnostics, node, `jr cc, disp expects two operands (cc, disp8)`);
-            return undefined;
-        }
-        return encodeRelativeDisp8(node, ops[0], env, diagnostics, ctx, 0x18, 'jr expects disp8');
-    }
-    if (head === 'jr' && ops.length === 2) {
-        const cc = ctx.conditionName(ops[0]);
-        const opcode = cc ? ctx.jrConditionOpcode(cc) : undefined;
-        if (opcode === undefined) {
-            ctx.diag(diagnostics, node, `jr cc expects valid condition code NZ/Z/NC/C`);
-            return undefined;
-        }
-        if (ops[1].kind === 'Mem') {
-            ctx.diag(diagnostics, node, `jr cc, disp does not support indirect targets`);
-            return undefined;
-        }
-        const n = ctx.immValue(ops[1], env);
-        if (n === undefined || n < -128 || n > 127) {
-            ctx.diag(diagnostics, node, `jr cc, disp expects disp8`);
-            return undefined;
-        }
-        return Uint8Array.of(opcode, n & 0xff);
-    }
-    if (head === 'jr') {
-        ctx.diag(diagnostics, node, `jr expects one operand (disp8) or two operands (cc, disp8)`);
-        return undefined;
-    }
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeCoreOps.d.ts

@@ -1,7 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { AsmInstructionNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { EncoderMemContext, EncoderRegisterContext } from './encodeContext.js';
-type CoreOpsEncodeContext = EncoderRegisterContext & EncoderMemContext;
-export declare function encodeCoreOpsInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: CoreOpsEncodeContext): Uint8Array | undefined;
-export {};

package/dist/legacy-root-azm/src/z80/encodeCoreOps.js

@@ -1,131 +0,0 @@
-function isMemSP(op) {
-    return op.kind === 'Mem' && op.expr.kind === 'EaName' && op.expr.name.toUpperCase() === 'SP';
-}
-const INC_SPEC = {
-    mnemonic: 'inc',
-    reg8Base: 0x04,
-    memOpcode: 0x34,
-    reg16Opcodes: {
-        BC: 0x03,
-        DE: 0x13,
-        HL: 0x23,
-        SP: 0x33,
-        IX: [0xdd, 0x23],
-        IY: [0xfd, 0x23],
-    },
-};
-const DEC_SPEC = {
-    mnemonic: 'dec',
-    reg8Base: 0x05,
-    memOpcode: 0x35,
-    reg16Opcodes: {
-        BC: 0x0b,
-        DE: 0x1b,
-        HL: 0x2b,
-        SP: 0x3b,
-        IX: [0xdd, 0x2b],
-        IY: [0xfd, 0x2b],
-    },
-};
-const PUSH_SPEC = {
-    mnemonic: 'push',
-    reg16Opcodes: {
-        BC: 0xc5,
-        DE: 0xd5,
-        HL: 0xe5,
-        AF: 0xf5,
-        IX: [0xdd, 0xe5],
-        IY: [0xfd, 0xe5],
-    },
-};
-const POP_SPEC = {
-    mnemonic: 'pop',
-    reg16Opcodes: {
-        BC: 0xc1,
-        DE: 0xd1,
-        HL: 0xe1,
-        AF: 0xf1,
-        IX: [0xdd, 0xe1],
-        IY: [0xfd, 0xe1],
-    },
-};
-function encodeIncDec(node, operand, env, diagnostics, ctx, spec) {
-    const indexed = ctx.indexedReg8(operand);
-    if (indexed)
-        return Uint8Array.of(indexed.prefix, spec.reg8Base + (indexed.code << 3));
-    const r = ctx.regName(operand);
-    if (r) {
-        const r8 = ctx.reg8Code(r);
-        if (r8 !== undefined) {
-            return Uint8Array.of(spec.reg8Base + (r8 << 3));
-        }
-        const reg16Opcode = spec.reg16Opcodes[r];
-        if (typeof reg16Opcode === 'number')
-            return Uint8Array.of(reg16Opcode);
-        if (reg16Opcode)
-            return Uint8Array.of(...reg16Opcode);
-    }
-    if (ctx.isMemHL(operand))
-        return Uint8Array.of(spec.memOpcode);
-    const idx = ctx.memIndexed(operand, env);
-    if (idx) {
-        const disp = idx.disp;
-        if (disp < -128 || disp > 127) {
-            ctx.diag(diagnostics, node, `${spec.mnemonic} (ix/iy+disp) expects disp8`);
-            return undefined;
-        }
-        return Uint8Array.of(idx.prefix, spec.memOpcode, disp & 0xff);
-    }
-    ctx.diag(diagnostics, node, `${spec.mnemonic} expects r8/rr/(hl) operand`);
-    return undefined;
-}
-function encodeStackRegPair(node, operand, diagnostics, ctx, spec) {
-    const r16 = ctx.regName(operand);
-    if (!r16) {
-        ctx.diag(diagnostics, node, `${spec.mnemonic} expects reg16`);
-        return undefined;
-    }
-    const opcode = spec.reg16Opcodes[r16];
-    if (typeof opcode === 'number')
-        return Uint8Array.of(opcode);
-    if (opcode)
-        return Uint8Array.of(...opcode);
-    ctx.diag(diagnostics, node, `${spec.mnemonic} supports BC/DE/HL/AF/IX/IY only`);
-    return undefined;
-}
-export function encodeCoreOpsInstruction(node, env, diagnostics, ctx) {
-    const head = node.head.toLowerCase();
-    const ops = node.operands;
-    if (head === 'inc' && ops.length === 1) {
-        return encodeIncDec(node, ops[0], env, diagnostics, ctx, INC_SPEC);
-    }
-    if (head === 'dec' && ops.length === 1) {
-        return encodeIncDec(node, ops[0], env, diagnostics, ctx, DEC_SPEC);
-    }
-    if (head === 'push' && ops.length === 1) {
-        return encodeStackRegPair(node, ops[0], diagnostics, ctx, PUSH_SPEC);
-    }
-    if (head === 'pop' && ops.length === 1) {
-        return encodeStackRegPair(node, ops[0], diagnostics, ctx, POP_SPEC);
-    }
-    if (head === 'ex' && ops.length === 2) {
-        const a = ctx.regName(ops[0]);
-        const b = ctx.regName(ops[1]);
-        if ((a === "AF'" && b === 'AF') || (a === 'AF' && b === "AF'"))
-            return Uint8Array.of(0x08);
-        if ((a === 'DE' && b === 'HL') || (a === 'HL' && b === 'DE'))
-            return Uint8Array.of(0xeb);
-        if ((isMemSP(ops[0]) && b === 'HL') || (isMemSP(ops[1]) && a === 'HL')) {
-            return Uint8Array.of(0xe3);
-        }
-        if ((isMemSP(ops[0]) && b === 'IX') || (isMemSP(ops[1]) && a === 'IX')) {
-            return Uint8Array.of(0xdd, 0xe3);
-        }
-        if ((isMemSP(ops[0]) && b === 'IY') || (isMemSP(ops[1]) && a === 'IY')) {
-            return Uint8Array.of(0xfd, 0xe3);
-        }
-        ctx.diag(diagnostics, node, `ex supports "AF, AF'", "DE, HL", "(SP), HL", "(SP), IX", and "(SP), IY" only`);
-        return undefined;
-    }
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeIo.d.ts

@@ -1,9 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { AsmInstructionNode, AsmOperandNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { EncoderImmContext, EncoderRegisterContext } from './encodeContext.js';
-type IoEncodeContext = EncoderRegisterContext & EncoderImmContext & {
-    portImmValue: (op: AsmOperandNode, env: CompileEnv) => number | undefined;
-};
-export declare function encodeIoInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: IoEncodeContext): Uint8Array | undefined;
-export {};

package/dist/legacy-root-azm/src/z80/encodeIo.js

@@ -1,128 +0,0 @@
-function outSourceReg8(node, diagnostics, ctx, operand) {
-    const name = ctx.regName(operand);
-    const code = name ? ctx.reg8Code(name) : undefined;
-    if (name !== undefined && code !== undefined)
-        return { name, code };
-    if (ctx.indexedReg8(operand)) {
-        ctx.diag(diagnostics, node, `out source must use plain reg8 B/C/D/E/H/L/A`);
-        return undefined;
-    }
-    ctx.diag(diagnostics, node, `out expects a reg8 source`);
-    return undefined;
-}
-function immediatePortByte(node, env, diagnostics, ctx, port, message) {
-    const n = ctx.portImmValue(port, env);
-    if (n === undefined || !ctx.fitsImm8(n)) {
-        ctx.diag(diagnostics, node, message);
-        return undefined;
-    }
-    return n & 0xff;
-}
-export function encodeIoInstruction(node, env, diagnostics, ctx) {
-    const head = node.head.toLowerCase();
-    const ops = node.operands;
-    if (head === 'rst' && ops.length === 1) {
-        const n = ctx.immValue(ops[0], env);
-        if (n === undefined || n < 0 || n > 0x38 || (n & 0x07) !== 0) {
-            ctx.diag(diagnostics, node, `rst expects an imm8 multiple of 8 (0..56)`);
-            return undefined;
-        }
-        return Uint8Array.of(0xc7 + n);
-    }
-    if (head === 'rst') {
-        ctx.diag(diagnostics, node, `rst expects one operand`);
-        return undefined;
-    }
-    if (head === 'im' && ops.length === 1) {
-        const n = ctx.immValue(ops[0], env);
-        if (n === 0)
-            return Uint8Array.of(0xed, 0x46);
-        if (n === 1)
-            return Uint8Array.of(0xed, 0x56);
-        if (n === 2)
-            return Uint8Array.of(0xed, 0x5e);
-        ctx.diag(diagnostics, node, `im expects 0, 1, or 2`);
-        return undefined;
-    }
-    if (head === 'im') {
-        ctx.diag(diagnostics, node, `im expects one operand`);
-        return undefined;
-    }
-    if (head === 'in' && ops.length === 1) {
-        if (ops[0].kind === 'PortC') {
-            return Uint8Array.of(0xed, 0x70);
-        }
-        ctx.diag(diagnostics, node, `in (c) is the only one-operand in form`);
-        return undefined;
-    }
-    if (head === 'in' && ops.length === 2) {
-        const dst = ctx.regName(ops[0]);
-        const dst8 = dst ? ctx.reg8Code(dst) : undefined;
-        if (dst8 === undefined) {
-            if (ctx.indexedReg8(ops[0])) {
-                ctx.diag(diagnostics, node, `in destination must use plain reg8 B/C/D/E/H/L/A`);
-                return undefined;
-            }
-            ctx.diag(diagnostics, node, `in expects a reg8 destination`);
-            return undefined;
-        }
-        const port = ops[1];
-        if (port.kind === 'PortC') {
-            return Uint8Array.of(0xed, 0x40 + (dst8 << 3));
-        }
-        if (port.kind === 'PortImm8') {
-            if (dst !== 'A') {
-                ctx.diag(diagnostics, node, `in a,(n) immediate port form requires destination A`);
-                return undefined;
-            }
-            const n = immediatePortByte(node, env, diagnostics, ctx, port, `in a,(n) expects an imm8 port number`);
-            if (n === undefined)
-                return undefined;
-            return Uint8Array.of(0xdb, n);
-        }
-        ctx.diag(diagnostics, node, `in expects a port operand (c) or (imm8)`);
-        return undefined;
-    }
-    if (head === 'in') {
-        ctx.diag(diagnostics, node, `in expects one or two operands`);
-        return undefined;
-    }
-    if (head === 'out' && ops.length === 2) {
-        const port = ops[0];
-        const srcOp = ops[1];
-        if (port.kind === 'PortC') {
-            if (srcOp.kind === 'Imm') {
-                const n = ctx.immValue(srcOp, env);
-                if (n === 0) {
-                    return Uint8Array.of(0xed, 0x71);
-                }
-                ctx.diag(diagnostics, node, `out (c), n immediate form supports n=0 only`);
-                return undefined;
-            }
-            const src = outSourceReg8(node, diagnostics, ctx, srcOp);
-            if (!src)
-                return undefined;
-            return Uint8Array.of(0xed, 0x41 + (src.code << 3));
-        }
-        if (port.kind === 'PortImm8') {
-            const src = outSourceReg8(node, diagnostics, ctx, srcOp);
-            if (!src)
-                return undefined;
-            if (src.name !== 'A') {
-                ctx.diag(diagnostics, node, `out (n),a immediate port form requires source A`);
-                return undefined;
-            }
-            const n = immediatePortByte(node, env, diagnostics, ctx, port, `out (n),a expects an imm8 port number`);
-            if (n === undefined)
-                return undefined;
-            return Uint8Array.of(0xd3, n);
-        }
-        ctx.diag(diagnostics, node, `out expects a port operand (c) or (imm8)`);
-        return undefined;
-    }
-    if (head === 'out') {
-        ctx.diag(diagnostics, node, `out expects two operands`);
-        return undefined;
-    }
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeLd.d.ts

@@ -1,13 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { AsmInstructionNode, AsmOperandNode } from '../frontend/ast.js';
-import type { CompileEnv } from '../semantics/env.js';
-import type { EncoderImmContext, EncoderMemContext, EncoderRegisterContext } from './encodeContext.js';
-type LdEncodeContext = EncoderRegisterContext & EncoderImmContext & EncoderMemContext & {
-    fitsImm16: (value: number) => boolean;
-    memAbs16: (op: AsmOperandNode, env: CompileEnv) => number | undefined;
-    isMemRegName: (op: AsmOperandNode, reg: string) => boolean;
-    isReg16TransferName: (name: string | undefined) => boolean;
-    isPlainHLReg8: (name: string | undefined) => boolean;
-};
-export declare function encodeLdInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: LdEncodeContext): Uint8Array | undefined;
-export {};