@jhlagado/azm 0.2.1 → 0.2.3

package/dist/legacy-root-azm/src/registerCare/fix.js

@@ -1,119 +0,0 @@
-import { getZ80InstructionEffect } from '../z80/effects.js';
-import { instructionSuccessors, labelIndex } from './controlFlow.js';
-import { contractCarrierList } from './report.js';
-import { joinSourceLines, splitSourceLines } from './sourceText.js';
-function sameLocation(a, b) {
-    return a.file === b.file && a.line === b.line && a.column === b.column;
-}
-function isUnconditionalDirectCall(item) {
-    const effect = getZ80InstructionEffect(item.instruction);
-    return (effect.control.kind === 'call' &&
-        effect.control.target !== undefined &&
-        !effect.control.conditional);
-}
-function continuationReads(routine, callIndex, carriers) {
-    const labels = labelIndex(routine);
-    const confirmed = new Set();
-    const work = callIndex + 1 < routine.instructions.length
-        ? [{ index: callIndex + 1, pending: [...new Set(carriers)] }]
-        : [];
-    const seen = new Set();
-    let steps = 0;
-    while (work.length > 0 && steps < 512) {
-        steps += 1;
-        const state = work.pop();
-        const pending = state.pending.filter((unit) => !confirmed.has(unit));
-        if (pending.length === 0)
-            continue;
-        const key = `${state.index}:${pending.join(',')}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        const item = routine.instructions[state.index];
-        if (!item)
-            continue;
-        const effect = getZ80InstructionEffect(item.instruction);
-        const reads = new Set(effect.reads);
-        const writes = new Set(effect.writes);
-        const remaining = [];
-        for (const unit of pending) {
-            if (reads.has(unit)) {
-                confirmed.add(unit);
-                continue;
-            }
-            if (!writes.has(unit))
-                remaining.push(unit);
-        }
-        if (remaining.length === 0)
-            continue;
-        for (const next of instructionSuccessors(routine, state.index, effect, labels)) {
-            work.push({ index: next, pending: remaining });
-        }
-    }
-    return carriers.filter((unit) => confirmed.has(unit));
-}
-export function findExpectOutFixes(routines, candidates) {
-    const out = [];
-    for (const routine of routines) {
-        for (let index = 0; index < routine.instructions.length; index += 1) {
-            const item = routine.instructions[index];
-            if (!isUnconditionalDirectCall(item))
-                continue;
-            const candidate = candidates.find((entry) => sameLocation(item, entry));
-            if (!candidate)
-                continue;
-            const carriers = continuationReads(routine, index, candidate.carriers);
-            if (carriers.length === 0)
-                continue;
-            out.push({ ...candidate, carriers });
-        }
-    }
-    return out;
-}
-function isExpectOutLine(line) {
-    return /^\s*;\s*expects\s+out\b/i.test(line);
-}
-function expectedCallLine(originalLines, fix) {
-    return originalLines[fix.line - 1]?.trim();
-}
-function findCallLineIndex(lines, originalLines, fix) {
-    const expected = expectedCallLine(originalLines, fix);
-    if (!expected)
-        return undefined;
-    const preferred = fix.line - 1;
-    if (lines[preferred]?.trim() === expected)
-        return preferred;
-    let best;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (let index = 0; index < lines.length; index += 1) {
-        if (lines[index]?.trim() !== expected)
-            continue;
-        const distance = Math.abs(index - preferred);
-        if (distance < bestDistance) {
-            best = index;
-            bestDistance = distance;
-        }
-    }
-    return best;
-}
-function indentation(line) {
-    return line.match(/^\s*/)?.[0] ?? '';
-}
-export function applyExpectOutFixesToSource(source, fixes, referenceSource = source) {
-    if (fixes.length === 0)
-        return source;
-    const originalLines = referenceSource.split(/\r?\n/);
-    const sourceLines = splitSourceLines(source);
-    const { lines } = sourceLines;
-    const sorted = [...fixes].sort((a, b) => b.line - a.line || b.column - a.column);
-    for (const fix of sorted) {
-        const index = findCallLineIndex(lines, originalLines, fix);
-        if (index === undefined)
-            continue;
-        if (index > 0 && isExpectOutLine(lines[index - 1] ?? ''))
-            continue;
-        const prefix = indentation(lines[index] ?? '');
-        lines.splice(index, 0, `${prefix}; expects out ${contractCarrierList(fix.carriers)}`);
-    }
-    return joinSourceLines(sourceLines);
-}

package/dist/legacy-root-azm/src/registerCare/liveness.d.ts

@@ -1,7 +0,0 @@
-import { type Diagnostic } from '../diagnosticTypes.js';
-import type { LocatedSmartComment, RegisterCareConflict, RegisterCareOutputCandidate, RegisterCareRoutine, RegisterCareUnit, RoutineSummary } from './types.js';
-export declare function findRegisterCareConflicts(routine: RegisterCareRoutine, summaries: Map<string, RoutineSummary>, hints: LocatedSmartComment[]): RegisterCareConflict[];
-export declare function findCallerOutputCandidateObservations(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>): RegisterCareOutputCandidate[];
-export declare function findCallerOutputCandidates(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>): Map<string, RegisterCareUnit[]>;
-export declare function findAcceptedOutputCandidatesFromHints(routines: RegisterCareRoutine[], summaries: Map<string, RoutineSummary>, hints: LocatedSmartComment[]): Map<string, RegisterCareUnit[]>;
-export declare function diagnosticsForRegisterCareConflicts(conflicts: RegisterCareConflict[], severity: 'warning' | 'error'): Diagnostic[];

package/dist/legacy-root-azm/src/registerCare/liveness.js

@@ -1,227 +0,0 @@
-import { DiagnosticIds } from '../diagnosticTypes.js';
-import { getZ80InstructionEffect } from '../z80/effects.js';
-import { precedingCServiceName } from './boundaryHints.js';
-import { instructionSuccessors, labelIndex } from './controlFlow.js';
-import { rstServiceTargetName, rstTargetName } from './profiles.js';
-function unique(units) {
-    return [...new Set(units)];
-}
-function withImpliedFlagUnits(units) {
-    return unique(units);
-}
-function boundaryTarget(routine, index, effect) {
-    const item = routine.instructions[index];
-    if (effect.control.kind === 'call' && effect.control.target) {
-        return {
-            targets: [effect.control.target],
-            conditional: effect.control.conditional,
-            subject: `CALL ${effect.control.target}`,
-        };
-    }
-    if (effect.control.kind === 'jump' &&
-        item?.head.toLowerCase() === 'jp' &&
-        !effect.control.conditional &&
-        effect.control.target &&
-        !effect.control.target.startsWith('.')) {
-        return {
-            targets: [effect.control.target],
-            conditional: false,
-            subject: `JP ${effect.control.target}`,
-        };
-    }
-    if (effect.control.kind === 'rst' && effect.control.vector !== undefined) {
-        const target = rstTargetName(effect.control.vector);
-        const service = precedingCServiceName(routine.instructions[index - 1]);
-        const targets = service
-            ? [rstServiceTargetName(effect.control.vector, service), target]
-            : [target];
-        return { targets, conditional: false, subject: target };
-    }
-    return undefined;
-}
-function summaryForBoundary(boundary, summaries) {
-    for (const target of boundary.targets) {
-        const summary = summaries.get(target);
-        if (summary)
-            return { target, summary };
-    }
-    return undefined;
-}
-function hintUnitsForLine(hints, file, callLine) {
-    const prior = hints.find((hint) => hint.file === file && hint.line === callLine - 1 && hint.comment.kind === 'expectOut');
-    return prior?.comment.kind === 'expectOut' ? withImpliedFlagUnits(prior.comment.carriers) : [];
-}
-function outputUnits(summary) {
-    return withImpliedFlagUnits(summary.valueRelations.flatMap((relation) => relation.out));
-}
-function setEqual(left, right) {
-    if (left.size !== right.size)
-        return false;
-    for (const item of left)
-        if (!right.has(item))
-            return false;
-    return true;
-}
-function unionLive(sets) {
-    const out = new Set();
-    for (const set of sets) {
-        for (const unit of set)
-            out.add(unit);
-    }
-    return out;
-}
-function transferLiveBefore(item, effect, boundary, summary, liveAfter, hints) {
-    const live = new Set(liveAfter);
-    if (boundary && summary) {
-        const accepted = new Set();
-        for (const unit of hintUnitsForLine(hints, item.file, item.line))
-            accepted.add(unit);
-        for (const unit of outputUnits(summary))
-            accepted.add(unit);
-        if (!boundary.conditional) {
-            for (const unit of summary.mayWrite)
-                live.delete(unit);
-            for (const unit of accepted)
-                live.delete(unit);
-        }
-        for (const unit of summary.mayRead)
-            live.add(unit);
-    }
-    const instructionWritesAreConditional = effect.control.kind === 'call' && effect.control.conditional;
-    if (!instructionWritesAreConditional) {
-        for (const unit of effect.writes)
-            live.delete(unit);
-    }
-    for (const unit of effect.reads)
-        live.add(unit);
-    return live;
-}
-function liveSetsForRoutine(routine, summaries, hints = []) {
-    const labels = labelIndex(routine);
-    const effects = routine.instructions.map((item) => getZ80InstructionEffect(item.instruction));
-    const boundaries = effects.map((effect, index) => boundaryTarget(routine, index, effect));
-    const resolvedSummaries = boundaries.map((boundary) => boundary ? summaryForBoundary(boundary, summaries)?.summary : undefined);
-    const successorIndexes = effects.map((effect, index) => instructionSuccessors(routine, index, effect, labels, { boundaryFallthrough: true }));
-    const liveIn = routine.instructions.map(() => new Set());
-    const liveOut = routine.instructions.map(() => new Set());
-    let changed = true;
-    let passes = 0;
-    while (changed && passes < Math.max(8, routine.instructions.length * 4)) {
-        changed = false;
-        passes += 1;
-        for (let index = routine.instructions.length - 1; index >= 0; index -= 1) {
-            const nextOut = unionLive(successorIndexes[index].map((successor) => liveIn[successor]));
-            const nextIn = transferLiveBefore(routine.instructions[index], effects[index], boundaries[index], resolvedSummaries[index], nextOut, hints);
-            if (!setEqual(nextOut, liveOut[index])) {
-                liveOut[index] = nextOut;
-                changed = true;
-            }
-            if (!setEqual(nextIn, liveIn[index])) {
-                liveIn[index] = nextIn;
-                changed = true;
-            }
-        }
-    }
-    return { liveIn, liveOut };
-}
-function resolvedBoundariesForRoutine(routine, summaries) {
-    const out = [];
-    for (let index = 0; index < routine.instructions.length; index += 1) {
-        const item = routine.instructions[index];
-        const effect = getZ80InstructionEffect(item.instruction);
-        const boundary = boundaryTarget(routine, index, effect);
-        if (!boundary)
-            continue;
-        const resolved = summaryForBoundary(boundary, summaries);
-        if (!resolved)
-            continue;
-        out.push({ item, index, boundary, target: resolved.target, summary: resolved.summary });
-    }
-    return out;
-}
-export function findRegisterCareConflicts(routine, summaries, hints) {
-    const conflicts = [];
-    const { liveOut } = liveSetsForRoutine(routine, summaries, hints);
-    for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
-        const accepted = new Set();
-        for (const unit of hintUnitsForLine(hints, item.file, item.line))
-            accepted.add(unit);
-        for (const unit of outputUnits(summary))
-            accepted.add(unit);
-        const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !accepted.has(unit)));
-        if (carriers.length > 0) {
-            conflicts.push({
-                file: item.file,
-                line: item.line,
-                column: item.column,
-                callTarget: target,
-                carriers,
-                message: `${boundary.subject} may modify ${carriers.join(',')}, but the pre-call value is used later.`,
-            });
-        }
-    }
-    return conflicts;
-}
-function appendMapUnits(out, target, units) {
-    const existing = out.get(target) ?? [];
-    for (const unit of units) {
-        if (!existing.includes(unit))
-            existing.push(unit);
-    }
-    out.set(target, existing);
-}
-function candidateMessage(boundary, units) {
-    const carriers = units.join(',');
-    const expectation = units.length === 1 ? units[0] : `{${carriers}}`;
-    return `${boundary.subject} writes ${carriers} and caller reads it later; review the call site and add \`; expects out ${expectation}\` above the call if this is intentional.`;
-}
-export function findCallerOutputCandidateObservations(routines, summaries) {
-    const out = [];
-    for (const routine of routines) {
-        const { liveOut } = liveSetsForRoutine(routine, summaries);
-        for (const { item, index, boundary, target, summary } of resolvedBoundariesForRoutine(routine, summaries)) {
-            const alreadyOutput = new Set(outputUnits(summary));
-            const carriers = unique(summary.mayWrite.filter((unit) => liveOut[index].has(unit) && !alreadyOutput.has(unit)));
-            if (carriers.length > 0) {
-                out.push({
-                    file: item.file,
-                    line: item.line,
-                    column: item.column,
-                    routine: target,
-                    carriers,
-                    message: candidateMessage(boundary, carriers),
-                });
-            }
-        }
-    }
-    return out;
-}
-export function findCallerOutputCandidates(routines, summaries) {
-    const candidates = new Map();
-    for (const item of findCallerOutputCandidateObservations(routines, summaries)) {
-        appendMapUnits(candidates, item.routine, item.carriers);
-    }
-    return candidates;
-}
-export function findAcceptedOutputCandidatesFromHints(routines, summaries, hints) {
-    const accepted = new Map();
-    for (const routine of routines) {
-        for (const { item, target } of resolvedBoundariesForRoutine(routine, summaries)) {
-            const units = hintUnitsForLine(hints, item.file, item.line);
-            if (units.length === 0)
-                continue;
-            appendMapUnits(accepted, target, units);
-        }
-    }
-    return accepted;
-}
-export function diagnosticsForRegisterCareConflicts(conflicts, severity) {
-    return conflicts.map((conflict) => ({
-        id: DiagnosticIds.RegisterCareConflict,
-        severity,
-        message: conflict.message,
-        file: conflict.file,
-        line: conflict.line,
-        column: conflict.column,
-    }));
-}

package/dist/legacy-root-azm/src/registerCare/profiles.d.ts

@@ -1,11 +0,0 @@
-import type { RoutineSummary } from './types.js';
-export type RegisterCareProfileName = 'mon3';
-interface RegisterCareProfile {
-    name: RegisterCareProfileName;
-    rst: Map<number, RoutineSummary>;
-    rstServices: Map<string, RoutineSummary>;
-}
-export declare function rstTargetName(vector: number): string;
-export declare function rstServiceTargetName(vector: number, service: string): string;
-export declare function getRegisterCareProfile(name: RegisterCareProfileName | undefined): RegisterCareProfile | undefined;
-export {};

package/dist/legacy-root-azm/src/registerCare/profiles.js

@@ -1,45 +0,0 @@
-const FLAG_UNITS = ['carry', 'zero', 'sign', 'parity', 'halfCarry'];
-export function rstTargetName(vector) {
-    return `RST_$${vector.toString(16).toUpperCase().padStart(2, '0')}`;
-}
-function normalizeServiceName(service) {
-    return service.replace(/[^A-Za-z0-9]/gu, '').toUpperCase();
-}
-export function rstServiceTargetName(vector, service) {
-    return `${rstTargetName(vector)}:${normalizeServiceName(service)}`;
-}
-export function getRegisterCareProfile(name) {
-    if (name !== 'mon3')
-        return undefined;
-    return {
-        name: 'mon3',
-        rst: new Map([
-            [
-                0x10,
-                {
-                    name: rstTargetName(0x10),
-                    mayRead: [],
-                    mayWrite: ['A', ...FLAG_UNITS],
-                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
-                    valueRelations: [],
-                    stackBalanced: true,
-                    hasUnknownStackEffect: false,
-                },
-            ],
-        ]),
-        rstServices: new Map([
-            [
-                rstServiceTargetName(0x10, 'API_SCANKEYS'),
-                {
-                    name: rstServiceTargetName(0x10, 'API_SCANKEYS'),
-                    mayRead: ['C'],
-                    mayWrite: ['sign', 'parity', 'halfCarry'],
-                    preserved: ['B', 'C', 'D', 'E', 'H', 'L'],
-                    valueRelations: [{ out: ['A', 'carry', 'zero'], from: [] }],
-                    stackBalanced: true,
-                    hasUnknownStackEffect: false,
-                },
-            ],
-        ]),
-    };
-}

package/dist/legacy-root-azm/src/registerCare/programModel.d.ts

@@ -1,3 +0,0 @@
-import type { ProgramNode } from '../frontend/ast.js';
-import type { RegisterCareProgramModel } from './types.js';
-export declare function buildRegisterCareProgramModel(program: ProgramNode): RegisterCareProgramModel;

package/dist/legacy-root-azm/src/registerCare/programModel.js

@@ -1,181 +0,0 @@
-import { createInlineOpInstructionStreamExpander } from '../lowering/opExpansionStream.js';
-function flattenItems(items, out, expandInstruction) {
-    for (const item of items) {
-        if (item.kind === 'AsmLabel') {
-            out.push({ kind: 'label', label: item });
-            continue;
-        }
-        if (item.kind === 'AsmInstruction') {
-            out.push(...expandInstruction(item));
-        }
-    }
-}
-function directCallTarget(inst) {
-    if (inst.head.toLowerCase() !== 'call')
-        return undefined;
-    if (inst.operands.length !== 1 && inst.operands.length !== 2)
-        return undefined;
-    const op = inst.operands[inst.operands.length - 1];
-    if (op?.kind !== 'Imm' || op.expr.kind !== 'ImmName')
-        return undefined;
-    return op.expr.name;
-}
-function directTailJumpTarget(inst, entryNames) {
-    if (inst.head.toLowerCase() !== 'jp')
-        return undefined;
-    if (inst.operands.length !== 1 && inst.operands.length !== 2)
-        return undefined;
-    if (inst.operands.length === 2 && entryNames === undefined)
-        return undefined;
-    const op = inst.operands[inst.operands.length - 1];
-    if (op?.kind !== 'Imm' || op.expr.kind !== 'ImmName')
-        return undefined;
-    if (op.expr.name.startsWith('.'))
-        return undefined;
-    if (entryNames !== undefined && !entryNames.has(op.expr.name))
-        return undefined;
-    return op.expr.name;
-}
-function toInstruction(inst, labels = []) {
-    return {
-        instruction: inst,
-        head: inst.head.toLowerCase(),
-        file: inst.span.file,
-        line: inst.span.start.line,
-        column: inst.span.start.column,
-        labels,
-    };
-}
-function spanFrom(start, end) {
-    if (start.file !== end.file)
-        return start;
-    return {
-        file: start.file,
-        start: start.start,
-        end: end.end,
-    };
-}
-function isLocalLabel(name) {
-    return name.startsWith('.');
-}
-function isEntryLabel(label) {
-    return label.isEntry === true;
-}
-function flatItemFile(item) {
-    return item.kind === 'label' ? item.label.span.file : item.instruction.span.file;
-}
-function isTerminalReturn(inst) {
-    const head = inst.head.toLowerCase();
-    if (head === 'ret')
-        return inst.operands.length === 0;
-    return head === 'retn' || head === 'reti';
-}
-export function buildRegisterCareProgramModel(program) {
-    const flat = [];
-    const { expandInstruction } = createInlineOpInstructionStreamExpander(program);
-    for (const file of program.files) {
-        flattenItems(file.items, flat, expandInstruction);
-    }
-    const labelItems = flat.filter((item) => item.kind === 'label');
-    const filesWithEntryLabels = new Set(labelItems.filter((item) => isEntryLabel(item.label)).map((item) => item.label.span.file));
-    const entryLabelNames = new Set(labelItems
-        .filter((item) => isEntryLabel(item.label) ||
-        (!filesWithEntryLabels.has(item.label.span.file) && !isLocalLabel(item.label.name)))
-        .map((item) => item.label.name));
-    const directCalls = flat.flatMap((item) => {
-        if (item.kind !== 'instruction')
-            return [];
-        const target = directCallTarget(item.instruction);
-        if (target === undefined)
-            return [];
-        return [
-            {
-                target,
-                subject: `CALL ${target}`,
-                file: item.instruction.span.file,
-                line: item.instruction.span.start.line,
-                column: item.instruction.span.start.column,
-            },
-        ];
-    });
-    const directTailJumps = flat.flatMap((item) => {
-        if (item.kind !== 'instruction')
-            return [];
-        const sourceFileUsesEntryLabels = filesWithEntryLabels.has(item.instruction.span.file);
-        const target = directTailJumpTarget(item.instruction, sourceFileUsesEntryLabels ? entryLabelNames : undefined);
-        if (target === undefined)
-            return [];
-        return [
-            {
-                target,
-                subject: `JP ${target}`,
-                file: item.instruction.span.file,
-                line: item.instruction.span.start.line,
-                column: item.instruction.span.start.column,
-            },
-        ];
-    });
-    const directBoundaries = [...directCalls, ...directTailJumps];
-    const directCallTargets = Array.from(new Set(directCalls.map((call) => call.target))).sort();
-    const routines = [];
-    const coalescedGlobalLabelIndexes = new Set();
-    for (let index = 0; index < flat.length; index += 1) {
-        const item = flat[index];
-        if (coalescedGlobalLabelIndexes.has(index))
-            continue;
-        if (item?.kind !== 'label' || isLocalLabel(item.label.name))
-            continue;
-        const routineFile = item.label.span.file;
-        const fileUsesEntryLabels = filesWithEntryLabels.has(routineFile);
-        if (fileUsesEntryLabels && !isEntryLabel(item.label))
-            continue;
-        const labels = [item.label.name];
-        const entryLabels = isEntryLabel(item.label) ? [item.label.name] : undefined;
-        const instructions = [];
-        let pendingInstructionLabels = [item.label.name];
-        let endSpan = item.label.span;
-        for (let rangeIndex = index + 1; rangeIndex < flat.length; rangeIndex += 1) {
-            const rangeItem = flat[rangeIndex];
-            if (!rangeItem)
-                break;
-            if (flatItemFile(rangeItem) !== routineFile)
-                break;
-            if (rangeItem.kind === 'label') {
-                if (fileUsesEntryLabels && isEntryLabel(rangeItem.label)) {
-                    if (instructions.length > 0)
-                        break;
-                    labels.push(rangeItem.label.name);
-                    entryLabels?.push(rangeItem.label.name);
-                    coalescedGlobalLabelIndexes.add(rangeIndex);
-                    endSpan = rangeItem.label.span;
-                    continue;
-                }
-                if (!fileUsesEntryLabels && !isLocalLabel(rangeItem.label.name)) {
-                    if (instructions.length > 0)
-                        break;
-                    labels.push(rangeItem.label.name);
-                    coalescedGlobalLabelIndexes.add(rangeIndex);
-                    endSpan = rangeItem.label.span;
-                    continue;
-                }
-                labels.push(rangeItem.label.name);
-                pendingInstructionLabels.push(rangeItem.label.name);
-                endSpan = rangeItem.label.span;
-                continue;
-            }
-            instructions.push(toInstruction(rangeItem.instruction, pendingInstructionLabels));
-            pendingInstructionLabels = [];
-            endSpan = rangeItem.instruction.span;
-            if (isTerminalReturn(rangeItem.instruction))
-                break;
-        }
-        routines.push({
-            name: item.label.name,
-            span: spanFrom(item.label.span, endSpan),
-            labels,
-            ...(entryLabels ? { entryLabels } : {}),
-            instructions,
-        });
-    }
-    return { routines, directCallTargets, directCalls, directBoundaries };
-}

package/dist/legacy-root-azm/src/registerCare/report.d.ts

@@ -1,5 +0,0 @@
-import type { RegisterCareReportModel, RegisterCareUnit, RoutineSummary } from './types.js';
-export declare function contractCarrierList(units: RegisterCareUnit[]): string;
-export declare function renderRegisterCareReport(model: RegisterCareReportModel): string;
-export declare function renderRegisterCareInterface(summaries: RoutineSummary[]): string;
-export declare function renderRegisterCareSourceBlock(summary: RoutineSummary): string[];