@jhlagado/azm 0.1.0

package/dist/src/lowering/loweredAsmByteEmission.js

@@ -0,0 +1,185 @@
+import { resolveAsmEquSymbol } from './asmEquResolution.js';
+import { evalBinaryImmOp, evalUnaryImmOp } from './immMath.js';
+const toByte = (value) => value & 0xff;
+const toWord = (value) => value & 0xffff;
+function evalLoweredImmExpr(expr, env) {
+    switch (expr.kind) {
+        case 'literal':
+            return expr.value;
+        case 'symbol': {
+            const direct = env.equates.get(expr.name) ?? env.enums.get(expr.name);
+            if (direct !== undefined)
+                return direct + expr.addend;
+            const lower = expr.name.toLowerCase();
+            const alt = env.equates.get(lower) ?? env.enums.get(lower);
+            if (alt !== undefined)
+                return alt + expr.addend;
+            const asmAlias = resolveAsmEquSymbol(expr.name, { env });
+            if (asmAlias !== undefined)
+                return asmAlias + expr.addend;
+            return undefined;
+        }
+        case 'unary': {
+            const value = evalLoweredImmExpr(expr.expr, env);
+            if (value === undefined)
+                return undefined;
+            return evalUnaryImmOp(expr.op, value);
+        }
+        case 'binary': {
+            const left = evalLoweredImmExpr(expr.left, env);
+            const right = evalLoweredImmExpr(expr.right, env);
+            if (left === undefined || right === undefined)
+                return undefined;
+            return evalBinaryImmOp(expr.op, left, right);
+        }
+        case 'opaque':
+            return undefined;
+    }
+}
+function blockPlacementKey(placement) {
+    return `base:${placement}`;
+}
+/** Byte length of a lowered item as emitted into a placement (matches {@link emitLoweredAsmItemBytes}). */
+function loweredAsmItemEmittedSize(item, env) {
+    switch (item.kind) {
+        case 'label':
+        case 'const':
+        case 'comment':
+            return 0;
+        case 'db':
+            return item.values.length;
+        case 'dw':
+            return item.values.length * 2;
+        case 'ds': {
+            const size = evalLoweredImmExpr(item.size, env);
+            if (size === undefined || size < 0)
+                return 0;
+            return size;
+        }
+        case 'instr':
+            return item.bytes?.length ?? 0;
+    }
+}
+/**
+ * After link-time fixups are applied to `finalBytes`, patch lowered `instr` byte arrays
+ * (including `@raw` placeholders from abs16/rel8 fixups) so ASM80 listings match the
+ * merged image.
+ */
+export function syncLoweredAsmInstructionBytesFromFinalBytes(program, finalBytes, env) {
+    for (const block of program.blocks) {
+        if (block.kind !== 'placed')
+            continue;
+        let offset = 0;
+        const origin = block.origin;
+        for (const item of block.items) {
+            if (item.kind === 'instr' && item.bytes && item.bytes.length > 0) {
+                const base = origin + offset;
+                for (let i = 0; i < item.bytes.length; i++) {
+                    const b = finalBytes.get(base + i);
+                    if (b !== undefined)
+                        item.bytes[i] = b;
+                }
+            }
+            offset += loweredAsmItemEmittedSize(item, env);
+        }
+    }
+}
+function emitLoweredAsmItemBytes(item, ctx, bytes, origin, offsetRef, maxAddressRef) {
+    const updateMax = (addr) => {
+        if (addr > maxAddressRef.current)
+            maxAddressRef.current = addr;
+    };
+    const emitByte = (value) => {
+        const offset = offsetRef.current;
+        bytes.set(offset, toByte(value));
+        updateMax(origin + offset);
+        offsetRef.current++;
+    };
+    const emitWord = (value) => {
+        const v = toWord(value);
+        emitByte(v & 0xff);
+        emitByte((v >> 8) & 0xff);
+    };
+    switch (item.kind) {
+        case 'label':
+        case 'const':
+        case 'comment':
+            return;
+        case 'db':
+            for (const value of item.values) {
+                const v = evalLoweredImmExpr(value, ctx.env);
+                if (v === undefined) {
+                    ctx.diag(ctx.diagnostics, ctx.primaryFile, 'Failed to evaluate lowered byte value.');
+                    emitByte(0);
+                }
+                else {
+                    emitByte(v);
+                }
+            }
+            return;
+        case 'dw':
+            for (const value of item.values) {
+                const v = evalLoweredImmExpr(value, ctx.env);
+                if (v === undefined) {
+                    ctx.diag(ctx.diagnostics, ctx.primaryFile, 'Failed to evaluate lowered word value.');
+                    emitWord(0);
+                }
+                else {
+                    emitWord(v);
+                }
+            }
+            return;
+        case 'ds': {
+            const size = evalLoweredImmExpr(item.size, ctx.env);
+            if (size === undefined || size < 0) {
+                ctx.diag(ctx.diagnostics, ctx.primaryFile, 'Failed to evaluate lowered reserve size.');
+                return;
+            }
+            if (item.fill === undefined) {
+                offsetRef.current += size;
+                return;
+            }
+            const fillValue = evalLoweredImmExpr(item.fill, ctx.env) ?? 0;
+            for (let i = 0; i < size; i++)
+                emitByte(fillValue);
+            return;
+        }
+        case 'instr': {
+            if (!item.bytes) {
+                ctx.diag(ctx.diagnostics, ctx.primaryFile, `Lowered instruction missing encoded bytes.`);
+                return;
+            }
+            for (const b of item.bytes)
+                emitByte(b);
+            return;
+        }
+    }
+}
+export function emitLoweredAsmProgramBytes(program, ctx) {
+    const codeBytes = new Map();
+    const dataBytes = new Map();
+    const blockSizesByKey = new Map();
+    const maxAddressRef = { current: -1 };
+    for (const block of program.blocks) {
+        if (block.kind !== 'placed')
+            continue;
+        const placement = block.placement ?? 'code';
+        const key = blockPlacementKey(placement);
+        const target = placement === 'code'
+            ? codeBytes
+            : placement === 'data'
+                ? dataBytes
+                : new Map();
+        const offsetRef = { current: 0 };
+        for (const item of block.items) {
+            emitLoweredAsmItemBytes(item, ctx, target, block.origin, offsetRef, maxAddressRef);
+        }
+        blockSizesByKey.set(key, offsetRef.current);
+    }
+    return {
+        codeBytes,
+        dataBytes,
+        blockSizesByKey,
+        maxAddress: maxAddressRef.current,
+    };
+}

package/dist/src/lowering/loweredAsmPlacement.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { LoweredAsmProgram, LoweredAsmStream } from './loweredAsmTypes.js';
+type LoweredAsmPlacementContext = {
+    diagnostics: Diagnostic[];
+    diag: (diagnostics: Diagnostic[], file: string, message: string) => void;
+    primaryFile: string;
+    baseAddresses: {
+        codeBase: number;
+        dataBase: number;
+    };
+};
+export declare function placeLoweredAsmStream(stream: LoweredAsmStream, ctx: LoweredAsmPlacementContext): LoweredAsmProgram;
+export {};

package/dist/src/lowering/loweredAsmPlacement.js

@@ -0,0 +1,86 @@
+import { evalBinaryImmOp, evalUnaryImmOp } from './immMath.js';
+import { loweredItemSize } from './loweredItemSize.js';
+function baseOriginForPlacement(placement, baseAddresses) {
+    switch (placement) {
+        case 'code':
+            return baseAddresses.codeBase;
+        case 'data':
+            return baseAddresses.dataBase;
+    }
+}
+function resolveBlockOrigin(block, ctx) {
+    return baseOriginForPlacement(block.placement, ctx.baseAddresses);
+}
+export function placeLoweredAsmStream(stream, ctx) {
+    const blocks = [];
+    for (const block of stream.blocks) {
+        blocks.push({
+            kind: 'placed',
+            origin: resolveBlockOrigin(block, ctx),
+            placement: block.placement,
+            items: block.items,
+        });
+    }
+    resolvePlacedLoweredDataSymbols(blocks);
+    return { blocks };
+}
+function evalPlacedConst(expr, values) {
+    switch (expr.kind) {
+        case 'literal':
+            return expr.value;
+        case 'symbol': {
+            const base = values.get(expr.name.toLowerCase());
+            return base === undefined ? undefined : base + expr.addend;
+        }
+        case 'unary': {
+            const value = evalPlacedConst(expr.expr, values);
+            if (value === undefined)
+                return undefined;
+            return evalUnaryImmOp(expr.op, value);
+        }
+        case 'binary': {
+            const left = evalPlacedConst(expr.left, values);
+            const right = evalPlacedConst(expr.right, values);
+            if (left === undefined || right === undefined)
+                return undefined;
+            return evalBinaryImmOp(expr.op, left, right);
+        }
+        case 'opaque':
+            return undefined;
+    }
+}
+function resolvePlacedExpr(expr, values) {
+    const resolved = evalPlacedConst(expr, values);
+    return resolved === undefined ? expr : { kind: 'literal', value: resolved };
+}
+function resolvePlacedLoweredDataSymbols(blocks) {
+    const values = new Map();
+    for (const block of blocks) {
+        let offset = 0;
+        for (const item of block.items) {
+            if (item.kind === 'label')
+                values.set(item.name.toLowerCase(), block.origin + offset);
+            if (item.kind === 'const') {
+                const resolved = evalPlacedConst(item.value, values);
+                if (resolved !== undefined)
+                    values.set(item.name.toLowerCase(), resolved);
+            }
+            offset += loweredItemSize(item);
+        }
+    }
+    for (const block of blocks) {
+        for (const item of block.items) {
+            if (item.kind === 'db' || item.kind === 'dw') {
+                item.values = item.values.map((value) => resolvePlacedExpr(value, values));
+            }
+            else if (item.kind === 'ds') {
+                item.size = resolvePlacedExpr(item.size, values);
+                if (item.fill)
+                    item.fill = resolvePlacedExpr(item.fill, values);
+            }
+            else if (item.kind === 'const') {
+                item.value = resolvePlacedExpr(item.value, values);
+            }
+        }
+    }
+}

package/dist/src/lowering/loweredAsmStreamRecording.d.ts

@@ -0,0 +1,27 @@
+import type { SourceSpan, ImmExprNode, AsmOperandNode, TypeExprNode } from '../frontend/ast.js';
+import type { PlacementKind } from './loweringTypes.js';
+import type { LoweredAsmItem, LoweredAsmStream, LoweredAsmStreamBlock, LoweredImmExpr, LoweredOperand } from './loweredAsmTypes.js';
+type LoweredAsmStreamRecordingContext = {
+    activePlacementRef: {
+        current: PlacementKind;
+    };
+    loweredAsmBlocksByKey: Map<string, LoweredAsmStreamBlock>;
+    loweredAsmStream: LoweredAsmStream;
+    sourceLineComments?: Map<string, Map<number, string>>;
+    sourceTexts?: Map<string, string>;
+    evalImmNoDiag: (expr: ImmExprNode) => number | undefined;
+    symbolicTargetFromExpr: (expr: ImmExprNode) => {
+        baseLower: string;
+        addend: number;
+    } | undefined;
+    formatImmExprForAsm: (expr: ImmExprNode) => string;
+    typeDisplay: (typeExpr: TypeExprNode) => string;
+};
+export declare function createLoweredAsmStreamRecordingHelpers(ctx: LoweredAsmStreamRecordingContext): {
+    flushTrailingUserComments: () => void;
+    getLoweredAsmBlock: () => LoweredAsmStreamBlock;
+    lowerImmExprForLoweredAsm: (expr: ImmExprNode) => LoweredImmExpr;
+    lowerOperandForLoweredAsm: (operand: AsmOperandNode) => LoweredOperand;
+    recordLoweredAsmItem: (item: LoweredAsmItem, span?: SourceSpan) => void;
+};
+export {};

package/dist/src/lowering/loweredAsmStreamRecording.js

@@ -0,0 +1,215 @@
+export function createLoweredAsmStreamRecordingHelpers(ctx) {
+    const { activePlacementRef, loweredAsmBlocksByKey, loweredAsmStream, sourceLineComments, sourceTexts, evalImmNoDiag, symbolicTargetFromExpr, formatImmExprForAsm, typeDisplay, } = ctx;
+    const getLoweredAsmBlock = () => {
+        const placement = activePlacementRef.current;
+        const key = `base:${placement}`;
+        let block = loweredAsmBlocksByKey.get(key);
+        if (!block) {
+            block = {
+                kind: 'base',
+                placement,
+                items: [],
+            };
+            loweredAsmBlocksByKey.set(key, block);
+            loweredAsmStream.blocks.push(block);
+        }
+        return block;
+    };
+    const commentByFileLine = new Map();
+    const pendingUserComments = new Map();
+    const emittedUserCommentLines = new Set();
+    const lastBlockByFile = new Map();
+    const registerUserCommentLines = (file, lineMap) => {
+        if (lineMap.size === 0)
+            return;
+        commentByFileLine.set(file, lineMap);
+        pendingUserComments.set(file, {
+            lines: [...lineMap.keys()].sort((a, b) => a - b),
+            texts: lineMap,
+            index: 0,
+        });
+    };
+    if (sourceLineComments) {
+        for (const [file, lineMap] of sourceLineComments) {
+            registerUserCommentLines(file, lineMap);
+        }
+    }
+    else if (sourceTexts) {
+        for (const [file, text] of sourceTexts) {
+            const lines = text.split(/\r?\n/);
+            const lineMap = new Map();
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i] ?? '';
+                const semi = line.indexOf(';');
+                if (semi < 0)
+                    continue;
+                const commentText = line.slice(semi + 1).trim();
+                if (!commentText)
+                    continue;
+                lineMap.set(i + 1, commentText);
+            }
+            registerUserCommentLines(file, lineMap);
+        }
+    }
+    const emitPendingUserComments = (span) => {
+        if (!span)
+            return;
+        const pending = pendingUserComments.get(span.file);
+        if (!pending)
+            return;
+        while (pending.index < pending.lines.length) {
+            const line = pending.lines[pending.index];
+            if (line > span.start.line)
+                break;
+            pending.index += 1;
+            const key = `${span.file}:${line}`;
+            if (emittedUserCommentLines.has(key))
+                continue;
+            const text = pending.texts.get(line);
+            if (!text)
+                continue;
+            emittedUserCommentLines.add(key);
+            getLoweredAsmBlock().items.push({ kind: 'comment', text, origin: 'user' });
+        }
+    };
+    const recordLoweredAsmItem = (item, span) => {
+        if (item.kind !== 'comment' || item.origin !== 'user') {
+            emitPendingUserComments(span);
+        }
+        if (span) {
+            lastBlockByFile.set(span.file, getLoweredAsmBlock());
+        }
+        getLoweredAsmBlock().items.push(item);
+    };
+    const flushTrailingUserComments = () => {
+        for (const [file, pending] of pendingUserComments) {
+            if (pending.index >= pending.lines.length)
+                continue;
+            const block = lastBlockByFile.get(file);
+            if (!block)
+                continue;
+            while (pending.index < pending.lines.length) {
+                const line = pending.lines[pending.index];
+                pending.index += 1;
+                const key = `${file}:${line}`;
+                if (emittedUserCommentLines.has(key))
+                    continue;
+                const text = pending.texts.get(line);
+                if (!text)
+                    continue;
+                emittedUserCommentLines.add(key);
+                block.items.push({ kind: 'comment', text, origin: 'user' });
+            }
+        }
+    };
+    const lowerImmExprForLoweredAsm = (expr) => {
+        const value = evalImmNoDiag(expr);
+        if (value !== undefined)
+            return { kind: 'literal', value };
+        if (expr.kind !== 'ImmName') {
+            const symbolic = symbolicTargetFromExpr(expr);
+            if (symbolic) {
+                return { kind: 'symbol', name: symbolic.baseLower, addend: symbolic.addend };
+            }
+        }
+        switch (expr.kind) {
+            case 'ImmLiteral':
+                return { kind: 'literal', value: expr.value };
+            case 'ImmName':
+                return { kind: 'symbol', name: expr.name, addend: 0 };
+            case 'ImmUnary':
+                return {
+                    kind: 'unary',
+                    op: expr.op,
+                    expr: lowerImmExprForLoweredAsm(expr.expr),
+                };
+            case 'ImmBinary':
+                return {
+                    kind: 'binary',
+                    op: expr.op,
+                    left: lowerImmExprForLoweredAsm(expr.left),
+                    right: lowerImmExprForLoweredAsm(expr.right),
+                };
+            default:
+                return { kind: 'opaque', text: formatImmExprForAsm(expr) };
+        }
+    };
+    const lowerEaExprForLoweredAsm = (expr) => {
+        switch (expr.kind) {
+            case 'EaName':
+                return { kind: 'name', name: expr.name };
+            case 'EaImm':
+                return { kind: 'imm', expr: lowerImmExprForLoweredAsm(expr.expr) };
+            case 'EaLayoutCast':
+                return {
+                    kind: 'layoutCast',
+                    typeName: typeDisplay(expr.typeExpr),
+                    base: lowerEaExprForLoweredAsm(expr.base),
+                };
+            case 'EaField':
+                return { kind: 'field', base: lowerEaExprForLoweredAsm(expr.base), field: expr.field };
+            case 'EaAdd':
+                return {
+                    kind: 'add',
+                    base: lowerEaExprForLoweredAsm(expr.base),
+                    offset: lowerImmExprForLoweredAsm(expr.offset),
+                };
+            case 'EaSub':
+                return {
+                    kind: 'sub',
+                    base: lowerEaExprForLoweredAsm(expr.base),
+                    offset: lowerImmExprForLoweredAsm(expr.offset),
+                };
+            case 'EaIndex': {
+                const lowerIndexExpr = (index) => {
+                    switch (index.kind) {
+                        case 'IndexImm':
+                            return { kind: 'imm', value: lowerImmExprForLoweredAsm(index.value) };
+                        case 'IndexReg8':
+                            return { kind: 'reg8', reg: index.reg };
+                        case 'IndexReg16':
+                            return { kind: 'reg16', reg: index.reg };
+                        case 'IndexMemHL':
+                            return { kind: 'memHL' };
+                        case 'IndexMemIxIy':
+                            return {
+                                kind: 'memIxIy',
+                                base: index.base,
+                                ...(index.disp ? { disp: lowerImmExprForLoweredAsm(index.disp) } : {}),
+                            };
+                        case 'IndexEa':
+                            return { kind: 'ea', expr: lowerEaExprForLoweredAsm(index.expr) };
+                    }
+                };
+                return {
+                    kind: 'index',
+                    base: lowerEaExprForLoweredAsm(expr.base),
+                    index: lowerIndexExpr(expr.index),
+                };
+            }
+        }
+    };
+    const lowerOperandForLoweredAsm = (operand) => {
+        switch (operand.kind) {
+            case 'Reg':
+                return { kind: 'reg', name: operand.name };
+            case 'Imm':
+                return { kind: 'imm', expr: lowerImmExprForLoweredAsm(operand.expr) };
+            case 'Ea':
+                return { kind: 'ea', expr: lowerEaExprForLoweredAsm(operand.expr) };
+            case 'Mem':
+                return { kind: 'mem', expr: lowerEaExprForLoweredAsm(operand.expr) };
+            case 'PortImm8':
+                return { kind: 'portImm8', expr: lowerImmExprForLoweredAsm(operand.expr) };
+            case 'PortC':
+                return { kind: 'portC' };
+        }
+    };
+    return {
+        flushTrailingUserComments,
+        getLoweredAsmBlock,
+        lowerImmExprForLoweredAsm,
+        lowerOperandForLoweredAsm,
+        recordLoweredAsmItem,
+    };
+}