@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/expansion/op-expansion.js

@@ -1,50 +1,63 @@
-import { encodeZ80Instruction } from '../z80/encode.js';
-import { parseZ80Instruction } from '../z80/parse-instruction.js';
 import { stripLineComment } from '../source/strip-line-comment.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
-import { parseExpression } from '../syntax/parse-expression.js';
+import { expandSelectedOp } from './op-expand-selected.js';
+import { splitOperands } from './op-operand-splitting.js';
+import { parseOpMatcher, parseOpOperand, } from './op-operands.js';
 export function collectOps(lines, diagnostics, parseOptions = {}) {
     const ops = new Map();
     const opLineIndexes = new Set();
     for (let index = 0; index < lines.length; index += 1) {
         const line = lines[index];
-        if (isTopLevelEnd(line.text)) {
+        if (isTopLevelEnd(line.text))
             break;
-        }
-        const opHeader = /^op\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*)\)\s*$/i.exec(stripLineComment(line.text).trim());
-        if (!opHeader) {
+        const header = parseOpHeader(line, diagnostics);
+        if (!header)
             continue;
-        }
-        const name = opHeader[1] ?? '';
-        const params = parseOpParams(opHeader[2] ?? '', line, diagnostics);
-        const paramNames = new Set(params.map((param) => param.name));
-        const body = [];
-        let terminated = false;
         opLineIndexes.add(index);
-        for (index += 1; index < lines.length; index += 1) {
-            opLineIndexes.add(index);
-            const bodyLine = lines[index];
-            const bodyText = stripLineComment(bodyLine.text).trim();
-            if (/^end\s*$/i.test(bodyText)) {
-                terminated = true;
-                break;
-            }
-            const template = parseOpBodyTemplate(bodyLine, paramNames, diagnostics, parseOptions);
-            if (template) {
-                body.push(template);
-            }
-        }
-        if (!terminated) {
-            diagnostics.push(parseDiagnostic(line, `op ${name} missing end`));
-        }
-        if (params.length > 0 || terminated) {
-            const overloads = ops.get(name) ?? [];
-            overloads.push({ name, params, body, sourceName: line.sourceName, line: line.line });
-            ops.set(name, overloads);
-        }
+        const collected = collectOpBody(lines, index + 1, header.params, diagnostics, parseOptions, opLineIndexes);
+        index = collected.endIndex;
+        recordCollectedOp(ops, header, collected, line, diagnostics);
     }
     return { ops, opLineIndexes };
 }
+function parseOpHeader(line, diagnostics) {
+    const opHeader = /^op\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*)\)\s*$/i.exec(stripLineComment(line.text).trim());
+    if (!opHeader)
+        return undefined;
+    return { name: opHeader[1] ?? '', params: parseOpParams(opHeader[2] ?? '', line, diagnostics) };
+}
+function collectOpBody(lines, startIndex, params, diagnostics, parseOptions, opLineIndexes) {
+    const paramNames = new Set(params.map((param) => param.name));
+    const body = [];
+    for (let index = startIndex; index < lines.length; index += 1) {
+        opLineIndexes.add(index);
+        const bodyLine = lines[index];
+        if (isOpEnd(bodyLine.text)) {
+            return { body, terminated: true, endIndex: index };
+        }
+        const template = parseOpBodyTemplate(bodyLine, paramNames, diagnostics, parseOptions);
+        if (template)
+            body.push(template);
+    }
+    return { body, terminated: false, endIndex: lines.length };
+}
+function recordCollectedOp(ops, header, collected, line, diagnostics) {
+    if (!collected.terminated) {
+        diagnostics.push(parseDiagnostic(line, `op ${header.name} missing end`));
+    }
+    if (header.params.length === 0 && !collected.terminated)
+        return;
+    ops.set(header.name, [
+        ...(ops.get(header.name) ?? []),
+        {
+            name: header.name,
+            params: header.params,
+            body: collected.body,
+            sourceName: line.sourceName,
+            line: line.line,
+        },
+    ]);
+}
 export function parseOpInvocation(line) {
     const text = stripLineComment(line.text).trim();
     const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
@@ -62,66 +75,6 @@ export function parseOpInvocation(line) {
 export function expandOpInvocation(ops, overloads, operands, line, diagnostics) {
     return expandSelectedOp(ops, overloads, operands, line, diagnostics, []);
 }
-function expandSelectedOp(ops, overloads, operands, line, diagnostics, stack) {
-    const name = overloads[0]?.name ?? '<unknown>';
-    const cycleStart = stack.findIndex((entry) => entry.name.toLowerCase() === name.toLowerCase());
-    if (cycleStart !== -1) {
-        diagnostics.push(parseDiagnostic(line, [
-            `Cyclic op expansion detected for "${name}".`,
-            `expansion chain: ${[...stack.slice(cycleStart), overloads[0]].map(formatOpChainEntry).join(' -> ')}`,
-        ].join('\n')));
-        return [];
-    }
-    const selection = selectOpOverload(overloads, operands);
-    if (selection.kind !== 'selected') {
-        diagnostics.push(parseDiagnostic(line, formatOpSelectionDiagnostic(selection, overloads, operands)));
-        return [];
-    }
-    const bindings = new Map();
-    selection.overload.params.forEach((param, index) => {
-        bindings.set(param.name, operands[index]);
-    });
-    const expanded = [];
-    const localLabelMap = buildLocalLabelMap(selection.overload, line);
-    const expansionStack = [...stack, selection.overload];
-    const emittedSource = {
-        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
-        kind: 'macro',
-    };
-    for (const item of selection.overload.body) {
-        if (item.kind === 'source-items') {
-            expanded.push(...renameSourceItems(item.items, localLabelMap).map((renamed) => stampOpSource(renamed, emittedSource)));
-            continue;
-        }
-        const concreteOperands = instantiateTemplateOperands(item, bindings);
-        if (!concreteOperands) {
-            diagnostics.push(parseDiagnostic(line, `invalid op expansion in "${selection.overload.name}"`));
-            continue;
-        }
-        const nested = ops.get(item.mnemonic);
-        if (nested) {
-            expanded.push(...expandSelectedOp(ops, nested, concreteOperands, line, diagnostics, expansionStack));
-            continue;
-        }
-        const instruction = instantiateTemplateInstruction(item, concreteOperands);
-        if (!instruction || encodeZ80Instruction(instruction).size === 0) {
-            reportInvalidOpExpansion(line, diagnostics, selection.overload, expansionStack, item, concreteOperands);
-            continue;
-        }
-        expanded.push({
-            kind: 'instruction',
-            instruction: renameInstructionExpressions(instruction, localLabelMap),
-            span: emittedSource.span,
-            emittedSource,
-        });
-    }
-    return expanded;
-}
-function stampOpSource(item, emittedSource) {
-    if (item.kind !== 'instruction')
-        return item;
-    return { ...item, emittedSource };
-}
 function parseOpParams(text, line, diagnostics) {
     const trimmed = text.trim();
     if (trimmed.length === 0) {
@@ -149,70 +102,48 @@ function parseOpParams(text, line, diagnostics) {
     }
     return params;
 }
-function parseOpMatcher(text) {
-    if (/^reg8$/i.test(text)) {
-        return { kind: 'reg8' };
-    }
-    if (/^reg16$/i.test(text)) {
-        return { kind: 'reg16' };
-    }
-    if (/^imm8$/i.test(text)) {
-        return { kind: 'imm8' };
-    }
-    if (/^imm16$/i.test(text)) {
-        return { kind: 'imm16' };
-    }
-    if (/^cc$/i.test(text)) {
-        return { kind: 'cc' };
-    }
-    if (/^idx16$/i.test(text)) {
-        return { kind: 'idx16' };
-    }
-    if (/^ea$/i.test(text)) {
-        return { kind: 'ea' };
-    }
-    if (/^mem8$/i.test(text)) {
-        return { kind: 'mem8' };
-    }
-    if (/^mem16$/i.test(text)) {
-        return { kind: 'mem16' };
-    }
-    if (/^[A-Za-z][A-Za-z0-9_]*$/.test(text)) {
-        return { kind: 'fixed', token: text.toUpperCase() };
-    }
-    return undefined;
-}
 function parseOpBodyTemplate(line, paramNames, diagnostics, parseOptions) {
     const text = stripLineComment(line.text).trim();
-    if (text.length === 0) {
+    if (text.length === 0)
         return undefined;
+    const template = parseTemplateInstructionCandidate(text, paramNames);
+    if (template && templateContainsParam(template)) {
+        return template;
     }
+    const parsedSource = parseOpBodySourceItems(line, diagnostics, parseOptions, template !== undefined);
+    if (parsedSource)
+        return parsedSource;
+    return template;
+}
+function parseTemplateInstructionCandidate(text, paramNames) {
     const instruction = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
-    if (instruction) {
-        const operandText = instruction[2] ?? '';
-        const operands = operandText.trim().length === 0
-            ? []
-            : splitOperands(operandText).map((operand) => parseTemplateOperand(operand, paramNames));
-        if (operands.every((operand) => operand !== undefined)) {
-            if (!operands.some((operand) => operand?.kind === 'param' || operand?.kind === 'port-param')) {
-                const result = parseLogicalLine(line, parseOptions);
-                if (result.items.length > 0 || !isUnsupportedSourceLine(result.diagnostics)) {
-                    diagnostics.push(...result.diagnostics);
-                    return result.items.length > 0
-                        ? { kind: 'source-items', items: result.items }
-                        : undefined;
-                }
-            }
-            return {
-                kind: 'instruction',
-                mnemonic: (instruction[1] ?? '').toLowerCase(),
-                operands: operands,
-            };
-        }
-    }
+    if (!instruction)
+        return undefined;
+    const operands = parseTemplateOperands(instruction[2] ?? '', paramNames);
+    return operands
+        ? { kind: 'instruction', mnemonic: (instruction[1] ?? '').toLowerCase(), operands }
+        : undefined;
+}
+function parseTemplateOperands(operandText, paramNames) {
+    const operands = operandText.trim().length === 0
+        ? []
+        : splitOperands(operandText).map((operand) => parseTemplateOperand(operand, paramNames));
+    return operands.every((operand) => operand !== undefined)
+        ? operands
+        : undefined;
+}
+function templateContainsParam(template) {
+    return template.operands.some((operand) => operand.kind === 'param' || operand.kind === 'port-param');
+}
+function parseOpBodySourceItems(line, diagnostics, parseOptions, suppressUnsupportedLineDiagnostic) {
     const result = parseLogicalLine(line, parseOptions);
+    if (suppressUnsupportedLineDiagnostic && isUnsupportedSourceLine(result.diagnostics)) {
+        return undefined;
+    }
     diagnostics.push(...result.diagnostics);
-    return result.items.length > 0 ? { kind: 'source-items', items: result.items } : undefined;
+    if (result.items.length === 0)
+        return undefined;
+    return { kind: 'source-items', items: result.items };
 }
 function isUnsupportedSourceLine(diagnostics) {
     return (diagnostics.length === 1 &&
@@ -231,673 +162,12 @@ function parseTemplateOperand(text, paramNames) {
     const operand = parseOpOperand(trimmed);
     return operand ? { kind: 'literal', operand } : undefined;
 }
-function parseOpOperand(text) {
-    const trimmed = text.trim();
-    if (/^(A|B|C|D|E|H|L)$/i.test(trimmed)) {
-        return { kind: 'reg8', register: trimmed.toLowerCase(), text: trimmed.toUpperCase() };
-    }
-    if (/^(BC|DE|HL|SP)$/i.test(trimmed)) {
-        return { kind: 'reg16', register: trimmed.toLowerCase(), text: trimmed.toUpperCase() };
-    }
-    if (/^\(HL\)$/i.test(trimmed)) {
-        return { kind: 'reg-indirect', register: 'hl', text: '(HL)' };
-    }
-    const indexed = parseIndexedOperand(trimmed);
-    if (indexed) {
-        return indexed;
-    }
-    if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
-        const expression = parseExpression(trimmed.slice(1, -1).trim());
-        return expression ? { kind: 'mem-abs', expression, text: trimmed } : undefined;
-    }
-    const expression = parseExpression(trimmed);
-    return expression ? { kind: 'imm', expression, text: trimmed } : undefined;
-}
-function selectOpOverload(overloads, operands) {
-    const arityMatches = overloads.filter((overload) => overload.params.length === operands.length);
-    if (arityMatches.length === 0) {
-        return { kind: 'arity_mismatch' };
-    }
-    const matches = arityMatches.filter((overload) => overload.params.every((param, index) => matcherMatchesOperand(param.matcher, operands[index])));
-    if (matches.length === 0) {
-        return { kind: 'no_match', candidates: arityMatches };
-    }
-    if (matches.length === 1) {
-        return { kind: 'selected', overload: matches[0] };
-    }
-    const selected = mostSpecificOverload(matches, operands);
-    return selected
-        ? { kind: 'selected', overload: selected }
-        : { kind: 'ambiguous', candidates: matches };
-}
-function mostSpecificOverload(overloads, operands) {
-    for (const candidate of overloads) {
-        let beatsAll = true;
-        for (const other of overloads) {
-            if (candidate === other) {
-                continue;
-            }
-            if (compareOverloadSpecificity(candidate, other, operands) !== 'x') {
-                beatsAll = false;
-                break;
-            }
-        }
-        if (beatsAll) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function compareOverloadSpecificity(x, y, operands) {
-    let xBetter = 0;
-    let yBetter = 0;
-    for (let index = 0; index < operands.length; index += 1) {
-        const comparison = compareMatcherSpecificity(x.params[index].matcher, y.params[index].matcher, operands[index]);
-        if (comparison === 'x') {
-            xBetter += 1;
-        }
-        else if (comparison === 'y') {
-            yBetter += 1;
-        }
-    }
-    if (xBetter > 0 && yBetter === 0)
-        return 'x';
-    if (yBetter > 0 && xBetter === 0)
-        return 'y';
-    if (xBetter === 0 && yBetter === 0)
-        return 'equal';
-    return 'incomparable';
-}
-function compareMatcherSpecificity(x, y, operand) {
-    if (x.kind === y.kind)
-        return 'equal';
-    if (x.kind === 'fixed' && fixedTokenBeatsMatcher(x, y, operand))
-        return 'x';
-    if (y.kind === 'fixed' && fixedTokenBeatsMatcher(y, x, operand))
-        return 'y';
-    if (x.kind === 'imm8' && y.kind === 'imm16' && operand.kind === 'imm') {
-        return expressionFitsKnownImm8(operand.expression) ? 'x' : 'equal';
-    }
-    if (x.kind === 'imm16' && y.kind === 'imm8' && operand.kind === 'imm') {
-        return expressionFitsKnownImm8(operand.expression) ? 'y' : 'equal';
-    }
-    return 'equal';
-}
-function fixedTokenBeatsMatcher(fixed, other, operand) {
-    return ((other.kind === 'reg8' && operand.kind === 'reg8' && operand.text === fixed.token) ||
-        (other.kind === 'reg16' && operand.kind === 'reg16' && operand.text === fixed.token) ||
-        (other.kind === 'cc' &&
-            isConditionToken(fixed.token) &&
-            operand.text.toUpperCase() === fixed.token));
-}
-function matcherMatchesOperand(matcher, operand) {
-    switch (matcher.kind) {
-        case 'reg8':
-            return operand.kind === 'reg8';
-        case 'reg16':
-            return operand.kind === 'reg16';
-        case 'imm8':
-            return operand.kind === 'imm' && expressionFitsKnownImm8(operand.expression);
-        case 'imm16':
-            return operand.kind === 'imm' && expressionFitsKnownImm16(operand.expression);
-        case 'cc':
-            return isConditionToken(operand.text);
-        case 'idx16':
-            return operand.kind === 'indexed';
-        case 'ea':
-            return operand.kind === 'imm';
-        case 'mem8':
-        case 'mem16':
-            return (operand.kind === 'reg-indirect' || operand.kind === 'mem-abs' || operand.kind === 'indexed');
-        case 'fixed':
-            return operand.text.toUpperCase() === matcher.token;
-    }
-}
-function formatOpSelectionDiagnostic(selection, overloads, operands) {
-    const name = overloads[0]?.name ?? '<unknown>';
-    const operandSummary = `call-site operands: (${operands.map(formatOpOperand).join(', ')})`;
-    switch (selection.kind) {
-        case 'arity_mismatch':
-            return [
-                `No op overload of "${name}" accepts ${operands.length} operand(s).`,
-                'available overloads:',
-                ...overloads.map((overload) => `  - ${formatOpSignature(overload)}`),
-            ].join('\n');
-        case 'no_match': {
-            return [
-                `No matching op overload for "${name}" with provided operands.`,
-                operandSummary,
-                'available overloads:',
-                ...selection.candidates.map((candidate) => {
-                    const mismatch = firstMismatchReason(candidate, operands);
-                    return `  - ${formatOpSignatureWithLocation(candidate)}${mismatch ? ` ; ${mismatch}` : ''}`;
-                }),
-            ].join('\n');
-        }
-        case 'ambiguous':
-            return [
-                `Ambiguous op overload for "${name}" (${selection.candidates.length} matches).`,
-                operandSummary,
-                'equally specific candidates:',
-                ...selection.candidates.map((candidate) => `  - ${formatOpSignatureWithLocation(candidate)}`),
-            ].join('\n');
-    }
-}
-function firstMismatchReason(overload, operands) {
-    for (let index = 0; index < overload.params.length; index += 1) {
-        const param = overload.params[index];
-        const operand = operands[index];
-        if (!matcherMatchesOperand(param.matcher, operand)) {
-            return `${param.name}: ${matcherMismatchReason(param.matcher, operand)}`;
-        }
-    }
-    return undefined;
-}
-function matcherMismatchReason(matcher, operand) {
-    switch (matcher.kind) {
-        case 'reg8':
-            return `expects reg8, got ${formatOpOperand(operand)}`;
-        case 'reg16':
-            return `expects reg16, got ${formatOpOperand(operand)}`;
-        case 'imm8':
-            return `expects imm8, got ${formatOpOperand(operand)}`;
-        case 'imm16':
-            return `expects imm16, got ${formatOpOperand(operand)}`;
-        case 'cc':
-            return `expects condition token NZ/Z/NC/C/PO/PE/P/M, got ${formatOpOperand(operand)}`;
-        case 'idx16':
-            return `expects IX/IY indexed memory operand, got ${formatOpOperand(operand)}`;
-        case 'ea':
-            return `expects ea, got ${formatOpOperand(operand)}`;
-        case 'mem8':
-            return `expects mem8 dereference, got ${formatOpOperand(operand)}`;
-        case 'mem16':
-            return `expects mem16 dereference, got ${formatOpOperand(operand)}`;
-        case 'fixed':
-            return `expects ${matcher.token}, got ${formatOpOperand(operand)}`;
-    }
-}
-function formatOpSignature(op) {
-    return `${op.name}(${op.params.map((param) => `${param.name} ${formatMatcher(param.matcher)}`).join(', ')})`;
-}
-function formatOpSignatureWithLocation(op) {
-    return `${formatOpSignature(op)} (${op.sourceName}:${op.line})`;
-}
-function formatOpChainEntry(op) {
-    return `${op.name} (${op.sourceName}:${op.line})`;
-}
-function formatMatcher(matcher) {
-    return matcher.kind === 'fixed' ? matcher.token : matcher.kind;
-}
-function formatOpOperand(operand) {
-    return operand.kind === 'imm' ? operand.text : operand.text.toUpperCase();
-}
-function formatExpandedInstruction(mnemonic, operands) {
-    return `${mnemonic} ${operands.map(formatOpOperand).join(', ')}`.trim();
-}
-function reportInvalidOpExpansion(line, diagnostics, overload, expansionStack, item, concreteOperands) {
-    const expandedInstruction = formatExpandedInstruction(item.mnemonic, concreteOperands);
-    const underlying = expandedInstructionUnderlyingError(item, concreteOperands);
-    if (underlying) {
-        diagnostics.push(parseDiagnostic(line, underlying));
-    }
-    diagnostics.push(parseDiagnostic(line, formatInvalidOpExpansionDiagnostic(overload, expandedInstruction, expansionStack)));
-}
-function expandedInstructionUnderlyingError(item, concreteOperands) {
-    const instruction = instantiateTemplateInstruction(item, concreteOperands);
-    if (instruction && encodeZ80Instruction(instruction).size > 0) {
-        return undefined;
-    }
-    if (instruction?.mnemonic === 'ld' || item.mnemonic === 'ld') {
-        return 'ld expects a supported register/memory/immediate transfer form';
-    }
-    const parsed = parseZ80Instruction(formatExpandedInstruction(item.mnemonic, concreteOperands));
-    return parsed?.error;
-}
-function formatInvalidOpExpansionDiagnostic(overload, expandedInstruction, expansionStack) {
-    return [
-        `Invalid op expansion in "${overload.name}" at call site.`,
-        `expanded instruction: ${expandedInstruction}`,
-        `op definition: ${overload.sourceName}:${overload.line}`,
-        `expansion chain: ${expansionStack.map(formatOpChainEntry).join(' -> ')}`,
-    ].join('\n');
-}
-function instantiateTemplateInstruction(item, concrete) {
-    const mnemonic = item.mnemonic;
-    if (mnemonic === 'ld' && concrete.length === 2) {
-        const target = toZ80Operand(concrete[0]);
-        const source = toZ80Operand(concrete[1]);
-        return target && source ? { mnemonic: 'ld', target, source } : undefined;
-    }
-    if (mnemonic === 'in' && concrete.length === 2 && concrete[0]?.kind === 'reg8') {
-        const port = toPortOperand(concrete[1]);
-        return port
-            ? {
-                mnemonic: 'in',
-                target: { kind: 'reg8', register: concrete[0].register },
-                port,
-            }
-            : undefined;
-    }
-    if (mnemonic === 'out' && concrete.length === 2) {
-        const port = toPortOperand(concrete[0]);
-        const source = concrete[1]?.kind === 'reg8' ? concrete[1] : undefined;
-        return port && source
-            ? {
-                mnemonic: 'out',
-                port,
-                source: { kind: 'reg8', register: source.register },
-            }
-            : undefined;
-    }
-    if ((mnemonic === 'inc' || mnemonic === 'dec') && concrete.length === 1) {
-        const operand = toIncDecOperand(concrete[0]);
-        return operand ? { mnemonic, operand } : undefined;
-    }
-    if (mnemonic === 'jp' && concrete.length === 1 && concrete[0]?.kind === 'imm') {
-        return { mnemonic: 'jp', expression: concrete[0].expression };
-    }
-    if (mnemonic === 'jp' &&
-        concrete.length === 2 &&
-        isConditionToken(concrete[0]?.text ?? '') &&
-        concrete[1]?.kind === 'imm') {
-        return {
-            mnemonic: 'jp-cc',
-            condition: concrete[0].text.toLowerCase(),
-            expression: concrete[1].expression,
-        };
-    }
-    if (mnemonic === 'jr' && concrete.length === 1 && concrete[0]?.kind === 'imm') {
-        return { mnemonic: 'jr', expression: concrete[0].expression };
-    }
-    if (mnemonic === 'jr' &&
-        concrete.length === 2 &&
-        isRelativeConditionToken(concrete[0]?.text ?? '') &&
-        concrete[1]?.kind === 'imm') {
-        return {
-            mnemonic: 'jr-cc',
-            condition: concrete[0].text.toLowerCase(),
-            expression: concrete[1].expression,
-        };
-    }
-    if (isAluMnemonic(mnemonic) && concrete.length === 1) {
-        const source = toZ80Operand(concrete[0]);
-        return source ? { mnemonic, source } : undefined;
-    }
-    if (isAluMnemonic(mnemonic) && concrete.length === 2 && concrete[0]?.kind === 'reg8') {
-        if (concrete[0].register !== 'a') {
-            return undefined;
-        }
-        const source = toZ80Operand(concrete[1]);
-        return source ? { mnemonic, source } : undefined;
-    }
-    if ((mnemonic === 'add' || mnemonic === 'adc' || mnemonic === 'sbc') &&
-        concrete.length === 2 &&
-        concrete[0]?.kind === 'reg16' &&
-        concrete[1]?.kind === 'reg16') {
-        const target = toZ80Operand(concrete[0]);
-        const source = toZ80Operand(concrete[1]);
-        return target?.kind === 'reg16' && source?.kind === 'reg16'
-            ? { mnemonic, target, source }
-            : undefined;
-    }
-    return parseExpandedInstruction(mnemonic, concrete);
-}
-function instantiateTemplateOperands(item, bindings) {
-    const operands = item.operands.map((operand) => operand.kind === 'param'
-        ? bindings.get(operand.name)
-        : operand.kind === 'port-param'
-            ? parenthesizedOperandFromBinding(item.mnemonic, bindings.get(operand.name))
-            : operand.operand);
-    if (operands.some((operand) => operand === undefined)) {
-        return undefined;
-    }
-    return operands;
-}
-function toZ80Operand(operand) {
-    switch (operand.kind) {
-        case 'reg8':
-            return { kind: 'reg8', register: operand.register };
-        case 'reg16':
-            return { kind: 'reg16', register: operand.register };
-        case 'reg-indirect':
-            return { kind: 'reg-indirect', register: operand.register };
-        case 'mem-abs':
-            return { kind: 'mem-abs', expression: operand.expression };
-        case 'indexed':
-            return {
-                kind: 'indexed',
-                register: operand.register,
-                displacement: operand.displacement,
-            };
-        case 'imm':
-            return { kind: 'imm', expression: operand.expression };
-    }
-}
-function toPortOperand(operand) {
-    if (operand.kind === 'reg8' && operand.register === 'c') {
-        return { kind: 'c' };
-    }
-    return operand.kind === 'imm' ? { kind: 'imm', expression: operand.expression } : undefined;
-}
-function toIncDecOperand(operand) {
-    switch (operand.kind) {
-        case 'reg8':
-            return { kind: 'reg8', register: operand.register };
-        case 'reg16':
-            return { kind: 'reg16', register: operand.register };
-        case 'reg-indirect':
-            return { kind: 'reg-indirect', register: operand.register };
-        case 'indexed':
-            return {
-                kind: 'indexed',
-                register: operand.register,
-                displacement: operand.displacement,
-            };
-        case 'imm':
-            return undefined;
-    }
-}
-function parenthesizedOperandFromBinding(mnemonic, operand) {
-    if (operand?.kind !== 'imm') {
-        return undefined;
-    }
-    return mnemonic === 'in' || mnemonic === 'out'
-        ? operand
-        : { kind: 'mem-abs', expression: operand.expression, text: `(${operand.text})` };
-}
-function buildLocalLabelMap(op, line) {
-    const map = new Map();
-    let ordinal = 0;
-    for (const item of op.body) {
-        if (item.kind !== 'source-items') {
-            continue;
-        }
-        for (const sourceItem of item.items) {
-            if (sourceItem.kind === 'label' && !map.has(sourceItem.name)) {
-                map.set(sourceItem.name, `__azm_op_${op.name}_${sourceItem.name}_${line.line}_${ordinal}`);
-                ordinal += 1;
-            }
-        }
-    }
-    return map;
-}
-function renameSourceItems(items, localLabelMap) {
-    if (localLabelMap.size === 0) {
-        return items;
-    }
-    return items.map((item) => renameSourceItem(item, localLabelMap));
-}
-function renameSourceItem(item, localLabelMap) {
-    switch (item.kind) {
-        case 'label':
-            return { ...item, name: localLabelMap.get(item.name) ?? item.name };
-        case 'org':
-        case 'binfrom':
-        case 'binto':
-            return { ...item, expression: renameExpression(item.expression, localLabelMap) };
-        case 'equ':
-            return { ...item, expression: renameExpression(item.expression, localLabelMap) };
-        case 'db':
-            return {
-                ...item,
-                values: item.values.map((value) => value.kind === 'string-fragment' ? value : renameExpression(value, localLabelMap)),
-            };
-        case 'dw':
-            return {
-                ...item,
-                values: item.values.map((value) => renameExpression(value, localLabelMap)),
-            };
-        case 'ds':
-            return item.fill
-                ? {
-                    ...item,
-                    size: renameExpression(item.size, localLabelMap),
-                    fill: renameExpression(item.fill, localLabelMap),
-                }
-                : { ...item, size: renameExpression(item.size, localLabelMap) };
-        case 'align':
-            return { ...item, alignment: renameExpression(item.alignment, localLabelMap) };
-        case 'instruction':
-            return {
-                ...item,
-                instruction: renameInstructionExpressions(item.instruction, localLabelMap),
-            };
-        case 'comment':
-        case 'end':
-        case 'enum':
-        case 'type':
-        case 'type-alias':
-        case 'string-data':
-            return item;
-    }
-}
-function renameInstructionExpressions(instruction, localLabelMap) {
-    if (localLabelMap.size === 0) {
-        return instruction;
-    }
-    switch (instruction.mnemonic) {
-        case 'ld':
-            return {
-                ...instruction,
-                target: renameOperandExpression(instruction.target, localLabelMap),
-                source: renameOperandExpression(instruction.source, localLabelMap),
-            };
-        case 'ld-a-imm':
-            return {
-                ...instruction,
-                expression: renameExpression(instruction.expression, localLabelMap),
-            };
-        case 'in':
-            return { ...instruction, port: renamePortExpression(instruction.port, localLabelMap) };
-        case 'out':
-            return { ...instruction, port: renamePortExpression(instruction.port, localLabelMap) };
-        case 'add':
-        case 'adc':
-        case 'sub':
-        case 'sbc':
-            if ('target' in instruction) {
-                return instruction;
-            }
-            return {
-                ...instruction,
-                source: renameOperandExpression(instruction.source, localLabelMap),
-            };
-        case 'and':
-        case 'or':
-        case 'xor':
-        case 'cp':
-            return { ...instruction, source: renameOperandExpression(instruction.source, localLabelMap) };
-        case 'jp':
-        case 'call':
-        case 'jr':
-        case 'djnz':
-            return {
-                ...instruction,
-                expression: renameExpression(instruction.expression, localLabelMap),
-            };
-        case 'jp-cc':
-        case 'call-cc':
-        case 'jr-cc':
-            return {
-                ...instruction,
-                expression: renameExpression(instruction.expression, localLabelMap),
-            };
-        default:
-            return instruction;
-    }
-}
-function renameOperandExpression(operand, localLabelMap) {
-    switch (operand.kind) {
-        case 'imm':
-            return { ...operand, expression: renameExpression(operand.expression, localLabelMap) };
-        case 'mem-abs':
-            return { ...operand, expression: renameExpression(operand.expression, localLabelMap) };
-        case 'indexed':
-            return { ...operand, displacement: renameExpression(operand.displacement, localLabelMap) };
-        default:
-            return operand;
-    }
-}
-function renamePortExpression(port, localLabelMap) {
-    return port.kind === 'imm'
-        ? { ...port, expression: renameExpression(port.expression, localLabelMap) }
-        : port;
-}
-function renameExpression(expression, localLabelMap) {
-    switch (expression.kind) {
-        case 'symbol':
-            return { ...expression, name: localLabelMap.get(expression.name) ?? expression.name };
-        case 'unary':
-            return { ...expression, expression: renameExpression(expression.expression, localLabelMap) };
-        case 'binary':
-            return {
-                ...expression,
-                left: renameExpression(expression.left, localLabelMap),
-                right: renameExpression(expression.right, localLabelMap),
-            };
-        case 'layout-cast':
-            return { ...expression, base: renameExpression(expression.base, localLabelMap) };
-        default:
-            return expression;
-    }
-}
-function isAluMnemonic(mnemonic) {
-    return /^(add|adc|sub|sbc|and|or|xor|cp)$/.test(mnemonic);
-}
-function expressionFitsKnownImm8(expression) {
-    const value = expressionConstantValue(expression);
-    return value === undefined || (value >= -0x80 && value <= 0xff);
-}
-function expressionFitsKnownImm16(expression) {
-    const value = expressionConstantValue(expression);
-    return value === undefined || (value >= -0x8000 && value <= 0xffff);
-}
-function parseIndexedOperand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-        return undefined;
-    }
-    const inner = trimmed.slice(1, -1).trim();
-    const match = /^(IX|IY)(?:\s*([+-])\s*(.+))?$/i.exec(inner);
-    if (!match) {
-        return undefined;
-    }
-    const displacementText = match[3] ?? '0';
-    const displacement = parseExpression(match[2] === '-' ? `-${displacementText}` : displacementText);
-    return displacement
-        ? {
-            kind: 'indexed',
-            register: (match[1] ?? '').toLowerCase(),
-            displacement,
-            text: trimmed,
-        }
-        : undefined;
-}
-function isConditionToken(text) {
-    return /^(NZ|Z|NC|C|PO|PE|P|M)$/i.test(text);
-}
-function isRelativeConditionToken(text) {
-    return /^(NZ|Z|NC|C)$/i.test(text);
-}
-function parseExpandedInstruction(mnemonic, operands) {
-    const text = formatExpandedInstruction(mnemonic, operands);
-    const result = parseLogicalLine({ sourceName: '<op-expansion>', line: 1, text });
-    if (result.diagnostics.length > 0 || result.items.length !== 1) {
-        return undefined;
-    }
-    const item = result.items[0];
-    return item?.kind === 'instruction' ? item.instruction : undefined;
-}
-function expressionConstantValue(expression) {
-    switch (expression.kind) {
-        case 'number':
-            return expression.value;
-        case 'unary': {
-            const value = expressionConstantValue(expression.expression);
-            if (value === undefined)
-                return undefined;
-            switch (expression.operator) {
-                case '+':
-                    return value;
-                case '-':
-                    return -value;
-                case '~':
-                    return ~value;
-            }
-        }
-        case 'binary': {
-            const left = expressionConstantValue(expression.left);
-            const right = expressionConstantValue(expression.right);
-            if (left === undefined || right === undefined)
-                return undefined;
-            switch (expression.operator) {
-                case '+':
-                    return left + right;
-                case '-':
-                    return left - right;
-                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;
-            }
-        }
-        default:
-            return undefined;
-    }
-}
-function splitOperands(text) {
-    const values = [];
-    let depth = 0;
-    let quote;
-    let escaped = false;
-    let start = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (char === '\\' && quote) {
-            escaped = true;
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = quote === char ? undefined : (quote ?? char);
-            continue;
-        }
-        if (quote) {
-            continue;
-        }
-        if (char === '(') {
-            depth += 1;
-        }
-        else if (char === ')') {
-            depth -= 1;
-        }
-        else if (char === ',' && depth === 0) {
-            values.push(text.slice(start, index).trim());
-            start = index + 1;
-        }
-    }
-    values.push(text.slice(start).trim());
-    return values;
-}
 function isTopLevelEnd(text) {
     return /^(?:\.end|end)\s*$/i.test(stripLineComment(text).trim());
 }
+function isOpEnd(text) {
+    return /^end\s*$/i.test(stripLineComment(text).trim());
+}
 function parseDiagnostic(line, message) {
     return {
         severity: 'error',