@jhlagado/azm 0.2.7 → 0.2.9

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

@@ -0,0 +1,143 @@
+import { encodeZ80Instruction } from '../z80/encode.js';
+import { parseZ80Instruction } from '../z80/parse-instruction.js';
+import { instantiateTemplateInstruction } from './op-instruction-instantiation.js';
+import { buildLocalLabelMap, renameInstructionExpressions, renameSourceItems, } from './op-local-labels.js';
+import { formatOpOperand, } from './op-operands.js';
+import { formatOpSelectionDiagnostic, selectOpOverload } from './op-selection.js';
+export 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, formatCycleDiagnostic(name, stack, cycleStart, overloads)));
+        return [];
+    }
+    const selection = selectOpOverload(overloads, operands);
+    if (selection.kind !== 'selected') {
+        diagnostics.push(parseDiagnostic(line, formatOpSelectionDiagnostic(selection, overloads, operands)));
+        return [];
+    }
+    const bindings = bindOpOperands(selection.overload, operands);
+    const expanded = [];
+    const localLabelMap = buildLocalLabelMap(selection.overload, line);
+    const expansionStack = [...stack, selection.overload];
+    const emittedSource = opEmittedSource(line);
+    for (const item of selection.overload.body) {
+        expanded.push(...expandTemplateItem(ops, item, bindings, line, diagnostics, selection.overload, expansionStack, localLabelMap, emittedSource));
+    }
+    return expanded;
+}
+function bindOpOperands(overload, operands) {
+    const bindings = new Map();
+    overload.params.forEach((param, index) => {
+        bindings.set(param.name, operands[index]);
+    });
+    return bindings;
+}
+function expandTemplateItem(ops, item, bindings, line, diagnostics, overload, expansionStack, localLabelMap, emittedSource) {
+    if (item.kind === 'source-items') {
+        return renameSourceItems(item.items, localLabelMap).map((renamed) => stampOpSource(renamed, emittedSource));
+    }
+    const concreteOperands = instantiateTemplateOperands(item, bindings);
+    if (!concreteOperands) {
+        diagnostics.push(parseDiagnostic(line, `invalid op expansion in "${overload.name}"`));
+        return [];
+    }
+    const nested = ops.get(item.mnemonic);
+    if (nested) {
+        return expandSelectedOp(ops, nested, concreteOperands, line, diagnostics, expansionStack);
+    }
+    const instruction = instantiateTemplateInstruction(item.mnemonic, concreteOperands);
+    if (!instruction || encodeZ80Instruction(instruction).size === 0) {
+        reportInvalidOpExpansion(line, diagnostics, overload, expansionStack, item, concreteOperands);
+        return [];
+    }
+    return [{
+            kind: 'instruction',
+            instruction: renameInstructionExpressions(instruction, localLabelMap),
+            span: emittedSource.span,
+            emittedSource,
+        }];
+}
+function opEmittedSource(line) {
+    return {
+        span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+        kind: 'macro',
+    };
+}
+function stampOpSource(item, emittedSource) {
+    if (item.kind !== 'instruction')
+        return item;
+    return { ...item, emittedSource };
+}
+function formatOpChainEntry(op) {
+    return `${op.name} (${op.sourceName}:${op.line})`;
+}
+function formatCycleDiagnostic(name, stack, cycleStart, overloads) {
+    return [
+        `Cyclic op expansion detected for "${name}".`,
+        `expansion chain: ${[...stack.slice(cycleStart), overloads[0]].map(formatOpChainEntry).join(' -> ')}`,
+    ].join('\n');
+}
+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.mnemonic, 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 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 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 parseDiagnostic(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}

package/dist/src/expansion/op-expansion.d.ts

@@ -1,64 +1,17 @@
 import type { Diagnostic } from '../model/diagnostic.js';
-import type { Expression } from '../model/expression.js';
 import type { SourceItem } from '../model/source-item.js';
 import { type ParseLogicalLineOptions } from '../syntax/parse-line.js';
-type LogicalLineLike = {
+import { type OpMatcher, type OpOperand } from './op-operands.js';
+export type LogicalLineLike = {
     readonly sourceName: string;
     readonly line: number;
     readonly text: string;
 };
-type OpMatcher = {
-    readonly kind: 'reg8';
-} | {
-    readonly kind: 'reg16';
-} | {
-    readonly kind: 'imm8';
-} | {
-    readonly kind: 'imm16';
-} | {
-    readonly kind: 'cc';
-} | {
-    readonly kind: 'idx16';
-} | {
-    readonly kind: 'ea';
-} | {
-    readonly kind: 'mem8';
-} | {
-    readonly kind: 'mem16';
-} | {
-    readonly kind: 'fixed';
-    readonly token: string;
-};
 interface OpParam {
     readonly name: string;
     readonly matcher: OpMatcher;
 }
-type OpOperand = {
-    readonly kind: 'reg8';
-    readonly register: string;
-    readonly text: string;
-} | {
-    readonly kind: 'reg16';
-    readonly register: string;
-    readonly text: string;
-} | {
-    readonly kind: 'reg-indirect';
-    readonly register: 'hl';
-    readonly text: string;
-} | {
-    readonly kind: 'mem-abs';
-    readonly expression: Expression;
-    readonly text: string;
-} | {
-    readonly kind: 'indexed';
-    readonly register: 'ix' | 'iy';
-    readonly displacement: Expression;
-    readonly text: string;
-} | {
-    readonly kind: 'imm';
-    readonly expression: Expression;
-    readonly text: string;
-};
+export type { OpOperand } from './op-operands.js';
 type OpTemplateOperand = {
     readonly kind: 'param';
     readonly name: string;
@@ -69,7 +22,7 @@ type OpTemplateOperand = {
     readonly kind: 'literal';
     readonly operand: OpOperand;
 };
-type OpTemplateItem = {
+export type OpTemplateItem = {
     readonly kind: 'source-items';
     readonly items: readonly SourceItem[];
 } | {
@@ -77,7 +30,7 @@ type OpTemplateItem = {
     readonly mnemonic: string;
     readonly operands: readonly OpTemplateOperand[];
 };
-interface OpDecl {
+export interface OpDecl {
     readonly name: string;
     readonly params: readonly OpParam[];
     readonly body: readonly OpTemplateItem[];
@@ -93,4 +46,3 @@ export declare function parseOpInvocation(line: LogicalLineLike): {
     readonly operands: readonly OpOperand[];
 } | undefined;
 export declare function expandOpInvocation(ops: ReadonlyMap<string, readonly OpDecl[]>, overloads: readonly OpDecl[], operands: readonly OpOperand[], line: LogicalLineLike, diagnostics: Diagnostic[]): readonly SourceItem[];
-export {};