@jhlagado/azm 0.2.7 → 0.2.8

package/dist/src/outputs/asm80-instructions.js

@@ -0,0 +1,272 @@
+import { formatExpression, formatLoweredNumber, } from './asm80-expressions.js';
+import { formatBitOp, formatIndexedMemory, formatLd, formatRotateShift, } from './asm80-instruction-operands.js';
+const ZERO_OPERAND_MNEMONICS = new Set([
+    'nop',
+    'ret',
+    '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',
+]);
+const BIT_MNEMONICS = new Set(['bit', 'res', 'set']);
+const ROTATE_SHIFT_MNEMONICS = new Set([
+    'rlc',
+    'rrc',
+    'rl',
+    'rr',
+    'sla',
+    'sra',
+    'sll',
+    'sls',
+    'srl',
+]);
+const TARGETED_ALU_MNEMONICS = new Set(['add', 'adc', 'sbc']);
+const ACCUMULATOR_ALU_MNEMONICS = new Set([
+    'add',
+    'adc',
+    'sbc',
+    'sub',
+    'and',
+    'or',
+    'xor',
+    'cp',
+]);
+export function formatInstruction(instruction, evalContext) {
+    if (ZERO_OPERAND_MNEMONICS.has(instruction.mnemonic)) {
+        return { text: instruction.mnemonic };
+    }
+    return (formatLoadOrImmediateInstruction(instruction, evalContext) ??
+        formatAluInstruction(instruction, evalContext) ??
+        formatBitRotateInstruction(instruction, evalContext) ??
+        formatIoInstruction(instruction, evalContext) ??
+        formatSingleOperandInstruction(instruction, evalContext) ??
+        formatBranchStackReturnInstruction(instruction, evalContext));
+}
+function formatLoadOrImmediateInstruction(instruction, evalContext) {
+    switch (instruction.mnemonic) {
+        case 'ld-a-imm': {
+            const expression = formatExpression(instruction.expression, evalContext, 'byte');
+            if (expression === undefined) {
+                return undefined;
+            }
+            return {
+                text: `ld a, ${expression}`,
+            };
+        }
+        case 'ld':
+            return formatLd(instruction.target, instruction.source, evalContext);
+        case 'im':
+            return { text: `im ${formatLoweredNumber(instruction.mode, 'byte')}` };
+        case 'rst':
+            return { text: `rst ${formatLoweredNumber(instruction.vector, 'byte')}` };
+        default:
+            return undefined;
+    }
+}
+function formatAluInstruction(instruction, evalContext) {
+    if (isTargetedAluInstruction(instruction)) {
+        return formatReg16Alu(instruction.mnemonic, instruction.target, instruction.source);
+    }
+    if (isAccumulatorAluInstruction(instruction)) {
+        return formatAlu(instruction.mnemonic, instruction.source, evalContext);
+    }
+    return undefined;
+}
+function isTargetedAluInstruction(instruction) {
+    return TARGETED_ALU_MNEMONICS.has(instruction.mnemonic) && 'target' in instruction;
+}
+function isAccumulatorAluInstruction(instruction) {
+    return ACCUMULATOR_ALU_MNEMONICS.has(instruction.mnemonic) && 'source' in instruction;
+}
+function formatBitRotateInstruction(instruction, evalContext) {
+    if (BIT_MNEMONICS.has(instruction.mnemonic)) {
+        return formatBitOp(instruction, evalContext);
+    }
+    if (ROTATE_SHIFT_MNEMONICS.has(instruction.mnemonic)) {
+        return formatRotateShift(instruction, evalContext);
+    }
+    return undefined;
+}
+function formatIoInstruction(instruction, evalContext) {
+    switch (instruction.mnemonic) {
+        case 'in':
+            return formatIn(instruction, evalContext);
+        case 'out':
+            return formatOut(instruction, evalContext);
+        default:
+            return undefined;
+    }
+}
+function formatSingleOperandInstruction(instruction, evalContext) {
+    switch (instruction.mnemonic) {
+        case 'inc':
+        case 'dec':
+            return formatIncDec(instruction, evalContext);
+        case 'ex':
+            return formatEx(instruction.form);
+        default:
+            return undefined;
+    }
+}
+function formatBranchStackReturnInstruction(instruction, evalContext) {
+    return (formatBranchInstruction(instruction, evalContext) ??
+        formatStackOrReturnInstruction(instruction));
+}
+function formatBranchInstruction(instruction, evalContext) {
+    switch (instruction.mnemonic) {
+        case 'jp':
+            return formatBranch('jp', instruction.expression, evalContext);
+        case 'jp-cc':
+            return formatBranch(`jp ${instruction.condition},`, instruction.expression, evalContext);
+        case 'jp-indirect':
+            return { text: `jp (${instruction.register})` };
+        case 'jr':
+            return formatBranch('jr', instruction.expression, evalContext);
+        case 'jr-cc':
+            return formatBranch(`jr ${instruction.condition},`, instruction.expression, evalContext);
+        case 'call':
+            return formatBranch('call', instruction.expression, evalContext);
+        case 'call-cc':
+            return formatBranch(`call ${instruction.condition},`, instruction.expression, evalContext);
+        case 'djnz':
+            return formatBranch('djnz', instruction.expression, evalContext);
+        default:
+            return undefined;
+    }
+}
+function formatStackOrReturnInstruction(instruction) {
+    switch (instruction.mnemonic) {
+        case 'push':
+        case 'pop':
+            return { text: `${instruction.mnemonic} ${instruction.register}` };
+        case 'ret-cc':
+            return { text: `ret ${instruction.condition}` };
+        default:
+            return undefined;
+    }
+}
+function formatAlu(mnemonic, source, evalContext) {
+    const operand = formatAluOperand(source, evalContext);
+    if (operand === undefined) {
+        return undefined;
+    }
+    if (mnemonic === 'add' || mnemonic === 'adc' || mnemonic === 'sbc') {
+        return { text: `${mnemonic} a, ${operand}` };
+    }
+    if (mnemonic === 'xor' && source.kind === 'reg8' && source.register === 'a') {
+        return { text: 'xor a' };
+    }
+    return { text: `${mnemonic} ${operand}` };
+}
+function formatAluOperand(source, evalContext) {
+    if (source.kind === 'reg8' || source.kind === 'reg-half-index') {
+        return source.register;
+    }
+    if (source.kind === 'reg-indirect' && source.register === 'hl') {
+        return '(HL)';
+    }
+    if (source.kind === 'imm') {
+        return formatExpression(source.expression, evalContext, 'byte');
+    }
+    return undefined;
+}
+function formatReg16Alu(mnemonic, target, source) {
+    const targetText = formatReg16PairOperand(target);
+    const sourceText = formatReg16PairOperand(source);
+    return targetText === undefined || sourceText === undefined
+        ? undefined
+        : { text: `${mnemonic} ${targetText}, ${sourceText}` };
+}
+function formatReg16PairOperand(operand) {
+    if (operand.kind === 'reg16') {
+        return operand.register;
+    }
+    if (operand.kind === 'reg-index16') {
+        return operand.register;
+    }
+    return undefined;
+}
+function formatEx(form) {
+    switch (form) {
+        case 'af-af':
+            return { text: "ex af, af'" };
+        case 'de-hl':
+            return { text: 'ex de, hl' };
+        case 'sp-hl':
+            return { text: 'ex (sp), hl' };
+        case 'sp-ix':
+            return { text: 'ex (SP), ix' };
+        case 'sp-iy':
+            return { text: 'ex (SP), iy' };
+    }
+}
+function formatBranch(mnemonic, expression, evalContext) {
+    const target = formatExpression(expression, evalContext, 'word');
+    return target === undefined ? undefined : { text: `${mnemonic} ${target}` };
+}
+function formatIn(instruction, evalContext) {
+    const port = formatPort(instruction.port, evalContext);
+    if (port === undefined) {
+        return undefined;
+    }
+    const target = instruction.target?.register ?? 'a';
+    return { text: `in ${target}, ${port}` };
+}
+function formatOut(instruction, evalContext) {
+    const port = formatPort(instruction.port, evalContext);
+    if (port === undefined) {
+        return undefined;
+    }
+    const source = instruction.source.kind === 'zero' ? '0' : instruction.source.register;
+    return { text: `out ${port}, ${source}` };
+}
+function formatPort(port, evalContext) {
+    if (port.kind === 'c') {
+        return '(c)';
+    }
+    const expression = formatExpression(port.expression, evalContext, 'byte');
+    return expression === undefined ? undefined : `(${expression})`;
+}
+function formatIncDec(instruction, evalContext) {
+    const operand = instruction.operand;
+    if (operand.kind === 'reg8' || operand.kind === 'reg16') {
+        return { text: `${instruction.mnemonic} ${operand.register}` };
+    }
+    if (operand.kind === 'reg-indirect' && operand.register === 'hl') {
+        return { text: `${instruction.mnemonic} (HL)` };
+    }
+    if (operand.kind === 'indexed') {
+        const memory = formatIndexedMemory(operand.register, operand.displacement, evalContext);
+        return memory === undefined ? undefined : { text: `${instruction.mnemonic} ${memory}` };
+    }
+    return undefined;
+}

package/dist/src/outputs/asm80-ld-operands.d.ts

@@ -0,0 +1,10 @@
+import type { Expression } from '../model/expression.js';
+import type { Z80IndexRegister16, Z80Instruction } from '../z80/instruction.js';
+import { type LoweredEvalContext } from './asm80-expressions.js';
+export type LdOperand = Extract<Z80Instruction, {
+    readonly mnemonic: 'ld';
+}>['target'];
+export declare function formatLd(target: LdOperand, source: LdOperand, evalContext: LoweredEvalContext): {
+    readonly text: string;
+} | undefined;
+export declare function formatIndexedMemory(register: Z80IndexRegister16, displacement: Expression, evalContext: LoweredEvalContext): string | undefined;

package/dist/src/outputs/asm80-ld-operands.js

@@ -0,0 +1,157 @@
+import { evaluateLoweredConstant, formatExpression, formatLoweredNumber, } from './asm80-expressions.js';
+export function formatLd(target, source, evalContext) {
+    return (formatLdRegisterForm(target, source) ??
+        formatLdImmediateOrAbsoluteLoad(target, source, evalContext) ??
+        formatLdIndirectForm(target, source, evalContext) ??
+        formatLdAbsoluteStore(target, source, evalContext));
+}
+export function formatIndexedMemory(register, displacement, evalContext) {
+    const value = evaluateLoweredConstant(displacement, evalContext);
+    if (value === undefined) {
+        return undefined;
+    }
+    const magnitude = formatLoweredNumber(Math.abs(value), 'byte');
+    if (value === 0) {
+        return `(${register}+$00)`;
+    }
+    if (value > 0) {
+        return `(${register}+${magnitude})`;
+    }
+    return `(${register}-${magnitude})`;
+}
+function formatLdRegisterForm(target, source) {
+    return (formatLdReg8FromReg8(target, source) ??
+        formatLdReg8FromHalfIndex(target, source) ??
+        formatLdAFromSpecial8(target, source) ??
+        formatLdSpecial8FromA(target, source));
+}
+function formatLdReg8FromReg8(target, source) {
+    if (target.kind === 'reg8' && source.kind === 'reg8') {
+        return { text: `ld ${target.register}, ${source.register}` };
+    }
+    return undefined;
+}
+function formatLdReg8FromHalfIndex(target, source) {
+    if (target.kind === 'reg8' && source.kind === 'reg-half-index') {
+        return { text: `ld ${target.register}, ${source.register}` };
+    }
+    return undefined;
+}
+function formatLdAFromSpecial8(target, source) {
+    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'special8') {
+        return { text: `ld a, ${source.register}` };
+    }
+    return undefined;
+}
+function formatLdSpecial8FromA(target, source) {
+    if (target.kind === 'special8' && source.kind === 'reg8' && source.register === 'a') {
+        return { text: `ld ${target.register}, a` };
+    }
+    return undefined;
+}
+function formatLdImmediateOrAbsoluteLoad(target, source, evalContext) {
+    return (formatLdReg8Immediate(target, source, evalContext) ??
+        formatLdReg16Immediate(target, source, evalContext) ??
+        formatLdIndex16Immediate(target, source, evalContext) ??
+        formatLdReg16AbsoluteLoad(target, source, evalContext) ??
+        formatLdReg8AbsoluteLoad(target, source, evalContext));
+}
+function formatLdReg8Immediate(target, source, evalContext) {
+    if (target.kind === 'reg8' && source.kind === 'imm') {
+        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'byte'));
+    }
+    return undefined;
+}
+function formatLdReg16Immediate(target, source, evalContext) {
+    if (target.kind === 'reg16' && source.kind === 'imm') {
+        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'word'));
+    }
+    return undefined;
+}
+function formatLdIndex16Immediate(target, source, evalContext) {
+    if (target.kind === 'reg-index16' && source.kind === 'imm') {
+        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'word'));
+    }
+    return undefined;
+}
+function formatLdReg16AbsoluteLoad(target, source, evalContext) {
+    if (target.kind === 'reg16' && source.kind === 'mem-abs') {
+        return formatLdText(target.register, formatParenthesizedExpression(source.expression, evalContext, 'auto'));
+    }
+    return undefined;
+}
+function formatLdReg8AbsoluteLoad(target, source, evalContext) {
+    if (target.kind === 'reg8' && source.kind === 'mem-abs') {
+        return formatLdText(target.register, formatParenthesizedExpression(source.expression, evalContext, 'auto'));
+    }
+    return undefined;
+}
+function formatLdIndirectForm(target, source, evalContext) {
+    return (formatLdRegisterIndirect(target, source, evalContext) ??
+        formatLdIndexed(target, source, evalContext));
+}
+function formatLdRegisterIndirect(target, source, evalContext) {
+    return (formatLdAFromRegisterIndirect(target, source) ??
+        formatLdAStoreToBcDeIndirect(target, source) ??
+        formatLdFromHlIndirect(target, source) ??
+        formatLdToHlIndirect(target, source, evalContext));
+}
+function formatLdAFromRegisterIndirect(target, source) {
+    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'reg-indirect') {
+        return { text: `ld a, (${source.register})` };
+    }
+    return undefined;
+}
+function formatLdAStoreToBcDeIndirect(target, source) {
+    if (target.kind === 'reg-indirect' && isBcDeIndirectAStore(target.register, source)) {
+        return { text: `ld (${target.register}), a` };
+    }
+    return undefined;
+}
+function formatLdFromHlIndirect(target, source) {
+    if (target.kind === 'reg8' && source.kind === 'reg-indirect' && source.register === 'hl') {
+        return { text: `ld ${target.register}, (hl)` };
+    }
+    return undefined;
+}
+function formatLdToHlIndirect(target, source, evalContext) {
+    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'reg8') {
+        return { text: `ld (hl), ${source.register}` };
+    }
+    if (target.kind === 'reg-indirect' && target.register === 'hl' && source.kind === 'imm') {
+        const value = formatExpression(source.expression, evalContext, 'byte');
+        return value === undefined ? undefined : { text: `ld (hl), ${value}` };
+    }
+    return undefined;
+}
+function formatLdIndexed(target, source, evalContext) {
+    if (target.kind === 'reg8' && source.kind === 'indexed') {
+        const memory = formatIndexedMemory(source.register, source.displacement, evalContext);
+        return memory === undefined ? undefined : { text: `ld ${target.register}, ${memory}` };
+    }
+    if (target.kind === 'indexed' && source.kind === 'reg8') {
+        const memory = formatIndexedMemory(target.register, target.displacement, evalContext);
+        return memory === undefined ? undefined : { text: `ld ${memory}, ${source.register}` };
+    }
+    return undefined;
+}
+function isBcDeIndirectAStore(register, source) {
+    return (register === 'bc' || register === 'de') && source.kind === 'reg8' && source.register === 'a';
+}
+function formatLdAbsoluteStore(target, source, evalContext) {
+    if (target.kind !== 'mem-abs') {
+        return undefined;
+    }
+    if (source.kind !== 'reg8' && source.kind !== 'reg16' && source.kind !== 'reg-index16') {
+        return undefined;
+    }
+    const targetText = formatParenthesizedExpression(target.expression, evalContext, 'auto');
+    return targetText === undefined ? undefined : { text: `ld ${targetText}, ${source.register}` };
+}
+function formatLdText(target, source) {
+    return source === undefined ? undefined : { text: `ld ${target}, ${source}` };
+}
+function formatParenthesizedExpression(expression, evalContext, width) {
+    const formatted = formatExpression(expression, evalContext, width);
+    return formatted === undefined ? undefined : `(${formatted})`;
+}

package/dist/src/outputs/asm80-strings.d.ts

@@ -0,0 +1,4 @@
+import type { SourceItem } from '../model/source-item.js';
+export declare function stringDirectiveBytes(directive: Extract<SourceItem, {
+    readonly kind: 'string-data';
+}>['directive'], value: string): number[];

package/dist/src/outputs/asm80-strings.js

@@ -0,0 +1,14 @@
+export function stringDirectiveBytes(directive, value) {
+    const bytes = [...value].map((char) => char.codePointAt(0) ?? 0);
+    switch (directive) {
+        case 'cstr':
+            return [...bytes, 0];
+        case 'pstr':
+            return [bytes.length & 0xff, ...bytes];
+        case 'istr':
+            if (bytes.length === 0) {
+                return [];
+            }
+            return bytes.map((byte, index) => (index === bytes.length - 1 ? byte | 0x80 : byte));
+    }
+}

package/dist/src/outputs/d8-files.d.ts

@@ -0,0 +1,10 @@
+import type { D8mFileEntry, D8mSymbol, EmittedSourceSegment } from './types.js';
+type AddressRange = {
+    start: number;
+    end: number;
+};
+export declare function buildD8mFiles(symbols: readonly D8mSymbol[], sourceSegments: readonly EmittedSourceSegment[], segments: readonly AddressRange[], fileList: readonly string[]): {
+    files: Record<string, D8mFileEntry>;
+    sortedSymbols: D8mSymbol[];
+};
+export {};

package/dist/src/outputs/d8-files.js

@@ -0,0 +1,103 @@
+import { compareFileSymbol, compareSegment, compareSymbol, rangesOverlap, } from './d8-helpers.js';
+function hasOverlappingSourceSegment(sourceSegmentsByFile, file, range) {
+    return (sourceSegmentsByFile.get(file) ?? []).some((segment) => rangesOverlap({ start: segment.start, end: segment.end }, range));
+}
+function sourceSegmentsByFile(sourceSegments) {
+    const byFile = new Map();
+    for (const segment of sourceSegments) {
+        const segments = byFile.get(segment.file);
+        if (segments) {
+            segments.push(segment);
+        }
+        else {
+            byFile.set(segment.file, [segment]);
+        }
+    }
+    return byFile;
+}
+function symbolRangesByFile(symbols) {
+    const byFile = new Map();
+    for (const symbol of symbols) {
+        if (symbol.kind === 'constant' || symbol.file === undefined)
+            continue;
+        if (symbol.address === undefined)
+            continue;
+        const size = symbol.size !== undefined && symbol.size > 0 ? symbol.size : 1;
+        const ranges = byFile.get(symbol.file) ?? [];
+        ranges.push({ start: symbol.address, end: Math.min(0x10000, symbol.address + size) });
+        byFile.set(symbol.file, ranges);
+    }
+    return byFile;
+}
+function ensureEntry(entries, file) {
+    let entry = entries.get(file);
+    if (!entry) {
+        entry = { symbols: [], segments: [] };
+        entries.set(file, entry);
+    }
+    return entry;
+}
+function addFileSymbols(entries, symbols) {
+    const sortedSymbols = [...symbols].sort(compareSymbol);
+    for (const symbol of sortedSymbols) {
+        const entry = ensureEntry(entries, symbol.file ?? '');
+        const symbolWithoutFile = { ...symbol };
+        delete symbolWithoutFile.file;
+        entry.symbols.push(symbolWithoutFile);
+    }
+    return sortedSymbols;
+}
+function addSourceSegments(entries, sourceSegments) {
+    for (const segment of sourceSegments) {
+        ensureEntry(entries, segment.file).segments.push({
+            start: segment.start,
+            end: segment.end,
+            line: segment.line,
+            lstLine: segment.line,
+            kind: segment.kind,
+            confidence: segment.confidence,
+        });
+    }
+}
+function addFallbackSegments(entries, segments, symbols, sourceSegments, fileList) {
+    const sourceByFile = sourceSegmentsByFile(sourceSegments);
+    const rangesByFile = symbolRangesByFile(symbols);
+    for (const segment of segments) {
+        const targetFiles = [...rangesByFile.entries()]
+            .filter(([, ranges]) => ranges.some((range) => rangesOverlap(range, segment)))
+            .map(([file]) => file)
+            .sort((a, b) => a.localeCompare(b));
+        const targets = targetFiles.length > 0 ? targetFiles : [fileList[0] ?? ''];
+        for (const target of targets) {
+            if (hasOverlappingSourceSegment(sourceByFile, target, segment))
+                continue;
+            ensureEntry(entries, target).segments.push({
+                start: segment.start,
+                end: segment.end,
+                lstLine: 1,
+                kind: 'unknown',
+                confidence: 'low',
+            });
+        }
+    }
+}
+export function buildD8mFiles(symbols, sourceSegments, segments, fileList) {
+    const entries = new Map();
+    const sortedSymbols = addFileSymbols(entries, symbols);
+    addSourceSegments(entries, sourceSegments);
+    addFallbackSegments(entries, segments, sortedSymbols, sourceSegments, fileList);
+    for (const entry of entries.values()) {
+        entry.symbols.sort(compareFileSymbol);
+        entry.segments.sort(compareSegment);
+    }
+    const files = Object.fromEntries([...entries.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, fileEntry]) => [
+        path,
+        {
+            ...(fileEntry.segments.length > 0 ? { segments: fileEntry.segments } : {}),
+            ...(fileEntry.symbols.length > 0 ? { symbols: fileEntry.symbols } : {}),
+        },
+    ]));
+    return { files, sortedSymbols };
+}

package/dist/src/outputs/d8-helpers.d.ts

@@ -0,0 +1,21 @@
+import type { D8mFileSymbol, D8mSegment, D8mSymbol, EmittedSourceSegment, SymbolEntry, WriteD8mOptions } from './types.js';
+export declare function toD8mSymbol(symbol: SymbolEntry, rootDir?: string): D8mSymbol;
+export declare function compareSymbol(a: D8mSymbol, b: D8mSymbol): number;
+export declare function compareFileSymbol(a: D8mFileSymbol, b: D8mFileSymbol): number;
+export declare function compareSegment(a: D8mSegment, b: D8mSegment): number;
+export declare function rangesOverlap(a: {
+    start: number;
+    end: number;
+}, b: {
+    start: number;
+    end: number;
+}): boolean;
+export declare function normalizeInputs(inputs: NonNullable<WriteD8mOptions['inputs']>, rootDir?: string): {
+    entry?: string;
+    hex?: string;
+    bin?: string;
+} | undefined;
+export declare function normalizeSourceSegments(sourceSegments: readonly EmittedSourceSegment[], writtenSegments: readonly {
+    readonly start: number;
+    readonly end: number;
+}[], rootDir?: string): EmittedSourceSegment[];