@jhlagado/azm 0.1.1 → 0.2.0

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

@@ -0,0 +1,34 @@
+import { buildAddressState, resolveSymbols } from './address-planning.js';
+import { emitProgramImage } from './program-emission.js';
+function emptyAssemblyResult(diagnostics, partial = {}) {
+    return {
+        diagnostics,
+        symbols: partial.symbols ?? {},
+        origin: partial.origin ?? 0,
+        initializedAddresses: [],
+        reservedAddresses: [],
+        sourceSegments: [],
+        bytes: new Uint8Array(),
+    };
+}
+export function assembleProgram(items) {
+    const diagnostics = [];
+    const addressState = buildAddressState(items, diagnostics);
+    if (diagnostics.length > 0) {
+        return emptyAssemblyResult(diagnostics, { origin: addressState.origin });
+    }
+    const symbols = resolveSymbols(addressState.labels, addressState.equates, addressState.layouts, diagnostics);
+    if (diagnostics.length > 0) {
+        return emptyAssemblyResult(diagnostics, { symbols, origin: addressState.origin });
+    }
+    const emitted = emitProgramImage(items, addressState, symbols, diagnostics);
+    return {
+        diagnostics,
+        symbols,
+        origin: emitted.origin,
+        initializedAddresses: emitted.initializedAddresses,
+        reservedAddresses: emitted.reservedAddresses,
+        sourceSegments: emitted.sourceSegments,
+        bytes: diagnostics.length > 0 ? new Uint8Array() : emitted.bytes,
+    };
+}

package/dist/src/assembly/fixup-emission.d.ts

@@ -0,0 +1,10 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { Expression } from '../model/expression.js';
+import type { Fixup } from '../model/fixup.js';
+import type { Instruction } from '../model/source-item.js';
+import type { SourceSpan } from '../source/source-span.js';
+import { type EquateRecord, type LayoutRecord } from '../semantics/expression-evaluation.js';
+export declare function emitInstruction(instruction: Instruction, span: SourceSpan, currentAddress: number, labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, diagnostics: Diagnostic[], bytes: number[], fixups: Fixup[], layouts?: ReadonlyMap<string, LayoutRecord>): number;
+export declare function emitAbs16Expression(expression: Expression, span: SourceSpan, currentAddress: number, labels: Readonly<Record<string, number>>, equates: ReadonlyMap<string, EquateRecord>, diagnostics: Diagnostic[], bytes: number[], fixups: Fixup[], layouts?: ReadonlyMap<string, LayoutRecord>): boolean;
+export declare function patchFixups(fixups: readonly Fixup[], symbols: Readonly<Record<string, number>>, bytes: number[], diagnostics: Diagnostic[]): void;
+export declare function instructionSize(instruction: Instruction): number;

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

@@ -0,0 +1,247 @@
+import { diagnostic, evaluateExpression, lookupSymbolValue, } from '../semantics/expression-evaluation.js';
+import { encodeZ80Instruction } from '../z80/encode.js';
+export function emitInstruction(instruction, span, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts) {
+    const encoded = encodeZ80Instruction(instruction);
+    for (const fragment of encoded.fragments) {
+        emitZ80Fragment(fragment, span, currentAddress, encoded.size, labels, equates, diagnostics, bytes, fixups, layouts);
+    }
+    return encoded.size;
+}
+export function emitAbs16Expression(expression, span, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts) {
+    const target = fixupTargetFromExpression(expression);
+    if (target) {
+        fixups.push({ kind: 'abs16', offset: bytes.length, target, span });
+        bytes.push(0, 0);
+        return true;
+    }
+    const value = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        currentLocation: currentAddress,
+        layouts,
+    });
+    if (value === undefined) {
+        return false;
+    }
+    if (!isAbs16Value(value)) {
+        diagnostics.push(diagnostic(span, `16-bit value out of range: ${value}.`));
+        bytes.push(0, 0);
+        return true;
+    }
+    bytes.push(value & 0xff, (value >> 8) & 0xff);
+    return true;
+}
+export function patchFixups(fixups, symbols, bytes, diagnostics) {
+    for (const fixup of fixups) {
+        const base = lookupSymbolValue(symbols, fixup.target.symbol);
+        if (base === undefined) {
+            const context = fixup.kind === 'rel8' ? `rel8 ${fixup.mnemonic} fixup` : '16-bit fixup';
+            diagnostics.push(diagnostic(fixup.span, `Unresolved symbol "${fixup.target.symbol}" in ${context}.`));
+            continue;
+        }
+        const target = base + fixup.target.addend;
+        if (fixup.kind === 'abs16') {
+            patchAbs16(fixup, target, bytes, diagnostics);
+        }
+        else {
+            emitRel8Displacement(target, fixup.origin, fixup.mnemonic, bytes, diagnostics, fixup.span, fixup.offset);
+        }
+    }
+}
+export function instructionSize(instruction) {
+    return encodeZ80Instruction(instruction).size;
+}
+function emitZ80Fragment(fragment, span, currentAddress, instructionSize, labels, equates, diagnostics, bytes, fixups, layouts) {
+    switch (fragment.kind) {
+        case 'bytes':
+            bytes.push(...fragment.bytes);
+            return;
+        case 'imm8':
+            emitImm8Expression(fragment.expression, fragment.failureMessage, span, currentAddress, labels, equates, diagnostics, bytes, layouts);
+            return;
+        case 'port8':
+            emitPort8Expression(fragment.expression, fragment.message, span, currentAddress, labels, equates, diagnostics, bytes, layouts);
+            return;
+        case 'disp8':
+            emitDisp8Expression(fragment.expression, fragment.message, span, currentAddress, labels, equates, diagnostics, bytes, layouts);
+            return;
+        case 'abs16':
+            emitAbs16Expression(fragment.expression, span, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts);
+            return;
+        case 'rel8':
+            emitRel8Expression(fragment.expression, fragment.mnemonic, span, currentAddress + instructionSize, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts);
+            return;
+    }
+}
+function emitPort8Expression(expression, message, span, currentAddress, labels, equates, diagnostics, bytes, layouts) {
+    const value = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        currentLocation: currentAddress,
+        layouts,
+    });
+    if (value === undefined) {
+        return;
+    }
+    if (!isImm8Value(value)) {
+        diagnostics.push(diagnostic(span, message));
+        bytes.push(0);
+        return;
+    }
+    bytes.push(value & 0xff);
+}
+function emitImm8Expression(expression, failureMessage, span, currentAddress, labels, equates, diagnostics, bytes, layouts) {
+    const value = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        currentLocation: currentAddress,
+        layouts,
+        reportUnknown: failureMessage === undefined,
+    });
+    if (value === undefined) {
+        if (failureMessage) {
+            diagnostics.push(diagnostic(span, failureMessage));
+            bytes.push(0);
+        }
+        return;
+    }
+    if (!isImm8Value(value)) {
+        diagnostics.push(diagnostic(span, `8-bit value out of range: ${value}.`));
+        bytes.push(0);
+        return;
+    }
+    bytes.push(value & 0xff);
+}
+function emitDisp8Expression(expression, message, span, currentAddress, labels, equates, diagnostics, bytes, layouts) {
+    const value = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        currentLocation: currentAddress,
+        layouts,
+    });
+    if (value === undefined) {
+        return;
+    }
+    if (value < -128 || value > 127) {
+        diagnostics.push(diagnostic(span, message ?? `indexed displacement out of range: ${value}.`));
+        bytes.push(0);
+        return;
+    }
+    bytes.push(value & 0xff);
+}
+function emitRel8Expression(expression, mnemonic, span, origin, currentAddress, labels, equates, diagnostics, bytes, fixups, layouts) {
+    const target = fixupTargetFromExpression(expression);
+    if (target) {
+        fixups.push({ kind: 'rel8', offset: bytes.length, origin, target, mnemonic, span });
+        bytes.push(0);
+        return;
+    }
+    const value = evaluateExpression(expression, labels, equates, span, diagnostics, {
+        currentLocation: currentAddress,
+        layouts,
+    });
+    if (value !== undefined) {
+        emitRel8Displacement(value, origin, mnemonic, bytes, diagnostics, span);
+    }
+}
+function patchAbs16(fixup, target, bytes, diagnostics) {
+    if (!isAbs16Value(target)) {
+        diagnostics.push(diagnostic(fixup.span, `16-bit fixup address out of range for "${fixup.target.symbol}" with addend ${fixup.target.addend}: ${target}.`));
+        return;
+    }
+    bytes[fixup.offset] = target & 0xff;
+    bytes[fixup.offset + 1] = (target >> 8) & 0xff;
+}
+function isAbs16Value(value) {
+    return Number.isInteger(value) && value >= -0x8000 && value <= 0xffff;
+}
+function isImm8Value(value) {
+    return value >= -128 && value <= 0xff;
+}
+function emitRel8Displacement(target, origin, mnemonic, bytes, diagnostics, span, offset = bytes.length) {
+    const displacement = target - origin;
+    if (displacement < -128 || displacement > 127) {
+        diagnostics.push(diagnostic(span, `${mnemonic} target out of range for rel8 branch (${displacement}, expected -128..127).`));
+        bytes[offset] = 0;
+        if (offset === bytes.length) {
+            bytes.push(0);
+        }
+        return;
+    }
+    bytes[offset] = displacement & 0xff;
+    if (offset === bytes.length) {
+        bytes.push(displacement & 0xff);
+    }
+}
+function fixupTargetFromExpression(expression) {
+    if (expression.kind === 'symbol') {
+        return { symbol: expression.name, addend: 0 };
+    }
+    if (expression.kind !== 'binary') {
+        return undefined;
+    }
+    if (expression.operator === '+' || expression.operator === '-') {
+        const leftSymbol = expression.left.kind === 'symbol' ? expression.left.name : undefined;
+        const rightSymbol = expression.right.kind === 'symbol' ? expression.right.name : undefined;
+        const leftConstant = constantExpressionValue(expression.left);
+        const rightConstant = constantExpressionValue(expression.right);
+        if (leftSymbol && rightConstant !== undefined) {
+            return {
+                symbol: leftSymbol,
+                addend: expression.operator === '+' ? rightConstant : -rightConstant,
+            };
+        }
+        if (expression.operator === '+' && rightSymbol && leftConstant !== undefined) {
+            return { symbol: rightSymbol, addend: leftConstant };
+        }
+    }
+    return undefined;
+}
+function constantExpressionValue(expression) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'unary':
+            return constantUnaryExpressionValue(expression);
+        case 'binary':
+            return constantBinaryExpressionValue(expression);
+        case 'current-location':
+        case 'symbol':
+            return undefined;
+    }
+}
+function constantUnaryExpressionValue(expression) {
+    const value = constantExpressionValue(expression.expression);
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (expression.operator) {
+        case '+':
+            return value;
+        case '-':
+            return -value;
+        case '~':
+            return ~value;
+    }
+}
+function constantBinaryExpressionValue(expression) {
+    const left = constantExpressionValue(expression.left);
+    const right = constantExpressionValue(expression.right);
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    switch (expression.operator) {
+        case '*':
+            return left * right;
+        case '/':
+            return right === 0 ? undefined : Math.trunc(left / right);
+        case '%':
+            return right === 0 ? undefined : left % right;
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '&':
+            return left & right;
+        case '^':
+            return left ^ right;
+        case '|':
+            return left | right;
+        case '<<':
+            return left << right;
+        case '>>':
+            return left >> right;
+    }
+}

package/dist/src/assembly/placement.d.ts

@@ -0,0 +1,26 @@
+import type { SourceItem } from '../model/source-item.js';
+export type PlacementKind = 'code' | 'data';
+export interface PlacementState {
+    activePlacement: PlacementKind;
+    codeOffset: number;
+    dataOffset: number;
+    codeBase: number | undefined;
+    dataBase: number | undefined;
+}
+export declare function createPlacementState(): PlacementState;
+/** Mirrors current AZM org lookahead: data org before raw storage, otherwise code. */
+export declare function placementForOrg(items: readonly SourceItem[], index: number): PlacementKind;
+export declare function placementAddress(state: PlacementState): number;
+export declare function applyOrg(state: PlacementState, target: number): void;
+export declare function advancePlacement(state: PlacementState, size: number): void;
+export declare function advanceCodePlacement(state: PlacementState, size: number): void;
+export declare function computeResolvedBases(state: PlacementState): {
+    readonly codeBase: number;
+    readonly dataBase: number;
+};
+export declare function absoluteCodeAddress(state: PlacementState, bases: {
+    readonly codeBase: number;
+}): number;
+export declare function absoluteDataAddress(state: PlacementState, bases: {
+    readonly dataBase: number;
+}): number;

package/dist/src/assembly/placement.js

@@ -0,0 +1,79 @@
+export function createPlacementState() {
+    return {
+        activePlacement: 'code',
+        codeOffset: 0,
+        dataOffset: 0,
+        codeBase: undefined,
+        dataBase: undefined,
+    };
+}
+/** Mirrors current AZM org lookahead: data org before raw storage, otherwise code. */
+export function placementForOrg(items, index) {
+    for (let lookahead = index + 1; lookahead < items.length; lookahead += 1) {
+        const next = items[lookahead];
+        if (!next) {
+            continue;
+        }
+        if (next.kind === 'db' || next.kind === 'dw' || next.kind === 'ds' || next.kind === 'string-data') {
+            return 'data';
+        }
+        if (next.kind === 'label' || next.kind === 'equ') {
+            continue;
+        }
+        return 'code';
+    }
+    return 'code';
+}
+function placementOffset(state) {
+    return state.activePlacement === 'data' ? state.dataOffset : state.codeOffset;
+}
+export function placementAddress(state) {
+    return (placementBase(state, state.activePlacement) ?? 0) + placementOffset(state);
+}
+function placementBase(state, kind) {
+    return kind === 'data' ? state.dataBase : state.codeBase;
+}
+export function applyOrg(state, target) {
+    const kind = state.activePlacement;
+    const base = placementBase(state, kind);
+    if (base === undefined) {
+        if (kind === 'data') {
+            state.dataBase = target;
+        }
+        else {
+            state.codeBase = target;
+        }
+        return;
+    }
+    const offset = target - base;
+    const offsetRef = kind === 'data' ? 'dataOffset' : 'codeOffset';
+    if (offset > state[offsetRef]) {
+        state[offsetRef] = offset;
+    }
+}
+export function advancePlacement(state, size) {
+    if (state.activePlacement === 'data') {
+        state.dataOffset += size;
+    }
+    else {
+        state.codeOffset += size;
+    }
+}
+export function advanceCodePlacement(state, size) {
+    state.codeOffset += size;
+}
+export function computeResolvedBases(state) {
+    const codeBase = state.codeBase ?? 0;
+    const dataBase = state.dataBase ?? alignUp(codeBase + state.codeOffset, 2);
+    return { codeBase, dataBase };
+}
+export function absoluteCodeAddress(state, bases) {
+    return bases.codeBase + state.codeOffset;
+}
+export function absoluteDataAddress(state, bases) {
+    return bases.dataBase + state.dataOffset;
+}
+function alignUp(value, alignment) {
+    const remainder = value % alignment;
+    return remainder === 0 ? value : value + (alignment - remainder);
+}

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

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

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

@@ -0,0 +1,267 @@
+import { diagnostic, evaluateExpression, lookupEquateRecord, } from '../semantics/expression-evaluation.js';
+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';
+function toByte(value) {
+    return value & 0xff;
+}
+function writeImageByte(image, initializedAddresses, address, value) {
+    image.set(address, toByte(value));
+    initializedAddresses.add(address);
+}
+function writeImageBytes(image, initializedAddresses, startAddress, bytes) {
+    for (let index = 0; index < bytes.length; index += 1) {
+        writeImageByte(image, initializedAddresses, startAddress + index, bytes[index] ?? 0);
+    }
+}
+function addSourceSegment(segments, span, start, end, kind) {
+    if (end <= start)
+        return;
+    segments.push({
+        start,
+        end,
+        file: span.sourceName,
+        line: span.line,
+        column: span.column,
+        kind,
+        confidence: 'high',
+    });
+}
+function clipSourceSegment(segment, start, end) {
+    const clippedStart = Math.max(segment.start, start);
+    const clippedEnd = Math.min(segment.end, end);
+    if (clippedEnd <= clippedStart)
+        return undefined;
+    return { ...segment, start: clippedStart, end: clippedEnd };
+}
+function outputRange(initializedAddresses, reservedAddresses, origin, binFrom, binTo) {
+    const initialized = [...initializedAddresses];
+    const touched = [...initializedAddresses, ...reservedAddresses];
+    const start = binFrom ?? (touched.length > 0 ? Math.min(...touched) : origin);
+    const end = binTo === undefined ? defaultExclusiveEnd(initialized, start) : binTo + 1;
+    return { start, end: Math.max(start, end) };
+}
+function defaultExclusiveEnd(initializedAddresses, start) {
+    if (initializedAddresses.length === 0) {
+        return start;
+    }
+    return Math.max(...initializedAddresses) + 1;
+}
+function flattenImage(image, start, end) {
+    const bytes = [];
+    for (let address = start; address < end; address += 1) {
+        bytes.push(image.get(address) ?? 0);
+    }
+    return Uint8Array.from(bytes);
+}
+function activePlacementAddress(placement) {
+    const bases = computeResolvedBases(placement);
+    return placement.activePlacement === 'data'
+        ? absoluteDataAddress(placement, bases)
+        : absoluteCodeAddress(placement, bases);
+}
+function emitDbValue(value, emitAddress, itemSpan, labels, equates, layouts, diagnostics, image, initializedAddresses, placement) {
+    if (value.kind === 'string-fragment') {
+        for (const char of value.value) {
+            const nextAddress = activePlacementAddress(placement);
+            writeImageByte(image, initializedAddresses, nextAddress, char.codePointAt(0) ?? 0);
+            advancePlacement(placement, 1);
+        }
+        return;
+    }
+    if (value.kind === 'symbol') {
+        const equate = lookupEquateRecord(equates, value.name);
+        if (equate?.record.stringValue !== undefined) {
+            for (const char of equate.record.stringValue) {
+                const nextAddress = activePlacementAddress(placement);
+                writeImageByte(image, initializedAddresses, nextAddress, char.codePointAt(0) ?? 0);
+                advancePlacement(placement, 1);
+            }
+            return;
+        }
+    }
+    const nextAddress = activePlacementAddress(placement);
+    const evaluated = evaluateExpression(value, labels, equates, itemSpan, diagnostics, {
+        currentLocation: emitAddress,
+        layouts,
+    });
+    if (evaluated !== undefined) {
+        writeImageByte(image, initializedAddresses, nextAddress, evaluated);
+        advancePlacement(placement, 1);
+    }
+}
+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();
+    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') {
+            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 '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;
+            }
+        }
+    }
+    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 {
+        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),
+        bytes: diagnostics.length > 0 ? new Uint8Array() : bytes,
+    };
+}