web-a2e 1.0.0

package/tests/gcr/gcr-test.cpp

@@ -0,0 +1,142 @@
+// Simple GCR encoding/decoding test
+// Compile: g++ -std=c++17 -I../src/core/disk -o gcr-test gcr-test.cpp ../src/core/disk/gcr_encoding.cpp
+
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include "../src/core/disk/gcr_encoding.hpp"
+
+using namespace a2e;
+
+// 6-and-2 decoding table (reverse of ENCODE_6_AND_2)
+static constexpr std::array<int8_t, 256> DECODE_6_AND_2 = []() {
+  std::array<int8_t, 256> table{};
+  for (int i = 0; i < 256; i++) {
+    table[i] = -1; // Invalid by default
+  }
+  // Fill in valid mappings from the encode table
+  for (int i = 0; i < 64; i++) {
+    table[GCR::ENCODE_6_AND_2[i]] = static_cast<int8_t>(i);
+  }
+  return table;
+}();
+
+bool decode6and2(const uint8_t *encoded, uint8_t *output) {
+  // Decode 343 nibbles back to 256 bytes
+  uint8_t buffer[342];
+
+  // XOR decode (reverse of encode)
+  uint8_t prev = 0;
+  for (int i = 0; i < 342; i++) {
+    int8_t decoded = DECODE_6_AND_2[encoded[i]];
+    if (decoded < 0) {
+      std::cerr << "Invalid nibble at position " << i << ": 0x"
+                << std::hex << (int)encoded[i] << std::dec << std::endl;
+      return false;
+    }
+    buffer[i] = decoded ^ prev;
+    prev = buffer[i];
+  }
+
+  // Verify checksum
+  int8_t checksum_decoded = DECODE_6_AND_2[encoded[342]];
+  if (checksum_decoded < 0) {
+    std::cerr << "Invalid checksum nibble: 0x" << std::hex << (int)encoded[342] << std::dec << std::endl;
+  } else if ((prev & 0x3F) != (checksum_decoded & 0x3F)) {
+    std::cerr << "Checksum mismatch: expected 0x" << std::hex << (int)(prev & 0x3F)
+              << " got 0x" << (int)(checksum_decoded & 0x3F) << std::dec << std::endl;
+  }
+
+  // Reconstruct 256 bytes from auxiliary (86) and primary (256) buffers
+  for (int i = 0; i < 256; i++) {
+    // High 6 bits from primary buffer
+    uint8_t high = buffer[86 + i] << 2;
+
+    // Low 2 bits from auxiliary buffer
+    // NOTE: encode swaps bits 0,1, so decode must unswap
+    uint8_t aux_byte = buffer[i % 86];
+    int shift = (i / 86) * 2;
+    uint8_t raw = (aux_byte >> shift) & 0x03;
+    // Unswap: bit 0 <-> bit 1
+    uint8_t low = ((raw & 0x01) << 1) | ((raw & 0x02) >> 1);
+
+    output[i] = high | low;
+  }
+
+  return true;
+}
+
+int main() {
+  // Create a test sector with known data
+  uint8_t sector_data[256];
+  for (int i = 0; i < 256; i++) {
+    sector_data[i] = i; // Simple pattern: 0, 1, 2, ..., 255
+  }
+
+  std::cout << "Original sector data (first 32 bytes):" << std::endl;
+  for (int i = 0; i < 32; i++) {
+    std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)sector_data[i] << " ";
+    if ((i + 1) % 16 == 0) std::cout << std::endl;
+  }
+  std::cout << std::dec << std::endl;
+
+  // Encode using 6-and-2
+  std::vector<uint8_t> encoded = GCR::encode6and2(sector_data);
+
+  std::cout << "Encoded nibbles: " << encoded.size() << " bytes" << std::endl;
+  std::cout << "First 48 nibbles:" << std::endl;
+  for (int i = 0; i < 48; i++) {
+    std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)encoded[i] << " ";
+    if ((i + 1) % 16 == 0) std::cout << std::endl;
+  }
+  std::cout << std::dec << std::endl;
+
+  // Verify all nibbles have bit 7 set
+  int invalid_count = 0;
+  for (size_t i = 0; i < encoded.size(); i++) {
+    if (!(encoded[i] & 0x80)) {
+      std::cout << "Warning: nibble at position " << i << " doesn't have bit 7 set: 0x"
+                << std::hex << (int)encoded[i] << std::dec << std::endl;
+      invalid_count++;
+    }
+  }
+  if (invalid_count == 0) {
+    std::cout << "All nibbles have bit 7 set (good)" << std::endl;
+  }
+  std::cout << std::endl;
+
+  // Decode
+  uint8_t decoded[256];
+  if (!decode6and2(encoded.data(), decoded)) {
+    std::cerr << "Decode failed!" << std::endl;
+    return 1;
+  }
+
+  std::cout << "Decoded sector data (first 32 bytes):" << std::endl;
+  for (int i = 0; i < 32; i++) {
+    std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)decoded[i] << " ";
+    if ((i + 1) % 16 == 0) std::cout << std::endl;
+  }
+  std::cout << std::dec << std::endl;
+
+  // Compare
+  int mismatches = 0;
+  for (int i = 0; i < 256; i++) {
+    if (sector_data[i] != decoded[i]) {
+      if (mismatches < 10) {
+        std::cout << "Mismatch at position " << i << ": expected 0x"
+                  << std::hex << (int)sector_data[i] << " got 0x" << (int)decoded[i]
+                  << std::dec << std::endl;
+      }
+      mismatches++;
+    }
+  }
+
+  if (mismatches == 0) {
+    std::cout << "SUCCESS: All 256 bytes match!" << std::endl;
+    return 0;
+  } else {
+    std::cout << "FAILED: " << mismatches << " mismatches" << std::endl;
+    return 1;
+  }
+}

package/tests/integration/check-rom.js

@@ -0,0 +1,70 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createContext, runInContext } from 'vm';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function loadWasmModule() {
+  const wasmJsPath = join(__dirname, '..', 'public', 'a2e.js');
+  const wasmDir = dirname(wasmJsPath);
+  const code = readFileSync(wasmJsPath, 'utf8');
+  const context = {
+    module: { exports: {} },
+    exports: {},
+    globalThis: global,
+    console: console,
+    require: (await import('module')).createRequire(import.meta.url),
+    __dirname: wasmDir,
+    __filename: wasmJsPath,
+    process: process,
+    WebAssembly: WebAssembly,
+    URL: URL,
+    TextDecoder: TextDecoder,
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    performance: { now: () => Date.now() }
+  };
+  createContext(context);
+  runInContext(code, context);
+  return context.module.exports;
+}
+
+async function runTest() {
+  const createA2EModule = await loadWasmModule();
+  const Module = await createA2EModule();
+  Module._init();
+
+  // Check ROM at FE89 and surrounding area
+  console.log('ROM at $FE80-$FE9F:');
+  for (let row = 0; row < 2; row++) {
+    const addr = 0xFE80 + row * 16;
+    let line = '$' + addr.toString(16).toUpperCase() + ': ';
+    for (let col = 0; col < 16; col++) {
+      line += Module._readMemory(addr + col).toString(16).padStart(2, '0').toUpperCase() + ' ';
+    }
+    console.log(line);
+  }
+
+  // Check IRQ/BRK vectors
+  console.log('\nVectors:');
+  const nmilo = Module._readMemory(0xFFFA);
+  const nmihi = Module._readMemory(0xFFFB);
+  console.log('NMI ($FFFA): $' + ((nmihi << 8) | nmilo).toString(16).toUpperCase());
+  
+  const resetlo = Module._readMemory(0xFFFC);
+  const resethi = Module._readMemory(0xFFFD);
+  console.log('RESET ($FFFC): $' + ((resethi << 8) | resetlo).toString(16).toUpperCase());
+  
+  const irqlo = Module._readMemory(0xFFFE);
+  const irqhi = Module._readMemory(0xFFFF);
+  console.log('IRQ/BRK ($FFFE): $' + ((irqhi << 8) | irqlo).toString(16).toUpperCase());
+
+  // What should be at FE89 in real Apple IIe ROM?
+  console.log('\n$FE89 contains: $' + Module._readMemory(0xFE89).toString(16).toUpperCase());
+  console.log('$FE8A contains: $' + Module._readMemory(0xFE8A).toString(16).toUpperCase());
+  console.log('$FE8B contains: $' + Module._readMemory(0xFE8B).toString(16).toUpperCase());
+}
+
+runTest().catch(err => { console.error(err); process.exit(1); });

package/tests/integration/compare-boot.js

@@ -0,0 +1,239 @@
+/**
+ * Compare boot sector loading between disk image and memory
+ */
+import { readFileSync } from 'fs';
+import { createContext, runInContext } from 'vm';
+
+async function loadWasmModule() {
+  const wasmJsPath = '/Users/michaeldaley/Source/web-a2e/public/a2e.js';
+
+  const code = readFileSync(wasmJsPath, 'utf8');
+
+  const context = {
+    module: { exports: {} },
+    exports: {},
+    globalThis: global,
+    console: console,
+    require: (await import('module')).createRequire(import.meta.url),
+    __dirname: '/Users/michaeldaley/Source/web-a2e/public',
+    __filename: wasmJsPath,
+    process: process,
+    WebAssembly: WebAssembly,
+    URL: URL,
+    TextDecoder: TextDecoder,
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    performance: { now: () => Date.now() }
+  };
+
+  createContext(context);
+  runInContext(code, context);
+
+  return context.module.exports;
+}
+
+async function main() {
+  console.log('Loading WASM module...');
+  const createA2EModule = await loadWasmModule();
+  const Module = await createA2EModule();
+
+  console.log('Initializing emulator...');
+  Module._init();
+
+  // Load the disk image
+  const diskPath = '/Users/michaeldaley/Source/web-a2e/public/Apple DOS 3.3 August 1980.dsk';
+  const diskData = readFileSync(diskPath);
+
+  // Allocate memory for disk data
+  const diskPtr = Module._malloc(diskData.length);
+  Module.HEAPU8.set(diskData, diskPtr);
+
+  // Allocate memory for filename
+  const filename = 'Apple DOS 3.3 August 1980.dsk';
+  const filenamePtr = Module._malloc(filename.length + 1);
+  Module.stringToUTF8(filename, filenamePtr, filename.length + 1);
+
+  // Insert the disk
+  const inserted = Module._insertDisk(0, diskPtr, diskData.length, filenamePtr);
+  Module._free(filenamePtr);
+
+  if (!inserted) {
+    console.error('Failed to insert disk!');
+    process.exit(1);
+  }
+
+  // Run boot cycles in batches to see progress
+  console.log('Running boot cycles...');
+
+  // Run first to get to the interesting part
+  Module._runCycles(4000000);
+  console.log(`At 4M cycles: PC=$${Module._getPC().toString(16).toUpperCase().padStart(4, '0')}`);
+
+  // Now run in smaller batches to catch the crash
+  for (let batch = 0; batch < 20; batch++) {
+    Module._runCycles(50000);
+    const pc = Module._getPC();
+    const track = Module._getDiskTrack(0);
+    const cycles = Module._getTotalCycles();
+    console.log(`${cycles} cycles: PC=$${pc.toString(16).toUpperCase().padStart(4, '0')}, Track=${track}`);
+
+    // Check if crashed
+    if (pc === 0) {
+      console.log('CRASHED at $0000!');
+
+      // Dump memory around $3900-$397F (boot stage 2 code)
+      console.log('\nBoot stage 2 code ($3900-$397F):');
+      let line = '';
+      for (let i = 0; i < 128; i++) {
+        const byte = Module._readMemory(0x3900 + i);
+        line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+        if ((i + 1) % 16 === 0) {
+          console.log('$' + (0x3900 + i - 15).toString(16).toUpperCase() + ': ' + line);
+          line = '';
+        }
+      }
+
+      // Dump memory around where crash happened ($3E50-$3EAF)
+      console.log('\nCode near crash location ($3E50-$3EAF):');
+      line = '';
+      for (let i = 0; i < 96; i++) {
+        const byte = Module._readMemory(0x3E50 + i);
+        line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+        if ((i + 1) % 16 === 0) {
+          console.log('$' + (0x3E50 + i - 15).toString(16).toUpperCase() + ': ' + line);
+          line = '';
+        }
+      }
+
+      // Dump stack area
+      console.log('\nStack area ($0100-$01FF):');
+      const sp = Module._getSP();
+      console.log(`SP = $${sp.toString(16).toUpperCase().padStart(2, '0')}`);
+      line = '';
+      for (let i = sp; i <= 0xFF; i++) {
+        const byte = Module._readMemory(0x0100 + i);
+        line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+      }
+      console.log('Stack: ' + line);
+
+      // Check what's at $0236 (the return address on the stack)
+      console.log('\nMemory at $0230-$024F:');
+      line = '';
+      for (let i = 0; i < 32; i++) {
+        const byte = Module._readMemory(0x0230 + i);
+        line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+        if ((i + 1) % 16 === 0) {
+          console.log('$' + (0x0230 + i - 15).toString(16).toUpperCase() + ': ' + line);
+          line = '';
+        }
+      }
+
+      // Check what's at $0000 (where we crashed)
+      console.log('\nMemory at $0000-$001F:');
+      line = '';
+      for (let i = 0; i < 32; i++) {
+        const byte = Module._readMemory(i);
+        line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+        if ((i + 1) % 16 === 0) {
+          console.log('$' + (i - 15).toString(16).toUpperCase() + ': ' + line);
+          line = '';
+        }
+      }
+
+      break;
+    }
+  }
+
+  // Read memory at $0800 to see if boot sector loaded
+  console.log('\nMemory at $0800 (boot sector destination):');
+  let line = '';
+  for (let i = 0; i < 32; i++) {
+    const byte = Module._readMemory(0x0800 + i);
+    line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+    if ((i + 1) % 16 === 0) {
+      console.log(line);
+      line = '';
+    }
+  }
+
+  // Check the raw DSK data for sector 0, track 0
+  console.log('\nRaw DSK file sector 0, track 0:');
+  line = '';
+  for (let i = 0; i < 32; i++) {
+    line += diskData[i].toString(16).padStart(2, '0').toUpperCase() + ' ';
+    if ((i + 1) % 16 === 0) {
+      console.log(line);
+      line = '';
+    }
+  }
+
+  // They should match if boot sector loaded correctly
+  console.log('\nComparing boot sector (256 bytes)...');
+  let match = true;
+  let mismatches = [];
+  for (let i = 0; i < 256; i++) {
+    const mem = Module._readMemory(0x0800 + i);
+    const disk = diskData[i];
+    if (mem !== disk) {
+      mismatches.push({
+        addr: 0x0800 + i,
+        mem: mem,
+        disk: disk
+      });
+      match = false;
+    }
+  }
+
+  if (match) {
+    console.log('Boot sector matches DSK data! Loading is correct.');
+  } else {
+    console.log('Boot sector MOSTLY matches DSK data!');
+    console.log('Mismatches (likely runtime modifications):');
+    mismatches.forEach(m => {
+      const addr = m.addr.toString(16).toUpperCase().padStart(4, '0');
+      const mem = m.mem.toString(16).toUpperCase().padStart(2, '0');
+      const disk = m.disk.toString(16).toUpperCase().padStart(2, '0');
+      console.log(`  $${addr}: memory=${mem} disk=${disk}`);
+    });
+  }
+
+  // Check CPU state
+  console.log('\nCPU State:');
+  console.log(`PC: $${Module._getPC().toString(16).toUpperCase().padStart(4, '0')}`);
+  console.log(`A: $${Module._getA().toString(16).toUpperCase().padStart(2, '0')}`);
+  console.log(`X: $${Module._getX().toString(16).toUpperCase().padStart(2, '0')}`);
+  console.log(`Y: $${Module._getY().toString(16).toUpperCase().padStart(2, '0')}`);
+  console.log(`SP: $${Module._getSP().toString(16).toUpperCase().padStart(2, '0')}`);
+  console.log(`Total cycles: ${Module._getTotalCycles()}`);
+
+  // Check disk state
+  console.log('\nDisk State:');
+  console.log(`Track: ${Module._getDiskTrack(0)}`);
+  console.log(`Motor: ${Module._getDiskMotorOn(0)}`);
+
+  // Check what DOS loads next - it should load sectors 1-9 of track 0 to RWTS area
+  // Let's check a few key memory locations
+  console.log('\nKey memory locations:');
+  console.log('$B600-$B60F (RWTS entry):');
+  line = '';
+  for (let i = 0; i < 16; i++) {
+    const byte = Module._readMemory(0xB600 + i);
+    line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+  }
+  console.log(line);
+
+  console.log('$9D00-$9D0F (DOS start):');
+  line = '';
+  for (let i = 0; i < 16; i++) {
+    const byte = Module._readMemory(0x9D00 + i);
+    line += byte.toString(16).padStart(2, '0').toUpperCase() + ' ';
+  }
+  console.log(line);
+
+  Module._free(diskPtr);
+}
+
+main().catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});

package/tests/integration/crash-trace.js

@@ -0,0 +1,102 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { createContext, runInContext } from 'vm';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function loadWasmModule() {
+  const wasmJsPath = join(__dirname, '..', 'public', 'a2e.js');
+  const wasmDir = dirname(wasmJsPath);
+  const code = readFileSync(wasmJsPath, 'utf8');
+  const context = {
+    module: { exports: {} },
+    exports: {},
+    globalThis: global,
+    console: console,
+    require: (await import('module')).createRequire(import.meta.url),
+    __dirname: wasmDir,
+    __filename: wasmJsPath,
+    process: process,
+    WebAssembly: WebAssembly,
+    URL: URL,
+    TextDecoder: TextDecoder,
+    setTimeout: setTimeout,
+    clearTimeout: clearTimeout,
+    performance: { now: () => Date.now() }
+  };
+  createContext(context);
+  runInContext(code, context);
+  return context.module.exports;
+}
+
+async function runTest() {
+  console.log('Loading...');
+  const createA2EModule = await loadWasmModule();
+  const Module = await createA2EModule();
+  Module._init();
+
+  const diskPath = join(__dirname, '..', 'public', 'Apple DOS 3.3 August 1980.dsk');
+  const diskData = readFileSync(diskPath);
+  const diskPtr = Module._malloc(diskData.length);
+  Module.HEAPU8.set(diskData, diskPtr);
+  const filename = 'test.dsk';
+  const filenamePtr = Module._malloc(filename.length + 1);
+  Module.stringToUTF8(filename, filenamePtr, filename.length + 1);
+  Module._insertDisk(0, diskPtr, diskData.length, filenamePtr);
+  Module._free(filenamePtr);
+
+  // Run to earlier point
+  console.log('Running to 4,050,000 cycles...');
+  while (Module._getTotalCycles() < 4050000) {
+    Module._runCycles(1000);
+  }
+  console.log('At cycle ' + Module._getTotalCycles());
+
+  // Capture last 200 instructions before crash
+  const history = [];
+  
+  for (let i = 0; i < 500000; i++) {
+    const pc = Module._getPC();
+    const sp = Module._getSP();
+    const a = Module._getA();
+    const x = Module._getX();
+    const y = Module._getY();
+    const op = Module._readMemory(pc);
+    
+    history.push({pc, sp, a, x, y, op});
+    if (history.length > 200) history.shift();
+    
+    Module._stepInstruction();
+    
+    const newPC = Module._getPC();
+    if (newPC === 0) {
+      console.log('\n*** CRASH at cycle ' + Module._getTotalCycles() + ' ***');
+      console.log('Last 100 instructions:');
+      for (let j = Math.max(0, history.length - 100); j < history.length; j++) {
+        const h = history[j];
+        console.log('$' + h.pc.toString(16).toUpperCase().padStart(4,'0') + 
+                    ' [' + h.op.toString(16).padStart(2,'0') + ']' +
+                    ' A=' + h.a.toString(16).padStart(2,'0') +
+                    ' X=' + h.x.toString(16).padStart(2,'0') +
+                    ' Y=' + h.y.toString(16).padStart(2,'0') +
+                    ' SP=' + h.sp.toString(16).padStart(2,'0'));
+      }
+      
+      console.log('\nStack ($01C0-$01FF):');
+      for (let row = 0; row < 4; row++) {
+        let line = '$' + (0x01C0 + row*16).toString(16).toUpperCase() + ': ';
+        for (let col = 0; col < 16; col++) {
+          line += Module._readMemory(0x01C0 + row*16 + col).toString(16).padStart(2,'0') + ' ';
+        }
+        console.log(line);
+      }
+      break;
+    }
+  }
+
+  Module._free(diskPtr);
+}
+
+runTest().catch(err => { console.error(err); process.exit(1); });