@jhlagado/azm 0.2.7 → 0.2.9

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

@@ -1,7 +1,26 @@
-import { evaluateExpression, } from '../semantics/expression-evaluation.js';
 import { instructionSize } from '../assembly/fixup-emission.js';
+import { evaluateLoweredConstant, formatExpression, formatLoweredNumber, } from './asm80-expressions.js';
+import { formatInstruction } from './asm80-instructions.js';
+import { stringDirectiveBytes } from './asm80-strings.js';
 const asm80Header = '; AZM lowered ASM80 output';
-const silentSpan = { sourceName: '', line: 0, column: 0 };
+const FORMATTERS = {
+    org: formatOrg,
+    equ: formatEqu,
+    comment: formatComment,
+    label: formatLabel,
+    db: formatDbItem,
+    dw: formatDwItem,
+    ds: formatDsItem,
+    align: formatAlignItem,
+    'string-data': formatStringDataItem,
+    instruction: formatInstructionItem,
+    enum: formatIgnoredItem,
+    type: formatIgnoredItem,
+    'type-alias': formatIgnoredItem,
+    end: formatIgnoredItem,
+    binfrom: formatIgnoredItem,
+    binto: formatIgnoredItem,
+};
 export class UnsupportedAsm80LoweringError extends Error {
     item;
     constructor(message, item) {
@@ -12,6 +31,10 @@ export class UnsupportedAsm80LoweringError extends Error {
 }
 export function writeAsm80(items, symbols, opts = {}) {
     void opts;
+    const importedItem = items.find((item) => item.span.sourceRelation === 'import');
+    if (importedItem !== undefined) {
+        throw new UnsupportedAsm80LoweringError('lowered .z80 output does not yet support .import source units', importedItem);
+    }
     const evalContext = {
         constants: collectConstants(symbols),
         symbols: collectSymbolValues(symbols),
@@ -72,52 +95,54 @@ function collectLayouts(items) {
     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 'comment':
-            return {
-                text: item.origin === 'user' ? `; ${item.text}` : `; AZM: ${item.text}`,
-                size: 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 'type-alias':
-        case 'end':
-        case 'binfrom':
-        case 'binto':
-            return { text: '', size: 0 };
-        default:
-            return undefined;
+    const formatter = FORMATTERS[item.kind];
+    return formatter(item, evalContext, state);
+}
+function formatOrg(item, evalContext, state) {
+    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 };
+}
+function formatEqu(item, evalContext, state) {
+    const expression = formatExpression(item.expression, evalContext, 'auto');
+    return expression === undefined
+        ? undefined
+        : withImplicitOrg(state, `${item.name} EQU ${expression}`, 0);
+}
+function formatComment(item) {
+    return {
+        text: item.origin === 'user' ? `; ${item.text}` : `; AZM: ${item.text}`,
+        size: 0,
+    };
+}
+function formatLabel(item, _evalContext, state) {
+    return withImplicitOrg(state, `${item.name}:`, 0);
+}
+function formatDbItem(item, evalContext, state) {
+    return formatDb(item.values, evalContext, state);
+}
+function formatDwItem(item, evalContext, state) {
+    return formatDw(item.values, evalContext, state);
+}
+function formatDsItem(item, evalContext, state) {
+    return formatDs(item.size, item.fill, evalContext, state);
+}
+function formatAlignItem(item, evalContext, state) {
+    return formatAlign(item.alignment, evalContext, state);
+}
+function formatStringDataItem(item, _evalContext, state) {
+    return formatStringData(item.directive, item.value, state);
+}
+function formatInstructionItem(item, evalContext, state) {
+    return withImplicitOrg(state, formatInstruction(item.instruction, evalContext)?.text, instructionSize(item.instruction));
+}
+function formatIgnoredItem() {
+    return { text: '', size: 0 };
 }
 function formatDb(values, evalContext, state) {
     const parts = [];
@@ -182,265 +207,6 @@ function formatStringData(directive, value, state) {
     }
     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 'rlc':
-        case 'rrc':
-        case 'rl':
-        case 'rr':
-        case 'sla':
-        case 'sra':
-        case 'sll':
-        case 'sls':
-        case 'srl':
-            return formatRotateShift(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);
-        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 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 === 'reg8' && source.kind === 'reg-half-index') {
-        return { text: `ld ${target.register}, ${source.register}` };
-    }
-    if (target.kind === 'reg8' && target.register === 'a' && source.kind === 'special8') {
-        return { text: `ld a, ${source.register}` };
-    }
-    if (target.kind === 'special8' && source.kind === 'reg8' && source.register === 'a') {
-        return { text: `ld ${target.register}, a` };
-    }
-    if (target.kind === 'reg-index16' && source.kind === 'imm') {
-        return formatLdText(target.register, formatExpression(source.expression, evalContext, 'word'));
-    }
-    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' && source.kind === 'reg-indirect' && source.register === 'hl') {
-        return { text: `ld ${target.register}, (hl)` };
-    }
-    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}` };
-    }
-    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}` };
-    }
-    if (target.kind === 'reg8' && source.kind === 'mem-abs') {
-        return formatLdText(target.register, formatParenthesizedExpression(source.expression, evalContext, 'auto'));
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg8') {
-        const targetText = formatParenthesizedExpression(target.expression, evalContext, 'auto');
-        return targetText === undefined
-            ? undefined
-            : { text: `ld ${targetText}, ${source.register}` };
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg16') {
-        const targetText = formatParenthesizedExpression(target.expression, evalContext, 'auto');
-        return targetText === undefined
-            ? undefined
-            : { text: `ld ${targetText}, ${source.register}` };
-    }
-    if (target.kind === 'mem-abs' && source.kind === 'reg-index16') {
-        const targetText = formatParenthesizedExpression(target.expression, evalContext, 'auto');
-        return targetText === undefined
-            ? undefined
-            : { text: `ld ${targetText}, ${source.register}` };
-    }
-    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;
@@ -451,297 +217,6 @@ function withImplicitOrg(state, 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;
-    }
-    if (expression.kind === 'type-size') {
-        const value = evaluateLoweredConstant(expression, evalContext);
-        return value === undefined ? expression.typeExpr.name : formatLoweredNumber(value, width);
-    }
-    if (expression.kind === 'current-location') {
-        return '$';
-    }
-    if (expression.kind === 'unary') {
-        const inner = formatExpression(expression.expression, evalContext, width);
-        if (inner === undefined) {
-            return undefined;
-        }
-        switch (expression.operator) {
-            case '+':
-                return inner;
-            case '-':
-                return `-${inner}`;
-            case '~': {
-                const value = evaluateLoweredConstant(expression, evalContext);
-                return value === undefined ? undefined : formatLoweredNumber(value, width);
-            }
-        }
-    }
-    if (expression.kind === 'binary') {
-        const left = formatExpression(expression.left, evalContext, width);
-        const right = formatExpression(expression.right, evalContext, width);
-        if (left === undefined || right === undefined) {
-            return undefined;
-        }
-        return `${left}${expression.operator}${right}`;
-    }
-    return undefined;
-}
-function evaluateLoweredConstant(expression, evalContext) {
-    switch (expression.kind) {
-        case 'number':
-            return expression.value;
-        case 'symbol':
-            return evalContext.constants.get(expression.name);
-        case 'type-size': {
-            const constant = evalContext.constants.get(expression.typeExpr.name);
-            if (constant !== undefined) {
-                return constant;
-            }
-            return evaluateExpression(expression, {}, new Map(), silentSpan, [], {
-                currentLocation: 0,
-                layouts: evalContext.layouts,
-                reportUnknown: false,
-            });
-        }
-        case 'offset':
-        case 'sizeof':
-            return evaluateExpression(expression, {}, new Map(), silentSpan, [], {
-                currentLocation: 0,
-                layouts: evalContext.layouts,
-                reportUnknown: false,
-            });
-        case 'byte-function': {
-            const value = evaluateLoweredResolvedConstant(expression.expression, evalContext);
-            if (value === undefined) {
-                return undefined;
-            }
-            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
-        }
-        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 evaluateLoweredResolvedConstant(expression, evalContext) {
-    switch (expression.kind) {
-        case 'symbol':
-            return evalContext.symbols.get(expression.name);
-        case 'unary': {
-            const value = evaluateLoweredResolvedConstant(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 = evaluateLoweredResolvedConstant(expression.left, evalContext);
-            const right = evaluateLoweredResolvedConstant(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;
-        }
-        case 'byte-function': {
-            const value = evaluateLoweredResolvedConstant(expression.expression, evalContext);
-            if (value === undefined) {
-                return undefined;
-            }
-            return expression.function === 'LSB' ? value & 0xff : (value >> 8) & 0xff;
-        }
-        default:
-            return evaluateLoweredConstant(expression, evalContext);
-    }
-}
-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 formatRotateShift(instruction, evalContext) {
-    const operand = formatBitOperand(instruction.operand, evalContext);
-    if (operand === undefined) {
-        return undefined;
-    }
-    const parts = [operand];
-    if (instruction.destination) {
-        parts.push(instruction.destination.register);
-    }
-    return { text: `${instruction.mnemonic} ${parts.join(', ')}` };
-}
-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}"`;