c64bridge 1.0.4 → 1.0.6

package/dist/tools/storage.js

@@ -97,10 +97,10 @@ const createD64ArgsSchema = objectSchema({
     properties: {
         path: diskImagePathSchema,
         tracks: optionalSchema(numberSchema({
-            description: "Track count (35 for standard, 40 for extended).",
+            description: "Track count: 35 for a standard disk, up to 41 for the extended area (firmware limit).",
             integer: true,
             minimum: 35,
-            maximum: 40,
+            maximum: 41,
         })),
         diskname: diskNameSchema,
     },
@@ -175,7 +175,7 @@ export const storageModule = defineToolModule({
                     drivesListArgsSchema.parse(args ?? {});
                     ctx.logger.info("Listing Ultimate drives");
                     const details = await ctx.client.drivesList();
-                    return textResult("Retrieved Ultimate drive status.", {
+                    return textResult("Retrieved drive status.", {
                         success: true,
                         drives: details,
                     });
@@ -221,14 +221,16 @@ export const storageModule = defineToolModule({
                         mode: parsed.mode,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while mounting disk image", {
+                        throw new ToolExecutionError("C64 backend reported failure while mounting disk image", {
                             details: normaliseFailure(result.details),
                         });
                     }
                     const details = toRecord(result.details) ?? {};
                     const finalMode = typeof details.mode === "string" ? details.mode : parsed.mode ?? null;
                     const finalType = typeof details.type === "string" ? details.type : parsed.type ?? null;
-                    return textResult(`Mounted ${parsed.image} on ${parsed.drive}.`, {
+                    // Backend notes (for example VICE's autoload resetting the machine) belong in the visible text.
+                    const note = typeof details.note === "string" ? ` ${details.note}` : "";
+                    return textResult(`Mounted ${parsed.image} on ${parsed.drive}.${note}`, {
                         success: true,
                         drive: parsed.drive,
                         image: parsed.image,
@@ -269,7 +271,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Removing disk image", { drive: parsed.drive });
                     const result = await ctx.client.driveRemove(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while removing disk image", {
+                        throw new ToolExecutionError("C64 backend reported failure while removing disk image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -311,7 +313,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Resetting drive", { drive: parsed.drive });
                     const result = await ctx.client.driveReset(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while resetting drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while resetting drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -353,7 +355,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Powering on drive", { drive: parsed.drive });
                     const result = await ctx.client.driveOn(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while powering on drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while powering on drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -396,7 +398,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Powering off drive", { drive: parsed.drive });
                     const result = await ctx.client.driveOff(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while powering off drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while powering off drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -439,7 +441,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Loading drive ROM", { drive: parsed.drive, path: parsed.path });
                     const result = await ctx.client.driveLoadRom(parsed.drive, parsed.path);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while loading drive ROM", {
+                        throw new ToolExecutionError("C64 backend reported failure while loading drive ROM", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -482,7 +484,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Setting drive mode", { drive: parsed.drive, mode: parsed.mode });
                     const result = await ctx.client.driveSetMode(parsed.drive, parsed.mode);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while setting drive mode", {
+                        throw new ToolExecutionError("C64 backend reported failure while setting drive mode", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -541,7 +543,7 @@ export const storageModule = defineToolModule({
         {
             name: "create_d64",
             description: "Create a blank D64 disk image on the Ultimate filesystem.",
-            summary: "Allocates a 35 or 40 track D64 image with an optional disk name.",
+            summary: "Allocates a 35 to 41 track D64 image with an optional disk name.",
             inputSchema: createD64ArgsSchema.jsonSchema,
             relatedResources: ["c64://guide/bootstrap"],
             tags: ["disk", "create"],
@@ -569,14 +571,16 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D64 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D64 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
+                    const firmwareTracks = toRecord(result.details)?.tracks;
                     return textResult(`Created D64 image at ${parsed.path}.`, {
                         success: true,
                         path: parsed.path,
-                        tracks: parsed.tracks ?? null,
+                        // The firmware reports the track count it used, including its default of 35.
+                        tracks: typeof firmwareTracks === "number" ? firmwareTracks : parsed.tracks ?? 35,
                         diskname: parsed.diskname ?? null,
                         details: toRecord(result.details) ?? {},
                     });
@@ -618,7 +622,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D71 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D71 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -666,7 +670,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D81 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D81 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -717,7 +721,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating DNP image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating DNP image", {
                             details: normaliseFailure(result.details),
                         });
                     }

package/dist/tools/streaming.js

@@ -80,7 +80,7 @@ export const streamingModule = defineToolModule({
                     });
                     const result = await ctx.client.streamStart(parsed.stream, parsed.target);
                     if (!result.success) {
-                        throw new ToolExecutionError(withFailureReason("C64 firmware reported failure while starting stream", result.details), {
+                        throw new ToolExecutionError(withFailureReason("C64 backend reported failure while starting stream", result.details), {
                             details: toRecord(result.details),
                         });
                     }
@@ -120,7 +120,7 @@ export const streamingModule = defineToolModule({
                     });
                     const result = await ctx.client.streamStop(parsed.stream);
                     if (!result.success) {
-                        throw new ToolExecutionError(withFailureReason("C64 firmware reported failure while stopping stream", result.details), {
+                        throw new ToolExecutionError(withFailureReason("C64 backend reported failure while stopping stream", result.details), {
                             details: toRecord(result.details),
                         });
                     }

package/dist/tools/translation/assembler.js

@@ -31,6 +31,41 @@ var AddressingMode;
     AddressingMode["Relative"] = "relative";
 })(AddressingMode || (AddressingMode = {}));
 const DEFAULT_LOAD_ADDRESS = 0x0801;
+const BASIC_START = 0x0801;
+// "10 SYS0nnnn": link $080C, line 10, SYS token, five digits, end of line, end
+// of program. The digits are the first instruction's address; a fixed width
+// keeps the stub, and so every address after it, the same in both passes.
+function basicSysStub(target) {
+    const digits = String(target & 0xffff).padStart(5, "0");
+    return [0x0c, 0x08, 0x0a, 0x00, 0x9e, ...[...digits].map((digit) => digit.charCodeAt(0)), 0x00, 0x00, 0x00];
+}
+/**
+ * Address to SYS to start a PRG: the target of a leading "SYS <n>" BASIC line
+ * when the PRG loads at $0801, otherwise the load address.
+ */
+export function prgEntryAddress(prg) {
+    const loadAddress = (prg[0] ?? 0) | ((prg[1] ?? 0) << 8);
+    if (loadAddress !== BASIC_START || prg.length < 8) {
+        return loadAddress;
+    }
+    // Skip the link pointer and line number, then expect the SYS token and digits.
+    let index = 6;
+    while (prg[index] === 0x20)
+        index += 1;
+    if (prg[index] !== 0x9e) {
+        return loadAddress;
+    }
+    index += 1;
+    while (prg[index] === 0x20 || prg[index] === 0x28)
+        index += 1;
+    let digits = "";
+    while (index < prg.length && prg[index] >= 0x30 && prg[index] <= 0x39) {
+        digits += String.fromCharCode(prg[index]);
+        index += 1;
+    }
+    const target = Number.parseInt(digits, 10);
+    return digits.length > 0 && target <= 0xffff ? target : loadAddress;
+}
 const MAX_ADDRESS = 0xffff;
 const SINGLE_CHAR_TOKENS = new Set([",", ":", "#", "(", ")", "+", "-", "*", "/", "%", "&", "|", "^", "<", ">", "=", "!", "~"]);
 const MULTI_CHAR_TOKENS = new Set([
@@ -91,7 +126,13 @@ export function assemblyToPrgDetailed(source, options) {
     const assembler = new Assembler(statements, loadAddress);
     assembler.runPass(0);
     assembler.runPass(1);
-    return { prg: assembler.buildPrg(), symbols: assembler.getSymbols() };
+    const prg = assembler.buildPrg();
+    const loadAddressOfPrg = prg.length >= 2 ? prg.readUInt16LE(0) : loadAddress;
+    const stubTarget = prg.length >= 2 ? prgEntryAddress(prg) : loadAddressOfPrg;
+    const entryAddress = stubTarget !== loadAddressOfPrg
+        ? stubTarget
+        : assembler.getFirstInstructionAddress() ?? loadAddressOfPrg;
+    return { prg, symbols: assembler.getSymbols(), entryAddress };
 }
 function normalizeSource(input) {
     return input.replace(/\r\n?/g, "\n");
@@ -280,6 +321,13 @@ function tokenize(line) {
         }
         if (isDigit(char) || char === "$") {
             const { value, nextIndex } = parseNumberToken(line, index);
+            const digits = line.slice(index, nextIndex);
+            const afterPercent = tokens[tokens.length - 1]?.kind === "punct" && tokens[tokens.length - 1]?.value === "%" && line[index - 1] === "%";
+            if (afterPercent && /^[01]+$/.test(digits)) {
+                tokens.push({ kind: "number", value, binaryValue: parseInt(digits, 2) });
+                index = nextIndex;
+                continue;
+            }
             tokens.push({ kind: "number", value });
             index = nextIndex;
             continue;
@@ -466,10 +514,29 @@ function parseUnaryExpression(stream, terminators) {
     if (!token) {
         throw new Error("Unexpected end of expression");
     }
-    if (token.kind === "punct" && (token.value === "+" || token.value === "-" || token.value === "!" || token.value === "~")) {
+    // In operand position, "<" and ">" are byte selectors and "*" is the current
+    // PC; parseBinaryExpression consumes them as binary operators elsewhere.
+    // As in ACME, 64tass, DASM and Kick Assembler, "<" and ">" apply to the
+    // whole rest of the expression: "#>msg+1" is the high byte of msg+1.
+    if (token.kind === "punct" && (token.value === "<" || token.value === ">")) {
+        const operand = parseBinaryExpression(stream, terminators, 0);
+        return { type: "unary", op: token.value, operand };
+    }
+    if (token.kind === "punct" &&
+        (token.value === "+" || token.value === "-" || token.value === "!" || token.value === "~")) {
         const operand = parseUnaryExpression(stream, terminators);
         return { type: "unary", op: token.value, operand };
     }
+    if (token.kind === "punct" && token.value === "*") {
+        return { type: "symbol", name: "*" };
+    }
+    if (token.kind === "punct" && token.value === "%") {
+        const digits = stream.peek();
+        if (digits?.kind === "number" && digits.binaryValue !== undefined) {
+            stream.consume();
+            return { type: "number", value: digits.binaryValue };
+        }
+    }
     if (token.kind === "punct" && token.value === "(") {
         const expr = parseExpression(stream, new Set([")"]));
         const closing = stream.consume();
@@ -591,17 +658,16 @@ class SymbolTable {
         }
     }
     ensureLabel(label, expected) {
-        const existing = this.get(label);
-        if (existing === undefined) {
-            throw new Error(`Symbol "${label}" was not defined in the first pass`);
-        }
-        if (existing !== expected) {
-            throw new Error(`Symbol "${label}" changed value between passes (expected ${formatHex(existing)}, got ${formatHex(expected)})`);
-        }
+        this.ensureUnchanged(label, expected);
         if (!label.startsWith(".")) {
             this.currentScope = label;
         }
     }
+    // Constant assignments never open a local-label scope (as in ACME and
+    // 64tass), matching setAssignment in the first pass.
+    ensureAssignment(label, expected) {
+        this.ensureUnchanged(label, expected);
+    }
     setAssignment(label, value) {
         if (label.startsWith(".")) {
             if (!this.currentScope) {
@@ -628,6 +694,15 @@ class SymbolTable {
     allGlobals() {
         return this.globals;
     }
+    ensureUnchanged(label, expected) {
+        const existing = this.get(label);
+        if (existing === undefined) {
+            throw new Error(`Symbol "${label}" was not defined in the first pass`);
+        }
+        if (existing !== expected) {
+            throw new Error(`Symbol "${label}" changed value between passes (expected ${formatHex(existing)}, got ${formatHex(expected)})`);
+        }
+    }
     ensureLocalScope(scope) {
         if (!this.locals.has(scope)) {
             this.locals.set(scope, new Map());
@@ -638,21 +713,36 @@ class SymbolTable {
 class Assembler {
     constructor(lines, defaultLoadAddress) {
         this.lines = lines;
+        this.defaultLoadAddress = defaultLoadAddress;
         this.symbolTable = new SymbolTable();
         this.memory = new Uint8Array(0x10000);
         this.written = new Uint8Array(0x10000);
         this.pc = 0;
         this.lowestWritten = MAX_ADDRESS;
         this.highestWritten = 0;
-        this.loadAddress = defaultLoadAddress;
+        /** Reserved (.res) ranges from the last pass, as [start, end] inclusive. */
+        this.reserved = [];
         this.symbolTable.reset();
     }
     runPass(pass) {
-        this.pc = 0;
+        // Code before the first org directive is assembled at the load address.
+        this.pc = this.defaultLoadAddress & 0xffff;
         if (pass === 0) {
             this.symbolTable.reset();
             this.lowestWritten = MAX_ADDRESS;
             this.highestWritten = 0;
+            this.firstInstructionAddress = undefined;
+        }
+        this.reserved = [];
+        // Loading a PRG at $0801 makes BASIC relink the bytes there as program
+        // lines, which corrupts raw machine code. Code that starts at $0801
+        // without its own org therefore gets a "10 SYS" stub that jumps to the
+        // first instruction, even when data comes before it.
+        if (this.pc === BASIC_START && this.emitsBeforeFirstOrg()) {
+            // Pass 0 does not know the first instruction's address yet; pass 1 uses the address pass 0 recorded.
+            for (const byte of basicSysStub(pass === 1 ? this.firstInstructionAddress ?? 0 : 0)) {
+                this.writeByte(byte, this.lines[0].location);
+            }
         }
         for (const line of this.lines) {
             try {
@@ -667,17 +757,57 @@ class Assembler {
             }
         }
     }
+    emitsBeforeFirstOrg() {
+        for (const line of this.lines) {
+            const statement = line.statement;
+            if (!statement)
+                continue;
+            if (statement.kind === "instruction")
+                return true;
+            if (statement.kind === "assignment" && statement.isLocationCounter)
+                return false;
+            if (statement.kind === "directive") {
+                if (statement.name === "org")
+                    return false;
+                if (statement.name !== "include")
+                    return true;
+            }
+        }
+        return false;
+    }
     buildPrg() {
-        if (this.lowestWritten === MAX_ADDRESS || this.highestWritten < this.loadAddress) {
+        // The PRG spans the bytes actually emitted, so org blocks that only define
+        // labels neither move the load address nor add padding.
+        if (this.lowestWritten > this.highestWritten) {
             return Buffer.alloc(0);
         }
-        const start = Math.min(this.lowestWritten, this.loadAddress);
-        const end = this.highestWritten;
+        let start = this.lowestWritten;
+        let end = this.highestWritten;
+        // Reserved space that adjoins the emitted bytes (a trailing "counter: .res 1")
+        // is part of the image and zero-filled, as in ca65 and DASM; detached blocks
+        // such as zero-page variables are not, so they do not stretch the PRG.
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const [resStart, resEnd] of this.reserved) {
+                // Adjoining or overlapping blocks extend the image.
+                if (resStart <= end + 1 && resEnd > end) {
+                    end = resEnd;
+                    changed = true;
+                }
+                if (resEnd >= start - 1 && resStart < start) {
+                    start = resStart;
+                    changed = true;
+                }
+            }
+        }
         const body = this.memory.subarray(start, end + 1);
         const header = Buffer.alloc(2);
         header.writeUInt16LE(start, 0);
         return Buffer.concat([header, Buffer.from(body)]);
     }
+    getFirstInstructionAddress() {
+        return this.firstInstructionAddress;
+    }
     getSymbols() {
         return this.symbolTable.allGlobals();
     }
@@ -714,15 +844,12 @@ class Assembler {
         }
         if (statement.isLocationCounter) {
             this.pc = value & 0xffff;
-            if (pass === 0) {
-                this.loadAddress = this.pc;
-            }
         }
         else if (pass === 0) {
             this.symbolTable.setAssignment(statement.target, value);
         }
         else {
-            this.symbolTable.ensureLabel(statement.target, value);
+            this.symbolTable.ensureAssignment(statement.target, value);
         }
     }
     handleDirective(statement, pass, location) {
@@ -736,9 +863,6 @@ class Assembler {
                     throw new AssemblyError("org directive requires a defined value", location);
                 }
                 this.pc = value & 0xffff;
-                if (pass === 0) {
-                    this.loadAddress = this.pc;
-                }
                 break;
             }
             case "byte": {
@@ -809,14 +933,11 @@ class Assembler {
                 if (amount < 0) {
                     throw new AssemblyError("reserve directive requires a non-negative size", location);
                 }
-                if (pass === 1) {
-                    for (let i = 0; i < amount; i += 1) {
-                        this.writeByte(0, location);
-                    }
-                }
-                else {
-                    this.pc += amount;
-                }
+                // Reserved space advances the PC without emitting; buildPrg includes it
+                // (zero-filled) only where it adjoins emitted bytes.
+                if (amount > 0)
+                    this.reserved.push([this.pc, Math.min(0xffff, this.pc + amount - 1)]);
+                this.pc = (this.pc + amount) & 0xffff;
                 break;
             }
             case "include": {
@@ -831,6 +952,7 @@ class Assembler {
         const info = determineInstruction(statement, pass, this.evaluate.bind(this), this.pc, location);
         statement.resolvedMode = info.mode;
         if (pass === 0) {
+            this.firstInstructionAddress ?? (this.firstInstructionAddress = this.pc);
             this.pc += info.size;
             return;
         }
@@ -889,6 +1011,10 @@ class Assembler {
                         return value ? 0 : 1;
                     case "~":
                         return ~value;
+                    case "<":
+                        return value & 0xff;
+                    case ">":
+                        return (value >> 8) & 0xff;
                     default:
                         throw new AssemblyError("Unknown unary operator", location);
                 }
@@ -961,6 +1087,7 @@ class Assembler {
 function determineInstruction(statement, pass, evaluator, locationCounter, location) {
     if (statement.resolvedMode && pass === 1) {
         const value = statement.operand.kind === "none" ? undefined : resolveOperandValue(statement.operand, evaluator, pass, location);
+        assertZeroPageOperand(statement.mnemonic, statement.resolvedMode, value, location);
         const size = instructionSize(statement.resolvedMode);
         return {
             mode: statement.resolvedMode,
@@ -1040,43 +1167,51 @@ function chooseAddressingMode(mnemonic, operand, value, pass, location) {
                 return AddressingMode.Relative;
             }
             if (register === "X") {
-                if (available.has(AddressingMode.ZeroPageX) && value !== undefined && fitsByte(value)) {
-                    return AddressingMode.ZeroPageX;
-                }
-                if (available.has(AddressingMode.AbsoluteX)) {
-                    return AddressingMode.AbsoluteX;
-                }
-            }
-            else if (register === "Y") {
-                if (available.has(AddressingMode.ZeroPageY) && value !== undefined && fitsByte(value)) {
-                    return AddressingMode.ZeroPageY;
-                }
-                if (available.has(AddressingMode.AbsoluteY)) {
-                    return AddressingMode.AbsoluteY;
-                }
+                return chooseZeroPageOrAbsolute(mnemonic, available, AddressingMode.ZeroPageX, AddressingMode.AbsoluteX, value, location);
             }
-            else if (register === "S") {
-                if (available.has(AddressingMode.ZeroPageS)) {
-                    return AddressingMode.ZeroPageS;
-                }
+            if (register === "Y") {
+                return chooseZeroPageOrAbsolute(mnemonic, available, AddressingMode.ZeroPageY, AddressingMode.AbsoluteY, value, location);
             }
-            else {
-                if (available.has(AddressingMode.ZeroPage) && value !== undefined && fitsByte(value)) {
-                    return AddressingMode.ZeroPage;
-                }
-                if (available.has(AddressingMode.Absolute)) {
-                    return AddressingMode.Absolute;
+            if (register === "S") {
+                if (!available.has(AddressingMode.ZeroPageS)) {
+                    throw new AssemblyError(`Instruction ${mnemonic} does not support expr,S addressing`, location);
                 }
+                return AddressingMode.ZeroPageS;
             }
-            if (available.has(AddressingMode.Absolute)) {
-                return AddressingMode.Absolute;
-            }
-            throw new AssemblyError(`Instruction ${mnemonic} cannot resolve addressing mode`, location);
+            return chooseZeroPageOrAbsolute(mnemonic, available, AddressingMode.ZeroPage, AddressingMode.Absolute, value, location);
         }
         default:
             throw new AssemblyError("Unsupported operand kind", location);
     }
 }
+function chooseZeroPageOrAbsolute(mnemonic, available, zeroPageMode, absoluteMode, value, location) {
+    const hasZeroPage = available.has(zeroPageMode);
+    const hasAbsolute = available.has(absoluteMode);
+    if (hasZeroPage && value !== undefined && fitsByte(value)) {
+        return zeroPageMode;
+    }
+    if (hasAbsolute) {
+        return absoluteMode;
+    }
+    // Without an absolute form (e.g. STX zp,Y), a forward reference must be
+    // sized as zero page; the second pass rejects values outside zero page.
+    if (hasZeroPage && value === undefined) {
+        return zeroPageMode;
+    }
+    throw new AssemblyError(`Instruction ${mnemonic} does not support ${absoluteMode} addressing`, location);
+}
+function assertZeroPageOperand(mnemonic, mode, value, location) {
+    const absoluteMode = ZERO_PAGE_TO_ABSOLUTE_MODE.get(mode);
+    if (absoluteMode === undefined || value === undefined || fitsByte(value)) {
+        return;
+    }
+    throw new AssemblyError(`Instruction ${mnemonic} does not support ${absoluteMode} addressing (operand ${formatHex(value)} is outside zero page)`, location);
+}
+const ZERO_PAGE_TO_ABSOLUTE_MODE = new Map([
+    [AddressingMode.ZeroPage, AddressingMode.Absolute],
+    [AddressingMode.ZeroPageX, AddressingMode.AbsoluteX],
+    [AddressingMode.ZeroPageY, AddressingMode.AbsoluteY],
+]);
 function instructionSize(mode) {
     switch (mode) {
         case AddressingMode.Implied: