@jhlagado/azm 0.1.0 → 0.2.0

package/dist/src/api-compile.js

@@ -1,3 +1,313 @@
-export { compile } from './compile.js';
-export { defaultFormatWriters } from './formats/index.js';
-export { DiagnosticIds } from './diagnosticTypes.js';
+import { readFile } from 'node:fs/promises';
+import { dirname, normalize } from 'node:path';
+import { assembleProgram } from './assembly/assemble-program.js';
+import { analyzeProgramNext, loadProgramNext } from './tooling/api.js';
+import { defaultFormatWriters } from './outputs/index.js';
+import { UnsupportedAsm80LoweringError } from './outputs/write-asm80.js';
+import { writeHex } from './outputs/write-hex.js';
+import { analyzeRegisterCare } from './register-care/analyze.js';
+import { buildRegisterCareProgramModel } from './register-care/programModel.js';
+import { parseAcceptedOutputCandidates } from './register-care/accept-output.js';
+import { parseInterfaceContracts } from './register-care/smartComments.js';
+function parseUnresolvedSymbolName(message) {
+    const match = /^Unresolved symbol "([^"]+)"/.exec(message);
+    return match?.[1];
+}
+function isSuppressedUnknownSymbolInRegisterCareMode(diagnostic, directCalls) {
+    if (directCalls === undefined || directCalls.length === 0) {
+        return false;
+    }
+    if (diagnostic.code !== 'AZMN_SYMBOL' || diagnostic.message === undefined) {
+        return false;
+    }
+    if (!diagnostic.message.includes('in 16-bit fixup')) {
+        return false;
+    }
+    const symbol = parseUnresolvedSymbolName(diagnostic.message);
+    if (symbol === undefined) {
+        return false;
+    }
+    return directCalls.some((call) => call.target === symbol &&
+        call.file === diagnostic.sourceName &&
+        call.line === diagnostic.line &&
+        call.column === diagnostic.column);
+}
+export { writeHex, defaultFormatWriters };
+let cachedPackageVersion;
+/**
+ * Compile an AZM/ASM80-style program into in-memory artifacts.
+ */
+export async function compile(entryFile, options = {}, deps = { formats: defaultFormatWriters }) {
+    const diagnostics = [];
+    const normalizedEntry = normalize(entryFile);
+    const loaded = await loadProgramNext({
+        entryFile: normalizedEntry,
+        ...(options.includeDirs !== undefined ? { includeDirs: options.includeDirs } : {}),
+        ...(options.directiveAliasFiles !== undefined
+            ? { directiveAliasFiles: options.directiveAliasFiles }
+            : {}),
+    });
+    diagnostics.push(...loaded.diagnostics);
+    if (loaded.loadedProgram === undefined) {
+        return { diagnostics, artifacts: [] };
+    }
+    const analysis = analyzeProgramNext(loaded.loadedProgram, {
+        ...(options.caseStyle !== undefined ? { caseStyle: options.caseStyle } : {}),
+    });
+    const registerCareMode = options.registerCare ?? 'off';
+    const shouldAnalyzeRegisterCare = registerCareMode !== 'off' ||
+        options.emitRegisterReport === true ||
+        options.emitRegisterInterface === true ||
+        options.emitRegisterAnnotations === true ||
+        options.fixRegisterContracts === true ||
+        (options.acceptRegisterOutputCandidates?.length ?? 0) > 0 ||
+        (options.registerCareInterfaces?.length ?? 0) > 0;
+    const directCalls = shouldAnalyzeRegisterCare
+        ? buildRegisterCareProgramModel(loaded.loadedProgram.program.files[0]?.items ?? []).directCalls
+        : undefined;
+    diagnostics.push(...analysis.diagnostics.filter((diagnostic) => shouldAnalyzeRegisterCare
+        ? !isSuppressedUnknownSymbolInRegisterCareMode(diagnostic, directCalls)
+        : true));
+    const artifacts = [];
+    if (shouldAnalyzeRegisterCare) {
+        // Validate interface references and accepted output markers now; full analysis is deferred.
+        const acceptedOutputCandidates = parseAcceptedOutputCandidates(options.acceptRegisterOutputCandidates ?? []);
+        const interfaceContracts = [];
+        for (const rawInterface of options.registerCareInterfaces ?? []) {
+            const contractPath = normalize(rawInterface);
+            if (contractPath.slice(-5).toLowerCase() !== '.asmi') {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'AZMN_REGISTER_CARE',
+                    message: 'Register-care interface files must use the .asmi extension',
+                    sourceName: contractPath,
+                });
+                continue;
+            }
+            const interfaceText = await readFile(contractPath, 'utf8');
+            for (const contract of parseInterfaceContracts(interfaceText, contractPath).values()) {
+                interfaceContracts.push(contract);
+            }
+        }
+        if (hasErrors(diagnostics)) {
+            return { diagnostics, artifacts: [] };
+        }
+        const registerCare = analyzeRegisterCare(loaded.loadedProgram, {
+            mode: registerCareMode,
+            emitReport: options.emitRegisterReport === true,
+            emitInterface: options.emitRegisterInterface === true,
+            emitAnnotations: options.emitRegisterAnnotations === true || options.fixRegisterContracts === true,
+            fixRegisterContracts: options.fixRegisterContracts === true,
+            acceptedOutputCandidates,
+            ...(options.registerCareProfile !== undefined
+                ? { registerCareProfile: options.registerCareProfile }
+                : {}),
+            ...(interfaceContracts.length > 0 ? { interfaceContracts } : {}),
+        });
+        if (registerCare.reportText !== undefined) {
+            artifacts.push({ kind: 'register-care-report', text: registerCare.reportText });
+        }
+        if (registerCare.interfaceText !== undefined) {
+            artifacts.push({ kind: 'register-care-interface', text: registerCare.interfaceText });
+        }
+        if (registerCare.annotations !== undefined && registerCare.annotations.length > 0) {
+            const files = registerCare.annotations.map((item) => ({
+                path: item.path,
+                text: item.text,
+            }));
+            artifacts.push({ kind: 'register-care-annotations', files });
+        }
+        diagnostics.push(...registerCare.diagnostics);
+        if (hasErrors(diagnostics))
+            return { diagnostics, artifacts: [] };
+    }
+    if (options.skipAssembly === true) {
+        return { diagnostics, artifacts };
+    }
+    const program = loaded.loadedProgram.program.files[0]?.items ?? [];
+    const assembled = assembleProgram(program);
+    diagnostics.push(...assembled.diagnostics.filter((diagnostic) => shouldAnalyzeRegisterCare
+        ? !isSuppressedUnknownSymbolInRegisterCareMode(diagnostic, directCalls)
+        : true));
+    sortDiagnosticsInPlace(diagnostics);
+    if (hasErrors(diagnostics)) {
+        return { diagnostics, artifacts: [] };
+    }
+    const map = assembledImageToMap(assembled.bytes, assembled.origin, assembled.sourceSegments);
+    const hexMap = assembledInitializedImageToMap(assembled.bytes, assembled.origin, assembled.initializedAddresses);
+    const sidecarMap = assembledInitializedImageToMap(assembled.bytes, assembled.origin, assembled.initializedAddresses, assembled.sourceSegments);
+    const symbols = collectSymbolEntries(program, assembled.symbols);
+    const emit = compileArtifactDefaults(options);
+    const d8Root = options.sourceRoot ?? dirname(normalizedEntry);
+    if (emit.emitBin) {
+        artifacts.push(deps.formats.writeBin(map, symbols));
+    }
+    if (emit.emitHex) {
+        artifacts.push(deps.formats.writeHex(hexMap, symbols));
+    }
+    if (emit.emitD8m) {
+        const main = symbols.find((symbol) => symbol.kind === 'label' && symbol.name.toLowerCase() === 'main');
+        const d8mOpts = {
+            rootDir: normalize(d8Root),
+            packageVersion: await readPackageVersion(),
+            inputs: {
+                entry: normalizedEntry,
+                ...(options.d8mInputs?.listing !== undefined ? { listing: options.d8mInputs.listing } : {}),
+                ...(options.d8mInputs?.hex !== undefined ? { hex: options.d8mInputs.hex } : {}),
+                ...(options.d8mInputs?.bin !== undefined ? { bin: options.d8mInputs.bin } : {}),
+            },
+            ...(main !== undefined ? { entrySymbol: main.name } : {}),
+            ...(main !== undefined
+                ? { entryAddress: main.kind === 'constant' ? main.value : main.address }
+                : {}),
+        };
+        artifacts.push(deps.formats.writeD8m(sidecarMap, symbols, d8mOpts));
+    }
+    if (emit.emitListing) {
+        if (deps.formats.writeListing !== undefined) {
+            artifacts.push(deps.formats.writeListing(sidecarMap, symbols));
+        }
+    }
+    if (emit.emitAsm80) {
+        if (deps.formats.writeAsm80 !== undefined) {
+            try {
+                artifacts.push(deps.formats.writeAsm80(program, symbols));
+            }
+            catch (error) {
+                if (error instanceof UnsupportedAsm80LoweringError) {
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'AZMN_ASM80',
+                        message: error.message,
+                        sourceName: error.item.span.sourceName,
+                        line: error.item.span.line,
+                        column: error.item.span.column,
+                    });
+                    return { diagnostics, artifacts: [] };
+                }
+                throw error;
+            }
+        }
+    }
+    return { diagnostics, artifacts };
+}
+function compileArtifactDefaults(options) {
+    const anyPrimary = [options.emitBin, options.emitHex, options.emitD8m].some((value) => value !== undefined);
+    const emitBin = anyPrimary ? (options.emitBin ?? false) : true;
+    const emitHex = anyPrimary ? (options.emitHex ?? false) : true;
+    const emitD8m = anyPrimary ? (options.emitD8m ?? false) : true;
+    const emitListing = options.emitListing ?? true;
+    const emitAsm80 = options.emitAsm80 ?? false;
+    return { emitBin, emitHex, emitD8m, emitListing, emitAsm80 };
+}
+function assembledImageToMap(bytes, origin, sourceSegments = []) {
+    const map = new Map();
+    for (let offset = 0; offset < bytes.length; offset += 1) {
+        map.set(origin + offset, bytes[offset] ?? 0);
+    }
+    const writtenRange = {
+        start: origin,
+        end: origin + bytes.length,
+    };
+    return { bytes: map, writtenRange, sourceSegments };
+}
+function assembledInitializedImageToMap(bytes, origin, initializedAddresses, sourceSegments = []) {
+    const map = new Map();
+    for (const address of initializedAddresses) {
+        const offset = address - origin;
+        if (offset >= 0 && offset < bytes.length) {
+            map.set(address, bytes[offset] ?? 0);
+        }
+    }
+    return { bytes: map, sourceSegments };
+}
+function collectSymbolEntries(items, resolvedSymbols) {
+    const map = new Map();
+    for (const item of items) {
+        switch (item.kind) {
+            case 'equ': {
+                const value = resolvedSymbols[item.name];
+                if (value !== undefined) {
+                    map.set(item.name, {
+                        kind: 'constant',
+                        name: item.name,
+                        value,
+                        file: item.span.sourceName,
+                        line: item.span.line,
+                        scope: 'global',
+                    });
+                }
+                break;
+            }
+            case 'label': {
+                const address = resolvedSymbols[item.name];
+                if (address !== undefined) {
+                    map.set(item.name, {
+                        kind: 'label',
+                        name: item.name,
+                        address,
+                        file: item.span.sourceName,
+                        line: item.span.line,
+                        scope: 'global',
+                    });
+                }
+                break;
+            }
+            case 'enum': {
+                for (const member of item.members) {
+                    const fullName = `${item.name}.${member}`;
+                    const value = resolvedSymbols[fullName];
+                    if (value !== undefined) {
+                        map.set(fullName, {
+                            kind: 'constant',
+                            name: fullName,
+                            value,
+                            file: item.span.sourceName,
+                            line: item.span.line,
+                            scope: 'global',
+                        });
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return [...map.values()];
+}
+function hasErrors(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === 'error');
+}
+function sortDiagnosticsInPlace(diagnostics) {
+    diagnostics.sort((left, right) => {
+        const lineDelta = (left.line ?? 0) - (right.line ?? 0);
+        if (lineDelta !== 0) {
+            return lineDelta;
+        }
+        return (left.column ?? 0) - (right.column ?? 0);
+    });
+}
+async function readPackageVersion() {
+    if (cachedPackageVersion !== undefined) {
+        return cachedPackageVersion;
+    }
+    const packageJsonCandidates = [
+        new URL('../package.json', import.meta.url),
+        new URL('../../package.json', import.meta.url),
+        new URL('../../../package.json', import.meta.url),
+    ];
+    for (const candidate of packageJsonCandidates) {
+        try {
+            const raw = await readFile(candidate, 'utf8');
+            const json = JSON.parse(raw);
+            if (json.version !== undefined) {
+                cachedPackageVersion = json.version;
+                return cachedPackageVersion;
+            }
+        }
+        catch {
+            // Continue searching candidates.
+        }
+    }
+    cachedPackageVersion = '0.0.0';
+    return cachedPackageVersion;
+}

package/dist/src/api-tooling.d.ts

@@ -1,25 +1,7 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-import { type AnalyzeProgramOptions, type AnalyzeProgramResult } from './analysis.js';
-import { type LoadedProgram, type LoadProgramOptions } from './sourceLoader.js';
-export type { Diagnostic, DiagnosticId, DiagnosticSeverity } from './diagnosticTypes.js';
-export { DiagnosticIds } from './diagnosticTypes.js';
-export type { BaseNode, SourceFileNode, SourceItemNode, ProgramNode, SourcePosition, SourceSpan, } from './frontend/ast.js';
-export type { CompileEnv } from './semantics/env.js';
-export type { LoadedProgram, LoadProgramOptions, AnalyzeProgramOptions, AnalyzeProgramResult };
-export { analyzeRegisterCareForTools, codeActionForOutputCandidate, diagnosticForOutputCandidate, } from './registerCare/tooling.js';
-export type { AnalyzeRegisterCareForToolsOptions, AnalyzeRegisterCareForToolsResult, RegisterCareCandidateDiagnostic, RegisterCareCodeAction, RegisterCareTextEdit, } from './registerCare/tooling.js';
-export type { RegisterCareMode, RegisterCareOutputCandidate, RegisterCareUnit, } from './registerCare/types.js';
-export interface ToolingLoadProgramResult {
-    diagnostics: Diagnostic[];
-    loadedProgram?: LoadedProgram;
-}
-/**
- * Layer A: expand textual includes and parse without emitting artifacts.
- */
-export declare function loadProgram(options: LoadProgramOptions & {
-    entryFile: string;
-}): Promise<ToolingLoadProgramResult>;
-/**
- * Layer B: run semantic checks without lowering or writing output artifacts.
- */
-export declare function analyzeProgram(loadedProgram: LoadedProgram, options?: AnalyzeProgramOptions): AnalyzeProgramResult;
+export { analyzeProgram, analyzeProgramNext, loadProgram, loadProgramNext } from './tooling/api.js';
+export { analyzeRegisterCareForTools, codeActionForOutputCandidate, diagnosticForOutputCandidate, type AnalyzeRegisterCareForToolsOptions, type AnalyzeRegisterCareForToolsResult, type RegisterCareCandidateDiagnostic, type RegisterCareCodeAction, type RegisterCareTextEdit, } from './register-care/tooling.js';
+export { DiagnosticIds } from './model/diagnostic.js';
+export type { AnalyzeProgramOptions, AnalyzeProgramResult, LoadedProgram, LoadProgramOptions, LoadProgramResult, AnalyzeProgramNextOptions, AnalyzeProgramNextResult, LoadedProgramNext, LoadProgramNextOptions, LoadProgramNextResult, } from './tooling/api.js';
+export type { CaseStyleMode } from './tooling/case-style.js';
+export type { Diagnostic, DiagnosticId, DiagnosticSeverity } from './model/diagnostic.js';
+export type { RegisterCareMode, RegisterCareOutputCandidate, RegisterCareUnit, } from './register-care/types.js';

package/dist/src/api-tooling.js

@@ -1,21 +1,3 @@
-import { analyzeLoadedProgram, } from './analysis.js';
-import { loadProgram as loadProgramInternal, } from './sourceLoader.js';
-export { DiagnosticIds } from './diagnosticTypes.js';
-export { analyzeRegisterCareForTools, codeActionForOutputCandidate, diagnosticForOutputCandidate, } from './registerCare/tooling.js';
-/**
- * Layer A: expand textual includes and parse without emitting artifacts.
- */
-export async function loadProgram(options) {
-    const diagnostics = [];
-    const loadedProgram = await loadProgramInternal(options.entryFile, diagnostics, options);
-    return {
-        diagnostics,
-        ...(loadedProgram ? { loadedProgram } : {}),
-    };
-}
-/**
- * Layer B: run semantic checks without lowering or writing output artifacts.
- */
-export function analyzeProgram(loadedProgram, options = {}) {
-    return analyzeLoadedProgram(loadedProgram, options);
-}
+export { analyzeProgram, analyzeProgramNext, loadProgram, loadProgramNext } from './tooling/api.js';
+export { analyzeRegisterCareForTools, codeActionForOutputCandidate, diagnosticForOutputCandidate, } from './register-care/tooling.js';
+export { DiagnosticIds } from './model/diagnostic.js';

package/dist/src/assembly/address-planning.d.ts

@@ -0,0 +1,19 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { SourceItem } from '../model/source-item.js';
+import type { SymbolTable } from '../model/symbol.js';
+import { type EquateRecord, type LayoutRecord } from '../semantics/expression-evaluation.js';
+export interface AddressState {
+    readonly labels: Record<string, number>;
+    readonly equates: Map<string, EquateRecord>;
+    readonly layouts: Map<string, LayoutRecord>;
+    readonly origin: number;
+}
+export declare function buildAddressState(items: readonly SourceItem[], diagnostics: Diagnostic[]): {
+    readonly labels: Record<string, number>;
+    readonly equates: Map<string, EquateRecord>;
+    readonly layouts: Map<string, LayoutRecord>;
+    readonly origin: number;
+};
+export declare function stringDirectiveBytes(directive: 'cstr' | 'pstr' | 'istr', value: string): readonly number[];
+export declare function alignmentPadding(address: number, alignment: number): number;
+export declare function resolveSymbols(labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, layouts: ReadonlyMap<string, LayoutRecord>, diagnostics: Diagnostic[]): SymbolTable;

package/dist/src/assembly/address-planning.js

@@ -0,0 +1,266 @@
+import { diagnostic, evaluateExpression, lookupEquateRecord, validateLayouts, } from '../semantics/expression-evaluation.js';
+import { instructionSize } from './fixup-emission.js';
+import { advanceCodePlacement, advancePlacement, applyOrg, createPlacementState, placementAddress, placementForOrg, } from './placement.js';
+export function buildAddressState(items, diagnostics) {
+    let state = buildAddressStateOnce(items, [], undefined, false);
+    let previousSignature = '';
+    for (let index = 0; index < Math.max(4, items.length + 1); index += 1) {
+        state = buildAddressStateOnce(items, [], state, false);
+        const signature = addressStateSignature(state);
+        if (signature === previousSignature) {
+            break;
+        }
+        previousSignature = signature;
+    }
+    return buildAddressStateOnce(items, diagnostics, state, true);
+}
+function buildAddressStateOnce(items, diagnostics, previous, reportUnknown) {
+    const labels = {};
+    const equates = new Map();
+    const layouts = new Map();
+    const enumNames = new Set();
+    const enumNamesLower = new Set();
+    let origin = 0;
+    let originSet = false;
+    const placement = createPlacementState();
+    let ended = false;
+    const lookupLabels = previous?.labels ?? labels;
+    const lookupEquates = previous?.equates ?? equates;
+    const lookupLayouts = previous?.layouts ?? layouts;
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+        const item = items[itemIndex];
+        if (ended && item.kind !== 'binfrom' && item.kind !== 'binto') {
+            continue;
+        }
+        switch (item.kind) {
+            case 'org': {
+                placement.activePlacement = placementForOrg(items, itemIndex);
+                const value = evaluateExpression(item.expression, lookupLabels, lookupEquates, item.span, diagnostics, {
+                    currentLocation: placementAddress(placement),
+                    layouts: lookupLayouts,
+                    reportUnknown,
+                });
+                if (value !== undefined) {
+                    if (!originSet) {
+                        origin = value;
+                        originSet = true;
+                    }
+                    applyOrg(placement, value);
+                }
+                break;
+            }
+            case 'type':
+                defineLayout(layouts, labels, equates, enumNamesLower, item.name, item.layoutKind, item.fields, item.span, diagnostics);
+                break;
+            case 'equ':
+                defineEquate(equates, labels, layouts, enumNames, enumNamesLower, item.name, item.expression, item.span, placementAddress(placement), diagnostics, item.stringValue);
+                break;
+            case 'enum':
+                defineEnumMembers(equates, labels, layouts, enumNames, enumNamesLower, item.name, item.members, item.span, diagnostics);
+                break;
+            case 'label':
+                defineLabel(labels, equates, layouts, enumNamesLower, item.name, placementAddress(placement), item.span, diagnostics);
+                break;
+            case 'db':
+                advancePlacement(placement, item.values.reduce((size, value) => size + dataValueSize(value, lookupEquates), 0));
+                break;
+            case 'dw':
+                advancePlacement(placement, item.values.length * 2);
+                break;
+            case 'ds': {
+                const size = evaluateExpression(item.size, lookupLabels, lookupEquates, item.span, diagnostics, {
+                    currentLocation: placementAddress(placement),
+                    layouts: lookupLayouts,
+                    reportUnknown,
+                });
+                if (size !== undefined) {
+                    advancePlacement(placement, size);
+                }
+                break;
+            }
+            case 'align': {
+                const alignment = evaluateExpression(item.alignment, lookupLabels, lookupEquates, item.span, diagnostics, {
+                    currentLocation: placementAddress(placement),
+                    layouts: lookupLayouts,
+                    reportUnknown,
+                });
+                if (alignment !== undefined) {
+                    if (alignment <= 0) {
+                        if (reportUnknown) {
+                            diagnostics.push(diagnostic(item.span, `.align value must be positive: ${alignment}.`));
+                        }
+                    }
+                    else {
+                        advancePlacement(placement, alignmentPadding(placementAddress(placement), alignment));
+                    }
+                }
+                break;
+            }
+            case 'end':
+                ended = true;
+                break;
+            case 'binfrom':
+            case 'binto':
+                break;
+            case 'string-data':
+                advancePlacement(placement, stringDirectiveBytes(item.directive, item.value).length);
+                break;
+            case 'instruction': {
+                const instructionBytes = instructionSize(item.instruction);
+                advanceCodePlacement(placement, instructionBytes);
+                if (placement.activePlacement === 'data') {
+                    advancePlacement(placement, instructionBytes);
+                }
+                break;
+            }
+        }
+    }
+    if (reportUnknown) {
+        validateLayouts(layouts, diagnostics);
+    }
+    return { labels, equates, layouts, origin };
+}
+export function stringDirectiveBytes(directive, value) {
+    const bytes = [...value].map((char) => char.codePointAt(0) ?? 0);
+    switch (directive) {
+        case 'cstr':
+            return [...bytes.map(toByte), 0];
+        case 'pstr':
+            return [bytes.length & 0xff, ...bytes.map(toByte)];
+        case 'istr':
+            return bytes.map((byte, index) => toByte(byte | (index === bytes.length - 1 ? 0x80 : 0)));
+    }
+}
+function toByte(value) {
+    return value & 0xff;
+}
+function dataValueSize(value, equates) {
+    if (value.kind === 'string-fragment') {
+        return [...value.value].length;
+    }
+    if (value.kind === 'symbol') {
+        const equate = lookupEquateRecord(equates, value.name);
+        if (equate?.record.stringValue !== undefined) {
+            return [...equate.record.stringValue].length;
+        }
+    }
+    return 1;
+}
+export function alignmentPadding(address, alignment) {
+    const remainder = address % alignment;
+    return remainder === 0 ? 0 : alignment - remainder;
+}
+function addressStateSignature(state) {
+    return JSON.stringify({
+        labels: state.labels,
+        equates: [...state.equates].map(([name, record]) => [name, record.currentLocation]),
+        layouts: [...state.layouts].map(([name, record]) => [name, record.kind, record.fields]),
+        origin: state.origin,
+    });
+}
+function defineLayout(layouts, labels, equates, enumNamesLower, name, layoutKind, fields, span, diagnostics) {
+    const lowerName = name.toLowerCase();
+    if (hasCaseInsensitiveMapKey(layouts, lowerName) ||
+        hasCaseInsensitiveKey(labels, lowerName) ||
+        hasCaseInsensitiveMapKey(equates, lowerName) ||
+        enumNamesLower.has(lowerName)) {
+        diagnostics.push(diagnostic(span, `duplicate type name: ${name}`));
+        return;
+    }
+    const fieldNames = new Set();
+    for (const field of fields) {
+        const fieldLower = field.name.toLowerCase();
+        if (fieldNames.has(fieldLower)) {
+            diagnostics.push(diagnostic(span, `duplicate type field name: ${field.name}`));
+            continue;
+        }
+        fieldNames.add(fieldLower);
+    }
+    layouts.set(name, { kind: layoutKind, fields, span });
+}
+function defineLabel(labels, equates, layouts, enumNamesLower, name, address, span, diagnostics) {
+    if (labels[name] !== undefined ||
+        equates.has(name) ||
+        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
+        enumNamesLower.has(name.toLowerCase())) {
+        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
+        return;
+    }
+    labels[name] = address;
+}
+function defineEquate(equates, labels, layouts, enumNames, enumNamesLower, name, expression, span, currentLocation, diagnostics, stringValue) {
+    if (labels[name] !== undefined ||
+        equates.has(name) ||
+        hasCaseInsensitiveMapKey(layouts, name.toLowerCase()) ||
+        enumNames.has(name) ||
+        enumNamesLower.has(name.toLowerCase())) {
+        diagnostics.push(diagnostic(span, `duplicate symbol: ${name}`));
+        return;
+    }
+    equates.set(name, {
+        expression,
+        span,
+        currentLocation,
+        ...(stringValue !== undefined ? { stringValue } : {}),
+    });
+}
+function defineEnumMembers(equates, labels, layouts, enumNames, enumNamesLower, enumName, members, span, diagnostics) {
+    const enumNameLower = enumName.toLowerCase();
+    if (hasCaseInsensitiveKey(labels, enumNameLower) ||
+        hasCaseInsensitiveMapKey(equates, enumNameLower) ||
+        hasCaseInsensitiveMapKey(layouts, enumNameLower) ||
+        enumNamesLower.has(enumNameLower)) {
+        diagnostics.push(diagnostic(span, `duplicate enum name: ${enumName}`));
+        return;
+    }
+    enumNames.add(enumName);
+    enumNamesLower.add(enumNameLower);
+    const memberNames = new Set();
+    for (let index = 0; index < members.length; index += 1) {
+        const member = members[index] ?? '';
+        const memberLower = member.toLowerCase();
+        if (memberNames.has(memberLower)) {
+            diagnostics.push(diagnostic(span, `duplicate enum member name: ${member}`));
+            continue;
+        }
+        memberNames.add(memberLower);
+        const qualifiedName = `${enumName}.${member}`;
+        if (hasCaseInsensitiveKey(labels, qualifiedName.toLowerCase()) ||
+            hasCaseInsensitiveMapKey(equates, qualifiedName.toLowerCase())) {
+            diagnostics.push(diagnostic(span, `duplicate symbol: ${qualifiedName}`));
+            continue;
+        }
+        equates.set(qualifiedName, {
+            expression: { kind: 'number', value: index },
+            span,
+            currentLocation: 0,
+            enumMember: true,
+        });
+    }
+}
+function hasCaseInsensitiveKey(record, lowerName) {
+    return Object.keys(record).some((key) => key.toLowerCase() === lowerName);
+}
+function hasCaseInsensitiveMapKey(map, lowerName) {
+    for (const key of map.keys()) {
+        if (key.toLowerCase() === lowerName) {
+            return true;
+        }
+    }
+    return false;
+}
+export function resolveSymbols(labels, equates, layouts, diagnostics) {
+    const symbols = { ...labels };
+    for (const [name, record] of equates) {
+        const value = evaluateExpression(record.expression, labels, equates, record.span, diagnostics, {
+            currentLocation: record.currentLocation,
+            visiting: new Set([name]),
+            layouts,
+            reportUnknown: false,
+        });
+        if (value !== undefined) {
+            symbols[name] = value;
+        }
+    }
+    return symbols;
+}

package/dist/src/assembly/assemble-program.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { SourceItem } from '../model/source-item.js';
+import type { EmittedSourceSegment } from '../outputs/types.js';
+export interface AssemblyResult {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly symbols: import('../model/symbol.js').SymbolTable;
+    readonly origin: number;
+    readonly initializedAddresses: readonly number[];
+    readonly reservedAddresses: readonly number[];
+    readonly sourceSegments: readonly EmittedSourceSegment[];
+    readonly bytes: Uint8Array;
+}
+export declare function assembleProgram(items: readonly SourceItem[]): AssemblyResult;