@jhlagado/azm 0.1.1 → 0.2.0

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

@@ -0,0 +1,549 @@
+import { evaluateExpression, } from '../semantics/expression-evaluation.js';
+import { instructionSize } from '../assembly/fixup-emission.js';
+const asm80Header = '; AZM lowered ASM80 output';
+const silentSpan = { sourceName: '', line: 0, column: 0 };
+export class UnsupportedAsm80LoweringError extends Error {
+    item;
+    constructor(message, item) {
+        super(message);
+        this.item = item;
+        this.name = 'UnsupportedAsm80LoweringError';
+    }
+}
+export function writeAsm80(items, symbols, opts = {}) {
+    void opts;
+    const evalContext = {
+        constants: collectConstants(symbols),
+        layouts: collectLayouts(items),
+    };
+    const lines = [asm80Header, ''];
+    const state = {
+        address: 0,
+        emittedOrg: false,
+        needsImplicitOrg: !items.some((item) => item.kind === 'org'),
+    };
+    for (const item of items) {
+        const line = formatItem(item, evalContext, state);
+        if (line === undefined) {
+            throw new UnsupportedAsm80LoweringError(`lowered .z80 output does not yet support ${describeItem(item)}`, item);
+        }
+        state.address += line.size;
+        if (line.text !== '') {
+            lines.push(line.text);
+        }
+    }
+    return { kind: 'asm80', text: `${lines.join('\n').replace(/\n+$/, '')}\n` };
+}
+function collectConstants(symbols) {
+    const constants = new Map();
+    for (const symbol of symbols) {
+        if (symbol.kind === 'constant') {
+            constants.set(symbol.name, symbol.value);
+        }
+    }
+    return constants;
+}
+function collectLayouts(items) {
+    const layouts = new Map();
+    for (const item of items) {
+        if (item.kind === 'type') {
+            layouts.set(item.name, {
+                kind: item.layoutKind,
+                fields: item.fields,
+                span: item.span,
+            });
+        }
+    }
+    return layouts;
+}
+function formatItem(item, evalContext, state) {
+    switch (item.kind) {
+        case 'org': {
+            const expression = formatExpression(item.expression, evalContext, 'word');
+            const address = evaluateLoweredConstant(item.expression, evalContext);
+            if (expression === undefined || address === undefined) {
+                return undefined;
+            }
+            state.address = address;
+            state.emittedOrg = true;
+            return { text: `ORG ${expression}`, size: 0 };
+        }
+        case 'equ': {
+            const expression = formatExpression(item.expression, evalContext, 'auto');
+            return expression === undefined
+                ? undefined
+                : withImplicitOrg(state, `${item.name} EQU ${expression}`, 0);
+        }
+        case 'label':
+            return withImplicitOrg(state, `${item.name}:`, 0);
+        case 'db':
+            return formatDb(item.values, evalContext, state);
+        case 'dw':
+            return formatDw(item.values, evalContext, state);
+        case 'ds':
+            return formatDs(item.size, item.fill, evalContext, state);
+        case 'align':
+            return formatAlign(item.alignment, evalContext, state);
+        case 'string-data':
+            return formatStringData(item.directive, item.value, state);
+        case 'instruction':
+            return withImplicitOrg(state, formatInstruction(item.instruction, evalContext)?.text, instructionSize(item.instruction));
+        case 'enum':
+        case 'type':
+        case 'end':
+        case 'binfrom':
+        case 'binto':
+            return { text: '', size: 0 };
+        default:
+            return undefined;
+    }
+}
+function formatDb(values, evalContext, state) {
+    const parts = [];
+    let size = 0;
+    for (const value of values) {
+        if (value.kind === 'string-fragment') {
+            for (const char of value.value) {
+                parts.push(formatLoweredNumber(char.codePointAt(0) ?? 0, 'byte'));
+                size += 1;
+            }
+            continue;
+        }
+        const expression = formatExpression(value, evalContext, 'byte');
+        if (expression === undefined) {
+            return undefined;
+        }
+        parts.push(expression);
+        size += 1;
+    }
+    if (parts.length === 0) {
+        return { text: '', size: 0 };
+    }
+    return withImplicitOrg(state, `DB ${parts.join(', ')}`, size);
+}
+function formatDs(sizeExpression, fillExpression, evalContext, state) {
+    const sizeValue = evaluateLoweredConstant(sizeExpression, evalContext);
+    const size = formatExpression(sizeExpression, evalContext, 'auto');
+    if (sizeValue === undefined || size === undefined) {
+        return undefined;
+    }
+    if (fillExpression === undefined) {
+        return withImplicitOrg(state, `DS ${size}`, sizeValue);
+    }
+    const fill = formatExpression(fillExpression, evalContext, 'byte');
+    return fill === undefined ? undefined : withImplicitOrg(state, `DS ${size}, ${fill}`, sizeValue);
+}
+function formatDw(values, evalContext, state) {
+    const parts = [];
+    for (const value of values) {
+        const expression = formatExpression(value, evalContext, 'auto');
+        if (expression === undefined) {
+            return undefined;
+        }
+        parts.push(expression);
+    }
+    return withImplicitOrg(state, `DW ${parts.join(', ')}`, values.length * 2);
+}
+function formatAlign(alignmentExpression, evalContext, state) {
+    const alignment = evaluateLoweredConstant(alignmentExpression, evalContext);
+    if (alignment === undefined || alignment <= 0) {
+        return undefined;
+    }
+    const padding = (alignment - (state.address % alignment)) % alignment;
+    return padding === 0
+        ? { text: '', size: 0 }
+        : withImplicitOrg(state, `DS ${formatLoweredNumber(padding, 'byte')}, $00`, padding);
+}
+function formatStringData(directive, value, state) {
+    const bytes = stringDirectiveBytes(directive, value);
+    if (bytes.length === 0) {
+        return { text: '', size: 0 };
+    }
+    return withImplicitOrg(state, `DB ${bytes.map((byte) => formatLoweredNumber(byte, 'byte')).join(', ')}`, bytes.length);
+}
+function formatInstruction(instruction, evalContext) {
+    const size = instructionSize(instruction);
+    void size;
+    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 'nop':
+            return { text: 'nop' };
+        case 'ret':
+            return { text: 'ret' };
+        case 'di':
+        case 'ei':
+        case 'scf':
+        case 'ccf':
+        case 'cpl':
+        case 'daa':
+        case 'exx':
+        case 'halt':
+        case 'rlca':
+        case 'rrca':
+        case 'rla':
+        case 'rra':
+        case 'neg':
+        case 'rrd':
+        case 'rld':
+        case 'ldi':
+        case 'ldir':
+        case 'ldd':
+        case 'lddr':
+        case 'cpi':
+        case 'cpir':
+        case 'cpd':
+        case 'cpdr':
+        case 'ini':
+        case 'inir':
+        case 'ind':
+        case 'indr':
+        case 'outi':
+        case 'otir':
+        case 'outd':
+        case 'otdr':
+        case 'reti':
+        case 'retn':
+            return { text: instruction.mnemonic };
+        case 'im':
+            return { text: `im ${formatLoweredNumber(instruction.mode, 'byte')}` };
+        case 'rst':
+            return { text: `rst ${formatLoweredNumber(instruction.vector, 'byte')}` };
+        case 'add':
+            if ('target' in instruction) {
+                return formatReg16Alu('add', instruction.target, instruction.source);
+            }
+            return formatAlu('add', instruction.source, evalContext);
+        case 'adc':
+        case 'sbc':
+            if ('target' in instruction) {
+                return formatReg16Alu(instruction.mnemonic, instruction.target, instruction.source);
+            }
+            return formatAlu(instruction.mnemonic, instruction.source, evalContext);
+        case 'sub':
+        case 'and':
+        case 'or':
+        case 'xor':
+        case 'cp':
+            return formatAlu(instruction.mnemonic, instruction.source, evalContext);
+        case 'bit':
+        case 'res':
+        case 'set':
+            return formatBitOp(instruction, evalContext);
+        case 'in':
+            return formatIn(instruction, evalContext);
+        case 'out':
+            return formatOut(instruction, evalContext);
+        case 'inc':
+        case 'dec':
+            return formatIncDec(instruction, evalContext);
+        case 'ex':
+            return formatEx(instruction.form);
+        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 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') {
+        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 formatLd(target, source, evalContext) {
+    if (target.kind === 'reg8' && source.kind === 'imm') {
+        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'byte'));
+    }
+    if (target.kind === 'reg8' && source.kind === 'reg8') {
+        return { text: `ld ${target.register}, ${source.register}` };
+    }
+    if (target.kind === 'reg16' && source.kind === 'imm') {
+        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'word'));
+    }
+    if (target.kind === 'reg16' && source.kind === 'mem-abs') {
+        return formatLdText(target.register, formatParenthesizedExpression(source.expression, evalContext, 'auto'));
+    }
+    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'reg-indirect') {
+        return { text: `ld a, (${source.register})` };
+    }
+    if (target.kind === 'reg-indirect' &&
+        (target.register === 'bc' || target.register === 'de') &&
+        source.kind === 'reg8' &&
+        source.register === 'a') {
+        return { text: `ld (${target.register}), a` };
+    }
+    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'mem-abs') {
+        return formatLdText('a', formatParenthesizedExpression(source.expression, evalContext, 'auto'));
+    }
+    if (target.kind === 'mem-abs' && source.kind === 'reg8' && source.register === 'a') {
+        const targetText = formatParenthesizedExpression(target.expression, evalContext, 'auto');
+        return targetText === undefined ? undefined : { text: `ld ${targetText}, a` };
+    }
+    return undefined;
+}
+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})`;
+}
+function withImplicitOrg(state, text, size) {
+    if (text === undefined) {
+        return undefined;
+    }
+    if (state.emittedOrg || !state.needsImplicitOrg) {
+        return { text, size };
+    }
+    state.emittedOrg = true;
+    return { text: `ORG $00\n${text}`, size };
+}
+function formatBranch(mnemonic, expression, evalContext) {
+    const target = formatExpression(expression, evalContext, 'word');
+    return target === undefined ? undefined : { text: `${mnemonic} ${target}` };
+}
+function formatExpression(expression, evalContext, width) {
+    const value = evaluateLoweredConstant(expression, evalContext);
+    if (value !== undefined) {
+        return formatLoweredNumber(value, width);
+    }
+    if (expression.kind === 'symbol') {
+        return expression.name;
+    }
+    return undefined;
+}
+function evaluateLoweredConstant(expression, evalContext) {
+    switch (expression.kind) {
+        case 'number':
+            return expression.value;
+        case 'symbol':
+            return evalContext.constants.get(expression.name);
+        case 'sizeof':
+            return evaluateExpression(expression, {}, new Map(), silentSpan, [], {
+                currentLocation: 0,
+                layouts: evalContext.layouts,
+                reportUnknown: false,
+            });
+        case 'unary': {
+            const value = evaluateLoweredConstant(expression.expression, evalContext);
+            if (value === undefined) {
+                return undefined;
+            }
+            switch (expression.operator) {
+                case '+':
+                    return value;
+                case '-':
+                    return -value;
+                case '~':
+                    return ~value;
+            }
+            break;
+        }
+        case 'binary': {
+            const left = evaluateLoweredConstant(expression.left, evalContext);
+            const right = evaluateLoweredConstant(expression.right, evalContext);
+            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;
+            }
+            break;
+        }
+        default:
+            return undefined;
+    }
+}
+function formatLoweredNumber(value, width) {
+    const normalized = value < 0 ? 0x10000 + (value & 0xffff) : value;
+    const digits = normalized.toString(16).toUpperCase();
+    const minWidth = width === 'word' || (width === 'auto' && normalized > 0xff) ? 4 : 2;
+    return `$${digits.padStart(minWidth, '0')}`;
+}
+function formatBitOp(instruction, evalContext) {
+    const bit = formatLoweredNumber(instruction.bit, 'byte');
+    const operand = formatBitOperand(instruction.operand, evalContext);
+    if (operand === undefined) {
+        return undefined;
+    }
+    const parts = [bit, operand];
+    if (instruction.destination) {
+        parts.push(instruction.destination.register);
+    }
+    return { text: `${instruction.mnemonic} ${parts.join(', ')}` };
+}
+function formatBitOperand(operand, evalContext) {
+    if (operand.kind === 'reg8') {
+        return operand.register;
+    }
+    if (operand.kind === 'reg-indirect' && operand.register === 'hl') {
+        return '(HL)';
+    }
+    if (operand.kind === 'indexed') {
+        return formatIndexedMemory(operand.register, operand.displacement, evalContext);
+    }
+    return undefined;
+}
+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 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;
+}
+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));
+    }
+}
+function describeItem(item) {
+    if (item.kind === 'instruction') {
+        return `instruction "${item.instruction.mnemonic}"`;
+    }
+    return `directive "${item.kind}"`;
+}

package/dist/src/outputs/write-bin.d.ts

@@ -0,0 +1,2 @@
+import type { EmittedByteMap, BinArtifact, SymbolEntry, WriteBinOptions } from './types.js';
+export declare function writeBin(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteBinOptions): BinArtifact;

package/dist/src/outputs/write-bin.js

@@ -0,0 +1,27 @@
+const BIN_FROM_SYMBOL_NAME = '__azm_binfrom';
+const BIN_TO_SYMBOL_NAME = '__azm_binto';
+export function writeBin(map, symbols, opts) {
+    const { start: writtenStart, end: writtenEnd } = getWrittenRange(map);
+    const optionStart = opts?.binFrom ?? opts?.startAddress;
+    const symbolStart = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BIN_FROM_SYMBOL_NAME);
+    const symbolEnd = symbols.find((symbol) => symbol.kind === 'constant' && symbol.name === BIN_TO_SYMBOL_NAME);
+    const start = optionStart ?? (symbolStart?.kind === 'constant' ? symbolStart.value : writtenStart);
+    const end = symbolEnd?.kind === 'constant' ? symbolEnd.value + 1 : writtenEnd;
+    const out = new Uint8Array(Math.max(0, end - start));
+    for (let index = 0; index < out.length; index += 1) {
+        out[index] = map.bytes.get(start + index) ?? 0;
+    }
+    return { kind: 'bin', bytes: out };
+}
+function getWrittenRange(map) {
+    if (map.writtenRange) {
+        return map.writtenRange;
+    }
+    if (map.bytes.size === 0) {
+        return { start: 0, end: 0 };
+    }
+    const keys = [...map.bytes.keys()];
+    const start = Math.min(...keys);
+    const end = Math.max(...keys) + 1;
+    return { start, end };
+}

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

@@ -0,0 +1,2 @@
+import type { D8mArtifact, EmittedByteMap, SymbolEntry, WriteD8mOptions } from './types.js';
+export declare function writeD8m(map: EmittedByteMap, symbols: readonly SymbolEntry[], opts?: WriteD8mOptions): D8mArtifact;