@jhlagado/azm 0.2.1 → 0.2.2

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

@@ -1,412 +0,0 @@
-import { flattenEaDottedName } from '../lowering/asmUtils.js';
-import { diagEncodeAt } from '../lowering/loweringDiagnostics.js';
-import { evalImmExpr } from '../semantics/env.js';
-import { getEncoderRegistryEntry } from './encoderRegistry.js';
-import { encodeAluInstruction } from './encodeAlu.js';
-import { encodeBitOpsInstruction } from './encodeBitOps.js';
-import { encodeControlInstruction } from './encodeControl.js';
-import { encodeCoreOpsInstruction } from './encodeCoreOps.js';
-import { encodeIoInstruction } from './encodeIo.js';
-import { encodeLdInstruction } from './encodeLd.js';
-/** Pass-through to {@link diagEncodeAt} for encoder submodules that take an instruction node. */
-function diag(diagnostics, node, message) {
-    diagEncodeAt(diagnostics, node.span, message);
-}
-function immValue(op, env) {
-    if (op.kind === 'Imm')
-        return evalImmExpr(op.expr, env);
-    if (op.kind !== 'Ea')
-        return undefined;
-    const dotted = flattenEaDottedName(op.expr);
-    if (!dotted || !env.enums.has(dotted))
-        return undefined;
-    return evalImmExpr({ kind: 'ImmName', span: op.span, name: dotted }, env);
-}
-function portImmValue(op, env) {
-    if (op.kind !== 'PortImm8')
-        return undefined;
-    return evalImmExpr(op.expr, env);
-}
-function fitsImm8(value) {
-    return value >= -0x80 && value <= 0xff;
-}
-function fitsImm16(value) {
-    return value >= -0x8000 && value <= 0xffff;
-}
-function regName(op) {
-    return op.kind === 'Reg' ? op.name.toUpperCase() : undefined;
-}
-function registerTokenName(op) {
-    const name = op.kind === 'Reg'
-        ? op.name.toUpperCase()
-        : op.kind === 'Imm' && op.expr.kind === 'ImmName'
-            ? op.expr.name.toUpperCase()
-            : undefined;
-    if (!name)
-        return undefined;
-    switch (name) {
-        case 'A':
-        case 'B':
-        case 'C':
-        case 'D':
-        case 'E':
-        case 'H':
-        case 'L':
-        case 'BC':
-        case 'DE':
-        case 'HL':
-        case 'SP':
-        case 'AF':
-        case 'IX':
-        case 'IY':
-        case 'IXH':
-        case 'IXL':
-        case 'IYH':
-        case 'IYL':
-            return name;
-        default:
-            return undefined;
-    }
-}
-function reg8Code(name) {
-    switch (name.toUpperCase()) {
-        case 'B':
-            return 0;
-        case 'C':
-            return 1;
-        case 'D':
-            return 2;
-        case 'E':
-            return 3;
-        case 'H':
-            return 4;
-        case 'L':
-            return 5;
-        case 'A':
-            return 7;
-        default:
-            return undefined;
-    }
-}
-function isPlainHLReg8(name) {
-    return name === 'H' || name === 'L';
-}
-function indexedReg8(op) {
-    const n = regName(op);
-    switch (n) {
-        case 'IXH':
-            return { prefix: 0xdd, code: 4, display: 'IXH' };
-        case 'IXL':
-            return { prefix: 0xdd, code: 5, display: 'IXL' };
-        case 'IYH':
-            return { prefix: 0xfd, code: 4, display: 'IYH' };
-        case 'IYL':
-            return { prefix: 0xfd, code: 5, display: 'IYL' };
-        default:
-            return undefined;
-    }
-}
-function isMemHL(op) {
-    return op.kind === 'Mem' && op.expr.kind === 'EaName' && op.expr.name.toUpperCase() === 'HL';
-}
-function isMemRegName(op, reg) {
-    return op.kind === 'Mem' && op.expr.kind === 'EaName' && op.expr.name.toUpperCase() === reg;
-}
-function isReg16TransferName(name) {
-    return (name === 'BC' ||
-        name === 'DE' ||
-        name === 'HL' ||
-        name === 'SP' ||
-        name === 'AF' ||
-        name === 'IX' ||
-        name === 'IY');
-}
-function memIndexed(op, env, _diagnostics) {
-    if (op.kind !== 'Mem')
-        return undefined;
-    const ea = op.expr;
-    const encodeBaseDisp = (baseExpr, dispExpr, negate = false) => {
-        if (baseExpr.kind !== 'EaName')
-            return undefined;
-        const base = baseExpr.name.toUpperCase();
-        if (base !== 'IX' && base !== 'IY')
-            return undefined;
-        const rawDisp = evalImmExpr(dispExpr, env);
-        if (rawDisp === undefined)
-            return undefined;
-        const prefix = base === 'IX' ? 0xdd : 0xfd;
-        return { prefix, disp: negate ? -rawDisp : rawDisp };
-    };
-    if (ea.kind === 'EaIndex' && ea.index.kind === 'IndexImm') {
-        return encodeBaseDisp(ea.base, ea.index.value);
-    }
-    if (ea.kind === 'EaName') {
-        const base = ea.name.toUpperCase();
-        if (base === 'IX')
-            return { prefix: 0xdd, disp: 0 };
-        if (base === 'IY')
-            return { prefix: 0xfd, disp: 0 };
-    }
-    if (ea.kind === 'EaAdd') {
-        return encodeBaseDisp(ea.base, ea.offset);
-    }
-    if (ea.kind === 'EaSub') {
-        return encodeBaseDisp(ea.base, ea.offset, true);
-    }
-    return undefined;
-}
-function memAbs16(op, env) {
-    if (op.kind !== 'Mem')
-        return undefined;
-    const evalEaAbs16 = (ea) => {
-        switch (ea.kind) {
-            case 'EaName':
-                return evalImmExpr({
-                    kind: 'ImmName',
-                    span: ea.span,
-                    name: ea.name,
-                }, env);
-            case 'EaImm':
-                return evalImmExpr(ea.expr, env);
-            case 'EaAdd': {
-                const base = evalEaAbs16(ea.base);
-                const delta = evalImmExpr(ea.offset, env);
-                if (base === undefined || delta === undefined)
-                    return undefined;
-                return base + delta;
-            }
-            case 'EaSub': {
-                const base = evalEaAbs16(ea.base);
-                const delta = evalImmExpr(ea.offset, env);
-                if (base === undefined || delta === undefined)
-                    return undefined;
-                return base - delta;
-            }
-            default:
-                return undefined;
-        }
-    };
-    return evalEaAbs16(op.expr);
-}
-function conditionName(op) {
-    if (op.kind === 'Reg')
-        return op.name.toUpperCase();
-    if (op.kind === 'Imm' && op.expr.kind === 'ImmName')
-        return op.expr.name.toUpperCase();
-    return undefined;
-}
-function symbolicImmBaseName(op, env) {
-    if (op.kind !== 'Imm')
-        return undefined;
-    const expr = op.expr;
-    if (expr.kind === 'ImmName')
-        return expr.name.toUpperCase();
-    if (expr.kind !== 'ImmBinary')
-        return undefined;
-    if (expr.op !== '+' && expr.op !== '-')
-        return undefined;
-    const leftName = expr.left.kind === 'ImmName' ? expr.left.name.toUpperCase() : undefined;
-    const rightName = expr.right.kind === 'ImmName' ? expr.right.name.toUpperCase() : undefined;
-    if (leftName) {
-        const right = evalImmExpr(expr.right, env);
-        if (right !== undefined)
-            return leftName;
-    }
-    if (expr.op === '+' && rightName) {
-        const left = evalImmExpr(expr.left, env);
-        if (left !== undefined)
-            return rightName;
-    }
-    return undefined;
-}
-function jpConditionOpcode(name) {
-    switch (name) {
-        case 'NZ':
-            return 0xc2;
-        case 'Z':
-            return 0xca;
-        case 'NC':
-            return 0xd2;
-        case 'C':
-            return 0xda;
-        case 'PO':
-            return 0xe2;
-        case 'PE':
-            return 0xea;
-        case 'P':
-            return 0xf2;
-        case 'M':
-            return 0xfa;
-        default:
-            return undefined;
-    }
-}
-function jrConditionOpcode(name) {
-    switch (name) {
-        case 'NZ':
-            return 0x20;
-        case 'Z':
-            return 0x28;
-        case 'NC':
-            return 0x30;
-        case 'C':
-            return 0x38;
-        default:
-            return undefined;
-    }
-}
-function callConditionOpcode(name) {
-    switch (name) {
-        case 'NZ':
-            return 0xc4;
-        case 'Z':
-            return 0xcc;
-        case 'NC':
-            return 0xd4;
-        case 'C':
-            return 0xdc;
-        case 'PO':
-            return 0xe4;
-        case 'PE':
-            return 0xec;
-        case 'P':
-            return 0xf4;
-        case 'M':
-            return 0xfc;
-        default:
-            return undefined;
-    }
-}
-function retConditionOpcode(name) {
-    switch (name) {
-        case 'NZ':
-            return 0xc0;
-        case 'Z':
-            return 0xc8;
-        case 'NC':
-            return 0xd0;
-        case 'C':
-            return 0xd8;
-        case 'PO':
-            return 0xe0;
-        case 'PE':
-            return 0xe8;
-        case 'P':
-            return 0xf0;
-        case 'M':
-            return 0xf8;
-        default:
-            return undefined;
-    }
-}
-function encodeFamilyInstruction(family, node, env, diagnostics) {
-    switch (family) {
-        case 'control':
-            return encodeControlInstruction(node, env, diagnostics, {
-                diag,
-                immValue,
-                registerTokenName,
-                conditionName,
-                symbolicImmBaseName,
-                fitsImm16,
-                isMemRegName,
-                retConditionOpcode,
-                callConditionOpcode,
-                jpConditionOpcode,
-                jrConditionOpcode,
-            });
-        case 'alu':
-            return encodeAluInstruction(node, env, diagnostics, {
-                diag,
-                regName,
-                immValue,
-                indexedReg8,
-                reg8Code,
-                fitsImm8,
-                isMemHL,
-                memIndexed: (op, env) => memIndexed(op, env, diagnostics),
-            });
-        case 'io':
-            return encodeIoInstruction(node, env, diagnostics, {
-                diag,
-                regName,
-                immValue,
-                portImmValue,
-                indexedReg8,
-                reg8Code,
-                fitsImm8,
-            });
-        case 'ld':
-            return encodeLdInstruction(node, env, diagnostics, {
-                diag,
-                regName,
-                immValue,
-                indexedReg8,
-                reg8Code,
-                fitsImm8,
-                fitsImm16,
-                memAbs16,
-                memIndexed: (op, env) => memIndexed(op, env, diagnostics),
-                isMemHL,
-                isMemRegName,
-                isReg16TransferName,
-                isPlainHLReg8,
-            });
-        case 'core':
-            return encodeCoreOpsInstruction(node, env, diagnostics, {
-                diag,
-                regName,
-                indexedReg8,
-                reg8Code,
-                isMemHL,
-                memIndexed: (op, env) => memIndexed(op, env, diagnostics),
-            });
-        case 'bit':
-            return encodeBitOpsInstruction(node, env, diagnostics, {
-                diag,
-                regName,
-                immValue,
-                indexedReg8,
-                reg8Code,
-                isMemHL,
-                memIndexed: (op, env) => memIndexed(op, env, diagnostics),
-            });
-    }
-}
-/**
- * Encode a single `asm` instruction node into Z80 machine-code bytes.
- *
- * - Immediate operands may be `imm` expressions (const/enum names and operators), evaluated via the env.
- * - Unsupported forms append an error diagnostic and return `undefined`.
- */
-export function encodeInstruction(node, env, diagnostics) {
-    const diagnosticsBefore = diagnostics.length;
-    const head = node.head.toLowerCase();
-    const entry = getEncoderRegistryEntry(head);
-    if (!entry) {
-        diagEncodeAt(diagnostics, node.span, `Unsupported instruction: ${node.head}`);
-        return undefined;
-    }
-    if (entry.kind === 'zero') {
-        if (node.operands.length === 0)
-            return entry.bytes;
-        diagEncodeAt(diagnostics, node.span, `${head} expects no operands`);
-        return undefined;
-    }
-    const encoded = encodeFamilyInstruction(entry.family, node, env, diagnostics);
-    if (encoded)
-        return encoded;
-    if (entry.fallback === 'none')
-        return undefined;
-    if (diagnostics.length > diagnosticsBefore)
-        return undefined;
-    const arityMessage = entry.arityDiagnostic(head, node.operands.length);
-    if (entry.fallback === 'arity-short-circuit' && arityMessage === undefined)
-        return undefined;
-    if (arityMessage !== undefined) {
-        diagEncodeAt(diagnostics, node.span, arityMessage);
-        return undefined;
-    }
-    diagEncodeAt(diagnostics, node.span, `${head} has unsupported operand form`);
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeAlu.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 { EncoderImmContext, EncoderMemContext, EncoderRegisterContext } from './encodeContext.js';
-type AluEncodeContext = EncoderRegisterContext & EncoderImmContext & EncoderMemContext;
-export declare function encodeAluInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: AluEncodeContext): Uint8Array | undefined;
-export {};

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

@@ -1,219 +0,0 @@
-function encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, rBase, immOpcode, memOpcode, mnemonic, allowExplicitA = false) {
-    const ops = node.operands;
-    let src;
-    if (ops.length === 1)
-        src = ops[0];
-    else if (ops.length === 2) {
-        if (allowExplicitA) {
-            if (ctx.regName(ops[0]) === 'A')
-                src = ops[1];
-            else {
-                ctx.diag(diagnostics, node, `${mnemonic} two-operand form requires destination A`);
-                return undefined;
-            }
-        }
-    }
-    if (!src)
-        return undefined;
-    const reg = ctx.regName(src);
-    const indexed = ctx.indexedReg8(src);
-    if (indexed)
-        return Uint8Array.of(indexed.prefix, rBase + indexed.code);
-    if (reg) {
-        const code = ctx.reg8Code(reg);
-        if (code === undefined) {
-            ctx.diag(diagnostics, node, `${mnemonic} expects reg8/imm8/(hl)`);
-            return undefined;
-        }
-        return Uint8Array.of(rBase + code);
-    }
-    if (ctx.isMemHL(src))
-        return Uint8Array.of(memOpcode);
-    const idx = ctx.memIndexed(src, env);
-    if (idx) {
-        const disp = idx.disp;
-        if (disp < -128 || disp > 127) {
-            ctx.diag(diagnostics, node, `${mnemonic} (ix/iy+disp) expects disp8`);
-            return undefined;
-        }
-        return Uint8Array.of(idx.prefix, memOpcode, disp & 0xff);
-    }
-    const n = ctx.immValue(src, env);
-    if (n === undefined || !ctx.fitsImm8(n)) {
-        ctx.diag(diagnostics, node, `${mnemonic} expects imm8`);
-        return undefined;
-    }
-    return Uint8Array.of(immOpcode, n & 0xff);
-}
-function encodeHlReg16Alu(node, diagnostics, ctx, src, mnemonic, opcodes) {
-    const opcode = src ? opcodes[src] : undefined;
-    if (opcode === undefined) {
-        ctx.diag(diagnostics, node, `${mnemonic} HL, rr expects BC/DE/HL/SP`);
-        return undefined;
-    }
-    return Uint8Array.of(0xed, opcode);
-}
-export function encodeAluInstruction(node, env, diagnostics, ctx) {
-    const head = node.head.toLowerCase();
-    const ops = node.operands;
-    if (head === 'add' && ops.length === 2) {
-        const dst = ctx.regName(ops[0]);
-        const src = ctx.regName(ops[1]);
-        if (dst === 'A') {
-            const indexedSrc = ctx.indexedReg8(ops[1]);
-            if (indexedSrc)
-                return Uint8Array.of(indexedSrc.prefix, 0x80 + indexedSrc.code);
-            if (src) {
-                const s = ctx.reg8Code(src);
-                if (s !== undefined)
-                    return Uint8Array.of(0x80 + s);
-            }
-            if (ctx.isMemHL(ops[1]))
-                return Uint8Array.of(0x86);
-            const idx = ctx.memIndexed(ops[1], env);
-            if (idx) {
-                const disp = idx.disp;
-                if (disp < -128 || disp > 127) {
-                    ctx.diag(diagnostics, node, `add A, (ix/iy+disp) expects disp8`);
-                    return undefined;
-                }
-                return Uint8Array.of(idx.prefix, 0x86, disp & 0xff);
-            }
-            const n = ctx.immValue(ops[1], env);
-            if (n !== undefined) {
-                if (!ctx.fitsImm8(n)) {
-                    ctx.diag(diagnostics, node, `add A, n expects imm8`);
-                    return undefined;
-                }
-                return Uint8Array.of(0xc6, n & 0xff);
-            }
-            ctx.diag(diagnostics, node, `add A, src expects reg8/imm8/(hl)/(ix/iy+disp)`);
-            return undefined;
-        }
-        if (dst === 'HL' && src) {
-            switch (src) {
-                case 'BC':
-                    return Uint8Array.of(0x09);
-                case 'DE':
-                    return Uint8Array.of(0x19);
-                case 'HL':
-                    return Uint8Array.of(0x29);
-                case 'SP':
-                    return Uint8Array.of(0x39);
-            }
-            ctx.diag(diagnostics, node, `add HL, rr expects BC/DE/HL/SP`);
-            return undefined;
-        }
-        if (dst === 'HL') {
-            ctx.diag(diagnostics, node, `add HL, rr expects BC/DE/HL/SP`);
-            return undefined;
-        }
-        if ((dst === 'IX' || dst === 'IY') && src) {
-            const prefix = dst === 'IX' ? 0xdd : 0xfd;
-            switch (src) {
-                case 'BC':
-                    return Uint8Array.of(prefix, 0x09);
-                case 'DE':
-                    return Uint8Array.of(prefix, 0x19);
-                case 'SP':
-                    return Uint8Array.of(prefix, 0x39);
-                case 'IX':
-                    if (dst === 'IX')
-                        return Uint8Array.of(0xdd, 0x29);
-                    break;
-                case 'IY':
-                    if (dst === 'IY')
-                        return Uint8Array.of(0xfd, 0x29);
-                    break;
-            }
-            ctx.diag(diagnostics, node, `add ${dst}, rr supports BC/DE/SP and same-index pair only`);
-            return undefined;
-        }
-        if (dst === 'IX' || dst === 'IY') {
-            ctx.diag(diagnostics, node, `add ${dst}, rr supports BC/DE/SP and same-index pair only`);
-            return undefined;
-        }
-        ctx.diag(diagnostics, node, `add expects destination A, HL, IX, or IY`);
-        return undefined;
-    }
-    if (head === 'sub') {
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0x90, 0xd6, 0x96, 'sub', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'cp') {
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0xb8, 0xfe, 0xbe, 'cp', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'and') {
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0xa0, 0xe6, 0xa6, 'and', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'or') {
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0xb0, 0xf6, 0xb6, 'or', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'xor') {
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0xa8, 0xee, 0xae, 'xor', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'adc') {
-        if (ops.length === 2) {
-            const dst = ctx.regName(ops[0]);
-            if (dst === 'HL') {
-                return encodeHlReg16Alu(node, diagnostics, ctx, ctx.regName(ops[1]), 'adc', {
-                    BC: 0x4a,
-                    DE: 0x5a,
-                    HL: 0x6a,
-                    SP: 0x7a,
-                });
-            }
-            if (dst !== 'A') {
-                ctx.diag(diagnostics, node, `adc expects destination A or HL`);
-                return undefined;
-            }
-        }
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0x88, 0xce, 0x8e, 'adc', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    if (head === 'sbc') {
-        if (ops.length === 2) {
-            const dst = ctx.regName(ops[0]);
-            if (dst === 'HL') {
-                return encodeHlReg16Alu(node, diagnostics, ctx, ctx.regName(ops[1]), 'sbc', {
-                    BC: 0x42,
-                    DE: 0x52,
-                    HL: 0x62,
-                    SP: 0x72,
-                });
-            }
-            if (dst !== 'A') {
-                ctx.diag(diagnostics, node, `sbc expects destination A or HL`);
-                return undefined;
-            }
-        }
-        const encoded = encodeAluAOrImm8OrMemHL(node, env, diagnostics, ctx, 0x98, 0xde, 0x9e, 'sbc', true);
-        if (encoded)
-            return encoded;
-        if (ops.length === 1 || ops.length === 2)
-            return undefined;
-    }
-    return undefined;
-}

package/dist/legacy-root-azm/src/z80/encodeBitOps.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 { EncoderImmContext, EncoderMemContext, EncoderRegisterContext } from './encodeContext.js';
-type BitOpsEncodeContext = EncoderRegisterContext & Pick<EncoderImmContext, 'immValue'> & EncoderMemContext;
-export declare function encodeBitOpsInstruction(node: AsmInstructionNode, env: CompileEnv, diagnostics: Diagnostic[], ctx: BitOpsEncodeContext): Uint8Array | undefined;
-export {};