@henols/c64-re-tools 2.0.0-rc.13 → 2.0.0-rc.15

package/src/mcp/tools/memory.ts

@@ -12,6 +12,8 @@ import { AddressInput, AddressOutput, Byte, defineTool, HexData, HexDataInput, M
 /** With out, a read or a disassembly can be larger than one answer of the session: it is read in parts (D39). */
 const MAX_MEMORY_READ_OUT = 0x10000;
 const MAX_DISASSEMBLE_OUT = 32768;
+/** A memory byte in a result: two lowercase hex digits, as memory data is. */
+const HexByte = z.string().regex(/^[0-9a-f]{2}$/);
 
 export const c64MemoryRead = defineTool({
   name: "c64_memory_read",
@@ -182,6 +184,7 @@ export const c64MemoryCompare = defineTool({
   description:
     `Compare two memory ranges of size bytes (1 to ${MAX_COMPARE_SIZE}). Each range has its own address, space and view. ` +
     `The result tells if they are equal, how many bytes differ, and the first ${MAX_COMPARE_DIFFERENCES} differences with their offset. ` +
+    "The bytes of a difference are lowercase hex. " +
     "This does not change the run state of the machine.",
   inputSchema: z
     .object({ left: Location, right: Location, size: z.number().int().min(1).max(MAX_COMPARE_SIZE) })
@@ -189,11 +192,13 @@ export const c64MemoryCompare = defineTool({
   outputSchema: z.object({
     equal: z.boolean(),
     differentBytes: z.number().int().min(0),
-    firstDifferences: z.array(z.object({ offset: z.number().int().min(0), left: Byte, right: Byte })),
+    firstDifferences: z.array(z.object({ offset: z.number().int().min(0), left: HexByte, right: HexByte })),
   }),
   readOnly: true,
   async run(input, session) {
-    return session.memoryCompare(input);
+    const result = await session.memoryCompare(input);
+    const hex = (byte: number) => byte.toString(16).padStart(2, "0");
+    return { ...result, firstDifferences: result.firstDifferences.map((difference) => ({ ...difference, left: hex(difference.left), right: hex(difference.right) })) };
   },
 });
 

package/src/mcp/tools/video.ts

@@ -3,7 +3,7 @@
 
 import { z } from "zod";
 
-import { formatC64Address } from "../../c64.ts";
+import { formatC64Address, formatSprite, formatVicii } from "../../c64.ts";
 import { WireFailure } from "../../protocol/messages.ts";
 import { CIA_SELECTIONS, MAX_MASK_RECTANGLES, MAX_MEMORY_READ, MAX_OBSERVE_BYTES, MAX_OBSERVE_RANGES, SPACES, VICII_MODES, type ObserveParams } from "../../protocol/vice.ts";
 import { OutInput, ProjectInput, writeOut, WrittenOutput } from "../output.ts";
@@ -31,8 +31,7 @@ export const c64Vicii = defineTool({
   }),
   readOnly: true,
   async run(_input, session) {
-    const state = await session.vicii();
-    return { ...state, screenAddress: formatC64Address(state.screenAddress), graphicsAddress: formatC64Address(state.graphicsAddress) };
+    return formatVicii(await session.vicii());
   },
 });
 
@@ -62,7 +61,7 @@ export const c64Sprite = defineTool({
   readOnly: true,
   async run(input, session) {
     const result = await session.sprites(input.sprites ?? []);
-    return { sprites: result.sprites.map((sprite) => ({ ...sprite, dataAddress: formatC64Address(sprite.dataAddress) })) };
+    return { sprites: result.sprites.map(formatSprite) };
   },
 });
 

package/src/native/ghidra/language/c64rt_6510.slaspec

@@ -263,13 +263,16 @@ REL: target      is rel [ target = inst_next + rel; ] { export *:2 target; }
 }
 
 # BRK skips its padding byte: the return address is two bytes on.
+# The vector at $FFFE is in ROM unless the program banks the KERNAL out, and
+# the analysis cannot know the banking. Thus BRK ends the flow, and Ghidra
+# does not follow the RAM bytes at $FFFE of a flat image (R2-07).
 :BRK is op=0x00 {
 	*:2 (SP - 1) = inst_next + 1;
 	SP = SP - 2;
 	pushP(1);
 	I = 1;
 	local vector:2 = 0xfffe;
-	goto [*:2 vector];
+	return [*:2 vector];
 }
 
 :CLC is op=0x18 { C = 0; }

package/src/protocol/vice.ts

@@ -337,8 +337,16 @@ export interface MachineStatus {
   pc?: number;
   /** True while a cartridge from an autostart is attached (D64). */
   cartridge: boolean;
+  /** Present only while stopped by a user breakpoint or watchpoint, or by a JAM. */
+  stopReason?: PointStopReason;
+  /** The id of the breakpoint or watchpoint that stopped the machine. */
+  pointId?: number;
 }
 
+/** What stopped the machine outside a request that stops it. */
+export const POINT_STOP_REASONS = ["breakpoint", "watchpoint", "jam"] as const;
+export type PointStopReason = (typeof POINT_STOP_REASONS)[number];
+
 export interface MemoryReadParams {
   address: number;
   size: number;
@@ -406,6 +414,10 @@ export interface ExecutionResult {
   pc?: number;
   executed?: number;
   advancedFrames?: number;
+  /** advance-frames only: frames when all frames ran, else what stopped the run early. */
+  stopReason?: "frames" | PointStopReason;
+  /** The id of the breakpoint or watchpoint that stopped the run. */
+  pointId?: number;
 }
 
 /** c64_run_until targets. */
@@ -425,6 +437,8 @@ export interface RunUntilResult {
   /** The PC of the CPU in `space`: the CPU that stopped. */
   pc: number;
   space: Space;
+  /** The id of the breakpoint or watchpoint that stopped the run. */
+  pointId?: number;
 }
 
 export interface ViceOperations {
@@ -469,7 +483,8 @@ export interface ViceOperations {
   backtrace: { params: { depth: number; space: Space }; result: { frames: BacktraceFrame[] } };
   /** `cycles` is a decimal string. */
   timing: { params: { action: (typeof TIMING_ACTIONS)[number] }; result: { started: boolean } | { cycles: string } };
-  profile: { params: { limit: number }; result: { entries: ProfileEntry[] } };
+  /** clear starts the profiler again from zero. */
+  profile: { params: { action: "read"; limit: number } | { action: "clear" }; result: { entries: ProfileEntry[] } | { cleared: boolean } };
   memmap: {
     params: { action: "read"; start: number; end: number; maxRanges: number } | { action: "clear" };
     /** `next`: more ranges follow from this address; read again from there. */
@@ -646,9 +661,11 @@ export function validateViceParams<O extends ViceOperation>(op: O, params: unkno
       return result as ViceOperations[O]["params"];
     }
     case "profile": {
-      onlyFields(params, ["limit"]);
+      onlyFields(params, params.action === "clear" ? ["action"] : ["action", "limit"]);
+      if (params.action === "clear") return { action: "clear" } as ViceOperations[O]["params"];
+      if (params.action !== "read") invalid("action must be read or clear");
       if (!isInteger(params.limit, 1, MAX_PROFILE)) invalid(`limit must be an integer from 1 to ${MAX_PROFILE}`);
-      return { limit: params.limit } as ViceOperations[O]["params"];
+      return { action: "read", limit: params.limit } as ViceOperations[O]["params"];
     }
     case "memmap": {
       onlyFields(params, params.action === "clear" ? ["action"] : ["action", "start", "end", "maxRanges"]);
@@ -1011,7 +1028,9 @@ export function validateViceResult<O extends ViceOperation>(op: O, value: unknow
         typeof value.warp === "boolean" &&
         typeof value.window === "boolean" &&
         (value.pc === undefined || isInteger(value.pc, 0, 0xffff)) &&
-        typeof value.cartridge === "boolean";
+        typeof value.cartridge === "boolean" &&
+        (value.stopReason === undefined || isOneOf(POINT_STOP_REASONS, value.stopReason)) &&
+        (value.pointId === undefined || isInteger(value.pointId, 1, Number.MAX_SAFE_INTEGER));
       if (!ok) throw new ProtocolError("status result is malformed");
       break;
     }
@@ -1080,7 +1099,8 @@ export function validateViceResult<O extends ViceOperation>(op: O, value: unknow
         isOneOf(STOP_REASONS, value.stopReason) &&
         isOneOf(RUN_STATES, value.state) &&
         isInteger(value.pc, 0, 0xffff) &&
-        isOneOf(SPACES, value.space);
+        isOneOf(SPACES, value.space) &&
+        (value.pointId === undefined || isInteger(value.pointId, 1, Number.MAX_SAFE_INTEGER));
       if (!ok) throw new ProtocolError("runUntil result is malformed");
       break;
     }
@@ -1089,7 +1109,9 @@ export function validateViceResult<O extends ViceOperation>(op: O, value: unknow
         isOneOf(RUN_STATES, value.state) &&
         (value.pc === undefined || isInteger(value.pc, 0, 0xffff)) &&
         (value.executed === undefined || isInteger(value.executed, 0, MAX_EXECUTION_COUNT)) &&
-        (value.advancedFrames === undefined || isInteger(value.advancedFrames, 0, MAX_EXECUTION_COUNT));
+        (value.advancedFrames === undefined || isInteger(value.advancedFrames, 0, MAX_EXECUTION_COUNT)) &&
+        (value.stopReason === undefined || value.stopReason === "frames" || isOneOf(POINT_STOP_REASONS, value.stopReason)) &&
+        (value.pointId === undefined || isInteger(value.pointId, 1, Number.MAX_SAFE_INTEGER));
       if (!ok) throw new ProtocolError("execution result is malformed");
       break;
     }
@@ -1198,6 +1220,10 @@ export function validateViceResult<O extends ViceOperation>(op: O, value: unknow
       break;
     }
     case "profile": {
+      if ("cleared" in value) {
+        if (value.cleared !== true) throw new ProtocolError("profile result is malformed");
+        break;
+      }
       const ok =
         Array.isArray(value.entries) &&
         value.entries.every(