romdevtools 0.14.0 → 0.16.0

package/src/platforms/sms/lib/c/vdp_init.c

@@ -3,15 +3,17 @@
  * Writes the 11 mode-4 registers to a sane baseline:
  *   display OFF, vblank IRQ off, 192-line mode 4, name table at $3800,
  *   BG tile data at $0000, sprite attr table at $3F00, sprite tile data
- *   at $0000 (R6=0xFB → SA13 clear → tiles read from $0000-$1FFF). Call
+ *   at $2000 (R6=0xFF → SA13 set → tiles read from $2000-$3FFF). Call
  *   once after reset before uploading palette/tiles/map.
  *
- * Footgun: many SMS references say "R6=0xFB → sprite tiles at $2000"
- * which is BACKWARDS. R6 bit 2 (the SA13 select) is CLEAR in 0xFB, so
- * sprite tiles read from $0000 (sharing the bank with BG tiles). To
- * separate sprite tiles to $2000, set R6 = 0xFF instead. The
- * sprites({op:'inspect'}) tool's spriteTileDataBase field will show you the
- * real address the VDP is reading from.
+ * Sprite-tile base: R6 bit 2 (SA13) selects $0000 (clear) vs $2000 (set).
+ * We default to R6=0xFF ($2000) because EVERY bundled scaffold uploads its
+ * sprite tiles to $2000 (sms_load_tiles(0x2000, ...)) — so the baseline must
+ * match what consumers do, or sprites read from the empty/BG bank and render
+ * invisible. (Many SMS references say "R6=0xFB → $2000", which is backwards:
+ * 0xFB has SA13 CLEAR = $0000.) If you instead keep sprite tiles in the BG
+ * bank at $0000, set R6=0xFB. sprites({op:'inspect'}) → spriteTileDataBase
+ * shows the address the VDP is actually reading from.
  *
  * After loading assets, enable display by re-writing R1 with bit 6 set:
  *   sms_vdp_display_on();
@@ -33,7 +35,7 @@ void sms_vdp_init(void) {
     0xFF,  /* R3:  color table (ignored in M4) */
     0xFF,  /* R4:  BG tile data at $0000 */
     0xFF,  /* R5:  sprite attr table at $3F00 */
-    0xFB,  /* R6:  sprite tile data at $0000 (set 0xFF for $2000) */
+    0xFF,  /* R6:  sprite tile data at $2000 (SA13 set; scaffolds upload here) */
     0x00,  /* R7:  border = sprite palette entry 0 */
     0x00,  /* R8:  BG X scroll */
     0x00,  /* R9:  BG Y scroll */

package/src/platforms/sms/lib/vdp_init.s

@@ -40,7 +40,7 @@ _vdp_init_regs:
         .db $FF                  ; R3: color table — M4 ignores
         .db $FF                  ; R4: BG tile data — M4: bit 2 selects $0000 vs $2000
         .db $FF                  ; R5: sprite attr table base ($3F00 = $7E << 7)
-        .db $FB                  ; R6: sprite tile data — bit 2 selects bank ($2000 here)
+        .db $FF                  ; R6: sprite tile data at $2000 (SA13 set; scaffolds upload here)
         .db $00                  ; R7: border color = sprite palette entry 0
         .db $00                  ; R8: BG X scroll
         .db $00                  ; R9: BG Y scroll

package/src/toolchains/cc65/cc65.js

@@ -257,7 +257,14 @@ export function parseRamUsage(mapText) {
  * @param {string} [args.linkerConfig] custom ld65 .cfg (overrides per-target default)
  */
 export async function buildC(args) {
-  const ccOpts = args.debug ? ["-g"] : [];
+  // Enable cc65's high-value warnings so the agent SEES real bugs (parsed into
+  // structured issues[]). These are the valid cc65 -W names that catch actual
+  // mistakes; unused-param is left off (scaffold callbacks commonly ignore
+  // params). cc65's warning set is thin to begin with, but errors always surface
+  // and these are pure upside. (NOTE: cc65 errors on an unknown -W name, so this
+  // list is verified valid against the bundled cc65.)
+  const ccWarn = ["-W", "unused-var,unused-func,unused-label,const-comparison,struct-param,pointer-sign"];
+  const ccOpts = args.debug ? ["-g", ...ccWarn] : [...ccWarn];
   const caOpts = args.debug ? ["-g"] : [];
   const sources = normalizeSources(args, "main.c");
 

package/src/toolchains/cc65/presets/nes/chr-ram-runtime.cfg

@@ -12,7 +12,7 @@
 #     runtime. There is no CHARS segment.
 #
 # To use this preset:
-#   1. linkerConfig: "chr-ram" on buildSource
+#   1. linkerConfig: "chr-ram" on build({output:'rom'})
 #   2. Supply your own crt0/header source that writes the 16-byte iNES
 #      header with byte 5 = 0. Easiest: paste the snippet
 #      getStarterSnippet({platform:"nes", name:"chr_ram_header", language:"asm"}).

package/src/toolchains/cc65/presets/nes/chr-ram.cfg

@@ -12,7 +12,7 @@
 #     runtime. There is no CHARS segment.
 #
 # To use this preset:
-#   1. linkerConfig: "chr-ram" on buildSource
+#   1. linkerConfig: "chr-ram" on build({output:'rom'})
 #   2. Supply your own crt0/header source that writes the 16-byte iNES
 #      header with byte 5 = 0. Easiest: paste the snippet
 #      getStarterSnippet({platform:"nes", name:"chr_ram_header", language:"asm"}).

package/src/toolchains/cc65/presets/nes/chr-ram.crt0.s

@@ -91,7 +91,7 @@ _exit:  jsr     donelib
 ;       rti
 ;
 ;   ; then DELETE the `nmi: rti` line below from this crt0 (or load a
-;   ; modified crt0 via your own buildSource sources entry).
+;   ; modified crt0 via your own build({output:'rom'}) sources entry).
 
 .segment "STARTUP"
 

package/src/toolchains/gba-c/gba-c.js

@@ -92,7 +92,12 @@ export async function buildGbaC(args) {
   // per-symbol `.bss.<name>`/`.data.<name>` line — that's what lets
   // symbols({op:'resolve'}) turn a static C global's name into an address on GBA
   // (same as SGDK does for Genesis). Pure metadata; no codegen change to what's kept.
-  const cc1Options = args.cc1Options ?? ["-O2", "-mthumb", "-ffunction-sections", "-fdata-sections"];
+  // -Wall -Wextra so the agent SEES warnings (unused vars, implicit decls,
+  // sign-compare, etc.) — they're parsed into structured issues[]. Without these
+  // gcc is silent and agents build blind. -Wno-unused-parameter keeps the common
+  // intentional `(void)`-style scaffold params from being noise. Applied to USER
+  // .c only (the libtonc/maxmod SDK is a prebuilt seed, not recompiled here).
+  const cc1Options = args.cc1Options ?? ["-O2", "-mthumb", "-ffunction-sections", "-fdata-sections", "-Wall", "-Wextra", "-Wno-unused-parameter"];
   const sources = normalizeGbaSources(args);
   const binaryIncludes = args.binaryIncludes ?? {};
 

package/src/toolchains/genesis-c/README.md

@@ -23,7 +23,7 @@ once the WASM artifacts ship. Pipeline shape:
 - **WASM port of cc1/as/ld (stage 2)**: pending.
 - **SGDK native build against the cross-toolchain (stage 3)**: pending.
 - **JS driver `buildGenesisC()`**: pending.
-- **buildSource wiring**: pending.
+- **build({output:'rom'}) wiring**: pending.
 
 ## Why a 3-stage build
 

package/src/toolchains/genesis-c/genesis-c.js

@@ -264,6 +264,12 @@ async function buildWithSgdk({ sources, headers, binaryIncludes, cc1Options, reb
     "-fdata-sections",
     ...cc1Options,
   ];
+  // USER source gets warnings on so the agent SEES its bugs (unused vars,
+  // implicit decls, …) parsed into structured issues[]. The SGDK runtime is
+  // compiled WITHOUT these (sgdkCc1Options) — we can't fix SDK warnings and they'd
+  // bury the agent's own. -Wno-unused-parameter avoids the common `(void)hard`
+  // scaffold-param noise.
+  const userCc1Options = [...sgdkCc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter"];
 
   // ── Stage A: gather SGDK headers (visible to tcc via tcc-style flat mount) ──
   // cc1's -iquote /work picks up sibling files mounted alongside main.c.
@@ -280,7 +286,7 @@ async function buildWithSgdk({ sources, headers, binaryIncludes, cc1Options, reb
     const cc = await runCc1m68k({
       source: sources[cName],
       headers: tccHeaders,
-      options: sgdkCc1Options,
+      options: userCc1Options,
     });
     log += `--- cc1 (${cName}) ---\n` + (cc.log || "(ok)") + "\n";
     if (cc.exitCode !== 0 || !cc.asmSource) {
@@ -469,12 +475,14 @@ async function buildMinimal(args) {
   // ── Stage 1: compile each .c file via cc1 → .s ─────────────────
   /** @type {Record<string, Uint8Array>} */
   const userObjs = {};
+  // User .c gets warnings on (minimal path has no SDK to flood). See buildWithSgdk.
+  const userCc1Options = [...cc1Options, "-Wall", "-Wextra", "-Wno-unused-parameter"];
   const cFiles = Object.keys(sources).filter((n) => /\.c$/i.test(n));
   for (const cName of cFiles) {
     const cc = await runCc1m68k({
       source: sources[cName],
       headers,
-      options: cc1Options,
+      options: userCc1Options,
     });
     log += `--- cc1 (${cName}) ---\n` + (cc.log || "(ok)") + "\n";
     if (cc.exitCode !== 0 || !cc.asmSource) {

package/src/toolchains/parse-errors.js

@@ -41,10 +41,12 @@ export function parseBuildLog(log) {
     } else if (/^vasm/.test(baseStage)) {
       issues.push(...parseVasm(text));
     } else if (/^sdcc$|^sdasz80$|^sdasgb$|^sdld$|^mcpp$/.test(baseStage)) {
-      // SDCC family: sdcc / sdasz80 / sdasgb / sdld / mcpp emit cc65-style
-      // `file:line: severity: msg` errors. Tag with the actual originating
-      // tool, not "asar" (the old fallback was wrong).
+      // SDCC family: sdcc / sdasz80 / sdasgb / sdld / mcpp. Some diagnostics use
+      // the cc65-style `file:line: Error: msg`; SDCC's frontend ALSO emits a
+      // keyword-less form — `main.c:2: syntax error: token -> ';' ; column 44`
+      // and `main.c:N: warning NNN: msg` — which parseCc65Like misses. Run both.
       issues.push(...parseCc65Like(text, baseStage));
+      issues.push(...parseSdcc(text, baseStage));
     } else if (/^wla|^wlalink|^wladx/.test(baseStage)) {
       // SNES C path: wla-65816 assembler + wlalink linker. wlalink floods a
       // symbol-table dump on failure — parseWla extracts just the diagnostics.
@@ -60,11 +62,18 @@ export function parseBuildLog(log) {
       // Tag everything with the (possibly empty) actual stage name so an
       // assembler error doesn't mistakenly report as "asar" on a non-SNES
       // build.
+      // Try EVERY parser — some toolchains (vasm genesis-asm) emit no
+      // "--- stage ---" marker, so the whole log lands here unnamed; if we skip
+      // a parser the error is silently swallowed (issues[] empty on a real
+      // failure). Include vasm + sdcc + wla, which the old fallback omitted.
       const tag = baseStage || "unknown";
       issues.push(...parseCc65Like(text, tag));
+      issues.push(...parseSdcc(text, tag));
       issues.push(...parseDasm(text));
       issues.push(...parseAsar(text, tag));
       issues.push(...parseRgbds(text, tag));
+      issues.push(...parseVasm(text));
+      issues.push(...parseWla(text, tag));
       issues.push(...parseGnuToolchain(text, tag));
     }
   }
@@ -122,6 +131,57 @@ function parseCc65Like(text, stage) {
   return out;
 }
 
+// SDCC's keyword-less diagnostics that parseCc65Like (which requires an explicit
+// "Error:"/"Warning:" word) doesn't catch:
+//   /work/main.c:2: syntax error: token -> ';' ; column 44
+//   /work/main.c:7: warning 112: function 'foo' implicit declaration
+//   /work/main.c:9: error 20: undefined identifier 'x'
+// We classify by the leading word after `file:line:` (syntax error / error / warning).
+function parseSdcc(text, stage) {
+  const out = [];
+  const re = /^(?<file>[^\n:]+):(?<line>\d+):\s*(?<kind>syntax error|error(?:\s+\d+)?|warning(?:\s+\d+)?):?\s*(?<msg>.*)$/gm;
+  let m;
+  while ((m = re.exec(text))) {
+    const kind = m.groups.kind.toLowerCase();
+    // Skip the forms parseCc65Like already caught ("Error:" capitalized w/ colon)
+    // — this regex is case-insensitive on `error`/`warning`, but parseCc65Like
+    // only matches when a colon immediately follows the keyword AND it's
+    // capitalized; SDCC's lowercase keyword-less form is what we add here.
+    const severity = kind.startsWith("warning") ? "warning"
+      : (kind.startsWith("error") || kind === "syntax error") ? "error" : "info";
+    const message = kind === "syntax error"
+      ? ("syntax error: " + m.groups.msg).trim().replace(/\s*;\s*$/, "")
+      : m.groups.msg.trim();
+    out.push({
+      severity,
+      file: m.groups.file,
+      line: parseInt(m.groups.line, 10),
+      message: message.replace(/\x1b\[[0-9;]*m/g, ""),
+      stage,
+    });
+  }
+  // sdld/ASlink linker diagnostics have NO file:line — they reference a symbol +
+  // module. The most common is an undefined symbol (a call to a function that was
+  // never defined/linked). Without parsing these the agent sees "build failed"
+  // with no reason in issues[] (the error lived only in the raw log).
+  //   ?ASlink-Warning-Undefined Global '_foo' referenced by module '_main'
+  //   ?ASlink-Error-...
+  const linkRe = /^\?ASlink-(?<sev>Warning|Error)-(?<msg>.+)$/gm;
+  let lm;
+  while ((lm = linkRe.exec(text))) {
+    const msg = lm.groups.msg.trim();
+    // An "Undefined Global" is effectively an error even though ASlink labels it
+    // a warning — the ROM won't run. Promote it so the agent treats it as fatal.
+    const isUndef = /undefined\s+global/i.test(msg);
+    out.push({
+      severity: lm.groups.sev === "Error" || isUndef ? "error" : "warning",
+      message: "linker: " + msg,
+      stage: "sdld",
+    });
+  }
+  return out;
+}
+
 // dasm example:
 //   main.asm (1): error: Unknown Mnemonic 'is'.
 function parseDasm(text) {
@@ -248,13 +308,15 @@ function parseWla(text, stage = "wla") {
 // vasm example:
 //   error 22 in line 5 of "/work/main.s": ...
 //   warning 1003 in line 8 of "main.s": ...
+//   fatal error 13 in line 1 of "/work/main.s": could not open <x.bin> for input
+//     (← a MISSING incbin asset: the #1 thing an agent forgets to pass)
 function parseVasm(text) {
   const out = [];
-  const re = /^(?<sev>error|warning)\s+\d+\s+in\s+line\s+(?<line>\d+)\s+of\s+"(?<file>[^"]+)":\s*(?<msg>.+)$/gm;
+  const re = /^(?<sev>fatal error|error|warning)\s+\d+\s+in\s+line\s+(?<line>\d+)\s+of\s+"(?<file>[^"]+)":\s*(?<msg>.+)$/gm;
   let m;
   while ((m = re.exec(text))) {
     out.push({
-      severity: m.groups.sev,
+      severity: m.groups.sev === "warning" ? "warning" : "error",
       file: m.groups.file,
       line: parseInt(m.groups.line, 10),
       message: m.groups.msg.trim(),

package/src/toolchains/sdcc/preflight-lint.js

@@ -68,13 +68,53 @@ export function lintSdccSource(source, file = "main.c", opts = {}) {
   // CONSERVATIVE: only flag when we can SEE the counter declared u8 and
   // the bound is a constant we can evaluate — never guess.
   {
-    // Collect names declared as 8-bit ints anywhere in the file.
-    const u8re = /\b(?:unsigned\s+char|char|u8|uint8_t|uint8|int8_t|int8|signed\s+char)\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*;/g;
-    const u8names = new Set();
-    let dm;
-    while ((dm = u8re.exec(source))) {
-      for (const n of dm[1].split(",")) u8names.add(n.trim());
+    // Build a SCOPE-AWARE map of where each name is declared and at what
+    // width. A name like `i` is commonly re-declared in several functions
+    // — some as uint8_t, some as uint16_t. A flat "is this name ever u8"
+    // set wrongly flags the uint16_t loop just because a DIFFERENT
+    // function declared its own `i` as uint8_t (the SMS/GG default
+    // scaffold false-positive). Instead we record EVERY declaration's
+    // line + width, then for each loop consult the nearest declaration of
+    // the counter that appears ABOVE the loop — i.e. the one actually in
+    // scope — and only flag it when that declaration is 8-bit.
+    //
+    // decls: Map<name, Array<{line:number, u8:boolean}>>  (line is 1-based)
+    const decls = new Map();
+    const addDecl = (names, line, u8) => {
+      for (const raw of names.split(",")) {
+        const n = raw.trim();
+        if (!n) continue;
+        if (!decls.has(n)) decls.set(n, []);
+        decls.get(n).push({ line, u8 });
+      }
+    };
+    const u8re   = /\b(?:unsigned\s+char|char|u8|uint8_t|uint8|int8_t|int8|signed\s+char)\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*;/;
+    // 16-bit-or-wider integer declarations (and float/double, which also
+    // can't overflow at 255). Anything not 8-bit is "wide" for our purpose.
+    const wideRe = /\b(?:unsigned\s+(?:short|int|long)|signed\s+(?:short|int|long)|short|int|long|u16|u32|u64|uint16_t|uint16|int16_t|int16|uint32_t|uint32|int32_t|int32|uint64_t|uint64|int64_t|int64|size_t|ptrdiff_t)\s+([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*;/;
+    for (let i = 0; i < lines.length; i++) {
+      const code = lines[i].replace(/\/\/.*$/, "").replace(/\/\*.*?\*\//g, "");
+      const m8 = code.match(u8re);
+      if (m8) { addDecl(m8[1], i + 1, true); continue; }
+      const mw = code.match(wideRe);
+      if (mw) addDecl(mw[1], i + 1, false);
     }
+    // Is the counter declared 8-bit in the scope visible at `loopLine`?
+    // Use the NEAREST declaration above the loop. If the nearest visible
+    // declaration is wide (uint16_t etc.), the loop is fine.
+    const counterIsU8AtLine = (counter, loopLine) => {
+      const ds = decls.get(counter);
+      if (!ds) return false;
+      let best = null;
+      for (const d of ds) {
+        if (d.line <= loopLine && (best === null || d.line > best.line)) best = d;
+      }
+      // No declaration above the loop (e.g. param/global declared after, or
+      // out-of-order) — fall back to "flag only if EVERY decl is u8" so we
+      // never wolf-cry on a name that is also declared wide somewhere.
+      if (best === null) return ds.every((d) => d.u8);
+      return best.u8;
+    };
     const evalConst = (expr) => {
       // Only literals and pure `A * B [* C]` products of decimal/hex ints.
       const t = expr.trim();
@@ -91,7 +131,7 @@ export function lintSdccSource(source, file = "main.c", opts = {}) {
       const m = code.match(/\bfor\s*\([^;]*;\s*([A-Za-z_]\w*)\s*<\s*([^;]+?)\s*;/);
       if (!m) continue;
       const [, counter, boundExpr] = m;
-      if (!u8names.has(counter)) continue;
+      if (!counterIsU8AtLine(counter, i + 1)) continue;
       const bound = evalConst(boundExpr);
       if (bound !== null && bound > 255) {
         issues.push({

package/src/toolchains/snes-c/snes-c.js

@@ -148,13 +148,9 @@ function normalizeSnesSources(args) {
     if (cFiles.length === 0) {
       throw new Error("buildSnesC: `sources` must include at least one .c file.");
     }
-    if (cFiles.length > 1) {
-      throw new Error(
-        `buildSnesC: multiple .c files in sources (${cFiles.join(", ")}). ` +
-        `Today only one .c file is supported per build — combine via #include or wait for ` +
-        `multi-TU support. .asm/.s siblings work fine.`,
-      );
-    }
+    // Multiple .c files ARE supported: buildWithPvSnesLib compiles each to its
+    // own .obj (tcc→wla) and links them all (Stage 1 + Stage 3). The genre
+    // scaffolds ship main.c + snes_sfx.c and rely on this.
     return args.sources;
   }
   if (typeof args.source === "string") {