romdevtools 0.15.0 → 0.21.0

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

@@ -0,0 +1,83 @@
+# NES CHR-ROM linker config preset for romdev (cc65-C with FIXED tile art).
+#
+# Use this when you write NES homebrew in C AND ship your pattern tables as a
+# fixed 8KB CHR-ROM blob (vs chr-ram-runtime, which has the CPU upload tiles to
+# CHR-RAM at runtime). The cartridge is NROM-256: 32KB PRG + 8KB CHR-ROM.
+#
+# DIFFERENCE FROM chr-ram-runtime.cfg:
+#   - Adds a ROM2 memory area (8KB CHR-ROM bank) + a CHARS segment. Put your
+#     tile data in `.segment "CHARS"` (e.g. `.incbin "tiles.chr"`); it lands in
+#     the CHR-ROM bank the PPU reads pattern tables from directly.
+#   - The companion crt0 (chr-rom.crt0.s) emits an iNES header with byte 5 = 1
+#     (one 8KB CHR-ROM bank) and does NOT clear CHR-RAM (there is none).
+#
+# To use this preset:
+#   1. linkerConfig: "chr-rom" on build({output:'rom'})  (pulls in chr-rom.crt0.s)
+#   2. Supply your tile art: a source with `.segment "CHARS"` + `.incbin
+#      "tiles.chr"`, plus the blob via binaryIncludePaths:{ "tiles.chr": path }.
+#      The CHARS segment must total exactly 8192 bytes (fill is on, so a short
+#      blob is padded; an over-long one errors).
+#   3. For a DIFFERENT cart config (NROM-128, >8KB CHR, a mapper, vertical
+#      mirroring), don't use this preset — use the parametric `inesHeader`
+#      build option instead (it generates the header + .cfg for any NROM shape).
+#
+# This is the cc65-C-with-segments shape. To rebuild a COMMERCIAL game from its
+# disassembly (one flat CODE blob with embedded vectors), use `inesHeader`.
+
+SYMBOLS {
+    __STACKSIZE__: type = weak, value = $0300;
+}
+MEMORY {
+    ZP:     file = "", start = $0002, size = $001A, type = rw, define = yes;
+
+    # iNES Cartridge Header — emitted by chr-rom.crt0.s (HEADER segment).
+    HEADER: file = %O, start = $0000, size = $0010, fill = yes;
+
+    # PRG-ROM: 2 × 16K = 32K (NROM-256).
+    ROM0:   file = %O, start = $8000, size = $7FFA, fill = yes, define = yes;
+
+    # Hardware vectors at end of PRG.
+    ROMV:   file = %O, start = $FFFA, size = $0006, fill = yes;
+
+    # CHR-ROM: one 8K bank. The PPU reads pattern tables straight from here —
+    # this is the whole point of the CHR-ROM preset.
+    ROM2:   file = %O, start = $0000, size = $2000, fill = yes, define = yes;
+
+    SRAM:   file = "", start = $0500, size = __STACKSIZE__, define = yes;
+
+    # BSS / DATA live in real RAM ($0300-$04FF, 512 bytes). NROM (mapper 0)
+    # with no battery has $6000-$7FFF UNMAPPED — don't put BSS there.
+    RAM:    file = "", start = $0300, size = $0200, define = yes;
+
+    # Shadow OAM at $0200 (page 2). NMI handler DMAs it to PPU sprite RAM.
+    OAM:    file = "", start = $0200, size = $0100;
+}
+SEGMENTS {
+    ZEROPAGE: load = ZP,              type = zp;
+    HEADER:   load = HEADER,          type = ro;
+    STARTUP:  load = ROM0,            type = ro,  define   = yes;
+    LOWCODE:  load = ROM0,            type = ro,  optional = yes;
+    ONCE:     load = ROM0,            type = ro,  optional = yes;
+    CODE:     load = ROM0,            type = ro,  define   = yes;
+    RODATA:   load = ROM0,            type = ro,  define   = yes;
+    DATA:     load = ROM0, run = RAM, type = rw,  define   = yes;
+    VECTORS:  load = ROMV,            type = rw;
+    CHARS:    load = ROM2,            type = ro;
+    BSS:      load = RAM,             type = bss, define   = yes;
+    OAM:      load = OAM,             type = bss, optional = yes;
+}
+FEATURES {
+    CONDES: type    = constructor,
+            label   = __CONSTRUCTOR_TABLE__,
+            count   = __CONSTRUCTOR_COUNT__,
+            segment = ONCE;
+    CONDES: type    = destructor,
+            label   = __DESTRUCTOR_TABLE__,
+            count   = __DESTRUCTOR_COUNT__,
+            segment = RODATA;
+    CONDES: type    = interruptor,
+            label   = __INTERRUPTOR_TABLE__,
+            count   = __INTERRUPTOR_COUNT__,
+            segment = RODATA,
+            import  = __CALLIRQ__;
+}

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

@@ -0,0 +1,153 @@
+; crt0 for NES CHR-ROM mode + nes_runtime NMI handler.
+;
+; Companion to the linkerConfig:"chr-rom" preset. Identical to
+; chr-ram-runtime.crt0.s EXCEPT:
+;   - the iNES header sets byte 5 = 1 (one 8KB CHR-ROM bank), and
+;   - there is NO CHR-RAM clear loop — pattern tables come from the CHR-ROM
+;     bank (the CHARS segment / ROM2 area) the PPU reads directly.
+;
+; The NMI handler is the canonical sprite-engine sequence (OAM DMA + VRAM-queue
+; flush + scroll + PPUCTRL), same as the CHR-RAM runtime.
+;
+; Loaded silently by the linkerConfig:"chr-rom" preset.
+
+        .export         _exit
+        .export         __STARTUP__ : absolute = 1
+        .export         start
+        .export         nmi
+        .export         irq
+        .export         _shadow_oam
+
+        .import         initlib, donelib, callmain
+        .import         _main, zerobss, copydata
+        .import         __RAM_START__, __RAM_SIZE__
+        .import         __SRAM_START__, __SRAM_SIZE__
+        .import         _vram_queue_flush
+        .import         _scroll_x, _scroll_y, _ppuctrl_value, _nmi_counter
+        .importzp       c_sp
+
+; ------------------------------------------------------------------------
+; 16-byte iNES header — CHR-ROM (byte 5 = 1 → one 8KB CHR-ROM bank).
+
+.segment "HEADER"
+        .byte   $4e, $45, $53, $1a   ; "NES" + EOF
+        .byte   2                    ; PRG-ROM banks (16K each) → 32K
+        .byte   1                    ; CHR-ROM banks (8K each)  → 8K CHR-ROM
+        .byte   %00000001            ; flags6 — vertical mirroring
+        .byte   %00000000            ; flags7 — mapper hi nybble
+        .byte   0, 0, 0, 0, 0, 0, 0, 0
+
+; ------------------------------------------------------------------------
+.segment "STARTUP"
+
+start:
+        sei
+        cld
+        ldx     #$ff
+        txs
+
+        ; Disable everything that could fire during init.
+        lda     #0
+        sta     $2000           ; disable NMI
+        sta     $2001           ; disable rendering
+        sta     $4010           ; disable DMC IRQ
+        sta     $4015           ; disable APU channels
+        bit     $2002           ; clear vblank flag
+
+        ; Wait two VBlanks before touching the PPU (standard NES init).
+@vbl1:  bit     $2002
+        bpl     @vbl1
+@vbl2:  bit     $2002
+        bpl     @vbl2
+
+        ; Initialise shadow_oam to Y=$FF (off-screen) before anything else.
+        ldx     #0
+        lda     #$ff
+@oam:   sta     _shadow_oam,x
+        inx
+        bne     @oam
+
+        ; NO CHR-RAM clear — pattern tables live in the CHR-ROM bank (CHARS).
+        ; Just point PPUADDR at the palette ($3F00) ready for the caller.
+        bit     $2002           ; reset PPUADDR latch
+        lda     #$3F
+        sta     $2006
+        lda     #$00
+        sta     $2006
+
+        ; Clear BSS + copy DATA (cc65 conventions).
+        jsr     zerobss
+        jsr     copydata
+
+        ; Set up cc65's C parameter stack pointer.
+        lda     #<(__SRAM_START__ + __SRAM_SIZE__)
+        ldx     #>(__SRAM_START__ + __SRAM_SIZE__)
+        sta     c_sp
+        stx     c_sp+1
+
+        jsr     initlib
+        jsr     callmain
+
+_exit:  jsr     donelib
+        jmp     start
+
+; ------------------------------------------------------------------------
+; NMI handler — runs every vblank when ppuctrl bit 7 is set.
+
+.segment "STARTUP"
+
+nmi:
+        pha
+        txa
+        pha
+        tya
+        pha
+
+        ; OAM DMA: copy 256 bytes from $0200 to PPU OAM. Takes 513 cycles.
+        lda     #$00
+        sta     $2003           ; PPU OAMADDR = 0
+        lda     #$02            ; high byte of $0200
+        sta     $4014           ; PPU OAMDMA — kicks off the copy
+
+        ; Flush the VRAM queue (nametable/palette writes game code stashed).
+        jsr     _vram_queue_flush
+
+        ; Reset PPUADDR to $2000 so the PPU doesn't sample random VRAM as BG.
+        bit     $2002
+        lda     #$20
+        sta     $2006
+        lda     #$00
+        sta     $2006
+
+        ; Set scroll (two PPUSCROLL writes: x then y).
+        lda     _scroll_x
+        sta     $2005
+        lda     _scroll_y
+        sta     $2005
+
+        ; Re-enable NMI + base nametable + pattern-table bits via cached PPUCTRL.
+        lda     _ppuctrl_value
+        sta     $2000
+
+        ; Tick the frame counter so ppu_wait_nmi can return.
+        inc     _nmi_counter
+
+        pla
+        tay
+        pla
+        tax
+        pla
+        rti
+
+irq:    rti
+
+; ------------------------------------------------------------------------
+; Shadow OAM at $0200 — the NMI handler DMAs this to the PPU each frame.
+.segment "OAM"
+_shadow_oam: .res 256
+
+; ------------------------------------------------------------------------
+.segment "VECTORS"
+        .word   nmi             ; $FFFA
+        .word   start           ; $FFFC
+        .word   irq             ; $FFFE

package/src/toolchains/common/reassemble.js

@@ -67,7 +67,7 @@ function firstDiff(a, b) {
 //   m68k (genesis)                            → objdump → m68k-elf-as/ld/objcopy
 //   arm (gba)                                 → objdump → arm-none-eabi-as/ld/objcopy
 
-const CPU_FAMILY = {
+export const CPU_FAMILY = {
   nes: "6502", c64: "6502", atari2600: "6502", atari7800: "6502", lynx: "6502",
   snes: "65816",
   sms: "z80", gg: "z80", msx: "z80",
@@ -254,7 +254,15 @@ async function reassembleGnuNative(disasm, startAddress, original, tools, family
     if (!pinned) { const n = codeIdx.find((i) => !forced.has(i)); if (n == null) break; forced.add(n); }
   }
   // Floor: clean all-`.byte` (proven byte-exact, no labels to perturb layout).
-  const rows = [".section .text", ".global _start", "_start:"];
+  // Mirror build()'s `.org` for the no-link (z80/gbz80) path: without it,
+  // objcopy emits the section from file offset 0, and assemble()'s
+  // `bin.slice(startAddress, …)` then returns bytes that are `startAddress`-short
+  // (empty for a $4000/$8000-based region) — so any non-zero-org region (MSX
+  // $4010, GB bank1 $4000, …) silently fails the floor. The linked path sets the
+  // origin via the link script, so it must NOT carry a redundant `.org`.
+  const rows = [".section .text", ".global _start"];
+  if (tools.noLink) rows.push(`.org 0x${startAddress.toString(16)}`);
+  rows.push("_start:");
   for (let i = 0; i < original.length; i += 16) rows.push("\t.byte " + Array.from(original.slice(i, i + 16)).map((b) => "0x" + b.toString(16).padStart(2, "0")).join(","));
   const r = await assemble(rows.join("\n") + "\n");
   const ok = r.ok && r.bytes.length === original.length && firstDiff(original, r.bytes) < 0;

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/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(),