web-a2e 1.0.0

package/src/js/debug/soft-switch-window.js

@@ -0,0 +1,458 @@
+/*
+ * soft-switch-window.js - Soft switch monitor window displaying switch states and addresses
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+import { BaseWindow } from "../windows/base-window.js";
+
+export class SoftSwitchWindow extends BaseWindow {
+  constructor(wasmModule) {
+    super({
+      id: "soft-switches",
+      title: "Soft Switches",
+      minWidth: 325,
+      minHeight: 200,
+      maxWidth: 325,
+      maxHeight: Infinity,
+      defaultWidth: 325,
+      defaultHeight: 500,
+    });
+
+    this.wasmModule = wasmModule;
+
+    // Define all soft switches with their bit positions, addresses, and descriptions
+    // Bit positions match the 64-bit state returned by getSoftSwitchState/getSoftSwitchStateHigh
+    this.switchGroups = [
+      {
+        title: "Display Mode",
+        switches: [
+          {
+            id: "text",
+            bit: 0,
+            name: "TEXT",
+            addr: "$C050/51",
+            desc: "Text mode",
+          },
+          {
+            id: "mixed",
+            bit: 1,
+            name: "MIXED",
+            addr: "$C052/53",
+            desc: "Mixed text+graphics",
+          },
+          {
+            id: "page2",
+            bit: 2,
+            name: "PAGE2",
+            addr: "$C054/55",
+            desc: "Display page 2",
+          },
+          {
+            id: "hires",
+            bit: 3,
+            name: "HIRES",
+            addr: "$C056/57",
+            desc: "Hi-res graphics",
+          },
+          {
+            id: "col80",
+            bit: 4,
+            name: "80COL",
+            addr: "$C00C/0D",
+            desc: "80 column mode",
+          },
+          {
+            id: "altchar",
+            bit: 5,
+            name: "ALTCHAR",
+            addr: "$C00E/0F",
+            desc: "Alt charset (MouseText)",
+          },
+          {
+            id: "dhires",
+            bit: 28,
+            name: "DHIRES",
+            addr: "computed",
+            desc: "Double hi-res active",
+          },
+        ],
+      },
+      {
+        title: "Memory Banking",
+        switches: [
+          {
+            id: "store80",
+            bit: 6,
+            name: "80STORE",
+            addr: "$C000/01",
+            desc: "PAGE2 selects aux mem",
+          },
+          {
+            id: "ramrd",
+            bit: 7,
+            name: "RAMRD",
+            addr: "$C002/03",
+            desc: "Read from aux RAM",
+          },
+          {
+            id: "ramwrt",
+            bit: 8,
+            name: "RAMWRT",
+            addr: "$C004/05",
+            desc: "Write to aux RAM",
+          },
+          {
+            id: "intcxrom",
+            bit: 9,
+            name: "INTCXROM",
+            addr: "$C006/07",
+            desc: "Internal $Cxxx ROM",
+          },
+          {
+            id: "altzp",
+            bit: 10,
+            name: "ALTZP",
+            addr: "$C008/09",
+            desc: "Aux zero page/stack",
+          },
+          {
+            id: "slotc3rom",
+            bit: 11,
+            name: "SLOTC3ROM",
+            addr: "$C00A/0B",
+            desc: "Slot 3 ROM enabled",
+          },
+          {
+            id: "intc8rom",
+            bit: 12,
+            name: "INTC8ROM",
+            addr: "internal",
+            desc: "Internal $C800 ROM",
+          },
+        ],
+      },
+      {
+        title: "Language Card",
+        switches: [
+          {
+            id: "lcram",
+            bit: 13,
+            name: "LCRAM",
+            addr: "$C080-8F",
+            desc: "LC RAM read enabled",
+          },
+          {
+            id: "lcbank2",
+            bit: 14,
+            name: "LCBANK2",
+            addr: "$C080-8F",
+            desc: "LC bank 2 selected",
+          },
+          {
+            id: "lcwrite",
+            bit: 15,
+            name: "LCWRITE",
+            addr: "$C080-8F",
+            desc: "LC RAM write enabled",
+          },
+          {
+            id: "lcprewrite",
+            bit: 16,
+            name: "LCPREWRT",
+            addr: "$C080-8F",
+            desc: "LC pre-write state",
+          },
+        ],
+      },
+      {
+        title: "Annunciators",
+        switches: [
+          {
+            id: "an0",
+            bit: 17,
+            name: "AN0",
+            addr: "$C058/59",
+            desc: "Annunciator 0",
+          },
+          {
+            id: "an1",
+            bit: 18,
+            name: "AN1",
+            addr: "$C05A/5B",
+            desc: "Annunciator 1",
+          },
+          {
+            id: "an2",
+            bit: 19,
+            name: "AN2",
+            addr: "$C05C/5D",
+            desc: "Annunciator 2",
+          },
+          {
+            id: "an3",
+            bit: 20,
+            name: "AN3",
+            addr: "$C05E/5F",
+            desc: "Annunciator 3 / DHIRES",
+          },
+        ],
+      },
+      {
+        title: "I/O Status",
+        switches: [
+          {
+            id: "vblbar",
+            bit: 21,
+            name: "VBLBAR",
+            addr: "$C019",
+            desc: "Vertical blank",
+            readOnly: true,
+          },
+          {
+            id: "cassout",
+            bit: 22,
+            name: "CASSOUT",
+            addr: "$C020",
+            desc: "Cassette output",
+          },
+          {
+            id: "cassin",
+            bit: 23,
+            name: "CASSIN",
+            addr: "$C060",
+            desc: "Cassette input",
+            readOnly: true,
+          },
+        ],
+      },
+      {
+        title: "Buttons",
+        switches: [
+          {
+            id: "btn0",
+            bit: 24,
+            name: "BTN0",
+            addr: "$C061",
+            desc: "Open Apple / Button 0",
+            readOnly: true,
+          },
+          {
+            id: "btn1",
+            bit: 25,
+            name: "BTN1",
+            addr: "$C062",
+            desc: "Closed Apple / Button 1",
+            readOnly: true,
+          },
+          {
+            id: "btn2",
+            bit: 26,
+            name: "BTN2",
+            addr: "$C063",
+            desc: "Button 2 / Shift",
+            readOnly: true,
+          },
+        ],
+      },
+      {
+        title: "Keyboard",
+        switches: [
+          {
+            id: "keyavail",
+            bit: 27,
+            name: "KEYAVAIL",
+            addr: "$C000",
+            desc: "Key available (bit 7)",
+            readOnly: true,
+          },
+        ],
+      },
+      {
+        title: "Other",
+        switches: [
+          {
+            id: "ioudis",
+            bit: 29,
+            name: "IOUDIS",
+            addr: "$C07E/7F",
+            desc: "IOU disable (IIc)",
+          },
+        ],
+      },
+    ];
+
+    // Reference addresses (read-only status registers)
+    this.statusRegisters = [
+      { addr: "$C011", name: "RDLCBNK2", desc: "LC bank 2 selected" },
+      { addr: "$C012", name: "RDLCRAM", desc: "LC RAM read enabled" },
+      { addr: "$C013", name: "RDRAMRD", desc: "Aux RAM read" },
+      { addr: "$C014", name: "RDRAMWRT", desc: "Aux RAM write" },
+      { addr: "$C015", name: "RDCXROM", desc: "Internal $Cxxx ROM" },
+      { addr: "$C016", name: "RDALTZP", desc: "Aux zero page" },
+      { addr: "$C017", name: "RDC3ROM", desc: "Slot 3 ROM" },
+      { addr: "$C018", name: "RD80STORE", desc: "80STORE enabled" },
+      { addr: "$C019", name: "RDVBLBAR", desc: "Vertical blank" },
+      { addr: "$C01A", name: "RDTEXT", desc: "Text mode" },
+      { addr: "$C01B", name: "RDMIXED", desc: "Mixed mode" },
+      { addr: "$C01C", name: "RDPAGE2", desc: "Page 2" },
+      { addr: "$C01D", name: "RDHIRES", desc: "Hi-res mode" },
+      { addr: "$C01E", name: "RDALTCHAR", desc: "Alt charset" },
+      { addr: "$C01F", name: "RD80COL", desc: "80 column mode" },
+    ];
+
+    // Other I/O addresses (for reference)
+    this.ioAddresses = [
+      { addr: "$C010", name: "KBDSTRB", desc: "Clear keyboard strobe" },
+      { addr: "$C030", name: "SPKR", desc: "Speaker toggle" },
+      { addr: "$C040", name: "STROBE", desc: "Utility strobe" },
+      { addr: "$C064", name: "PDL0", desc: "Paddle 0 (joystick X)" },
+      { addr: "$C065", name: "PDL1", desc: "Paddle 1 (joystick Y)" },
+      { addr: "$C066", name: "PDL2", desc: "Paddle 2" },
+      { addr: "$C067", name: "PDL3", desc: "Paddle 3" },
+      { addr: "$C070", name: "PTRIG", desc: "Paddle trigger" },
+    ];
+
+    // Slot I/O ranges
+    this.slotRanges = [
+      { range: "$C090-9F", slot: 1, desc: "Slot 1 I/O" },
+      { range: "$C0A0-AF", slot: 2, desc: "Slot 2 I/O" },
+      { range: "$C0B0-BF", slot: 3, desc: "Slot 3 I/O" },
+      { range: "$C0C0-CF", slot: 4, desc: "Slot 4 I/O" },
+      { range: "$C0D0-DF", slot: 5, desc: "Slot 5 I/O" },
+      { range: "$C0E0-EF", slot: 6, desc: "Slot 6 I/O (Disk II)" },
+      { range: "$C0F0-FF", slot: 7, desc: "Slot 7 I/O" },
+    ];
+  }
+
+  renderContent() {
+    let html = '<div class="softswitch-content">';
+
+    // Render switch groups
+    for (const group of this.switchGroups) {
+      html += `
+        <div class="switch-group">
+          <div class="switch-group-title">${group.title}</div>
+          <div class="switch-list">
+      `;
+
+      for (const sw of group.switches) {
+        const readOnlyClass = sw.readOnly ? " read-only" : "";
+        html += `
+          <div class="switch-item${readOnlyClass}" id="sw-item-${sw.id}">
+            <span class="switch-addr">${sw.addr}</span>
+            <span class="switch-badge" id="sw-${sw.id}">${sw.name}</span>
+            <span class="switch-desc">${sw.desc}</span>
+          </div>
+        `;
+      }
+
+      html += `
+          </div>
+        </div>
+      `;
+    }
+
+    // Add collapsible reference section
+    html += `
+      <div class="switch-group reference-section">
+        <div class="switch-group-title collapsible" id="ref-toggle">
+          ▶ I/O Reference
+        </div>
+        <div class="switch-list reference-list hidden" id="ref-content">
+    `;
+
+    // Status registers
+    html += '<div class="ref-subtitle">Status Registers ($C011-$C01F)</div>';
+    for (const reg of this.statusRegisters) {
+      html += `
+        <div class="ref-item">
+          <span class="ref-addr">${reg.addr}</span>
+          <span class="ref-name">${reg.name}</span>
+          <span class="ref-desc">${reg.desc}</span>
+        </div>
+      `;
+    }
+
+    // Other I/O
+    html += '<div class="ref-subtitle">Other I/O</div>';
+    for (const io of this.ioAddresses) {
+      html += `
+        <div class="ref-item">
+          <span class="ref-addr">${io.addr}</span>
+          <span class="ref-name">${io.name}</span>
+          <span class="ref-desc">${io.desc}</span>
+        </div>
+      `;
+    }
+
+    // Slot I/O
+    html += '<div class="ref-subtitle">Slot I/O</div>';
+    for (const slot of this.slotRanges) {
+      html += `
+        <div class="ref-item">
+          <span class="ref-addr">${slot.range}</span>
+          <span class="ref-name">Slot ${slot.slot}</span>
+          <span class="ref-desc">${slot.desc}</span>
+        </div>
+      `;
+    }
+
+    html += `
+        </div>
+      </div>
+    `;
+
+    html += "</div>";
+    return html;
+  }
+
+  /**
+   * Called after content is rendered
+   */
+  onContentRendered() {
+    // Set up collapsible reference section
+    const toggle = this.contentElement.querySelector("#ref-toggle");
+    const content = this.contentElement.querySelector("#ref-content");
+
+    if (toggle && content) {
+      toggle.addEventListener("click", () => {
+        content.classList.toggle("hidden");
+        toggle.textContent = content.classList.contains("hidden")
+          ? "▶ I/O Reference"
+          : "▼ I/O Reference";
+      });
+    }
+
+  }
+
+  /**
+   * Update all soft switch states
+   */
+  update(wasmModule) {
+    this.wasmModule = wasmModule;
+
+    // Get both low and high 32-bit parts of the state
+    const stateLow = wasmModule._getSoftSwitchState();
+    const stateHigh = wasmModule._getSoftSwitchStateHigh
+      ? wasmModule._getSoftSwitchStateHigh()
+      : 0;
+
+    for (const group of this.switchGroups) {
+      for (const sw of group.switches) {
+        let isOn;
+        if (sw.bit < 32) {
+          isOn = (stateLow & (1 << sw.bit)) !== 0;
+        } else {
+          isOn = (stateHigh & (1 << (sw.bit - 32))) !== 0;
+        }
+
+        const badge = this.contentElement.querySelector(`#sw-${sw.id}`);
+        if (badge) {
+          badge.classList.toggle("active", isOn);
+        }
+      }
+    }
+  }
+}

package/src/js/debug/stack-viewer-window.js

@@ -0,0 +1,221 @@
+/*
+ * stack-viewer-window.js - Stack viewer debug window with live stack contents
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+import { BaseWindow } from "../windows/base-window.js";
+
+export class StackViewerWindow extends BaseWindow {
+  constructor(wasmModule) {
+    super({
+      id: "stack-viewer",
+      title: "Stack Viewer",
+      defaultWidth: 280,
+      defaultHeight: 400,
+      minWidth: 280,
+      minHeight: 250,
+      maxWidth: 280,
+    });
+    this.wasmModule = wasmModule;
+    this.previousSP = 0xff;
+    this.returnAddresses = new Set(); // Track likely return addresses
+  }
+
+  renderContent() {
+    return `
+      <div class="stack-info">
+        <span class="stack-sp-label">SP:</span>
+        <span class="stack-sp-value">$FF</span>
+        <span class="stack-depth-label">Depth:</span>
+        <span class="stack-depth-value">0</span>
+      </div>
+      <div class="stack-depth-bar">
+        <div class="stack-depth-fill"></div>
+      </div>
+      <div class="stack-call-stack" id="call-stack"></div>
+      <div class="stack-header">
+        <span class="stack-col-addr">Addr</span>
+        <span class="stack-col-value">Value</span>
+        <span class="stack-col-info">Info</span>
+      </div>
+      <div class="stack-content"></div>
+    `;
+  }
+
+  onContentRendered() {
+    this.spValueSpan = this.contentElement.querySelector(".stack-sp-value");
+    this.depthValueSpan =
+      this.contentElement.querySelector(".stack-depth-value");
+    this.depthFill = this.contentElement.querySelector(".stack-depth-fill");
+    this.contentDiv = this.contentElement.querySelector(".stack-content");
+  }
+
+  analyzeReturnAddress(lowByte, highByte) {
+    // Return addresses on 6502 are pushed as addr-1 (JSR pushes PC+2, which points to last byte of JSR)
+    const retAddr = ((highByte << 8) | lowByte) + 1;
+
+    if (retAddr > 0xffff) return null;
+
+    // Try to disassemble the instruction at the return address
+    const disasm = this.wasmModule._disassembleAt(retAddr);
+    if (disasm) {
+      const disasmStr = this.wasmModule.UTF8ToString(disasm);
+      // Extract just the instruction mnemonic
+      const match = disasmStr.match(/:\s*[0-9A-F ]+\s+(\w+)/);
+      if (match) {
+        return {
+          addr: retAddr,
+          instr: match[1],
+        };
+      }
+    }
+    return { addr: retAddr, instr: "???" };
+  }
+
+  isLikelyReturnAddress(sp, wasmModule) {
+    if (sp >= 0xfe) return false; // Need at least 2 bytes
+
+    const low = wasmModule._peekMemory(0x100 + sp + 1);
+    const high = wasmModule._peekMemory(0x100 + sp + 2);
+    const addr = ((high << 8) | low) + 1;
+
+    return wasmModule._isLikelyReturnAddress(addr & 0xffff);
+  }
+
+  update(wasmModule) {
+    if (!this.isVisible || !this.contentDiv) return;
+
+    const sp = wasmModule._getSP();
+    const stackDepth = 0xff - sp;
+
+    // Update SP display
+    this.spValueSpan.textContent = `$${this.formatHex(sp, 2)}`;
+    this.depthValueSpan.textContent = stackDepth.toString();
+
+    // Update depth bar (max depth is 256 bytes)
+    const depthPercent = (stackDepth / 256) * 100;
+    this.depthFill.style.width = `${depthPercent}%`;
+
+    // Color code depth bar
+    if (depthPercent > 80) {
+      this.depthFill.classList.add("danger");
+      this.depthFill.classList.remove("warning");
+    } else if (depthPercent > 60) {
+      this.depthFill.classList.add("warning");
+      this.depthFill.classList.remove("danger");
+    } else {
+      this.depthFill.classList.remove("warning", "danger");
+    }
+
+    // Build stack view (from top of stack down to SP)
+    let html = "";
+    let i = 0xff;
+    let skipReturnAddr = false;
+
+    while (i > sp) {
+      const addr = 0x100 + i;
+      const value = wasmModule._peekMemory(addr);
+      const isSP = i === sp + 1; // Current top of stack
+
+      // Try to detect return addresses (pairs of bytes)
+      let returnInfo = null;
+      let isReturnAddr = false;
+
+      if (i > sp + 1) {
+        // Check if this could be the high byte of a return address
+        const prevValue = wasmModule._peekMemory(0x100 + i - 1);
+        const testAddr = ((value << 8) | prevValue) + 1;
+
+        // Heuristic: return addresses typically point to ROM or program area
+        if (
+          (testAddr >= 0x0800 && testAddr < 0xc000) ||
+          (testAddr >= 0xd000 && testAddr <= 0xffff)
+        ) {
+          // Check if the instruction before the return address was a JSR
+          const beforeRet = testAddr - 3;
+          if (beforeRet >= 0) {
+            const possibleJSR = wasmModule._peekMemory(beforeRet);
+            if (possibleJSR === 0x20) {
+              // JSR opcode
+              isReturnAddr = true;
+              returnInfo = this.analyzeReturnAddress(prevValue, value);
+            }
+          }
+        }
+      }
+
+      const classes = ["stack-entry"];
+      if (isSP) classes.push("stack-top");
+      if (skipReturnAddr) {
+        classes.push("return-addr-low");
+        skipReturnAddr = false;
+      } else if (isReturnAddr) {
+        classes.push("return-addr-high");
+        skipReturnAddr = true;
+      }
+
+      let infoStr = "";
+      if (isReturnAddr && returnInfo) {
+        infoStr = `→ $${this.formatHex(returnInfo.addr, 4)} (${returnInfo.instr})`;
+      } else if (value >= 0x20 && value < 0x7f) {
+        infoStr = `'${String.fromCharCode(value)}'`;
+      }
+
+      html += `
+        <div class="${classes.join(" ")}">
+          <span class="stack-addr">$${this.formatHex(addr, 4)}</span>
+          <span class="stack-value">$${this.formatHex(value, 2)}</span>
+          <span class="stack-info-text">${infoStr}</span>
+        </div>
+      `;
+
+      i--;
+    }
+
+    // Add empty stack marker if stack is empty
+    if (stackDepth === 0) {
+      html = '<div class="stack-empty">Stack is empty</div>';
+    }
+
+    this.contentDiv.innerHTML = html;
+    this.previousSP = sp;
+
+    // Build call stack summary
+    this.updateCallStack(wasmModule, sp);
+  }
+
+  /**
+   * Build a call stack summary by walking the stack for return addresses.
+   * Display: current_PC → caller → caller → ...
+   */
+  updateCallStack(wasmModule, sp) {
+    const callStackEl = this.contentElement.querySelector("#call-stack");
+    if (!callStackEl) return;
+
+    const pc = wasmModule._getPC();
+    const count = wasmModule._getCallStack();
+
+    if (count === 0) {
+      callStackEl.innerHTML = "";
+      return;
+    }
+
+    // Read packed CallStackEntry structs (4 bytes each: uint16_t returnAddr, uint16_t jsrTarget)
+    const bufPtr = wasmModule._getCallStackBuffer();
+    const heap = wasmModule.HEAPU8;
+
+    let stackHtml = '<span class="call-stack-label">Call:</span> ';
+    stackHtml += `<span class="call-stack-addr">$${this.formatHex(pc, 4)}</span>`;
+
+    for (let i = 0; i < count; i++) {
+      const offset = bufPtr + i * 4;
+      const retAddr = heap[offset] | (heap[offset + 1] << 8);
+      const jsrTarget = heap[offset + 2] | (heap[offset + 3] << 8);
+      stackHtml += ` ← <span class="call-stack-addr" title="Returns to $${this.formatHex(retAddr, 4)}">$${this.formatHex(jsrTarget, 4)}</span>`;
+    }
+
+    callStackEl.innerHTML = stackHtml;
+  }
+}