@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/assembly/program-emission.js

@@ -2,6 +2,24 @@ import { diagnostic, evaluateExpression, lookupEquateRecord, } from '../semantic
 import { emitAbs16Expression, emitInstruction, patchFixups, } from './fixup-emission.js';
 import { absoluteCodeAddress, absoluteDataAddress, advanceCodePlacement, advancePlacement, applyOrg, computeResolvedBases, createPlacementState, placementAddress, placementForOrg, } from './placement.js';
 import { alignmentPadding, stringDirectiveBytes, } from './address-planning.js';
+const EMIT_ITEM_HANDLERS = {
+    org: (context, item, items, itemIndex) => emitOrg(context, items, itemIndex, item),
+    comment: () => undefined,
+    equ: () => undefined,
+    label: () => undefined,
+    enum: () => undefined,
+    type: () => undefined,
+    'type-alias': () => undefined,
+    db: (context, item) => emitDb(context, item),
+    dw: (context, item) => emitDw(context, item),
+    ds: (context, item) => emitDs(context, item),
+    align: (context, item) => emitAlign(context, item),
+    end: () => true,
+    binfrom: (context, item) => emitBinRangeControl(context, item),
+    binto: (context, item) => emitBinRangeControl(context, item),
+    'string-data': (context, item) => emitStringData(context, item),
+    instruction: (context, item) => emitProgramInstruction(context, item),
+};
 function toByte(value) {
     return value & 0xff;
 }
@@ -91,178 +109,159 @@ function emitDbValue(value, emitAddress, itemSpan, labels, equates, layouts, dia
     }
 }
 export function emitProgramImage(items, addressState, symbols, diagnostics) {
-    const { labels, equates, layouts, origin } = addressState;
-    const image = new Map();
-    const initializedAddresses = new Set();
-    const reservedAddresses = new Set();
-    const sourceSegments = [];
-    const placement = createPlacementState();
+    const context = createEmitContext(addressState, symbols, diagnostics);
     let ended = false;
-    let binFrom;
-    let binTo;
     for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
         const item = items[itemIndex];
-        if (ended && item.kind !== 'binfrom' && item.kind !== 'binto') {
+        if (shouldSkipAfterEnd(ended, item)) {
             continue;
         }
-        switch (item.kind) {
-            case 'org': {
-                placement.activePlacement = placementForOrg(items, itemIndex);
-                const value = evaluateExpression(item.expression, labels, equates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts,
-                });
-                if (value !== undefined) {
-                    applyOrg(placement, value);
-                }
-                break;
-            }
-            case 'comment':
-            case 'equ':
-            case 'label':
-            case 'enum':
-            case 'type':
-                break;
-            case 'db':
-                {
-                    const segmentStart = activePlacementAddress(placement);
-                    for (const value of item.values) {
-                        emitDbValue(value, activePlacementAddress(placement), item.span, labels, equates, layouts, diagnostics, image, initializedAddresses, placement);
-                    }
-                    void segmentStart;
-                }
-                break;
-            case 'dw':
-                {
-                    const segmentStart = activePlacementAddress(placement);
-                    for (const expression of item.values) {
-                        const emitAddress = activePlacementAddress(placement);
-                        const bytes = [];
-                        const fixups = [];
-                        if (emitAbs16Expression(expression, item.span, emitAddress, labels, equates, diagnostics, bytes, fixups, layouts)) {
-                            patchFixups(fixups, symbols, bytes, diagnostics);
-                            writeImageBytes(image, initializedAddresses, emitAddress, bytes);
-                            advancePlacement(placement, 2);
-                        }
-                    }
-                    void segmentStart;
-                }
-                break;
-            case 'ds': {
-                const emitAddress = activePlacementAddress(placement);
-                const size = evaluateExpression(item.size, labels, equates, item.span, diagnostics, {
-                    currentLocation: emitAddress,
-                    layouts,
-                });
-                if (size !== undefined) {
-                    const fill = item.fill === undefined
-                        ? undefined
-                        : evaluateExpression(item.fill, labels, equates, item.span, diagnostics, {
-                            currentLocation: emitAddress,
-                            layouts,
-                        });
-                    if (item.fill === undefined || fill !== undefined) {
-                        if (fill !== undefined) {
-                            for (let index = 0; index < size; index += 1) {
-                                writeImageByte(image, initializedAddresses, emitAddress + index, fill);
-                            }
-                        }
-                        else {
-                            for (let index = 0; index < size; index += 1) {
-                                reservedAddresses.add(emitAddress + index);
-                            }
-                        }
-                        advancePlacement(placement, size);
-                    }
-                }
-                break;
-            }
-            case 'align': {
-                const emitAddress = activePlacementAddress(placement);
-                const alignment = evaluateExpression(item.alignment, labels, equates, item.span, diagnostics, {
-                    currentLocation: emitAddress,
-                    layouts,
-                });
-                if (alignment !== undefined) {
-                    if (alignment <= 0) {
-                        diagnostics.push(diagnostic(item.span, `.align value must be positive: ${alignment}.`));
-                    }
-                    else {
-                        const padding = alignmentPadding(emitAddress, alignment);
-                        for (let index = 0; index < padding; index += 1) {
-                            writeImageByte(image, initializedAddresses, emitAddress + index, 0);
-                        }
-                        advancePlacement(placement, padding);
-                        addSourceSegment(sourceSegments, item.span, emitAddress, emitAddress + padding, 'directive');
-                    }
-                }
-                break;
-            }
-            case 'end':
-                ended = true;
-                break;
-            case 'binfrom': {
-                const value = evaluateExpression(item.expression, labels, equates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts,
-                });
-                if (value !== undefined) {
-                    binFrom = value;
-                }
-                break;
-            }
-            case 'binto': {
-                const value = evaluateExpression(item.expression, labels, equates, item.span, diagnostics, {
-                    currentLocation: placementAddress(placement),
-                    layouts,
-                });
-                if (value !== undefined) {
-                    binTo = value;
-                }
-                break;
-            }
-            case 'string-data':
-                {
-                    const segmentStart = activePlacementAddress(placement);
-                    for (const value of stringDirectiveBytes(item.directive, item.value)) {
-                        const stringEmitAddress = activePlacementAddress(placement);
-                        writeImageByte(image, initializedAddresses, stringEmitAddress, value);
-                        advancePlacement(placement, 1);
-                    }
-                    void segmentStart;
-                }
-                break;
-            case 'instruction': {
-                const bases = computeResolvedBases(placement);
-                const codeAddress = absoluteCodeAddress(placement, bases);
-                const bytes = [];
-                const fixups = [];
-                const size = emitInstruction(item.instruction, item.span, codeAddress, labels, equates, diagnostics, bytes, fixups, layouts);
-                patchFixups(fixups, symbols, bytes, diagnostics);
-                writeImageBytes(image, initializedAddresses, codeAddress, bytes);
-                advanceCodePlacement(placement, size);
-                addSourceSegment(sourceSegments, item.emittedSource?.span ?? item.span, codeAddress, codeAddress + size, item.emittedSource?.kind ?? 'code');
-                if (placement.activePlacement === 'data') {
-                    const dataAddress = absoluteDataAddress(placement, bases);
-                    writeImageBytes(image, initializedAddresses, dataAddress, bytes);
-                    advancePlacement(placement, size);
-                }
-                break;
-            }
-        }
+        ended = EMIT_ITEM_HANDLERS[item.kind](context, item, items, itemIndex) === true || ended;
     }
-    const range = outputRange(initializedAddresses, reservedAddresses, origin, binFrom, binTo);
-    const bytes = flattenImage(image, range.start, range.end);
-    const initializedAddressList = [...initializedAddresses].sort((a, b) => a - b);
-    const reservedAddressList = [...reservedAddresses].sort((a, b) => a - b);
+    return emittedProgramFromContext(context, addressState.origin, diagnostics);
+}
+function shouldSkipAfterEnd(ended, item) {
+    return ended && item.kind !== 'binfrom' && item.kind !== 'binto';
+}
+function emittedProgramFromContext(context, defaultOrigin, diagnostics) {
+    const range = outputRange(context.initializedAddresses, context.reservedAddresses, defaultOrigin, context.binFrom, context.binTo);
+    const bytes = flattenImage(context.image, range.start, range.end);
     return {
         origin: range.start,
-        initializedAddresses: initializedAddressList,
-        reservedAddresses: reservedAddressList,
-        sourceSegments: sourceSegments
-            .map((segment) => clipSourceSegment(segment, range.start, range.end))
-            .filter((segment) => segment !== undefined)
-            .sort((a, b) => a.start - b.start || a.end - b.end),
+        initializedAddresses: sortedAddresses(context.initializedAddresses),
+        reservedAddresses: sortedAddresses(context.reservedAddresses),
+        sourceSegments: clippedSourceSegments(context.sourceSegments, range.start, range.end),
         bytes: diagnostics.length > 0 ? new Uint8Array() : bytes,
     };
 }
+function sortedAddresses(addresses) {
+    return [...addresses].sort((a, b) => a - b);
+}
+function clippedSourceSegments(sourceSegments, start, end) {
+    return sourceSegments
+        .map((segment) => clipSourceSegment(segment, start, end))
+        .filter((segment) => segment !== undefined)
+        .sort((a, b) => a.start - b.start || a.end - b.end);
+}
+function createEmitContext(addressState, symbols, diagnostics) {
+    return {
+        labels: addressState.labels,
+        equates: addressState.equates,
+        layouts: addressState.layouts,
+        symbols,
+        diagnostics,
+        image: new Map(),
+        initializedAddresses: new Set(),
+        reservedAddresses: new Set(),
+        sourceSegments: [],
+        placement: createPlacementState(),
+        binFrom: undefined,
+        binTo: undefined,
+    };
+}
+function emitOrg(context, items, itemIndex, item) {
+    context.placement.activePlacement = placementForOrg(items, itemIndex);
+    const value = evaluateEmitExpression(context, item.expression, item.span, placementAddress(context.placement));
+    if (value !== undefined) {
+        applyOrg(context.placement, value);
+    }
+}
+function emitDb(context, item) {
+    for (const value of item.values) {
+        emitDbValue(value, activePlacementAddress(context.placement), item.span, context.labels, context.equates, context.layouts, context.diagnostics, context.image, context.initializedAddresses, context.placement);
+    }
+}
+function emitDw(context, item) {
+    for (const expression of item.values) {
+        const emitAddress = activePlacementAddress(context.placement);
+        const bytes = [];
+        const fixups = [];
+        if (emitAbs16Expression(expression, item.span, emitAddress, context.labels, context.equates, context.diagnostics, bytes, fixups, context.layouts)) {
+            patchFixups(fixups, context.symbols, bytes, context.diagnostics);
+            writeImageBytes(context.image, context.initializedAddresses, emitAddress, bytes);
+            advancePlacement(context.placement, 2);
+        }
+    }
+}
+function emitDs(context, item) {
+    const emitAddress = activePlacementAddress(context.placement);
+    const size = evaluateEmitExpression(context, item.size, item.span, emitAddress);
+    if (size === undefined) {
+        return;
+    }
+    const fill = item.fill === undefined
+        ? undefined
+        : evaluateEmitExpression(context, item.fill, item.span, emitAddress);
+    if (item.fill !== undefined && fill === undefined) {
+        return;
+    }
+    if (fill !== undefined) {
+        for (let index = 0; index < size; index += 1) {
+            writeImageByte(context.image, context.initializedAddresses, emitAddress + index, fill);
+        }
+    }
+    else {
+        for (let index = 0; index < size; index += 1) {
+            context.reservedAddresses.add(emitAddress + index);
+        }
+    }
+    advancePlacement(context.placement, size);
+}
+function emitAlign(context, item) {
+    const emitAddress = activePlacementAddress(context.placement);
+    const alignment = evaluateEmitExpression(context, item.alignment, item.span, emitAddress);
+    if (alignment === undefined) {
+        return;
+    }
+    if (alignment <= 0) {
+        context.diagnostics.push(diagnostic(item.span, `.align value must be positive: ${alignment}.`));
+        return;
+    }
+    const padding = alignmentPadding(emitAddress, alignment);
+    for (let index = 0; index < padding; index += 1) {
+        writeImageByte(context.image, context.initializedAddresses, emitAddress + index, 0);
+    }
+    advancePlacement(context.placement, padding);
+    addSourceSegment(context.sourceSegments, item.span, emitAddress, emitAddress + padding, 'directive');
+}
+function emitBinRangeControl(context, item) {
+    const value = evaluateEmitExpression(context, item.expression, item.span, placementAddress(context.placement));
+    if (value === undefined) {
+        return;
+    }
+    if (item.kind === 'binfrom') {
+        context.binFrom = value;
+    }
+    else {
+        context.binTo = value;
+    }
+}
+function emitStringData(context, item) {
+    for (const value of stringDirectiveBytes(item.directive, item.value)) {
+        const stringEmitAddress = activePlacementAddress(context.placement);
+        writeImageByte(context.image, context.initializedAddresses, stringEmitAddress, value);
+        advancePlacement(context.placement, 1);
+    }
+}
+function emitProgramInstruction(context, item) {
+    const bases = computeResolvedBases(context.placement);
+    const codeAddress = absoluteCodeAddress(context.placement, bases);
+    const bytes = [];
+    const fixups = [];
+    const size = emitInstruction(item.instruction, item.span, codeAddress, context.labels, context.equates, context.diagnostics, bytes, fixups, context.layouts);
+    patchFixups(fixups, context.symbols, bytes, context.diagnostics);
+    writeImageBytes(context.image, context.initializedAddresses, codeAddress, bytes);
+    advanceCodePlacement(context.placement, size);
+    addSourceSegment(context.sourceSegments, item.emittedSource?.span ?? item.span, codeAddress, codeAddress + size, item.emittedSource?.kind ?? 'code');
+    if (context.placement.activePlacement === 'data') {
+        const dataAddress = absoluteDataAddress(context.placement, bases);
+        writeImageBytes(context.image, context.initializedAddresses, dataAddress, bytes);
+        advancePlacement(context.placement, size);
+    }
+}
+function evaluateEmitExpression(context, expression, span, currentLocation) {
+    return evaluateExpression(expression, context.labels, context.equates, span, context.diagnostics, {
+        currentLocation,
+        layouts: context.layouts,
+    });
+}

package/dist/src/cli/artifact-files.d.ts

@@ -0,0 +1,15 @@
+import type { Artifact } from '../outputs/types.js';
+interface ArtifactPaths {
+    readonly hex: string;
+    readonly bin: string;
+    readonly d8m: string;
+    readonly asm80: string;
+    readonly registerContractsReport: string;
+    readonly registerContractsInterface: string;
+}
+interface ArtifactWriteResult {
+    readonly primaryPath?: string;
+    readonly registerContractsPath?: string;
+}
+export declare function writeArtifactFiles(artifacts: readonly Artifact[], paths: ArtifactPaths, outputType: 'hex' | 'bin'): Promise<ArtifactWriteResult>;
+export {};

package/dist/src/cli/artifact-files.js

@@ -0,0 +1,86 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+function artifactByKind(artifacts) {
+    const byKind = new Map();
+    for (const artifact of artifacts) {
+        byKind.set(artifact.kind, artifact);
+    }
+    return byKind;
+}
+async function ensureDir(path) {
+    await mkdir(dirname(path), { recursive: true });
+}
+async function writeTextArtifact(path, text) {
+    await ensureDir(path);
+    await writeFile(path, text, 'utf8');
+}
+async function writeBinArtifact(path, bytes) {
+    await ensureDir(path);
+    await writeFile(path, Buffer.from(bytes));
+}
+function queuePrimaryArtifacts(writes, byKind, paths, outputType) {
+    let primaryPath;
+    const bin = byKind.get('bin');
+    if (bin?.kind === 'bin') {
+        writes.push(writeBinArtifact(paths.bin, bin.bytes));
+        if (outputType === 'bin')
+            primaryPath = paths.bin;
+    }
+    const hex = byKind.get('hex');
+    if (hex?.kind === 'hex') {
+        writes.push(writeTextArtifact(paths.hex, hex.text));
+        if (outputType === 'hex')
+            primaryPath = paths.hex;
+    }
+    return primaryPath;
+}
+function queueDebugArtifacts(writes, byKind, paths) {
+    const d8m = byKind.get('d8m');
+    if (d8m?.kind === 'd8m') {
+        const text = JSON.stringify(d8m.json, null, 2);
+        writes.push(writeTextArtifact(paths.d8m, `${text}\n`));
+    }
+    const asm80 = byKind.get('asm80');
+    if (asm80?.kind === 'asm80') {
+        writes.push(writeTextArtifact(paths.asm80, asm80.text));
+    }
+}
+function queueRegisterContractsArtifacts(writes, byKind, paths) {
+    let registerContractsPath;
+    const report = byKind.get('register-contracts-report');
+    if (report?.kind === 'register-contracts-report') {
+        writes.push(writeTextArtifact(paths.registerContractsReport, report.text));
+        registerContractsPath = paths.registerContractsReport;
+    }
+    const iface = byKind.get('register-contracts-interface');
+    if (iface?.kind === 'register-contracts-interface') {
+        writes.push(writeTextArtifact(paths.registerContractsInterface, iface.text));
+        registerContractsPath ??= paths.registerContractsInterface;
+    }
+    return registerContractsPath;
+}
+function queueRegisterContractsAnnotationArtifacts(writes, byKind) {
+    const annotations = byKind.get('register-contracts-annotations');
+    if (annotations?.kind !== 'register-contracts-annotations')
+        return undefined;
+    let firstAnnotationPath;
+    for (const item of annotations.files) {
+        writes.push(writeTextArtifact(item.path, item.text));
+        firstAnnotationPath ??= item.path;
+    }
+    return firstAnnotationPath;
+}
+export async function writeArtifactFiles(artifacts, paths, outputType) {
+    const byKind = artifactByKind(artifacts);
+    const writes = [];
+    const primaryPath = queuePrimaryArtifacts(writes, byKind, paths, outputType);
+    queueDebugArtifacts(writes, byKind, paths);
+    const registerContractsPath = queueRegisterContractsArtifacts(writes, byKind, paths);
+    const annotationPrimaryPath = queueRegisterContractsAnnotationArtifacts(writes, byKind);
+    await Promise.all(writes);
+    const selectedPrimaryPath = primaryPath ?? annotationPrimaryPath;
+    return {
+        ...(selectedPrimaryPath ? { primaryPath: selectedPrimaryPath } : {}),
+        ...(registerContractsPath ? { registerContractsPath } : {}),
+    };
+}

package/dist/src/cli/parse-args.d.ts

@@ -1,5 +1,6 @@
-import type { RegisterCareMode } from '../register-care/types.js';
+import type { RegisterContractsMode } from '../register-contracts/types.js';
 import type { CaseStyleMode } from '../tooling/case-style.js';
+import { cliUsage } from './usage.js';
 export type CliExit = {
     code: number;
 };
@@ -13,16 +14,16 @@ export type CliOptions = {
     emitD8m: boolean;
     emitAsm80: boolean;
     caseStyle: CaseStyleMode;
-    registerCare: RegisterCareMode;
+    registerContracts: RegisterContractsMode;
     emitRegisterReport: boolean;
     emitRegisterInterface: boolean;
     emitRegisterAnnotations: boolean;
     fixRegisterContracts: boolean;
     acceptRegisterOutputCandidates: string[];
-    registerCareProfile?: 'mon3';
-    registerCareInterfaces: string[];
+    registerContractsProfile?: 'mon3';
+    registerContractsInterfaces: string[];
     includeDirs: string[];
     directiveAliasFiles: string[];
 };
-export declare function cliUsage(): string;
+export { cliUsage };
 export declare function parseCliArgs(argv: string[]): CliOptions | CliExit;