@jhlagado/azm 0.2.6 → 0.2.8

package/dist/src/z80/ld-support.d.ts

@@ -0,0 +1,3 @@
+import type { Z80Operand } from './instruction.js';
+export declare function isSupportedLd(target: Z80Operand, source: Z80Operand): boolean;
+export declare function unsupportedLdReason(target: Z80Operand, source: Z80Operand): string | undefined;

package/dist/src/z80/ld-support.js

@@ -0,0 +1,146 @@
+const LD_SUPPORT_PREDICATES = [
+    isSupportedSpecialRegisterLd,
+    isSupportedHalfIndexLd,
+    isReg8Ld,
+    isIndexedByteLd,
+    isReg16ImmediateLd,
+    isLegacyReg16Ld,
+    isIndex16ImmediateLd,
+    isStackPointerRegisterLd,
+    isRegisterFromAbsoluteMemoryLd,
+    isAbsoluteMemoryFromRegisterLd,
+    isAccumulatorFromRegisterIndirectLd,
+    isRegisterIndirectFromAccumulatorLd,
+    isHlIndirectByteLd,
+    isByteFromHlIndirectLd,
+];
+export function isSupportedLd(target, source) {
+    return LD_SUPPORT_PREDICATES.some((predicate) => predicate(target, source));
+}
+export function unsupportedLdReason(target, source) {
+    if (isMemoryOperand(target) && isMemoryOperand(source)) {
+        return 'ld does not support memory-to-memory transfers';
+    }
+    const halfIndexReason = unsupportedHalfIndexLdReason(target, source);
+    if (halfIndexReason) {
+        return halfIndexReason;
+    }
+    return unsupportedRegisterPairLdReason(target, source);
+}
+function isReg8Ld(target, source) {
+    return target.kind === 'reg8' && (source.kind === 'reg8' || source.kind === 'imm');
+}
+function isIndexedByteLd(target, source) {
+    return ((target.kind === 'reg8' && source.kind === 'indexed') ||
+        (target.kind === 'indexed' && (source.kind === 'reg8' || source.kind === 'imm')));
+}
+function isReg16ImmediateLd(target, source) {
+    return target.kind === 'reg16' && source.kind === 'imm';
+}
+function isLegacyReg16Ld(target, source) {
+    return (target.kind === 'reg16' &&
+        source.kind === 'reg16' &&
+        isLegacyReg16ByteTransferPair(target.register, source.register));
+}
+function isIndex16ImmediateLd(target, source) {
+    return target.kind === 'reg-index16' && source.kind === 'imm';
+}
+function isStackPointerRegisterLd(target, source) {
+    return (target.kind === 'reg16' &&
+        target.register === 'sp' &&
+        (source.kind === 'reg16' || source.kind === 'reg-index16') &&
+        (source.register === 'hl' || source.register === 'ix' || source.register === 'iy'));
+}
+function isRegisterFromAbsoluteMemoryLd(target, source) {
+    return ((target.kind === 'reg8' || target.kind === 'reg16' || target.kind === 'reg-index16') &&
+        source.kind === 'mem-abs' &&
+        (target.kind !== 'reg8' || target.register === 'a'));
+}
+function isAbsoluteMemoryFromRegisterLd(target, source) {
+    return (target.kind === 'mem-abs' &&
+        (source.kind === 'reg16' ||
+            source.kind === 'reg-index16' ||
+            (source.kind === 'reg8' && source.register === 'a')));
+}
+function isAccumulatorFromRegisterIndirectLd(target, source) {
+    return target.kind === 'reg8' && target.register === 'a' && source.kind === 'reg-indirect';
+}
+function isRegisterIndirectFromAccumulatorLd(target, source) {
+    return target.kind === 'reg-indirect' && source.kind === 'reg8' && source.register === 'a';
+}
+function isHlIndirectByteLd(target, source) {
+    return target.kind === 'reg-indirect' && target.register === 'hl' && (source.kind === 'reg8' || source.kind === 'imm');
+}
+function isByteFromHlIndirectLd(target, source) {
+    return target.kind === 'reg8' && source.kind === 'reg-indirect' && source.register === 'hl';
+}
+function isLegacyReg16ByteTransferPair(target, source) {
+    return (target === 'hl' && source === 'de') || (target === 'bc' && source === 'de');
+}
+function isSupportedSpecialRegisterLd(target, source) {
+    return ((target.kind === 'special8' && source.kind === 'reg8' && source.register === 'a') ||
+        (target.kind === 'reg8' && target.register === 'a' && source.kind === 'special8'));
+}
+function isMemoryOperand(operand) {
+    return operand.kind === 'reg-indirect' || operand.kind === 'indexed' || operand.kind === 'mem-abs';
+}
+function isSupportedHalfIndexLd(target, source) {
+    return (hasHalfIndexRegister(target, source) &&
+        isSameIndexHalfFamily(target, source) &&
+        !usesPlainHlCounterpart(target, source) &&
+        isHalfIndexCompatibleByteOperand(target) &&
+        isHalfIndexCompatibleByteOperand(source));
+}
+function unsupportedHalfIndexLdReason(target, source) {
+    if (!hasHalfIndexRegister(target, source)) {
+        return undefined;
+    }
+    if (!isSameIndexHalfFamily(target, source)) {
+        return 'ld between IX* and IY* byte registers is not supported';
+    }
+    return usesPlainHlCounterpart(target, source)
+        ? 'ld with IX*/IY* does not support plain H/L counterpart operands'
+        : undefined;
+}
+function unsupportedRegisterPairLdReason(target, source) {
+    if (isUnsupportedIndexPairLd(target, source)) {
+        return 'ld rr, rr supports SP <- HL/IX/IY only';
+    }
+    if (!isRegisterPairLdReasonCandidate(target, source)) {
+        return undefined;
+    }
+    return isSupportedRegisterPairLd(target, source)
+        ? undefined
+        : 'ld rr, rr supports SP <- HL/IX/IY only';
+}
+function isUnsupportedIndexPairLd(target, source) {
+    return target.kind === 'reg-index16' && source.kind === 'reg-index16' && target.register !== source.register;
+}
+function isRegisterPairLdReasonCandidate(target, source) {
+    return target.kind === 'reg16' && source.kind !== 'imm' && (source.kind === 'reg16' || source.kind === 'reg-index16');
+}
+function isSupportedRegisterPairLd(target, source) {
+    return isStackPointerRegisterLd(target, source) || isLegacyReg16Ld(target, source);
+}
+function hasHalfIndexRegister(target, source) {
+    return target.kind === 'reg-half-index' || source.kind === 'reg-half-index';
+}
+function isSameIndexHalfFamily(target, source) {
+    const targetFamily = indexHalfFamily(target);
+    const sourceFamily = indexHalfFamily(source);
+    return !targetFamily || !sourceFamily || targetFamily === sourceFamily;
+}
+function indexHalfFamily(operand) {
+    return operand.kind === 'reg-half-index' ? (operand.register.startsWith('ix') ? 'ix' : 'iy') : undefined;
+}
+function usesPlainHlCounterpart(target, source) {
+    return ((target.kind === 'reg-half-index' && isPlainHlReg8(source)) ||
+        (source.kind === 'reg-half-index' && isPlainHlReg8(target)));
+}
+function isPlainHlReg8(operand) {
+    return operand.kind === 'reg8' && (operand.register === 'h' || operand.register === 'l');
+}
+function isHalfIndexCompatibleByteOperand(operand) {
+    return (operand.kind === 'reg-half-index' ||
+        (operand.kind === 'reg8' && operand.register !== 'h' && operand.register !== 'l'));
+}

package/dist/src/z80/operand-split-state.d.ts

@@ -0,0 +1,8 @@
+export interface OperandSplitState {
+    depth: number;
+    quote: string | undefined;
+    escaped: boolean;
+    start: number;
+}
+export declare function createOperandSplitState(): OperandSplitState;
+export declare function scanInstructionOperandSeparator(text: string, index: number, state: OperandSplitState): boolean;

package/dist/src/z80/operand-split-state.js

@@ -0,0 +1,46 @@
+export function createOperandSplitState() {
+    return { depth: 0, quote: undefined, escaped: false, start: 0 };
+}
+export function scanInstructionOperandSeparator(text, index, state) {
+    const char = text[index];
+    if (consumeEscapedOperandChar(state))
+        return false;
+    if (beginOperandEscape(char, state))
+        return false;
+    if (toggleOperandQuote(text, index, char, state))
+        return false;
+    if (state.quote)
+        return false;
+    updateOperandParenDepth(char, state);
+    return char === ',' && state.depth === 0;
+}
+function consumeEscapedOperandChar(state) {
+    if (!state.escaped)
+        return false;
+    state.escaped = false;
+    return true;
+}
+function beginOperandEscape(char, state) {
+    if (char !== '\\' || !state.quote)
+        return false;
+    state.escaped = true;
+    return true;
+}
+function toggleOperandQuote(text, index, char, state) {
+    if (!isOperandQuoteStart(text, index, char, state.quote))
+        return false;
+    state.quote = state.quote === char ? undefined : (state.quote ?? char);
+    return true;
+}
+function isOperandQuoteStart(text, index, char, quote) {
+    return ((char === '"' || char === "'") &&
+        !(char === "'" && quote === undefined && /[A-Za-z0-9_]/.test(text[index - 1] ?? '')));
+}
+function updateOperandParenDepth(char, state) {
+    if (char === '(') {
+        state.depth += 1;
+    }
+    else if (char === ')') {
+        state.depth -= 1;
+    }
+}

package/dist/src/z80/operand-split.d.ts

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

package/dist/src/z80/operand-split.js

@@ -0,0 +1,13 @@
+import { createOperandSplitState, scanInstructionOperandSeparator } from './operand-split-state.js';
+export function splitInstructionOperands(text) {
+    const values = [];
+    const state = createOperandSplitState();
+    for (let index = 0; index < text.length; index += 1) {
+        if (scanInstructionOperandSeparator(text, index, state)) {
+            values.push(text.slice(state.start, index));
+            state.start = index + 1;
+        }
+    }
+    values.push(text.slice(state.start));
+    return values.map((value) => value.trim());
+}

package/dist/src/z80/parse-basic.d.ts

@@ -0,0 +1,4 @@
+import type { ParseZ80InstructionResult } from './parse-instruction.js';
+export declare function parseNopInstruction(text: string): ParseZ80InstructionResult | undefined;
+export declare function parseRetInstruction(text: string): ParseZ80InstructionResult | undefined;
+export declare function parseNoOperandCoreInstruction(text: string): ParseZ80InstructionResult | undefined;

package/dist/src/z80/parse-basic.js

@@ -0,0 +1,39 @@
+import { splitInstructionOperands } from './operand-split.js';
+import { parseCondition } from './parse-conditions.js';
+export function parseNopInstruction(text) {
+    const nop = /^NOP(?:\s+(.*))?$/i.exec(text);
+    if (nop) {
+        return nop[1] === undefined
+            ? { instruction: { mnemonic: 'nop' } }
+            : { error: 'nop expects no operands' };
+    }
+    return undefined;
+}
+export function parseRetInstruction(text) {
+    const ret = /^RET(?:\s+(.*))?$/i.exec(text);
+    if (ret) {
+        const operandText = ret[1] ?? '';
+        if (operandText.trim().length === 0) {
+            return { instruction: { mnemonic: 'ret' } };
+        }
+        const parts = splitInstructionOperands(operandText);
+        if (parts.length !== 1) {
+            return { error: 'ret expects no operands or one condition code' };
+        }
+        const condition = parseCondition(parts[0] ?? '');
+        return condition
+            ? { instruction: { mnemonic: 'ret-cc', condition } }
+            : { error: 'ret cc expects a valid condition code' };
+    }
+    return undefined;
+}
+export function parseNoOperandCoreInstruction(text) {
+    const noOperandCore = /^(DI|EI|SCF|CCF|CPL|DAA|EXX|HALT|RLCA|RRCA|RLA|RRA|NEG|RRD|RLD|LDI|LDIR|LDD|LDDR|CPI|CPIR|CPD|CPDR|INI|INIR|IND|INDR|OUTI|OTIR|OUTD|OTDR|RETI|RETN)(?:\s+(.*))?$/i.exec(text);
+    if (noOperandCore) {
+        const mnemonic = (noOperandCore[1] ?? '').toLowerCase();
+        return noOperandCore[2] === undefined
+            ? { instruction: { mnemonic } }
+            : { error: `${mnemonic} expects no operands` };
+    }
+    return undefined;
+}

package/dist/src/z80/parse-branch.d.ts

@@ -0,0 +1,4 @@
+import type { ParseZ80InstructionResult } from './parse-instruction.js';
+export declare function parseJumpInstruction(text: string): ParseZ80InstructionResult | undefined;
+export declare function parseCallInstruction(text: string): ParseZ80InstructionResult | undefined;
+export declare function parseRelativeBranchInstruction(text: string): ParseZ80InstructionResult | undefined;

package/dist/src/z80/parse-branch.js

@@ -0,0 +1,218 @@
+import { parseExpression } from '../syntax/parse-expression.js';
+import { splitInstructionOperands } from './operand-split.js';
+import { parseCondition, parseRelativeCondition } from './parse-conditions.js';
+export function parseJumpInstruction(text) {
+    const jump = /^JP(?:\s+(.*))?$/i.exec(text);
+    if (jump) {
+        const operandText = jump[1] ?? '';
+        const parts = splitInstructionOperands(operandText);
+        if (operandText.trim().length === 0) {
+            return {
+                error: 'jp expects one operand (nn/(hl)/(ix)/(iy)) or two operands (cc, nn)',
+            };
+        }
+        if (parts.length === 2)
+            return parseConditionalJump(parts[0] ?? '', parts[1] ?? '');
+        if (parts.length !== 1) {
+            return {
+                error: 'jp expects one operand (nn/(hl)/(ix)/(iy)) or two operands (cc, nn)',
+            };
+        }
+        return parseSingleJump(parts[0] ?? '');
+    }
+    return undefined;
+}
+function parseConditionalJump(conditionText, targetText) {
+    const condition = parseCondition(conditionText);
+    if (!condition) {
+        return { error: 'jp cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M' };
+    }
+    if (/^\(.*\)$/.test(targetText.trim())) {
+        return { error: 'jp cc, nn does not support indirect targets' };
+    }
+    const expression = parseAbsoluteBranchTarget(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'jp-cc', condition, expression } }
+        : { error: 'jp cc, nn expects imm16' };
+}
+function parseSingleJump(targetText) {
+    const condition = parseCondition(targetText);
+    if (condition) {
+        return { error: 'jp cc, nn expects two operands (cc, nn)' };
+    }
+    const indirect = parseJumpIndirect(targetText);
+    if (indirect) {
+        return { instruction: { mnemonic: 'jp-indirect', register: indirect } };
+    }
+    const targetError = singleJumpTargetError(targetText);
+    if (targetError) {
+        return { error: targetError };
+    }
+    const expression = parseExpression(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'jp', expression } }
+        : { error: `invalid JP target: ${targetText}` };
+}
+function singleJumpTargetError(targetText) {
+    const trimmed = targetText.trim();
+    if (/^\(.*\)$/.test(trimmed)) {
+        return 'jp indirect form supports (hl), (ix), or (iy) only';
+    }
+    if (/^(HL|IX|IY)$/i.test(trimmed)) {
+        return 'jp indirect form requires parentheses; use (hl), (ix), or (iy)';
+    }
+    return isRegisterName(targetText) ? 'jp does not support register targets; use imm16' : undefined;
+}
+export function parseCallInstruction(text) {
+    const call = /^CALL(?:\s+(.*))?$/i.exec(text);
+    if (call) {
+        const operandText = call[1] ?? '';
+        const parts = splitInstructionOperands(operandText);
+        if (operandText.trim().length === 0) {
+            return { error: 'call expects one operand (nn) or two operands (cc, nn)' };
+        }
+        if (parts.length === 2)
+            return parseConditionalCall(parts[0] ?? '', parts[1] ?? '');
+        if (parts.length !== 1) {
+            return { error: 'call expects one operand (nn) or two operands (cc, nn)' };
+        }
+        return parseSingleCall(parts[0] ?? '');
+    }
+    return undefined;
+}
+function parseConditionalCall(conditionText, targetText) {
+    const condition = parseCondition(conditionText);
+    if (!condition) {
+        return { error: 'call cc expects valid condition code NZ/Z/NC/C/PO/PE/P/M' };
+    }
+    if (/^\(.*\)$/.test(targetText.trim())) {
+        return { error: 'call cc, nn does not support indirect targets' };
+    }
+    const expression = parseAbsoluteBranchTarget(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'call-cc', condition, expression } }
+        : { error: 'call cc, nn expects imm16' };
+}
+function parseSingleCall(targetText) {
+    const condition = parseCondition(targetText);
+    if (condition) {
+        return { error: 'call cc, nn expects two operands (cc, nn)' };
+    }
+    if (/^\(.*\)$/.test(targetText.trim())) {
+        return { error: 'call does not support indirect targets; use imm16' };
+    }
+    if (isRegisterName(targetText)) {
+        return { error: 'call does not support register targets; use imm16' };
+    }
+    const expression = parseExpression(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'call', expression } }
+        : { error: `invalid CALL target: ${targetText}` };
+}
+export function parseRelativeBranchInstruction(text) {
+    const relativeBranch = /^(JR|DJNZ)(?:\s+(.*))?$/i.exec(text);
+    if (relativeBranch) {
+        const mnemonic = (relativeBranch[1] ?? '').toLowerCase();
+        return parseRelativeBranchOperands(mnemonic, relativeBranch[2] ?? '');
+    }
+    return undefined;
+}
+function parseRelativeBranchOperands(mnemonic, operandText) {
+    const trimmed = operandText.trim();
+    if (trimmed.length === 0)
+        return { error: relativeBranchArityError(mnemonic) };
+    const parts = splitInstructionOperands(trimmed);
+    return mnemonic === 'djnz' ? parseDjnzBranch(parts) : parseJrBranch(parts);
+}
+function parseJrBranch(parts) {
+    if (parts.length === 1) {
+        return parseUnconditionalRelativeJump(parts[0] ?? '');
+    }
+    if (parts.length === 2) {
+        return parseConditionalRelativeJump(parts[0] ?? '', parts[1] ?? '');
+    }
+    return { error: 'jr expects one operand (disp8) or two operands (cc, disp8)' };
+}
+function relativeBranchArityError(mnemonic) {
+    return mnemonic === 'djnz'
+        ? 'djnz expects one operand (disp8)'
+        : 'jr expects one operand (disp8) or two operands (cc, disp8)';
+}
+function parseDjnzBranch(parts) {
+    if (parts.length !== 1) {
+        return { error: 'djnz expects one operand (disp8)' };
+    }
+    const targetText = parts[0] ?? '';
+    const targetError = relativeDispTargetError(targetText, {
+        indirect: 'djnz does not support indirect targets; expects disp8',
+        register: 'djnz does not support register targets; expects disp8',
+    });
+    if (targetError) {
+        return { error: targetError };
+    }
+    const expression = parseExpression(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'djnz', expression } }
+        : { error: 'djnz expects disp8' };
+}
+function parseUnconditionalRelativeJump(targetText) {
+    const targetError = relativeDispTargetError(targetText, {
+        indirect: 'jr does not support indirect targets; expects disp8',
+        register: 'jr does not support register targets; expects disp8',
+    });
+    if (targetError) {
+        return { error: targetError };
+    }
+    if (parseRelativeCondition(targetText)) {
+        return { error: 'jr cc, disp expects two operands (cc, disp8)' };
+    }
+    const expression = parseExpression(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'jr', expression } }
+        : { error: 'jr expects disp8' };
+}
+function parseConditionalRelativeJump(conditionText, targetText) {
+    const condition = parseRelativeCondition(conditionText);
+    if (!condition) {
+        return { error: 'jr cc expects valid condition code NZ/Z/NC/C' };
+    }
+    const targetError = relativeDispTargetError(targetText, {
+        indirect: 'jr cc, disp does not support indirect targets',
+        register: 'jr cc, disp does not support register targets; expects disp8',
+    });
+    if (targetError) {
+        return { error: targetError };
+    }
+    const expression = parseExpression(targetText);
+    return expression
+        ? { instruction: { mnemonic: 'jr-cc', condition, expression } }
+        : { error: 'jr cc, disp expects disp8' };
+}
+function parseAbsoluteBranchTarget(text) {
+    const trimmed = text.trim();
+    if (/^\(.*\)$/.test(trimmed) || isRegisterName(trimmed)) {
+        return undefined;
+    }
+    return parseExpression(trimmed);
+}
+function parseJumpIndirect(text) {
+    const indirect = /^\((HL|IX|IY)\)$/i.exec(text.trim());
+    return indirect ? (indirect[1] ?? '').toLowerCase() : undefined;
+}
+function isRegisterName(text) {
+    return /^(A|B|C|D|E|H|L|I|R|AF|BC|DE|HL|SP|IX|IY|IXH|IXL|IYH|IYL)$/i.test(text.trim());
+}
+function relativeDispTargetError(text, messages) {
+    const trimmed = text.trim();
+    if (/^\(.*\)$/.test(trimmed)) {
+        return messages.indirect;
+    }
+    if (isRegisterName(trimmed)) {
+        return messages.register;
+    }
+    const expression = parseExpression(trimmed);
+    if (expression?.kind === 'symbol' && isRegisterName(expression.name)) {
+        return messages.register;
+    }
+    return undefined;
+}

package/dist/src/z80/parse-conditions.d.ts

@@ -0,0 +1,6 @@
+import type { Z80Instruction, Z80RelativeCondition } from './instruction.js';
+export type Z80InstructionCondition = Extract<Z80Instruction, {
+    readonly condition: unknown;
+}>['condition'];
+export declare function parseCondition(text: string): Z80InstructionCondition | undefined;
+export declare function parseRelativeCondition(text: string): Z80RelativeCondition | undefined;

package/dist/src/z80/parse-conditions.js

@@ -0,0 +1,10 @@
+export function parseCondition(text) {
+    const trimmed = text.trim();
+    return /^(NZ|Z|NC|C|PO|PE|P|M)$/i.test(trimmed)
+        ? trimmed.toLowerCase()
+        : undefined;
+}
+export function parseRelativeCondition(text) {
+    const trimmed = text.trim().toLowerCase();
+    return /^(nz|z|nc|c)$/.test(trimmed) ? trimmed : undefined;
+}

package/dist/src/z80/parse-exchange.d.ts

@@ -0,0 +1,2 @@
+import type { ParseZ80InstructionResult } from './parse-instruction.js';
+export declare function parseExchangeInstruction(text: string): ParseZ80InstructionResult | undefined;

package/dist/src/z80/parse-exchange.js

@@ -0,0 +1,30 @@
+import { splitInstructionOperands } from './operand-split.js';
+const EXCHANGE_FORMS = {
+    "af|af'": 'af-af',
+    "af'|af": 'af-af',
+    'de|hl': 'de-hl',
+    '(sp)|hl': 'sp-hl',
+    '(sp)|ix': 'sp-ix',
+    'ix|(sp)': 'sp-ix',
+    '(sp)|iy': 'sp-iy',
+    'iy|(sp)': 'sp-iy',
+};
+export function parseExchangeInstruction(text) {
+    const exchange = /^EX\s+(.+)$/i.exec(text);
+    if (!exchange)
+        return undefined;
+    const operandText = exchange[1] ?? '';
+    const parts = splitInstructionOperands(operandText);
+    if (parts.length !== 2) {
+        return { error: 'ex expects two operands' };
+    }
+    const left = (parts[0] ?? '').toLowerCase();
+    const right = (parts[1] ?? '').toLowerCase();
+    const form = EXCHANGE_FORMS[`${left}|${right}`];
+    if (form) {
+        return { instruction: { mnemonic: 'ex', form } };
+    }
+    return {
+        error: `ex supports "AF, AF'", "DE, HL", "(SP), HL", "(SP), IX", and "(SP), IY" only`,
+    };
+}