@jhlagado/azm 0.2.6 → 0.2.8

package/dist/src/outputs/d8-helpers.js

@@ -0,0 +1,136 @@
+import { isAbsolute, normalize, relative, resolve } from 'node:path';
+function toHexFilePath(path, rootDir) {
+    const normalized = normalize(path).replace(/\\/g, '/');
+    if (!rootDir) {
+        return normalized;
+    }
+    const root = normalize(resolve(rootDir)).replace(/\\/g, '/');
+    const resolvedPath = normalize(resolve(path)).replace(/\\/g, '/');
+    const rel = relative(root, resolvedPath).replace(/\\/g, '/');
+    if (rel.startsWith('..') || rel === '' || isAbsolute(rel)) {
+        return resolvedPath;
+    }
+    return rel;
+}
+export function toD8mSymbol(symbol, rootDir) {
+    if (symbol.kind === 'constant') {
+        return {
+            name: symbol.name,
+            kind: symbol.kind,
+            value: symbol.value,
+            ...(symbol.file !== undefined ? { file: toHexFilePath(symbol.file, rootDir) } : {}),
+            ...(symbol.line !== undefined ? { line: symbol.line } : {}),
+            ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
+        };
+    }
+    return {
+        name: symbol.name,
+        kind: symbol.kind,
+        address: symbol.address,
+        ...(symbol.file !== undefined ? { file: toHexFilePath(symbol.file, rootDir) } : {}),
+        ...(symbol.line !== undefined ? { line: symbol.line } : {}),
+        ...(symbol.scope !== undefined ? { scope: symbol.scope } : {}),
+        ...(symbol.size !== undefined ? { size: symbol.size } : {}),
+    };
+}
+export function compareSymbol(a, b) {
+    return firstNonZero([
+        symbolClass(a) - symbolClass(b),
+        symbolAddress(a) - symbolAddress(b),
+        a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+        a.kind.localeCompare(b.kind),
+        (a.file ?? '').localeCompare(b.file ?? ''),
+        (a.line ?? 0) - (b.line ?? 0),
+        symbolTieBreaker(a, b),
+    ]);
+}
+function firstNonZero(values) {
+    return values.find((value) => value !== 0) ?? 0;
+}
+function symbolClass(symbol) {
+    return symbol.kind === 'constant' ? 1 : 0;
+}
+function symbolAddress(symbol) {
+    return symbol.kind === 'constant'
+        ? (symbol.value ?? 0) & 0xffff
+        : (symbol.address ?? 0) & 0xffff;
+}
+function symbolTieBreaker(a, b) {
+    if (a.kind === 'constant' && b.kind === 'constant') {
+        return (a.value ?? 0) - (b.value ?? 0);
+    }
+    return (a.size ?? 0) - (b.size ?? 0);
+}
+export function compareFileSymbol(a, b) {
+    return compareSymbol(a, b);
+}
+export function compareSegment(a, b) {
+    if (a.start !== b.start)
+        return a.start - b.start;
+    if (a.end !== b.end)
+        return a.end - b.end;
+    if (a.lstLine !== b.lstLine)
+        return a.lstLine - b.lstLine;
+    const lineCmp = (a.line ?? 0) - (b.line ?? 0);
+    if (lineCmp !== 0)
+        return lineCmp;
+    const kindCmp = a.kind.localeCompare(b.kind);
+    if (kindCmp !== 0)
+        return kindCmp;
+    return a.confidence.localeCompare(b.confidence);
+}
+export function rangesOverlap(a, b) {
+    return a.start < b.end && b.start < a.end;
+}
+export function normalizeInputs(inputs, rootDir) {
+    const out = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        if (value !== undefined && value.length > 0) {
+            out[key] = toHexFilePath(value, rootDir);
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function normalizeSourceSegments(sourceSegments, writtenSegments, rootDir) {
+    return coalesceSourceSegments(sourceSegments.flatMap((segment) => clipSourceSegmentToWrittenSegments(segment, writtenSegments).map((clipped) => ({
+        ...clipped,
+        file: toHexFilePath(clipped.file, rootDir),
+    }))));
+}
+function clipSourceSegmentToWrittenSegments(segment, writtenSegments) {
+    const clipped = [];
+    for (const writtenSegment of writtenSegments) {
+        const start = Math.max(segment.start, writtenSegment.start);
+        const end = Math.min(segment.end, writtenSegment.end);
+        if (end > start) {
+            clipped.push({ ...segment, start, end });
+        }
+    }
+    return clipped;
+}
+function coalesceSourceSegments(segments) {
+    const sorted = [...segments].sort((a, b) => a.file.localeCompare(b.file) ||
+        a.line - b.line ||
+        a.column - b.column ||
+        a.kind.localeCompare(b.kind) ||
+        a.confidence.localeCompare(b.confidence) ||
+        a.start - b.start ||
+        a.end - b.end);
+    const coalesced = [];
+    for (const segment of sorted) {
+        const previous = coalesced[coalesced.length - 1];
+        if (previous &&
+            previous.file === segment.file &&
+            previous.line === segment.line &&
+            previous.column === segment.column &&
+            previous.kind === segment.kind &&
+            previous.confidence === segment.confidence &&
+            previous.end === segment.start) {
+            coalesced[coalesced.length - 1] = { ...previous, end: segment.end };
+        }
+        else {
+            coalesced.push(segment);
+        }
+    }
+    return coalesced;
+}

package/dist/src/outputs/hex.js

@@ -25,30 +25,18 @@ export function writeIntelHex(origin, bytes, reservedAddresses = [], initialized
     return `${records.join('\n')}\n:00000001FF\n`;
 }
 function toNonReservedSegments(start, end, reservedAddresses, initializedAddresses) {
-    if (reservedAddresses.length === 0 || initializedAddresses.length === 0) {
+    const bounds = initializedBounds(start, end, initializedAddresses);
+    if (!bounds)
         return [];
-    }
-    const inRangeInitialized = initializedAddresses.filter((address) => address >= start && address < end);
-    if (inRangeInitialized.length === 0) {
-        return [];
-    }
-    const firstInitialized = inRangeInitialized.reduce((best, address) => Math.min(best, address), end);
-    const lastInitialized = inRangeInitialized.reduce((best, address) => Math.max(best, address), start - 1);
-    const reservedInRange = new Set(reservedAddresses.filter((address) => address >= start && address < end));
-    if (reservedInRange.size === 0) {
+    const reservedInRange = addressSetInRange(start, end, reservedAddresses);
+    if (reservedInRange.size === 0)
         return [];
-    }
     const segments = [];
     let segmentStart;
     let segmentEnd = start;
     for (let address = start; address < end; address += 1) {
-        const skipReserved = address > firstInitialized &&
-            address < lastInitialized &&
-            reservedInRange.has(address);
-        if (skipReserved) {
-            if (segmentStart !== undefined) {
-                segments.push({ start: segmentStart, end: segmentEnd });
-            }
+        if (shouldSkipReservedAddress(address, bounds, reservedInRange)) {
+            closeSegment(segments, segmentStart, segmentEnd);
             segmentStart = undefined;
             segmentEnd = address + 1;
             continue;
@@ -63,6 +51,26 @@ function toNonReservedSegments(start, end, reservedAddresses, initializedAddress
     }
     return segments;
 }
+function initializedBounds(start, end, initializedAddresses) {
+    const inRange = initializedAddresses.filter((address) => address >= start && address < end);
+    if (inRange.length === 0)
+        return undefined;
+    return {
+        first: inRange.reduce((best, address) => Math.min(best, address), end),
+        last: inRange.reduce((best, address) => Math.max(best, address), start - 1),
+    };
+}
+function addressSetInRange(start, end, addresses) {
+    return new Set(addresses.filter((address) => address >= start && address < end));
+}
+function shouldSkipReservedAddress(address, initialized, reservedInRange) {
+    return address > initialized.first && address < initialized.last && reservedInRange.has(address);
+}
+function closeSegment(segments, segmentStart, segmentEnd) {
+    if (segmentStart !== undefined) {
+        segments.push({ start: segmentStart, end: segmentEnd });
+    }
+}
 function writeRecord(length, address, type, bytes) {
     const fields = [length, (address >> 8) & 0xff, address & 0xff, type, ...bytes];
     const checksum = ((~fields.reduce((sum, value) => sum + value, 0) + 1) & 0xff) >>> 0;

package/dist/src/outputs/types.d.ts

@@ -50,27 +50,33 @@ export interface HexArtifact {
     path?: string;
     text: string;
 }
-/** In-memory register-care audit report artifact. */
-export interface RegisterCareReportArtifact {
-    kind: 'register-care-report';
+/** In-memory register contracts audit report artifact. */
+export interface RegisterContractsReportArtifact {
+    kind: 'register-contracts-report';
     path?: string;
     text: string;
 }
-/** In-memory inferred register-care interface artifact. */
-export interface RegisterCareInterfaceArtifact {
-    kind: 'register-care-interface';
+/** @deprecated Use RegisterContractsReportArtifact. */
+export type RegisterCareReportArtifact = RegisterContractsReportArtifact;
+/** In-memory inferred register contracts interface artifact. */
+export interface RegisterContractsInterfaceArtifact {
+    kind: 'register-contracts-interface';
     path?: string;
     text: string;
 }
-/** In-memory register-care source annotation artifact. */
-export interface RegisterCareAnnotationsArtifact {
-    kind: 'register-care-annotations';
+/** @deprecated Use RegisterContractsInterfaceArtifact. */
+export type RegisterCareInterfaceArtifact = RegisterContractsInterfaceArtifact;
+/** In-memory register contracts source annotation artifact. */
+export interface RegisterContractsAnnotationsArtifact {
+    kind: 'register-contracts-annotations';
     path?: string;
     files: {
         path: string;
         text: string;
     }[];
 }
+/** @deprecated Use RegisterContractsAnnotationsArtifact. */
+export type RegisterCareAnnotationsArtifact = RegisterContractsAnnotationsArtifact;
 /** Lowered .z80 artifact. */
 export interface Asm80Artifact {
     kind: 'asm80';
@@ -159,7 +165,7 @@ export interface WriteD8mOptions {
 }
 export interface WriteAsm80Options {
 }
-export type Artifact = BinArtifact | HexArtifact | D8mArtifact | Asm80Artifact | RegisterCareReportArtifact | RegisterCareInterfaceArtifact | RegisterCareAnnotationsArtifact;
+export type Artifact = BinArtifact | HexArtifact | D8mArtifact | Asm80Artifact | RegisterContractsReportArtifact | RegisterContractsInterfaceArtifact | RegisterContractsAnnotationsArtifact;
 /** Writer contract used by the compile API. */
 export interface FormatWriters {
     writeHex(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteHexOptions): HexArtifact;