@henols/c64-re-tools 2.1.1 → 2.1.2

package/src/protocol/vice.ts

@@ -385,6 +385,8 @@ export interface MachineStatus {
   stopReason?: PointStopReason;
   /** The id of the breakpoint or watchpoint that stopped the machine. */
   pointId?: number;
+  /** With pc: the CPU whose address pc is, drive8 when a point in the drive stopped the machine. */
+  space?: "c64" | "drive8";
 }
 
 /** What stopped the machine outside a request that stops it. */
@@ -1092,7 +1094,8 @@ export function validateViceResult<O extends ViceOperation>(op: O, value: unknow
         (value.pc === undefined || isInteger(value.pc, 0, 0xffff)) &&
         typeof value.cartridge === "boolean" &&
         (value.stopReason === undefined || isOneOf(POINT_STOP_REASONS, value.stopReason)) &&
-        (value.pointId === undefined || isInteger(value.pointId, 1, Number.MAX_SAFE_INTEGER));
+        (value.pointId === undefined || isInteger(value.pointId, 1, Number.MAX_SAFE_INTEGER)) &&
+        (value.space === undefined || isOneOf(SPACES, value.space));
       if (!ok) throw new ProtocolError("status result is malformed");
       break;
     }

package/src/script.ts

@@ -13,7 +13,7 @@ import { parseArgs } from "node:util";
 
 import { c64AddressOf, formatC64Address, SPACE_PATTERN, SYMBOL_NAME, type AddressRange } from "./c64.ts";
 import { isRefusal, Refusal, type ErrorCode } from "./errors.ts";
-import { projectRoot, resolveProjectPath, useProject } from "./project.ts";
+import { checkOutputPath, projectRoot, resolveProjectPath, useProject, type OutputKind } from "./project.ts";
 import { shownMessage } from "./protocol/messages.ts";
 import { elapsedMs, startTrace, trace, type TraceFields } from "./trace.ts";
 
@@ -59,6 +59,12 @@ export interface OptionSpec {
   max?: number;
   /** The value when the option is not given. */
   default?: number | string;
+  /**
+   * path only: the command writes there, a file or files in a folder. The
+   * path is checked before the command runs (checkOutputPath). Every option
+   * --out and --out-<name> has it.
+   */
+  output?: OutputKind;
 }
 
 /** The options that have one meaning in every script. A command can change the help, the value and whether it is required, never the kind. */
@@ -157,7 +163,7 @@ export class Call {
 
   /** The knowledge space of the command: --space, else c64. */
   get space(): string {
-    return "space" in this.#options ? this.string("space")! : "c64";
+    return ("space" in this.#options ? this.string("space") : undefined) ?? "c64";
   }
 
   /** Subject `index` as text. */
@@ -339,6 +345,8 @@ function commandOptions(command: CommandSpec): Record<string, OptionSpec> {
     const shared = (OPTIONS as Record<string, OptionSpec>)[name];
     if (shared !== undefined && shared.kind !== spec.kind) throw fault(`--${name} of ${command.name} is a ${spec.kind}, but OPTIONS has it as a ${shared.kind}`);
     if (name === "help" || name === "project") throw fault(`--${name} of ${command.name}: the contract owns this option`);
+    if (spec.kind === "path" && (name === "out" || name.startsWith("out-")) && spec.output === undefined) throw fault(`--${name} of ${command.name} has no output kind (file or folder)`);
+    if (spec.output !== undefined && spec.kind !== "path") throw fault(`--${name} of ${command.name} has an output kind, but it is a ${spec.kind}, not a path`);
   }
   return options;
 }
@@ -391,9 +399,49 @@ function checkPath(text: string, what: string): void {
   }
 }
 
+/**
+ * Refuses a range in two parts: two subjects '$1bc2' '$1bd0' where the command
+ * takes one <range>, or --start and --end where it takes a range option. The
+ * message gives the range as one token.
+ */
+function refuseSplitRange(command: CommandSpec, options: Readonly<Record<string, OptionSpec>>, argv: readonly string[], subjects?: readonly string[]): void {
+  if (subjects === undefined) {
+    const end = argv.indexOf("--");
+    const words = end < 0 ? argv : argv.slice(0, end);
+    const valueOf = (name: string) => {
+      const index = words.findIndex((word) => word === `--${name}` || word.startsWith(`--${name}=`));
+      if (index < 0) return undefined;
+      const word = words[index]!;
+      return word.includes("=") ? word.slice(word.indexOf("=") + 1) : (words[index + 1] ?? "");
+    };
+    const [start, last] = [valueOf("start"), valueOf("end")];
+    const range = Object.entries(options).find(([, spec]) => spec.kind === "range")?.[0];
+    if ((start === undefined && last === undefined) || range === undefined || "start" in options || "end" in options) return;
+    throw new UsageError(`${command.name} takes no --start or --end. Give the range as one option: --${range} '${start || "<start>"}-${last || "<end>"}'`);
+  }
+  const specs = command.subjects ?? [];
+  for (let index = 0; index + 1 < subjects.length; index++) {
+    const spec = specs[Math.min(index, specs.length - 1)];
+    const [first, second] = [subjects[index]!, subjects[index + 1]!];
+    if (spec === undefined || !spec.name.includes("range") || rangeParts(first) !== undefined || !isAddressText(first) || c64AddressOf(second) === undefined) continue;
+    throw new UsageError(`${spec.name} is one token <start>-<end>: give '${first}-${second}', not '${first}' '${second}'`);
+  }
+}
+
+/**
+ * Refuses an output path before the command does any work: a path that
+ * leaves the project, a path in the knowledge, a folder where a file must be,
+ * a file where a folder must be, or a folder that cannot be written.
+ */
+function checkOutput(text: string, what: string, kind: OutputKind): void {
+  checkPath(text, what);
+  checkOutputPath(text, kind, { root: projectRoot(), what });
+}
+
 /** Parses the command line of one command. Refuses a wrong count of subjects, an unknown option, a missing required option or a value of the wrong form. */
 export function parseCall(script: ScriptSpec, command: CommandSpec, argv: readonly string[]): Call {
   const options = commandOptions(command);
+  refuseSplitRange(command, options, argv);
   let parsed: ReturnType<typeof parseArgs>;
   try {
     parsed = parseArgs({
@@ -407,6 +455,7 @@ export function parseCall(script: ScriptSpec, command: CommandSpec, argv: readon
   }
   const values = parsed.values as Record<string, string | boolean | string[] | undefined>;
   const subjects = parsed.positionals;
+  refuseSplitRange(command, options, argv, subjects);
   const specs = command.subjects ?? [];
   const last = specs.at(-1);
   const least = specs.filter((subject) => !subject.optional).length;
@@ -428,7 +477,10 @@ export function parseCall(script: ScriptSpec, command: CommandSpec, argv: readon
       if (spec.kind === "range" && rangeParts(text) === undefined) throw new UsageError(`--${name} must be <start>-<end>, each ${ADDRESS_FORM}, for example '$c000-$cfff', not ${JSON.stringify(text)}`);
       if (spec.kind === "space" && !SPACE_PATTERN.test(text)) throw new UsageError(`--${name} must be c64, drive8, or bank0 to bank255, not ${JSON.stringify(text)}`);
       if (spec.kind === "choice" && !(spec.choices ?? []).includes(text)) throw new UsageError(`--${name} must be one of ${(spec.choices ?? []).join(", ")}, not ${JSON.stringify(text)}`);
-      if (spec.kind === "path") checkPath(text, `--${name}`);
+      if (spec.kind === "path") {
+        if (spec.output === undefined) checkPath(text, `--${name}`);
+        else checkOutput(text, `--${name}`, spec.output);
+      }
     }
   }
   const call = new Call(script.name, command.name, subjects, options, values, script.names);