Files

788 lines
49 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-or-later
// Optional integration check: user supplies the ROM; no ROM bytes live here.
#include "CoreChecks.h"
#include "../../src/devices/FD502/Fd502Device.h"
#include "../../src/devices/HardDisk/HardDiskDevice.h"
#include "../../src/devices/Orchestra90Device.h"
#include "../../src/devices/SpeechSoundDevice.h"
#include "../../src/core/MachineSession.h"
#include "../../src/core/tcc1014mmu.h"
#include <fstream>
#include <limits>
#include <algorithm>
#include <stdexcept>
#include <string>
#include <cstdio>
namespace {
void frames(VCC::Mac::MachineSession& machine, unsigned count) {
while (count--) machine.advance();
}
std::string screen() {
std::string text;
for (unsigned i = 0; i < 512; ++i) {
const unsigned c = SafeMemRead8(0x400 + i) & 0x3f;
text += static_cast<char>(c < 32 ? c + 64 : c);
if (i % 32 == 31) text += '\n';
}
return text;
}
std::uint64_t key(char c) {
unsigned bit;
if (c >= 'A' && c <= 'Z') bit = c - '@';
else if (c >= '0' && c <= '9') bit = 32 + c - '0';
else if (c == ',') bit = 44;
else if (c == '/') bit = 47;
else if (c == '>') return (std::uint64_t{1} << 46) | (std::uint64_t{1} << 55);
else if (c == '"') return (std::uint64_t{1} << 34) | (std::uint64_t{1} << 55);
else if (c == ' ') bit = 31;
else if (c == '\r') bit = 48;
else if (c == '*') return (std::uint64_t{1} << 42) | (std::uint64_t{1} << 55);
else throw std::logic_error("Unsupported authored probe character");
return std::uint64_t{1} << bit;
}
}
namespace {
void type(VCC::Mac::MachineSession& machine, const std::string& text) {
for (char c : text) {
machine.setKeyboard(key(c)); frames(machine, 4);
machine.setKeyboard(0); frames(machine, 4);
}
}
}
namespace {
// Direct Run from either workspace must supply a callable entry and leave BASIC
// responsive after RTS, including when rerunning from inside an earlier build.
void checkWorkspaceReturn(VCC::Mac::MachineSession& machine) {
const std::vector<std::uint8_t> program{0, 0, 2, 0x3f, 0, 0x12, 0x39, 0xff, 0, 0, 0x3f, 0}; // NOP, RTS
const auto word = [](unsigned at) { return (SafeMemRead8(at) << 8) | SafeMemRead8(at + 1); };
const auto stack = word(0x21) - 2;
const auto before = machine.snapshot();
machine.launchAssembly(program, {}, {}, true, false, before.generation, before.debuggerProgramRevision,
before.debuggerMappingFingerprint);
const auto entry = machine.snapshot();
if (entry.cpu.PC != 0x3f00 || entry.cpu.S != stack || entry.cpu.DP || (entry.cpu.CC & 0x50) ||
word(stack) != 0xac73)
throw std::runtime_error("Assembly Direct Run did not establish the BASIC return frame");
machine.debuggerStep();
if (machine.snapshot().cpu.PC != 0x3f01) throw std::runtime_error("Assembly Direct Run missed its next instruction");
auto overlap = program;
overlap.insert(overlap.end() - 5, {0, 0, 1, std::uint8_t(stack >> 8), std::uint8_t(stack), 0});
try {
machine.debuggerLoadBinary(overlap, 0x3f00);
throw std::runtime_error("A development image overwrote BASIC's return frame");
} catch (const std::invalid_argument&) {}
if (word(stack) != 0xac73 || machine.snapshot().cpu.PC != 0x3f01 ||
machine.snapshot().debuggerProgramRevision != entry.debuggerProgramRevision)
throw std::runtime_error("Rejected development image changed the session");
machine.debuggerLoadBinary(program, 0x3f00);
if (machine.snapshot().cpu.S != stack) throw std::runtime_error("Rerunning a development image nested its stack");
machine.debuggerClearDevelopmentBreakpoints();
machine.resume(); frames(machine, 60);
type(machine, "PRINT 8*9\r"); frames(machine, 30);
if (screen().find(" 72 ") == std::string::npos)
throw std::runtime_error("BASIC did not accept a new command after the workspace program returned");
}
void pasteText(VCC::Mac::MachineSession& machine, const std::string& text) {
std::vector<std::uint64_t> chords;
for(char c:text) {
if(c>='a' && c<='z') chords.push_back(key(c-'a'+'A'));
else if(c>='A' && c<='Z') chords.push_back(key(c) | (std::uint64_t{1}<<55));
else chords.push_back(key(c));
}
machine.paste(chords);
for(unsigned n=0;machine.pasteRemaining() && n<20000;++n)machine.advance();
if(machine.pasteRemaining())throw std::runtime_error("Paced text did not complete");
}
}
void CheckRomBoot(const char* path) {
std::ifstream file(path, std::ios::binary);
std::vector<std::uint8_t> bytes(32769);
file.read(reinterpret_cast<char*>(bytes.data()), bytes.size());
if (file.gcount() != 32768) throw std::runtime_error("ROM check needs a readable 32 KiB system ROM");
bytes.resize(32768);
for (auto processor : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) {
VCC::Mac::MachineSession machine; machine.load(bytes, processor); machine.resume(); frames(machine, 300);
if (screen().find("OK") == std::string::npos) throw std::runtime_error("ROM did not reach BASIC");
checkWorkspaceReturn(machine);
type(machine, "10 PRINT 6*7\rRUN\r");
frames(machine, 60);
if (screen().find(" 42 ") == std::string::npos) throw std::runtime_error("BASIC keyboard/program check did not print 42");
machine.pause(); const auto before = machine.snapshot(); frames(machine, 5);
if (machine.snapshot().cycles != before.cycles) throw std::runtime_error("Paused ROM continued executing");
machine.resume(); type(machine, "CLS\r");
machine.softReset(); frames(machine, 300);
type(machine, "LIST\r"); frames(machine, 20);
if (screen().find("PRINT 6*7") == std::string::npos)
throw std::runtime_error("Soft reset lost the BASIC program");
type(machine, "CLS\rRUN\r"); frames(machine, 60);
if (screen().find(" 42 ") == std::string::npos)
throw std::runtime_error("Preserved BASIC program did not run after soft reset");
machine.pause(); machine.softReset(); frames(machine, 5);
if (machine.snapshot().cycles != 0 || machine.snapshot().state != VCC::Mac::RunState::Paused)
throw std::runtime_error("Paused soft reset executed guest code");
machine.resume(); frames(machine, 300); type(machine, "CLS\rRUN\r"); frames(machine, 60);
if (screen().find(" 42 ") == std::string::npos)
throw std::runtime_error("Paused soft reset lost the BASIC program");
type(machine, "SOUND100,10\r");
bool sound=false;
for(unsigned i=0;i<120;++i) {
machine.advance();
for(auto sample:machine.takeAudio()) if(sample.left!=0 || sample.right!=0) sound=true;
}
if(!sound) throw std::runtime_error("BASIC SOUND produced no audio samples");
for(auto format:{VCC::Mac::TapeFormat::CAS,VCC::Mac::TapeFormat::WAV}) {
auto& tape=machine.cassette(); tape.record(format);
type(machine, "CSAVE\"TEST\"\r"); frames(machine,1800);
auto saved=tape.exportImage();
if(saved.size()<100 || tape.snapshot().motor) throw std::runtime_error("BASIC CSAVE did not finish recording");
tape.mount(saved,format); tape.setFast(false); tape.play();
type(machine,"NEW\rCLS\rCLOAD\r"); frames(machine,2400);
type(machine,"LIST\rRUN\r"); frames(machine,60);
if(screen().find(" 42 ")==std::string::npos) {
std::fprintf(stderr,"Tape load screen:\n%s\n",screen().c_str());
throw std::runtime_error(format==VCC::Mac::TapeFormat::CAS ? "CAS round trip failed" : "WAV round trip failed");
}
if(format==VCC::Mac::TapeFormat::CAS) {
tape.rewind(); tape.setFast(true); tape.play();
type(machine,"NEW\rCLS\rCLOAD\r"); frames(machine,1200);
type(machine,"RUN\r"); frames(machine,60);
if(screen().find(" 42 ")==std::string::npos) throw std::runtime_error("Fast CAS round trip failed");
}
}
std::printf("PASS: BASIC SOUND, CAS/WAV CSAVE/CLOAD, fast CAS (%s)\n",
processor == VCC::Mac::Processor::MC6809 ? "6809" : "6309");
machine.reset(); machine.resume(); frames(machine, 300);
if (screen().find("OK") == std::string::npos || screen().find(" 42 ") != std::string::npos)
throw std::runtime_error("Cold reset did not return to a clean BASIC prompt");
std::printf("PASS: supplied ROM BASIC boot, keyboard program, pause, soft/cold reset (%s)\n",
processor == VCC::Mac::Processor::MC6809 ? "6809" : "6309");
// Two authored BIN data blocks: clear text RAM, then execute a program
// that writes BIN OK to the display. No assembled binary is bundled.
std::vector<std::uint8_t> binary{0,2,0,4,0}; binary.insert(binary.end(),512,0x60);
std::vector<std::uint8_t> code;
const std::string message = "BIN OK";
for (unsigned i=0;i<message.size();++i)
code.insert(code.end(),{0x86,std::uint8_t((message[i]&63)|64),0xb7,4,std::uint8_t(i)});
code.insert(code.end(),{0x20,0xfe});
binary.insert(binary.end(),{0,0,std::uint8_t(code.size()),0x30,0});
binary.insert(binary.end(),code.begin(),code.end()); binary.insert(binary.end(),{255,0,0,0x30,0});
const auto rawStack = machine.snapshot().cpu.S;
machine.quickLoad(binary);
if (machine.snapshot().cpu.S != rawStack) throw std::runtime_error("Raw BIN quickload changed the stack");
frames(machine,10);
if (screen().find(message)==std::string::npos) throw std::runtime_error("Quick-loaded BIN did not execute after BASIC boot");
std::printf("PASS: supplied ROM with multi-block BIN quick-load (%s)\n",
processor == VCC::Mac::Processor::MC6809 ? "6809" : "6309");
}
// Machine Settings matrix: a real ROM must also boot and run BASIC with
// all retained RAM sizes. No media, generated captures, or ROM data is saved.
for (auto processor : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) {
for (unsigned ram = 0; ram < 4; ++ram) {
VCC::Mac::MachineSession machine;
VCC::Mac::MachineConfiguration settings;
settings.processor = processor; settings.ram = ram; settings.frameInterval = 6;
machine.configure(settings); machine.load(bytes, processor); machine.resume(); frames(machine, 300);
if (screen().find("OK") == std::string::npos) throw std::runtime_error("Configured RAM did not boot BASIC");
type(machine, "CLS\rPRINT 6*7\r"); frames(machine, 20);
if (screen().find(" 42 ") == std::string::npos) throw std::runtime_error("Configured RAM did not run BASIC");
std::printf("PASS: supplied ROM machine settings (%s, RAM choice %u, present every 6 frames)\n",
processor == VCC::Mac::Processor::MC6809 ? "6809" : "6309", ram);
}
}
}
// Optional disk BASIC integration. Both ROMs are supplied by the user; every
// disk byte is authored here, and the source files are opened read-only.
void CheckDiskRom(const char* systemPath, const char* diskPath) {
using namespace VCC::Devices;
auto readRom = [](const char* path, unsigned size) {
std::ifstream file(path, std::ios::binary);
std::vector<std::uint8_t> bytes(size + 1);
file.read(reinterpret_cast<char*>(bytes.data()), bytes.size());
if (file.gcount() != size) throw std::runtime_error("Disk check needs a 32 KiB system ROM and 8 KiB disk ROM");
bytes.resize(size); return bytes;
};
const auto systemRom = readRom(systemPath, 32768), diskRom = readRom(diskPath, 8192);
auto checkScreen = [](const char* expected, const char* operation) {
const auto text = screen();
if (text.find(expected) == std::string::npos || text.find("ERROR") != std::string::npos) {
std::fprintf(stderr, "%s screen:\n%s\n", operation, text.c_str());
throw std::runtime_error(operation);
}
};
auto checkFormat = [&](auto cpu, DiskFormat format, const char* formatName) {
VCC::Mac::MachineSession machine;
auto device = makeDevice(DeviceKind::FD502, diskRom);
auto* fdc = static_cast<Fd502Device*>(device.get());
fdc->mount(0, DiskImage::blank({}, format));
machine.cartridges().install(std::move(device)); machine.load(systemRom, cpu); machine.resume();
frames(machine, 300); checkScreen("DISK EXTENDED", "Disk BASIC boot");
type(machine, "CLS\rDSKINI0\r"); frames(machine, 6000);
checkScreen("OK", "DSKINI formatting");
if (fdc->snapshot().busy) throw std::runtime_error("DSKINI left the controller busy");
type(machine, "10 PRINT 6*7\rSAVE\"TEST\"\r"); frames(machine, 1200);
checkScreen("OK", "BASIC disk SAVE");
type(machine, "CLS\rDIR\r"); frames(machine, 300); checkScreen("TEST", "Directory after SAVE");
const auto saved = fdc->image(0)->bytes();
fdc->markSaved(0); fdc->eject(0); fdc->mount(0, DiskImage::load(saved));
machine.reset(); frames(machine, 300);
type(machine, "CLS\rLOAD\"TEST\"\r"); frames(machine, 1200);
type(machine, "LIST\rRUN\r"); frames(machine, 60);
checkScreen("PRINT 6*7", "Reloaded disk program LIST"); checkScreen(" 42 ", "Reloaded disk program RUN");
if (fdc->image(0)->bytes() != saved) throw std::runtime_error("Reading changed the disk image");
fdc->mount(0, DiskImage::load(saved, true));
type(machine, "CLS\rSAVE\"BLOCK\"\r"); frames(machine, 600);
if (screen().find("?WP ERROR") == std::string::npos || fdc->image(0)->bytes() != saved)
throw std::runtime_error("Write-protected SAVE must report WP ERROR and preserve disk bytes");
std::printf("PASS: Disk BASIC DSKINI, SAVE, DIR, eject/reopen, cold boot, LOAD/LIST/RUN and write protection (%s, %s)\n",
formatName,
cpu == VCC::Mac::Processor::MC6809 ? "6809" : "6309");
};
for (auto cpu : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) {
checkFormat(cpu, DiskFormat::JVC, "DSK");
checkFormat(cpu, DiskFormat::DMK, "DMK");
checkFormat(cpu, DiskFormat::VDK, "VDK");
}
}
// Optional reference-image check. All writes stay in an owned memory copy;
// supplied system ROM, RGBDOS ROM and NitrOS-9 VHD are opened read-only.
void CheckHardDiskRom(const char* systemPath, const char* rgbPath, const char* imagePath, const char* dataPath) {
using namespace VCC::Devices;
auto read = [](const char* path, std::size_t limit) {
std::ifstream file(path, std::ios::binary | std::ios::ate);
auto length = file.tellg();
if (!file || length <= 0 || std::uint64_t(length) > limit) throw std::runtime_error("Invalid supplied hard-disk fixture");
std::vector<std::uint8_t> bytes(static_cast<std::size_t>(length)); file.seekg(0);
if (!file.read(reinterpret_cast<char*>(bytes.data()), bytes.size())) throw std::runtime_error("Unable to read supplied hard-disk fixture");
return bytes;
};
const auto system = read(systemPath,32768), rgb = read(rgbPath,16384), original = read(imagePath,HardDiskImage::maxBytes);
// Read a standard OS-9 RBF file descriptor and its segment list. Used only
// for independent verification of the guest's on-disk result.
auto fileBytes = [](const std::vector<std::uint8_t>& disk, std::uint32_t descriptor) {
const auto fd = std::size_t(descriptor) * 256;
if (fd + 256 > disk.size()) throw std::runtime_error("RBF descriptor outside image");
std::uint32_t size = 0; for (unsigned i=9;i<13;++i) size = (size<<8)|disk[fd+i];
if (size > HardDiskImage::maxBytes) throw std::runtime_error("RBF file size outside limit");
std::vector<std::uint8_t> result;
for (unsigned entry=16; entry+5<=256 && result.size()<size; entry+=5) {
std::uint32_t sector = (disk[fd+entry]<<16)|(disk[fd+entry+1]<<8)|disk[fd+entry+2];
unsigned count = (disk[fd+entry+3]<<8)|disk[fd+entry+4];
if (!count) break;
auto start=std::size_t(sector)*256, length=std::min(std::size_t(count)*256,std::size_t(size)-result.size());
if (start+length > disk.size()) throw std::runtime_error("RBF segment outside image");
result.insert(result.end(),disk.begin()+start,disk.begin()+start+length);
}
if (result.size()!=size) throw std::runtime_error("Incomplete RBF file");
return result;
};
for (auto cpu : {VCC::Mac::Processor::MC6809,VCC::Mac::Processor::HD6309}) {
VCC::Mac::MachineSession machine;
auto hard = std::make_shared<HardDiskDevice>(); hard->mount(0,HardDiskImage(original));
if (dataPath) hard->mount(1,HardDiskImage(read(dataPath,HardDiskImage::maxBytes)));
auto floppy = std::make_shared<Fd502Device>(rgb);
machine.cartridges().configure({nullptr,hard,nullptr,nullptr,floppy},true,4);
machine.load(system,cpu);
if (dataPath) machine.requestNitros9Boot();
machine.resume();
try { frames(machine,600); } catch (...) { std::fprintf(stderr,"Boot screen:\n%s\n",screen().c_str()); throw; }
if (!dataPath && screen().find("HARD DISK BASIC")==std::string::npos) throw std::runtime_error("RGBDOS did not boot");
if (!dataPath) type(machine,"DOS255\r");
frames(machine,3600);
if (machine.nitros9BootPending()) throw std::runtime_error("Automatic boot still pending");
type(machine,"ECHO VCCPORTCHECK >/H0/VCCMACTEST\r"); frames(machine,600);
const auto& result = hard->image(0)->bytes();
auto root = (result[8]<<16)|(result[9]<<8)|result[10]; auto entries = fileBytes(result,root);
bool found = false;
for (std::size_t i=0;i+32<=entries.size();i+=32) {
if (!entries[i]) continue;
std::string name;
for (unsigned j=0;j<29;++j) { auto c=entries[i+j]; name += char(c&127); if(c&128) break; }
if (name!="vccmactest") continue;
auto fd = (entries[i+29]<<16)|(entries[i+30]<<8)|entries[i+31];
auto bytes = fileBytes(result,fd); auto text = std::string(bytes.begin(),bytes.end());
if (text.find("vccportcheck")==std::string::npos) throw std::runtime_error("NitrOS-9 file contents mismatch");
// Reopen the serialized image independently and read the same file.
HardDiskImage reopened(result);
if (fileBytes(reopened.bytes(),fd)!=bytes) throw std::runtime_error("Hard disk reopen mismatch");
found = true; break;
}
if (!found || !hard->image(0)->dirty()) throw std::runtime_error("NitrOS-9 did not create its test file");
if (dataPath) {
pasteText(machine,"echo sharedportcheck >/h1/vccmactest\r"); frames(machine,600);
// Interleave reads from HD0 with writes to HD1; this catches a
// driver that selects a unit once instead of on every transfer.
pasteText(machine,"dir /dd/games >/h1/catalog\r"); frames(machine,600);
const auto shared = hard->image(1)->bytes();
const auto before = read(dataPath,HardDiskImage::maxBytes);
if (!std::equal(before.begin()+0x5a000*256,before.end(),shared.begin()+0x5a000*256))
throw std::runtime_error("OS-9 write modified BASIC volumes");
auto root1=(shared[8]<<16)|(shared[9]<<8)|shared[10]; auto directory=fileBytes(shared,root1);
bool written=false, catalog=false;
for (std::size_t i=0;i+32<=directory.size();i+=32) {
if (!directory[i]) continue;
std::string name;
for(unsigned j=0;j<29;++j) { auto c=directory[i+j];name+=char(c&127);if(c&128)break; }
if(name!="vccmactest" && name!="catalog")continue;
auto fd=(directory[i+29]<<16)|(directory[i+30]<<8)|directory[i+31];
auto bytes=fileBytes(shared,fd);
if(name=="catalog") {
std::string listing(bytes.begin(),bytes.end());
std::transform(listing.begin(),listing.end(),listing.begin(),[](unsigned char c) { return c >= 'A' && c <= 'Z' ? c+32 : c; });
catalog=listing.find("rogue")!=std::string::npos;
continue;
}
if(std::string(bytes.begin(),bytes.end()).find("sharedportcheck")==std::string::npos)
throw std::runtime_error("Shared HD1 write content mismatch");
HardDiskImage reopened(shared);
if(fileBytes(reopened.bytes(),fd)!=bytes)throw std::runtime_error("Shared HD1 reopen mismatch");
written=true;
}
if(!written || !catalog)throw std::runtime_error("NitrOS-9 HD1 write or cross-drive catalogue read failed");
std::printf("PASS: automatic DOS 255, shared OS-9 HD1 write/reopen, BASIC volumes unchanged\n");
}
std::printf("PASS: RGBDOS, NitrOS-9 boot, guest file creation and raw-image reopen (%s)\n",cpu==VCC::Mac::Processor::MC6809?"6809":"6309");
}
}
namespace {
void installPlanetSource(VCC::Mac::MachineSession& machine) {
// Packaging and the documented regeneration commands run from the checkout.
std::ifstream file("examples/basic/planet.bas");
if (!file) throw std::runtime_error("Cannot open examples/basic/planet.bas; run from the repository root");
std::string source{std::istreambuf_iterator<char>(file), {}};
machine.basicLoadSource(source, false);
frames(machine, 30);
}
void runPlanetStarter(VCC::Mac::MachineSession& machine, char choice) {
type(machine, "CLS\rRUN\r");
frames(machine, 30);
type(machine, "3"); // An unrelated key leaves BASIC waiting at the menu.
const auto menu = machine.copyScreenText();
if (menu.find("What planet do you live on?\n1) Earth\n2) Mars") == std::string::npos ||
menu.find("World!") != std::string::npos || menu.find("OK") != std::string::npos)
throw std::runtime_error("Planet starter did not wait for a choice:\n" + menu);
type(machine, std::string(1, choice));
frames(machine, 30);
const auto result = machine.copyScreenText();
const auto greeting = result.find(choice == '1' ? "Hello Nice Blue Dot World!" : "Hello Cold Red Dot World!");
if (greeting == std::string::npos || result.find("OK", greeting) == std::string::npos)
throw std::runtime_error("Planet starter did not greet the player and return to BASIC:\n" + result);
type(machine, "WIDTH 32\r"); // The disk command probes use the 32-column BASIC display.
}
}
// Reproducible starter media, authored through real BASIC and independently
// reloaded on both CPUs. Only the caller-supplied output directory is written.
void CreateStarterMedia(const char* systemPath, const char* diskPath, const char* output) {
using namespace VCC::Devices;
using namespace VCC::Mac;
auto read = [](const char* path, std::size_t size) {
std::ifstream f(path, std::ios::binary);
std::vector<std::uint8_t> data(size + 1);
f.read(reinterpret_cast<char*>(data.data()), data.size());
if (std::size_t(f.gcount()) != size) throw std::runtime_error("Starter media requires a 32 KiB system and 8 KiB disk ROM");
data.resize(size); return data;
};
auto expect = [](const char* text) {
if (screen().find(text) == std::string::npos || screen().find("ERROR") != std::string::npos)
throw std::runtime_error(std::string("Starter verification failed: ") + text + "\n" + screen());
};
const auto system = read(systemPath,32768), rom = read(diskPath,8192);
std::vector<std::uint8_t> disk, tape;
{
MachineSession m; auto fdc=std::make_shared<Fd502Device>(rom);
fdc->mount(0,DiskImage::blank());
m.cartridges().configure({nullptr,nullptr,nullptr,nullptr,fdc},true,4);
m.load(system);m.resume();frames(m,300);expect("DISK EXTENDED");
type(m,"CLS\rDSKINI0\r");frames(m,6000);expect("OK");
installPlanetSource(m);
type(m,"SAVE\"HELLO\"\r");frames(m,1200);expect("OK");
type(m,"CLS\rDIR\r");frames(m,120);expect("HELLO");disk=fdc->image(0)->bytes();
m.cassette().record(TapeFormat::CAS);type(m,"CSAVE\"HELLO\"\r");frames(m,1800);
if(m.cassette().snapshot().motor) throw std::runtime_error("Starter CSAVE did not finish");
tape=m.cassette().exportImage();
}
for(auto cpu:{Processor::MC6809,Processor::HD6309}) {
MachineSession m;auto fdc=std::make_shared<Fd502Device>(rom);fdc->mount(0,DiskImage::load(disk));
m.cartridges().configure({nullptr,nullptr,nullptr,nullptr,fdc},true,4);
m.cassette().mount(tape,TapeFormat::CAS);m.load(system,cpu);m.resume();frames(m,300);
expect("DISK EXTENDED");expect("OK");
if(m.cassette().snapshot().mode!=TapeMode::Stopped || m.cassette().snapshot().position!=0)
throw std::runtime_error("Starter cassette must remain stopped at launch");
type(m,"CLS\rLIST\r");frames(m,60);
if(!m.basicReadSource().empty())
throw std::runtime_error("Starter program was loaded automatically");
type(m,"LOAD\"HELLO\"\r");frames(m,1200);
runPlanetStarter(m,'1');
runPlanetStarter(m,'2');
type(m,"NEW\rCLS\r");m.cassette().play();type(m,"CLOAD\"HELLO\"\r");frames(m,3600);
runPlanetStarter(m,'1');
runPlanetStarter(m,'2');
if(fdc->image(0)->bytes()!=disk) throw std::runtime_error("Starter disk changed on read");
std::printf("PASS: starter Disk BASIC, no auto-load, disk LOAD/RUN, cassette CLOAD/RUN (%s)\n",cpu==Processor::MC6809?"6809":"6309");
}
auto write=[&](const char* name,const std::vector<std::uint8_t>& data) {
std::ofstream f(std::string(output)+"/"+name,std::ios::binary|std::ios::trunc);
f.write(reinterpret_cast<const char*>(data.data()),data.size());
if(!f)throw std::runtime_error("Could not write starter media");
};
write("Hello World.dsk",disk);write("Hello World.cas",tape);
}
// Authored BASIC-only hard-disk template. Reserved OS-9 space is zero-filled;
// no downloaded disk contents or operating system are redistributed.
void CreateHardBasicMedia(const char* systemPath, const char* rgbPath, const char* floppyPath, const char* output) {
using namespace VCC::Devices;
using namespace VCC::Mac;
auto read=[](const char* path, std::size_t size) {
std::ifstream f(path,std::ios::binary); std::vector<std::uint8_t> data(size+1);
f.read(reinterpret_cast<char*>(data.data()),data.size());
if(std::size_t(f.gcount())!=size) throw std::runtime_error("Unexpected hard BASIC input size");
data.resize(size);return data;
};
auto expect=[](const char* text) {
if(screen().find(text)==std::string::npos || screen().find("ERROR")!=std::string::npos)
throw std::runtime_error(std::string("Hard BASIC verification failed: ")+text+"\n"+screen());
};
const auto system=read(systemPath,32768), rgb=read(rgbPath,8192), floppy=read(floppyPath,161280);
constexpr std::size_t offset=0x5a000*256, volume=161280;
std::vector<std::uint8_t> image(offset+256*volume,0), blank, hello;
{
MachineSession m;auto hd=std::make_shared<HardDiskDevice>();hd->mount(0,HardDiskImage(image));
auto fd=std::make_shared<Fd502Device>(rgb);fd->mount(0,DiskImage::load(floppy));
m.cartridges().configure({nullptr,hd,nullptr,nullptr,fd},true,4);
m.load(system);m.resume();frames(m,600);expect("HARD DISK BASIC");
type(m,"CLS\rDSKINI0\r");frames(m,60);type(m,"Y");frames(m,1200);expect("OK");
const auto& formatted=hd->image(0)->bytes();
blank.assign(formatted.begin()+offset,formatted.begin()+offset+volume);
installPlanetSource(m);
type(m,"SAVE\"HELLO\"\r");frames(m,1200);expect("OK");
const auto& saved=hd->image(0)->bytes();
hello.assign(saved.begin()+offset,saved.begin()+offset+volume);
std::copy(hello.begin(),hello.end(),image.begin()+offset);
for(unsigned i=1;i<256;++i) std::copy(blank.begin(),blank.end(),image.begin()+offset+i*volume);
}
for(auto cpu:{Processor::MC6809,Processor::HD6309}) {
MachineSession m;auto hd=std::make_shared<HardDiskDevice>();hd->mount(0,HardDiskImage(image));
auto fd=std::make_shared<Fd502Device>(rgb);fd->mount(0,DiskImage::load(floppy));
m.cartridges().configure({nullptr,hd,nullptr,nullptr,fd},true,4);
m.load(system,cpu);m.resume();frames(m,600);expect("HARD DISK BASIC");
type(m,"CLS\rLIST\r");frames(m,60);expect("OK");
if(!m.basicReadSource().empty())
throw std::runtime_error("Hard BASIC must not load/run a program at boot");
const auto hdReads = hd->readEvents(0);
const auto fdReads = fd->readEvents(0);
type(m,"DIR\rLOAD\"HELLO\"\r");frames(m,600);expect("OK");
runPlanetStarter(m,'1');
runPlanetStarter(m,'2');
if(hd->readEvents(0)==hdReads || fd->readEvents(0)!=fdReads)
throw std::runtime_error("RGBDOS did not read the starter from HD0");
const auto afterHD = hd->readEvents(0);
type(m,"NEW\rDRIVE OFF\rLOAD\"HELLO\"\r");frames(m,1200);expect("OK");
runPlanetStarter(m,'1');
if(fd->readEvents(0)==fdReads || hd->readEvents(0)!=afterHD)
throw std::runtime_error("DRIVE OFF did not read the starter from FD0");
const auto afterFD = fd->readEvents(0);
type(m,"NEW\rDRIVE ON\rLOAD\"HELLO\"\r");frames(m,600);
runPlanetStarter(m,'2');
if(hd->readEvents(0)==afterHD || fd->readEvents(0)!=afterFD)
throw std::runtime_error("DRIVE ON did not return to HD0");
if(fd->image(0)->bytes()!=floppy || hd->image(0)->bytes()!=image)
throw std::runtime_error("Reading starters altered their images");
type(m,"CLS\rDRIVE255\rSAVE\"CHECK\"\r");frames(m,600);expect("OK");
auto saved=hd->image(0)->bytes();hd->eject(0,true);hd->mount(0,HardDiskImage(saved));
type(m,"NEW\rLOAD\"CHECK\"\r");frames(m,600);
runPlanetStarter(m,'2');
if(saved==image || !std::equal(image.begin(),image.begin()+offset+255*volume,saved.begin()))
throw std::runtime_error("Last virtual disk SAVE altered other volumes");
std::printf("PASS: Hard BASIC boot/no auto-load, HD/floppy LOAD/RUN, DRIVE OFF/ON, volume 255 SAVE/reopen (%s)\n",cpu==Processor::MC6809?"6809":"6309");
}
auto write=[&](const char* name,const std::vector<std::uint8_t>& data) {
std::ofstream f(std::string(output)+"/"+name,std::ios::binary|std::ios::trunc);
f.write(reinterpret_cast<const char*>(data.data()),data.size());
if(!f)throw std::runtime_error("Could not write authored hard BASIC template");
};
write("Blank Disk.dsk",blank);write("Hello Hard Disk.dsk",hello);
}
void CheckClipboardRom(const char* path) {
std::ifstream file(path,std::ios::binary);
std::vector<std::uint8_t> rom((std::istreambuf_iterator<char>(file)),{});
for(auto cpu:{VCC::Mac::Processor::MC6809,VCC::Mac::Processor::HD6309}) {
VCC::Mac::MachineSession m;m.load(rom,cpu);m.resume();frames(m,300);
auto paste=[&](const std::string& text) {
std::vector<std::uint64_t> keys;
for(char c:text) {
auto chord=key(c);
if(c>='A' && c<='Z')chord|=std::uint64_t{1}<<55; // Native clipboard uppercase mapping.
keys.push_back(chord);
}
m.paste(keys);
for(unsigned n=0;m.pasteRemaining() && n<20000;++n)m.advance();
if(m.pasteRemaining())throw std::runtime_error("Paste did not finish");
frames(m,30);
};
paste("10 PRINT 6*7\r20 PRINT 7*7\r");
paste("20 PRINT 8*8\rCLS\rRUN\r");
auto text=m.copyScreenText();
if(text.find(" 42")==std::string::npos || text.find(" 64")==std::string::npos || text.find(" 49")!=std::string::npos)
throw std::runtime_error("BASIC merge/copy did not preserve or replace lines: "+text);
paste("NEW\r10 PRINT 9*9\rCLS\rRUN\r");text=m.copyScreenText();
if(text.find(" 81")==std::string::npos || text.find(" 42")!=std::string::npos)
throw std::runtime_error("BASIC replacement/copy failed: "+text);
// Verify the safe entry limit through the actual interpreter.
std::string line="30 REM "+std::string(242,'A'); // exactly 249 characters
paste(line+"\r");
paste("CLS\rLIST 30\r");text=m.copyScreenText();
if(text.find("30 REM")==std::string::npos || std::count(text.begin(),text.end(),'A')!=242)
throw std::runtime_error("Boundary BASIC line failed: "+text);
std::printf("PASS: paced BASIC merge/replace, 249-character boundary, copy screen (%s)\n",cpu==VCC::Mac::Processor::MC6809?"6809":"6309");
}
}
// Optional private-ROM integration; generated PCM is a local listening artifact.
void CheckOrchestraRom(const char* systemPath, const char* orchestraPath, const char* outputPrefix) {
auto read = [](const char* path, std::size_t size) {
std::ifstream f(path, std::ios::binary); std::vector<std::uint8_t> b(size+1);
f.read(reinterpret_cast<char*>(b.data()), b.size());
if (std::size_t(f.gcount()) != size) throw std::runtime_error("Unexpected Orchestra reference ROM size");
b.resize(size); return b;
};
auto system = read(systemPath,32768), rom = read(orchestraPath,8192);
for (auto cpu : {VCC::Mac::Processor::MC6809, VCC::Mac::Processor::HD6309}) {
VCC::Mac::MachineSession m;
m.cartridges().configure({nullptr,std::make_shared<VCC::Devices::Orchestra90Device>(rom),nullptr,nullptr,nullptr},true,1);
m.load(system,cpu); m.resume(); frames(m,300);
type(m," "); frames(m,60); // Dismiss the copyright screen, per manual page 8.
if (screen().find("WILLIAM TELL") == std::string::npos) {
std::fprintf(stderr,"%s",screen().c_str()); throw std::runtime_error("Orchestra ROM did not reach its demonstration screen");
}
type(m,"S\r"); frames(m,600); m.takeAudio();
type(m,"P\r"); m.takeAudio();
std::vector<VCC::Mac::StereoSample> pcm;
for (unsigned i=0;i<3600;++i) { m.advance(); auto part=m.takeAudio(); pcm.insert(pcm.end(),part.begin(),part.end()); }
float minL=1,maxL=-1,minR=1,maxR=-1; unsigned different=0;
for(auto v:pcm) { minL=std::min(minL,v.left);maxL=std::max(maxL,v.left);minR=std::min(minR,v.right);maxR=std::max(maxR,v.right);different+=v.left!=v.right; }
if(maxL-minL<.05f || maxR-minR<.05f || different<1000) throw std::runtime_error("Demonstration did not produce independent stereo music");
std::string path=std::string(outputPrefix)+(cpu==VCC::Mac::Processor::MC6809 ? "-6809.wav" : "-6309.wav");
if (pcm.size() > (std::numeric_limits<std::uint32_t>::max() - 36u) / 4u)
throw std::runtime_error("Listening capture exceeds the WAV size limit");
const auto dataBytes = static_cast<std::uint32_t>(pcm.size() * 4u);
std::ofstream out(path,std::ios::binary);
auto word=[&](std::uint32_t v,unsigned n){while(n--){out.put(v&255);v>>=8;}};
out.write("RIFF",4);word(36u+dataBytes,4);out.write("WAVEfmt ",8);word(16,4);word(1,2);word(2,2);
word(44100,4);word(44100*4,4);word(4,2);word(16,2);out.write("data",4);word(dataBytes,4);
for(auto v:pcm) {word(std::uint16_t(std::int16_t(v.left*32767)),2);word(std::uint16_t(std::int16_t(v.right*32767)),2);}
if(!out)throw std::runtime_error("Could not write private listening capture");
std::printf("Orchestra %s: %zu stereo samples, %u differing channels, ranges %.3f/%.3f; %s\n",cpu==VCC::Mac::Processor::MC6809 ? "6809" : "6309",pcm.size(),different,maxL-minL,maxR-minR,path.c_str());
}
}
// Authored guest sends documented SSC command bytes, polling BUSY before each.
void CheckSpeechSoundRom(const char* systemPath, const char* picPath, const char* speechPath, const char* outputPrefix) {
using namespace VCC::Mac;
auto read=[](const char* path,std::size_t size){
std::ifstream f(path,std::ios::binary);std::vector<std::uint8_t> b(size+1);
f.read(reinterpret_cast<char*>(b.data()),b.size());
if(std::size_t(f.gcount())!=size)throw std::runtime_error("Unexpected Speech/Sound reference ROM size");
b.resize(size);return b;
};
auto system=read(systemPath,32768),rom=read(picPath,4096),speech=read(speechPath,2048);
rom.insert(rom.end(),speech.begin(),speech.end());
for(auto cpu:{Processor::MC6809,Processor::HD6309}) {
MachineSession m;auto device=std::make_shared<VCC::Devices::SpeechSoundDevice>(rom);
m.cartridges().configure({nullptr,nullptr,device,nullptr,nullptr},true,4);
m.load(system,cpu);m.resume();frames(m,60);m.takeAudio();
auto send=[&](const std::vector<std::uint8_t>& bytes){
const auto end=0x3040+bytes.size();
// Authored guest explicitly selects cartridge SND and enables the
// analog mux, just as physical Speech/Sound software must do.
std::vector<std::uint8_t> code{0xb6,0xff,0x01,0x84,0xf7,0xb7,0xff,0x01,
0xb6,0xff,0x03,0x8a,0x08,0xb7,0xff,0x03,
0xb6,0xff,0x23,0x8a,0x08,0xb7,0xff,0x23,0x8e,0x30,0x40,0x8c,std::uint8_t(end>>8),std::uint8_t(end),
0x27,12,0xe6,0x80,0xb6,0xff,0x7e,0x2a,0xfb,0xf7,0xff,0x7e,0x20,0xef,0x20,0xfe};
code.resize(64,0x12);code.insert(code.end(),bytes.begin(),bytes.end());
std::vector<std::uint8_t> binary{0,0,std::uint8_t(code.size()),0x30,0};
binary.insert(binary.end(),code.begin(),code.end());binary.insert(binary.end(),{0xff,0,0,0x30,0});
m.quickLoad(binary);
};
std::string phrase="HELLO FROM YOUR COLOR COMPUTER. \r";
send({phrase.begin(),phrase.end()});
std::vector<StereoSample> pcm;
for(unsigned i=0;i<600;++i){m.advance();auto part=m.takeAudio();pcm.insert(pcm.end(),part.begin(),part.end());}
if(device->diagnostics().CommandCount()!=phrase.size() || device->diagnostics().AldSpeechCount()<5 || device->diagnostics().CpuIllegalCount()!=0)
throw std::runtime_error("Speech firmware failed command/phoneme execution");
float low=1,high=-1;
for(auto sample:pcm){low=std::min(low,sample.left);high=std::max(high,sample.left);if(sample.left!=sample.right)throw std::runtime_error("SSC must be mono on both output channels");}
if(high-low<.05f)throw std::runtime_error("Speech produced no signal");
std::string path=std::string(outputPrefix)+(cpu==Processor::MC6809?"-6809.wav":"-6309.wav");
if (pcm.size() > (std::numeric_limits<std::uint32_t>::max() - 36u) / 4u)
throw std::runtime_error("Listening capture exceeds the WAV size limit");
const auto dataBytes = static_cast<std::uint32_t>(pcm.size() * 4u);
std::ofstream out(path,std::ios::binary);
auto word=[&](std::uint32_t v,unsigned n){while(n--){out.put(v&255);v>>=8;}};
out.write("RIFF",4);word(36u+dataBytes,4);out.write("WAVEfmt ",8);word(16,4);word(1,2);word(2,2);
word(44100,4);word(44100*4,4);word(4,2);word(16,2);out.write("data",4);word(dataBytes,4);
// Capture the actual signed native PCM without introducing a DC offset.
for(auto v:pcm){word(std::uint16_t(std::int16_t(std::clamp(v.left,-1.0f,1.0f)*32767)),2);word(std::uint16_t(std::int16_t(std::clamp(v.right,-1.0f,1.0f)*32767)),2);}
if(!out)throw std::runtime_error("Could not write speech listening capture");
const auto ay=device->diagnostics().AyWriteCount();
send({0xaf,0,100,1,0,7,62,8,15,0xff});
float musicLow=1,musicHigh=-1;
for(unsigned i=0;i<60;++i){m.advance();for(auto v:m.takeAudio()){musicLow=std::min(musicLow,v.left);musicHigh=std::max(musicHigh,v.left);}}
if(device->diagnostics().AyWriteCount()<ay+4 || musicHigh-musicLow<.05f)throw std::runtime_error("SSC music registers produced no tone");
send({0});frames(m,30);
std::printf("PASS SSC %s: %zu speech samples, %u phonemes, range %.3f; AY tone range %.3f; %s\n",cpu==Processor::MC6809?"6809":"6309",pcm.size(),device->diagnostics().AldSpeechCount(),high-low,musicHigh-musicLow,path.c_str());
}
}
// Direct-memory BASIC transfers must match bytes produced by the ROM itself.
void CheckBasicProgramRom(const char* systemPath, const char* diskPath) {
auto read = [](const char* path) {
std::ifstream stream(path, std::ios::binary);
if (!stream) throw std::runtime_error("Unable to open BASIC integration ROM");
return std::vector<std::uint8_t>((std::istreambuf_iterator<char>(stream)), {});
};
const auto system=read(systemPath), disk=read(diskPath);
for (auto cpu : {VCC::Mac::Processor::MC6809,VCC::Mac::Processor::HD6309}) {
VCC::Mac::MachineSession m;
auto floppy = std::make_shared<VCC::Devices::Fd502Device>(disk);
m.cartridges().configure({nullptr,nullptr,nullptr,nullptr,floppy},true,4);
m.load(system,cpu);m.resume();frames(m,300);
type(m,"10 PRINT 6*7\r20 END\r");frames(m,30);
auto program = [&] {
unsigned start=(SafeMemRead8(0x19)<<8)|SafeMemRead8(0x1a), end=(SafeMemRead8(0x1b)<<8)|SafeMemRead8(0x1c);
std::vector<std::uint8_t> bytes;
for(unsigned p=start;p<end;++p) bytes.push_back(SafeMemRead8(p));
return bytes;
};
const auto oracle=program();
m.pause();const auto before=m.snapshot();
m.basicLoadSource("10 PRINT 6*7\n20 END\n",false);
if(program()!=oracle || m.snapshot().cycles!=before.cycles || m.snapshot().state!=VCC::Mac::RunState::Paused)
throw std::runtime_error("Direct BASIC bytes differ from ROM or paused load executed instructions");
if(m.basicReadSource()!="10 PRINT 6*7\n20 END\n") throw std::runtime_error("BASIC source readback differs");
m.basicLoadSource("10 PRINT 6*7\n20 END\n",true);frames(m,180);
if(screen().find(" 42 ")==std::string::npos || m.pasteRemaining() || m.snapshot().generation!=before.generation)
throw std::runtime_error("Direct BASIC Run did not execute without reset or paste");
const auto exportBefore=m.snapshot();
std::string exportSource="10 REM EXPORTED SOURCE\n20 PRINT 6*7\n30 END\n";
for(unsigned line=40;line<240;line+=10)exportSource+=std::to_string(line)+" REM "+std::string(180,'X')+"\n";
const auto exportedDisk=m.basicExportSource(exportSource,"HELLO",VCC::Mac::BasicExportFormat::Disk);
const auto exportedTape=m.basicExportSource(exportSource,"HELLO",VCC::Mac::BasicExportFormat::Cassette);
if(m.snapshot().cycles!=exportBefore.cycles || m.snapshot().cpu.PC!=exportBefore.cpu.PC || program()!=oracle)
throw std::runtime_error("BASIC export changed running machine state");
floppy->mount(0,VCC::Devices::DiskImage::load(exportedDisk));
type(m,"NEW\rCLS\rLOAD\"HELLO\"\r");frames(m,1200);
if(m.basicReadSource()!=exportSource) throw std::runtime_error("Exported DSK did not LOAD identical BASIC source: "+screen());
type(m,"RUN\r");frames(m,60);
if(screen().find(" 42 ")==std::string::npos)throw std::runtime_error("Exported DSK program did not execute");
type(m,"NEW\rCLS\r");m.cassette().mount(exportedTape,VCC::Mac::TapeFormat::CAS);m.cassette().setFast(false);m.cassette().play();
type(m,"CLOAD\"HELLO\"\r");frames(m,3600);
if(m.basicReadSource()!=exportSource)throw std::runtime_error("Exported CAS did not CLOAD identical BASIC source: "+screen());
type(m,"RUN\r");frames(m,60);
if(screen().find(" 42 ")==std::string::npos)throw std::runtime_error("Exported CAS program did not execute");
const auto stable=m.basicReadSource();
bool rejected=false;
try {m.basicLoadSource("10 PRINT1\n10 PRINT2",true);}catch(const std::exception&){rejected=true;}
if(!rejected || m.basicReadSource()!=stable) throw std::runtime_error("Rejected BASIC source changed RAM");
m.basicLoadSource("10 GOTO10",true);frames(m,10);
rejected=false;try{m.basicLoadSource("10 END",true);}catch(const std::exception&){rejected=true;}
if(!rejected || m.basicReadSource()!="10 GOTO10\n") throw std::runtime_error("Running BASIC program was replaced");
std::printf("PASS: BASIC token oracle, paused Load/Read/Run, disk LOAD/cassette CLOAD multi-block exports, output, and atomic rejection (%s)\n",cpu==VCC::Mac::Processor::MC6809?"6809":"6309");
}
}
void CheckGraphicsPreviewRom(const char* systemPath, const char* diskPath, const char* programPath) {
using namespace VCC::Mac;
using Mode = DebugGraphicsMode;
auto read = [](const char* path) {
std::ifstream input(path, std::ios::binary);
if (!input) throw std::runtime_error(std::string("Unable to open ") + path);
return std::vector<std::uint8_t>((std::istreambuf_iterator<char>(input)), {});
};
const auto system = read(systemPath), disk = read(diskPath), sourceBytes = read(programPath);
const std::string program(sourceBytes.begin(), sourceBytes.end());
auto expect = [](bool condition, const char* message) {
if (!condition) throw std::runtime_error(message);
};
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
MachineSession machine;
auto floppy = std::make_shared<VCC::Devices::Fd502Device>(disk);
machine.cartridges().configure({nullptr, nullptr, nullptr, nullptr, floppy}, true, 4);
machine.load(system, cpu);
machine.resume();
frames(machine, 300);
machine.basicLoadSource(program, true, {40, 50, 60});
auto stop = [&](int line) {
for (unsigned i = 0; i < 300 && machine.snapshot().state == RunState::Running; ++i)
machine.advance();
const auto stopped = machine.snapshot();
if (stopped.basicStoppedLine != line || stopped.state != RunState::Paused || !stopped.frame)
throw std::runtime_error("Two-page program did not stop before line " + std::to_string(line));
return stopped;
};
auto current = [&] { return machine.debuggerGraphicsPreview(true, false, 0, Mode::SG4); };
// These are Disk BASIC's legacy pages 1 and 3 in the default memory map.
// A PMODE 1 bitmap occupies two consecutive 1,536-byte pages.
constexpr unsigned first = 0x0e00, second = 0x1a00;
auto mapped = [&](unsigned address) { return machine.debuggerGraphicsPreview(false, false, address, Mode::PMODE1); };
auto compareToFrame = [&](const DebugGraphicsPreview& preview, const Snapshot& stopped) {
expect(preview.width == 128 && preview.height == 96 && preview.bytesPerRow == 32 &&
preview.pixels.size() == 128*96 && preview.modeName == "PMODE 1", "Wrong active PMODE 1 layout");
const auto& frame = *stopped.frame;
const auto r = frame.activeArea;
expect(r.width == 512 && r.height == 384, "Unexpected live PMODE raster geometry");
for (unsigned y = 0; y < 96; ++y)
for (unsigned x = 0; x < 128; ++x)
expect(frame.pixels[(r.y+y*4)*Frame::width + r.x+x*4] == preview.pixels[y*128+x],
"Current-page colors differ from the actual published video frame");
};
const auto beforeDraw = stop(40);
const auto front = current(), hiddenBlank = mapped(second);
compareToFrame(front, beforeDraw);
expect(front.physical && front.pixels == mapped(first).pixels && front.bytes == mapped(first).bytes,
"Mapped page 1 does not match displayed RAM");
expect(front.pixels[10*128+10] != front.pixels[0], "First page is missing its square");
expect(std::all_of(hiddenBlank.bytes.begin(), hiddenBlank.bytes.end(), [](auto b) { return b == 0xff; }),
"The selected drawing page should still be clear");
machine.basicContinue(program);
const auto beforeFlip = stop(50);
const auto stillFront = current(), hiddenDrawing = mapped(second);
compareToFrame(stillFront, beforeFlip);
expect(front.pixels == stillFront.pixels && front.address == stillFront.address &&
beforeDraw.frame->pixels == beforeFlip.frame->pixels, "Drawing to hidden page affected the displayed screen");
for (unsigned y = 0; y < 96; ++y) {
for (unsigned x = 0; x < 128; ++x) {
const bool changed = hiddenDrawing.pixels[y*128+x] != hiddenBlank.pixels[y*128+x];
expect(changed == (x >= 80 && x < 112 && y >= 32 && y < 64),
"The hidden square must occupy exactly its BASIC coordinates");
}
}
const auto selected = hiddenDrawing.pixelInfo(81, 32);
expect(hiddenDrawing.byteAddresses[selected.byteIndex] == 0x1e14 &&
hiddenDrawing.bytes[selected.byteIndex] == 0xaa && selected.mask == 0x30,
"Wrong mapped byte or bits for a pixel in the hidden drawing");
expect(machine.snapshot().cycles == beforeFlip.cycles && machine.snapshot().cpu.PC == beforeFlip.cpu.PC,
"Preview moved the stopped CPU");
machine.basicContinue(program);
const auto afterFlip = stop(60);
const auto displayed = current();
compareToFrame(displayed, afterFlip);
expect(displayed.address == front.address + second - first &&
displayed.bytes == hiddenDrawing.bytes && displayed.pixels == hiddenDrawing.pixels &&
mapped(first).pixels == front.pixels, "SCREEN did not reveal the untouched second page");
std::printf("PASS: PMODE 1 two-page preview, 1,024 hidden changed pixels, $1E14 bits 5–4, "
"and SCREEN page flip (%s)\n", cpu == Processor::MC6809 ? "6809" : "6309");
}
}