@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/lowering/loweredAsmByteEmission.js

@@ -1,185 +0,0 @@
-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/legacy-root-azm/src/lowering/loweredAsmPlacement.d.ts

@@ -1,13 +0,0 @@
-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/legacy-root-azm/src/lowering/loweredAsmPlacement.js

@@ -1,86 +0,0 @@
-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/legacy-root-azm/src/lowering/loweredAsmStreamRecording.d.ts

@@ -1,27 +0,0 @@
-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/legacy-root-azm/src/lowering/loweredAsmStreamRecording.js

@@ -1,215 +0,0 @@
-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,
-    };
-}