@jhlagado/azm 0.2.7 → 0.2.9

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

@@ -0,0 +1,3 @@
+import type { Z80Instruction } from '../z80/instruction.js';
+import type { OpOperand } from './op-expansion.js';
+export declare function instantiateTemplateInstruction(mnemonic: string, concrete: readonly OpOperand[]): Z80Instruction | undefined;

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

@@ -0,0 +1,194 @@
+import { parseLogicalLine } from '../syntax/parse-line.js';
+export function instantiateTemplateInstruction(mnemonic, concrete) {
+    return (instantiateLoadInstruction(mnemonic, concrete) ??
+        instantiatePortInstruction(mnemonic, concrete) ??
+        instantiateIncDecInstruction(mnemonic, concrete) ??
+        instantiateBranchInstruction(mnemonic, concrete) ??
+        instantiateAluInstruction(mnemonic, concrete) ??
+        parseExpandedInstruction(mnemonic, concrete));
+}
+function instantiateLoadInstruction(mnemonic, concrete) {
+    if (mnemonic !== 'ld' || concrete.length !== 2)
+        return undefined;
+    const target = toZ80Operand(concrete[0]);
+    const source = toZ80Operand(concrete[1]);
+    return target && source ? { mnemonic: 'ld', target, source } : undefined;
+}
+function instantiatePortInstruction(mnemonic, concrete) {
+    if (mnemonic === 'in')
+        return instantiateInInstruction(concrete);
+    if (mnemonic === 'out')
+        return instantiateOutInstruction(concrete);
+    return undefined;
+}
+function instantiateInInstruction(concrete) {
+    if (concrete.length !== 2 || concrete[0]?.kind !== 'reg8')
+        return undefined;
+    const port = toPortOperand(concrete[1]);
+    return port
+        ? {
+            mnemonic: 'in',
+            target: { kind: 'reg8', register: concrete[0].register },
+            port,
+        }
+        : undefined;
+}
+function instantiateOutInstruction(concrete) {
+    if (concrete.length !== 2)
+        return undefined;
+    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;
+}
+function instantiateIncDecInstruction(mnemonic, concrete) {
+    if ((mnemonic !== 'inc' && mnemonic !== 'dec') || concrete.length !== 1)
+        return undefined;
+    const operand = toIncDecOperand(concrete[0]);
+    return operand ? { mnemonic, operand } : undefined;
+}
+function instantiateBranchInstruction(mnemonic, concrete) {
+    if (mnemonic === 'jp')
+        return instantiateJpInstruction(concrete);
+    if (mnemonic === 'jr')
+        return instantiateJrInstruction(concrete);
+    return undefined;
+}
+function instantiateJpInstruction(concrete) {
+    if (isSingleImmediate(concrete)) {
+        return { mnemonic: 'jp', expression: concrete[0].expression };
+    }
+    if (isConditionalImmediate(concrete, isConditionToken)) {
+        return {
+            mnemonic: 'jp-cc',
+            condition: concrete[0].text.toLowerCase(),
+            expression: concrete[1].expression,
+        };
+    }
+    return undefined;
+}
+function instantiateJrInstruction(concrete) {
+    if (isSingleImmediate(concrete)) {
+        return { mnemonic: 'jr', expression: concrete[0].expression };
+    }
+    if (isConditionalImmediate(concrete, isRelativeConditionToken)) {
+        return {
+            mnemonic: 'jr-cc',
+            condition: concrete[0].text.toLowerCase(),
+            expression: concrete[1].expression,
+        };
+    }
+    return undefined;
+}
+function isSingleImmediate(concrete) {
+    return concrete.length === 1 && concrete[0]?.kind === 'imm';
+}
+function isConditionalImmediate(concrete, isCondition) {
+    return (concrete.length === 2 &&
+        isCondition(concrete[0]?.text ?? '') &&
+        concrete[1]?.kind === 'imm');
+}
+function instantiateAluInstruction(mnemonic, concrete) {
+    if (!isAluMnemonic(mnemonic))
+        return undefined;
+    if (isRegisterPairAluShape(mnemonic, concrete)) {
+        return instantiateRegisterPairAluInstruction(mnemonic, concrete);
+    }
+    return instantiateAccumulatorAluInstruction(mnemonic, concrete);
+}
+function isRegisterPairAluShape(mnemonic, concrete) {
+    return ((mnemonic === 'add' || mnemonic === 'adc' || mnemonic === 'sbc') &&
+        concrete.length === 2 &&
+        concrete[0]?.kind === 'reg16' &&
+        concrete[1]?.kind === 'reg16');
+}
+function instantiateRegisterPairAluInstruction(mnemonic, concrete) {
+    const target = toZ80Operand(concrete[0]);
+    const source = toZ80Operand(concrete[1]);
+    return target?.kind === 'reg16' && source?.kind === 'reg16'
+        ? { mnemonic, target, source }
+        : undefined;
+}
+function instantiateAccumulatorAluInstruction(mnemonic, concrete) {
+    if (concrete.length === 1) {
+        const source = toZ80Operand(concrete[0]);
+        return source ? { mnemonic, source } : undefined;
+    }
+    if (!isExplicitAccumulatorAluShape(concrete))
+        return undefined;
+    const source = toZ80Operand(concrete[1]);
+    return source ? { mnemonic, source } : undefined;
+}
+function isExplicitAccumulatorAluShape(concrete) {
+    return concrete.length === 2 && concrete[0]?.kind === 'reg8' && concrete[0].register === 'a';
+}
+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 isAluMnemonic(mnemonic) {
+    return /^(add|adc|sub|sbc|and|or|xor|cp)$/.test(mnemonic);
+}
+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 = `${mnemonic} ${operands.map(formatOpOperand).join(', ')}`.trim();
+    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 formatOpOperand(operand) {
+    return operand.kind === 'imm' ? operand.text : operand.text.toUpperCase();
+}

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

@@ -0,0 +1,8 @@
+import type { SourceItem } from '../model/source-item.js';
+import type { Z80Instruction } from '../z80/instruction.js';
+import type { OpDecl } from './op-expansion.js';
+export declare function buildLocalLabelMap(op: OpDecl, line: {
+    readonly line: number;
+}): ReadonlyMap<string, string>;
+export declare function renameSourceItems(items: readonly SourceItem[], localLabelMap: ReadonlyMap<string, string>): readonly SourceItem[];
+export declare function renameInstructionExpressions(instruction: Z80Instruction, localLabelMap: ReadonlyMap<string, string>): Z80Instruction;

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

@@ -0,0 +1,166 @@
+const EXPRESSION_ITEM_KINDS = new Set(['org', 'equ', 'binfrom', 'binto']);
+const SOURCE_OPERAND_MNEMONICS = new Set([
+    'and',
+    'or',
+    'xor',
+    'cp',
+]);
+const JUMP_EXPRESSION_MNEMONICS = new Set([
+    'jp',
+    'call',
+    'jr',
+    'djnz',
+    'jp-cc',
+    'call-cc',
+    'jr-cc',
+]);
+export 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;
+}
+export function renameSourceItems(items, localLabelMap) {
+    if (localLabelMap.size === 0)
+        return items;
+    return items.map((item) => renameSourceItem(item, localLabelMap));
+}
+function renameSourceItem(item, localLabelMap) {
+    if (item.kind === 'label')
+        return renameLabelItem(item, localLabelMap);
+    if (isExpressionItem(item))
+        return renameExpressionItem(item, localLabelMap);
+    if (item.kind === 'db')
+        return renameDbItem(item, localLabelMap);
+    if (item.kind === 'dw')
+        return renameDwItem(item, localLabelMap);
+    if (item.kind === 'ds')
+        return renameDsItem(item, localLabelMap);
+    if (item.kind === 'align')
+        return renameAlignItem(item, localLabelMap);
+    if (item.kind === 'instruction')
+        return renameInstructionItem(item, localLabelMap);
+    return item;
+}
+export function renameInstructionExpressions(instruction, localLabelMap) {
+    if (localLabelMap.size === 0)
+        return instruction;
+    if (instruction.mnemonic === 'ld')
+        return renameLdInstruction(instruction, localLabelMap);
+    if (instruction.mnemonic === 'ld-a-imm')
+        return renameExpressionInstruction(instruction, localLabelMap);
+    if (instruction.mnemonic === 'in' || instruction.mnemonic === 'out') {
+        return { ...instruction, port: renamePortExpression(instruction.port, localLabelMap) };
+    }
+    if (isAluSourceInstruction(instruction))
+        return renameSourceOperandInstruction(instruction, localLabelMap);
+    if (isJumpExpressionInstruction(instruction))
+        return renameExpressionInstruction(instruction, localLabelMap);
+    return instruction;
+}
+function renameLabelItem(item, localLabelMap) {
+    return { ...item, name: localLabelMap.get(item.name) ?? item.name };
+}
+function isExpressionItem(item) {
+    return EXPRESSION_ITEM_KINDS.has(item.kind);
+}
+function renameExpressionItem(item, localLabelMap) {
+    return { ...item, expression: renameExpression(item.expression, localLabelMap) };
+}
+function renameDbItem(item, localLabelMap) {
+    return {
+        ...item,
+        values: item.values.map((value) => value.kind === 'string-fragment' ? value : renameExpression(value, localLabelMap)),
+    };
+}
+function renameDwItem(item, localLabelMap) {
+    return { ...item, values: item.values.map((value) => renameExpression(value, localLabelMap)) };
+}
+function renameDsItem(item, localLabelMap) {
+    return item.fill
+        ? {
+            ...item,
+            size: renameExpression(item.size, localLabelMap),
+            fill: renameExpression(item.fill, localLabelMap),
+        }
+        : { ...item, size: renameExpression(item.size, localLabelMap) };
+}
+function renameAlignItem(item, localLabelMap) {
+    return { ...item, alignment: renameExpression(item.alignment, localLabelMap) };
+}
+function renameInstructionItem(item, localLabelMap) {
+    return {
+        ...item,
+        instruction: renameInstructionExpressions(item.instruction, localLabelMap),
+    };
+}
+function renameLdInstruction(instruction, localLabelMap) {
+    return {
+        ...instruction,
+        target: renameOperandExpression(instruction.target, localLabelMap),
+        source: renameOperandExpression(instruction.source, localLabelMap),
+    };
+}
+function renameExpressionInstruction(instruction, localLabelMap) {
+    return { ...instruction, expression: renameExpression(instruction.expression, localLabelMap) };
+}
+function isAluSourceInstruction(instruction) {
+    return SOURCE_OPERAND_MNEMONICS.has(instruction.mnemonic) || isAccumulatorAluInstruction(instruction);
+}
+function isAccumulatorAluInstruction(instruction) {
+    return ((instruction.mnemonic === 'add' ||
+        instruction.mnemonic === 'adc' ||
+        instruction.mnemonic === 'sub' ||
+        instruction.mnemonic === 'sbc') &&
+        !('target' in instruction));
+}
+function renameSourceOperandInstruction(instruction, localLabelMap) {
+    return { ...instruction, source: renameOperandExpression(instruction.source, localLabelMap) };
+}
+function isJumpExpressionInstruction(instruction) {
+    return JUMP_EXPRESSION_MNEMONICS.has(instruction.mnemonic);
+}
+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;
+    }
+}

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

@@ -0,0 +1 @@
+export declare function splitOperands(text: string): string[];

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

@@ -0,0 +1,44 @@
+export function splitOperands(text) {
+    const state = {
+        depth: 0,
+        quote: undefined,
+        escaped: false,
+        start: 0,
+        values: [],
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        advanceOperandSplitState(state, text, index);
+    }
+    state.values.push(text.slice(state.start).trim());
+    return state.values;
+}
+function advanceOperandSplitState(state, text, index) {
+    const char = text[index];
+    if (state.escaped) {
+        state.escaped = false;
+        return;
+    }
+    if (char === '\\' && state.quote) {
+        state.escaped = true;
+        return;
+    }
+    if (char === '"' || char === "'") {
+        state.quote = state.quote === char ? undefined : (state.quote ?? char);
+        return;
+    }
+    if (state.quote)
+        return;
+    updateOperandSplitDepthOrValue(state, text, index, char);
+}
+function updateOperandSplitDepthOrValue(state, text, index, char) {
+    if (char === '(') {
+        state.depth += 1;
+    }
+    else if (char === ')') {
+        state.depth -= 1;
+    }
+    else if (char === ',' && state.depth === 0) {
+        state.values.push(text.slice(state.start, index).trim());
+        state.start = index + 1;
+    }
+}

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

@@ -0,0 +1,53 @@
+import type { Expression } from '../model/expression.js';
+export 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;
+};
+export 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 declare function parseOpMatcher(text: string): OpMatcher | undefined;
+export declare function parseOpOperand(text: string): OpOperand | undefined;
+export declare function isConditionToken(text: string): boolean;
+export declare function formatOpOperand(operand: OpOperand): string;

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

@@ -0,0 +1,66 @@
+import { parseExpression } from '../syntax/parse-expression.js';
+const MATCHERS = new Map([
+    ['reg8', { kind: 'reg8' }],
+    ['reg16', { kind: 'reg16' }],
+    ['imm8', { kind: 'imm8' }],
+    ['imm16', { kind: 'imm16' }],
+    ['cc', { kind: 'cc' }],
+    ['idx16', { kind: 'idx16' }],
+    ['ea', { kind: 'ea' }],
+    ['mem8', { kind: 'mem8' }],
+    ['mem16', { kind: 'mem16' }],
+]);
+export function parseOpMatcher(text) {
+    const matcher = MATCHERS.get(text.toLowerCase());
+    if (matcher)
+        return matcher;
+    return /^[A-Za-z][A-Za-z0-9_]*$/.test(text)
+        ? { kind: 'fixed', token: text.toUpperCase() }
+        : undefined;
+}
+export 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 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;
+}
+export function isConditionToken(text) {
+    return /^(NZ|Z|NC|C|PO|PE|P|M)$/i.test(text);
+}
+export function formatOpOperand(operand) {
+    return operand.kind === 'imm' ? operand.text : operand.text.toUpperCase();
+}

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

@@ -0,0 +1,18 @@
+import type { OpDecl } from './op-expansion.js';
+import { type OpOperand } from './op-operands.js';
+export type OpSelection = {
+    readonly kind: 'selected';
+    readonly overload: OpDecl;
+} | {
+    readonly kind: 'arity_mismatch';
+} | {
+    readonly kind: 'no_match';
+    readonly candidates: readonly OpDecl[];
+} | {
+    readonly kind: 'ambiguous';
+    readonly candidates: readonly OpDecl[];
+};
+export declare function selectOpOverload(overloads: readonly OpDecl[], operands: readonly OpOperand[]): OpSelection;
+export declare function formatOpSelectionDiagnostic(selection: Exclude<OpSelection, {
+    readonly kind: 'selected';
+}>, overloads: readonly OpDecl[], operands: readonly OpOperand[]): string;