Files
VCCPlusOSS/platforms/macos/Bridge/VCCMachineController.mm
T

2219 lines
138 KiB
Plaintext
Raw 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
#include <atomic>
#import "VCCMachineController.h"
#include "../../../src/core/MachineSession.h"
#include "../../../src/core/DebugDisassembler.h"
#include "MacAudioOutput.h"
#include "DriveWireEndpoint.h"
#include "../../../src/core/FramePacing.h"
#include "../../../src/devices/FD502/Fd502Device.h"
#include "../../../src/devices/RomCartridge.h"
#include "../../../src/devices/RamDiskDevice.h"
#include "../../../src/devices/Orchestra90Device.h"
#include "../../../src/devices/SpeechSoundDevice.h"
#include "../../../src/devices/SDCDevice.h"
#include "../../../src/devices/HardDisk/HardDiskDevice.h"
#include "../../../src/core/BinaryImage.h"
#include <chrono>
#include <algorithm>
#include <cmath>
#include <exception>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
@interface VCCTraceRecord ()
@property(nonatomic, readwrite) NSUInteger index;
@property(nonatomic, readwrite) uint64_t clock, frame;
@property(nonatomic, readwrite) NSInteger cycles;
@property(nonatomic, readwrite) uint16_t address;
@property(nonatomic, readwrite, copy) NSString *kind, *instruction, *detail, *before, *after;
@end
@implementation VCCTraceRecord
@end
@interface VCCTraceSnapshot ()
@property(nonatomic, readwrite) BOOL armed, capturing;
@property(nonatomic, readwrite) uint64_t identifier;
@property(nonatomic, readwrite) NSUInteger total, limit, offset;
@property(nonatomic, readwrite, copy) NSString *status;
@property(nonatomic, readwrite, copy) NSArray<VCCTraceRecord *> *records;
@end
@implementation VCCTraceSnapshot
@end
static NSString* TraceRegisters(const VCC::CPUState& state, bool extended) {
auto common = [NSString stringWithFormat:@"PC %04X A %02X B %02X X %04X Y %04X U %04X S %04X DP %02X CC %02X", state.PC, state.A, state.B, state.X, state.Y, state.U, state.S, state.DP, state.CC];
return extended ? [common stringByAppendingFormat:@" E %02X F %02X V %04X MD %02X", state.E, state.F, state.V, state.MD] : common;
}
static NSString* TraceKind(VCC::TraceEvent event) {
switch (event) {
case VCC::TraceEvent::Instruction: return @"Instruction";
case VCC::TraceEvent::IRQRequested: return @"IRQ requested";
case VCC::TraceEvent::IRQMasked: return @"IRQ masked";
case VCC::TraceEvent::IRQServicing: return @"IRQ servicing";
case VCC::TraceEvent::IRQExecuting: return @"IRQ vector";
case VCC::TraceEvent::ScreenHSYNCLow: return @"HSYNC low";
case VCC::TraceEvent::ScreenHSYNCHigh: return @"HSYNC high";
case VCC::TraceEvent::ScreenVSYNCLow: return @"VSYNC low";
case VCC::TraceEvent::ScreenVSYNCHigh: return @"VSYNC high";
case VCC::TraceEvent::ScreenReg: return @"Video register";
case VCC::TraceEvent::ScreenTopBorder: return @"Top border";
case VCC::TraceEvent::ScreenRender: return @"Active display";
case VCC::TraceEvent::ScreenBottomBorder: return @"Bottom border";
case VCC::TraceEvent::EmulatorCycle: return @"Scheduler";
default: return @"Event";
}
}
static std::vector<uint16_t> DebugAddresses(NSArray<NSNumber*>* values, unsigned maximum) {
if (values.count > maximum) throw std::invalid_argument("Too many debugger addresses");
std::vector<uint16_t> result;
for (NSNumber* value in values) {
const double n = value.doubleValue;
if (!std::isfinite(n) || n < 0 || n > 65535 || n != std::floor(n)) throw std::invalid_argument("Use logical addresses from 0000 to FFFF");
result.push_back(uint16_t(n));
}
return result;
}
@interface VCCDebugInstruction ()
@property(nonatomic, readwrite) uint16_t address;
@property(nonatomic, readwrite, copy) NSData *bytes;
@property(nonatomic, readwrite, copy) NSString *mnemonic, *operand;
@property(nonatomic, readwrite) BOOL valid;
@end
@implementation VCCDebugInstruction
@end
@interface VCCDebugMemoryCapture ()
@property(nonatomic, readwrite) VCCMachineSnapshot *machine;
@property(nonatomic, readwrite) uint32_t address, capacity;
@property(nonatomic, readwrite, copy) NSData *bytes, *available;
@property(nonatomic, readwrite, copy) NSArray<VCCDebugInstruction *> *instructions;
@property(nonatomic, readwrite, copy) NSArray<NSNumber *> *instructionOffsets;
@end
@implementation VCCDebugMemoryCapture
@end
@interface VCCDebugGraphicsPixel ()
@property(nonatomic, readwrite) uint32_t address;
@property(nonatomic, readwrite) uint8_t value, mask;
@property(nonatomic, readwrite) BOOL available;
@property(nonatomic, readwrite) NSNumber *attributeAddress, *attributeValue;
@end
@implementation VCCDebugGraphicsPixel
@end
@interface VCCDebugGraphicsCapture ()
@property(nonatomic, readwrite) VCCMachineSnapshot *machine;
@property(nonatomic, readwrite, copy) NSString *errorMessage;
- (void)takePreview:(VCC::Mac::DebugGraphicsPreview&)preview;
@end
@implementation VCCDebugGraphicsCapture {
VCC::Mac::DebugGraphicsPreview _source;
NSData *_rgba;
NSString *_modeName;
}
- (void)takePreview:(VCC::Mac::DebugGraphicsPreview&)preview {
_modeName = [NSString stringWithUTF8String:preview.modeName.c_str()];
NSMutableData *rgba = [NSMutableData dataWithLength:preview.pixels.size() * 4];
auto* out = static_cast<uint8_t*>(rgba.mutableBytes);
for (const auto rgb : preview.pixels) {
*out++ = uint8_t(rgb >> 16);
*out++ = uint8_t(rgb >> 8);
*out++ = uint8_t(rgb);
*out++ = 255;
}
_rgba = rgba;
// Keep only the packed RGBA buffer and source-byte metadata after publication.
std::vector<uint32_t>().swap(preview.pixels);
_source = std::move(preview);
}
- (NSString *)modeName { return _modeName ?: @""; }
- (NSData *)rgba { return _rgba ?: [NSData data]; }
- (NSInteger)width { return _source.width; }
- (NSInteger)height { return _source.height; }
- (uint32_t)address { return _source.address; }
- (BOOL)physical { return _source.physical; }
- (VCCDebugGraphicsPixel *)pixelAtX:(NSInteger)x y:(NSInteger)y {
if (!_rgba || x < 0 || y < 0 || x >= self.width || y >= self.height) return nil;
const auto selection = _source.pixelInfo(unsigned(x), unsigned(y));
const auto i = selection.byteIndex;
auto result = [VCCDebugGraphicsPixel new];
result.address = _source.byteAddresses[i];
result.available = _source.available[i] != 0;
result.value = _source.bytes[i];
result.mask = selection.mask;
if (_source.bytesPerCell == 2) {
result.attributeAddress = @(_source.byteAddresses[i + 1]);
if (_source.available[i + 1]) result.attributeValue = @(_source.bytes[i + 1]);
}
return result;
}
- (BOOL)hasSameLayoutAs:(VCCDebugGraphicsCapture *)other {
if (!_rgba || !other->_rgba || self.machine.generation != other.machine.generation) return NO;
const auto& otherSource = other->_source;
return (_source.physical || self.machine.debuggerMappingFingerprint == other.machine.debuggerMappingFingerprint)
&& _source.physical == otherSource.physical && _source.address == otherSource.address
&& _source.width == otherSource.width && _source.height == otherSource.height
&& _source.modeName == otherSource.modeName && _source.bytesPerCell == otherSource.bytesPerCell
&& _source.pixelsPerByte == otherSource.pixelsPerByte && _source.linesPerRow == otherSource.linesPerRow
&& _source.rowByteOffsets == otherSource.rowByteOffsets && _source.byteAddresses == otherSource.byteAddresses;
}
@end
@interface VCCMemoryMapping ()
@property(nonatomic, readwrite) uint16_t page;
@property(nonatomic, readwrite) uint32_t ramAddress, sourceAddress;
@property(nonatomic, readwrite) NSInteger source;
@end
@implementation VCCMemoryMapping
@end
@interface VCCMMUSnapshot ()
@property(nonatomic, readwrite) BOOL enabled, ramVectors, allRAM;
@property(nonatomic, readwrite) NSUInteger activeTask, romMap, prefix;
@property(nonatomic, readwrite) uint32_t ramByteCount, vectorRAMAddress;
@property(nonatomic, readwrite, copy) NSArray<NSNumber *> *task0, *task1;
@property(nonatomic, readwrite, copy) NSArray<VCCMemoryMapping *> *effective;
@end
@implementation VCCMMUSnapshot
@end
@interface VCCDebuggerSnapshot ()
@property(nonatomic, readwrite) VCCMachineSnapshot *machine;
@property(nonatomic, readwrite, copy) NSDictionary<NSString *, NSNumber *> *registers;
@property(nonatomic, readwrite, copy) NSArray<VCCDebugInstruction *> *instructions;
@property(nonatomic, readwrite, copy) NSArray<NSNumber *> *breakpoints, *disabledBreakpoints;
@property(nonatomic, readwrite) uint16_t memoryAddress;
@property(nonatomic, readwrite, copy) NSData *memory, *memoryAvailable;
@property(nonatomic, readwrite, copy) NSData *logicalMemory, *logicalMemoryAvailable;
@property(nonatomic, readwrite, copy) NSString *stopReason;
@property(nonatomic, readwrite) VCCMMUSnapshot *mmu;
@property(nonatomic, readwrite) uint32_t physicalAddress;
@property(nonatomic, readwrite, copy) NSData *physicalMemory;
@end
@implementation VCCDebuggerSnapshot
@end
@implementation VCCMachineProfile
- (instancetype)init {
if ((self = [super init])) {
_ram = 1; _overclock = _frameInterval = 1; _physicalSlot = 4; _videoOutput = 1;
_volume = 0.5; _sound = _clockEnabled = _clockReadOnly = YES;
_diskROMName = @"";
_kinds = @[@0,@0,@0,@0,@0];
_cartridgeROMs = @[[NSData data],[NSData data],[NSData data],[NSData data],[NSData data]];
_cartridgeNames = @[@"",@"",@"",@"",@""];
_sdcFolders = @[@"",@"",@"",@"",@""]; _sdcReadOnly = @[@YES,@YES,@YES,@YES,@YES];
_images = @[[NSData data],[NSData data],[NSData data],[NSData data],[NSData data],[NSData data]];
_imageNames = @[@"",@"",@"",@"",@"",@""];
_readOnly = _protectedImages = @[@NO,@NO,@NO,@NO,@NO,@NO];
}
return self;
}
- (id)copyWithZone:(NSZone*)zone {
auto value = [[VCCMachineProfile allocWithZone:zone] init];
value.use6309 = self.use6309;
value.fastForward = self.fastForward;
value.sound = self.sound;
value.multiPak = self.multiPak;
value.clockEnabled = self.clockEnabled;
value.clockReadOnly = self.clockReadOnly;
value.cassetteWAV = self.cassetteWAV;
value.fastCassette = self.fastCassette;
value.ram = self.ram;
value.overclock = self.overclock;
value.frameInterval = self.frameInterval;
value.videoOutput = self.videoOutput;
value.physicalSlot = self.physicalSlot;
value.volume = self.volume;
value.systemROM = self.systemROM;
value.diskROM = self.diskROM;
value.cassette = self.cassette;
value.diskROMName = self.diskROMName;
value.kinds = [[NSArray alloc] initWithArray:self.kinds copyItems:YES];
value.readOnly = [[NSArray alloc] initWithArray:self.readOnly copyItems:YES];
value.protectedImages = [[NSArray alloc] initWithArray:self.protectedImages copyItems:YES];
value.cartridgeROMs = [[NSArray alloc] initWithArray:self.cartridgeROMs copyItems:YES];
value.images = [[NSArray alloc] initWithArray:self.images copyItems:YES];
value.cartridgeNames = [[NSArray alloc] initWithArray:self.cartridgeNames copyItems:YES];
value.imageNames = [[NSArray alloc] initWithArray:self.imageNames copyItems:YES];
value.sdcFolders = [[NSArray alloc] initWithArray:self.sdcFolders copyItems:YES];
value.sdcReadOnly = [[NSArray alloc] initWithArray:self.sdcReadOnly copyItems:YES];
return value;
}
@end
@interface VCCDiskSnapshot ()
@property(nonatomic, readwrite) BOOL mounted, dirty, writeProtected, sourceReadOnly;
@property(nonatomic, readwrite, copy) NSString *name;
@property(nonatomic, readwrite, copy) NSString *floppyExtension;
@property(nonatomic, readwrite) BOOL formatWriteProtected;
@property(nonatomic, readwrite) NSUInteger tracks, sides, byteCount;
@property(nonatomic, readwrite) uint64_t readEvents, writeEvents;
@end
@implementation VCCDiskSnapshot
@end
@interface VCCDiskEditCapture ()
@property(nonatomic, readwrite, copy) NSData *data;
@property(nonatomic, readwrite, copy) NSString *name;
@property(nonatomic, readwrite) uint64_t token;
@property(nonatomic, readwrite) NSInteger drive;
@property(nonatomic, readwrite) BOOL canApply;
@end
@implementation VCCDiskEditCapture
@end
@interface VCCHardDiskSave ()
@property(nonatomic, readwrite, copy) NSData *data;
@property(nonatomic, readwrite) uint64_t token;
@property(nonatomic, readwrite) NSUInteger byteCount;
@end
@implementation VCCHardDiskSave
@end
@interface VCCPrinterOutput ()
@property(nonatomic, readwrite, copy) NSData *bytes;
@property(nonatomic, readwrite) uint64_t revision, droppedBytes;
@property(nonatomic, readwrite) NSUInteger capacity;
@property(nonatomic, readwrite) BOOL enabled;
@end
@implementation VCCPrinterOutput
@end
@interface VCCJoystickInputSnapshot ()
@property(nonatomic, readwrite) NSUInteger x, y, buttons, mode;
@end
@implementation VCCJoystickInputSnapshot
@end
@interface VCCMachineSnapshot ()
@property(nonatomic, readwrite) NSUInteger pasteRemaining;
@property(nonatomic, readwrite) BOOL printerEnabled;
@property(nonatomic, readwrite) uint64_t printerRevision, printerDroppedBytes;
@property(nonatomic, readwrite) NSUInteger printerByteCount;
@property(nonatomic, readwrite) VCCMachineState state;
@property(nonatomic, readwrite) uint64_t generation, frames, cycles;
@property(nonatomic, readwrite, copy) NSArray<VCCJoystickInputSnapshot *> *joystickInputs;
@property(nonatomic, readwrite) BOOL keyboardInputHeld;
@property(nonatomic, readwrite) uint64_t debuggerProgramRevision, debuggerMappingFingerprint, assistantMediaRevision;
@property(nonatomic, readwrite) BOOL debuggerDevelopmentAttached, debuggerAssemblyAttached, debuggerSourceStepping;
@property(nonatomic, readwrite) BOOL debuggerBankedDevelopment;
@property(nonatomic, readwrite) BOOL basicDebugAttached, assistantCompiledReturned;
@property(nonatomic, readwrite, nullable) NSNumber *assistantDirectPrompt, *assistantEmptyBASIC;
@property(nonatomic, readwrite, copy, nullable) NSString *assistantLoadedSource;
@property(nonatomic, readwrite) NSInteger basicStoppedLine;
@property(nonatomic, readwrite) NSInteger basicSourceOffset;
@property(nonatomic, readwrite) NSUInteger basicSourceLength;
@property(nonatomic, readwrite) BOOL basicStepping, basicCanStepOut;
@property(nonatomic, readwrite) NSInteger basicErrorLine;
@property(nonatomic, readwrite, copy) NSString *basicErrorCode;
@property(nonatomic, readwrite, copy) NSString *basicDebugStatus;
@property(nonatomic, readwrite) uint16_t programCounter;
@property(nonatomic, readwrite) CGRect activeVideoRect;
@property(nonatomic, readwrite, copy, nullable) NSData *pixels;
@property(nonatomic, readwrite, copy, nullable) NSString *errorMessage;
@property(nonatomic, readwrite) BOOL use6309, fastForward;
@property(nonatomic, readwrite) NSUInteger ramConfiguration, cpuOverclock, frameInterval;
@property(nonatomic, readwrite) uint64_t presentedFrame, pixelRevision;
@property(nonatomic, readwrite) NSInteger videoOutput;
@property(nonatomic, readwrite) BOOL audioEnabled;
@property(nonatomic, readwrite) BOOL driveWireEnabled;
@property(nonatomic, readwrite, copy) NSString *macShellStatus;
@property(nonatomic, readwrite) uint64_t macShellRequestID;
@property(nonatomic, readwrite) uint64_t audioUnderruns, audioOverruns, audioConsumed;
@property(nonatomic, readwrite) uint64_t audioSubmitted, audioSignalSamples, audioBuffered, audioStarts;
@property(nonatomic, readwrite) uint64_t audioMaximumRequest, audioMaximumRefillGapNanoseconds;
@property(nonatomic, readwrite) BOOL tapeMounted, tapeMotor, tapeDirty, tapeFast, tapeWAV;
@property(nonatomic, readwrite) NSInteger tapeMode;
@property(nonatomic, readwrite) uint64_t tapePosition, tapeLength;
@property(nonatomic, readwrite) uint64_t tapeReadEvents, tapeWriteEvents;
@property(nonatomic, readwrite) BOOL diskEnabled, diskBusy, diskMotor, diskConnected, diskEditorLocked;
@property(nonatomic, readwrite) BOOL hardDiskConnected, hardClockEnabled, hardClockReadOnly;
@property(nonatomic, readwrite) NSUInteger hardSelectedDrive, hardSector, hardStatus;
@property(nonatomic, readwrite) uint64_t hardFlushRequests;
@property(nonatomic, readwrite, copy) NSArray<VCCDiskSnapshot *> *hardDisks;
@property(nonatomic, readwrite) BOOL sdcReadOnly;
@property(nonatomic, readwrite, copy) NSArray<NSString *> *sdcDriveNames;
@property(nonatomic, readwrite, copy) NSString *sdcDirectory;
@property(nonatomic, readwrite, copy, nullable) NSString *sdcError;
@property(nonatomic, readwrite) uint64_t sdcReadCount, sdcWriteCount;
@property(nonatomic, readwrite) BOOL multiPakEnabled;
@property(nonatomic, readwrite) NSUInteger physicalSlot, romSlot, ioSlot;
@property(nonatomic, readwrite, copy) NSArray<NSNumber *> *cartridgeKinds;
@property(nonatomic, readwrite, copy) NSArray<NSString *> *cartridgeNames;
@property(nonatomic, readwrite, copy) NSString *diskROMName;
@property(nonatomic, readwrite) NSInteger diskSelectedDrive;
@property(nonatomic, readwrite) NSUInteger diskTrack, diskSector, diskSide;
@property(nonatomic, readwrite, copy) NSArray<VCCDiskSnapshot *> *disks;
@end
@implementation VCCCompiledRunLease {
std::atomic<bool> _valid;
}
- (instancetype)init { if ((self = [super init])) _valid.store(true); return self; }
- (BOOL)isValid { return _valid.load(); }
- (void)invalidate { _valid.store(false); }
@end
@implementation VCCMachineSnapshot
- (NSArray<NSString *> *)assistantDeviceBlockers {
NSMutableArray *reasons = [NSMutableArray array];
if (self.driveWireEnabled || ![self.macShellStatus isEqualToString:@"idle"])
[reasons addObject:@"Disable DriveWire networking and end Mac shell access before running a shared program."];
if (self.tapeMounted || self.tapeMode == 2)
[reasons addObject:@"Eject the cassette and end recording before running a shared program."];
for (VCCDiskSnapshot *drive in [self.disks arrayByAddingObjectsFromArray:self.hardDisks])
if (drive.mounted && !drive.writeProtected) {
[reasons addObject:@"Eject writable disks or enable write protection before running a shared program."];
break;
}
for (NSNumber *kind in self.cartridgeKinds)
if (kind.integerValue != 0 && kind.integerValue != 2) {
[reasons addObject:@"Choose a BASIC setup with only a floppy controller before running a shared program."];
break;
}
return reasons;
}
@end
namespace {
struct Worker {
VCC::Mac::DriveWireShell shell;
uint64_t shellGeneration = 0, mediaRevision = 0;
std::string assistantPasteRun;
VCCCompiledRunLease *compiledKeyLease = nil;
VCCMachineSnapshot *compiledKeyExpected = nil;
bool compiledKeyAssembly = false;
std::optional<std::pair<uint64_t, uint64_t>> assistantProgram;
VCC::Mac::MachineSession machine;
VCC::Mac::MacAudioOutput audio;
bool audioEnabled = false, fastForward = false;
VCC::Mac::FramePacer pacer;
VCC::Mac::AudioProgress audioProgress;
std::chrono::steady_clock::time_point previousAudioTick{};
uint64_t maximumAudioGap = 0;
std::shared_ptr<const VCC::Mac::Frame> capturedFrame;
NSData* capturedPixels = nil;
uint64_t pixelRevision = 0;
bool closed = false;
std::string error;
std::string diskROMName;
struct Export { uint64_t token; std::vector<std::uint8_t> bytes; };
std::array<std::optional<Export>, 4> exports;
std::array<std::string, 4> diskNames;
std::array<bool, 4> readOnly{};
uint64_t nextExport = 0;
struct DiskEdit {
uint64_t token, generation, mediaRevision;
unsigned drive;
std::vector<std::uint8_t> original;
std::optional<VCC::Devices::DiskImage> prepared;
bool hardDisk = false;
std::optional<VCC::Devices::HardDiskImage> preparedHard;
};
std::optional<DiskEdit> diskEdit;
uint64_t nextDiskEdit = 0;
void requireNoDiskEditor() const {
if (diskEdit) throw std::logic_error("Close the Disk Image Editor before running, resetting or changing the CoCo and its media.");
}
DiskEdit& requireDiskEditor(uint64_t token) {
if (!diskEdit || diskEdit->token != token) throw std::logic_error("This disk edit session has ended. Reopen the disk to edit it.");
auto& edit = *diskEdit;
const auto* floppyImage = !edit.hardDisk && floppy() ? floppy()->image(edit.drive) : nullptr;
const auto* hardImage = edit.hardDisk ? hardDevice->image(edit.drive) : nullptr;
const bool unchanged = edit.hardDisk ? hardImage && hardImage->bytes() == edit.original :
floppyImage && floppyImage->bytes() == edit.original;
if (closed || machine.snapshot().generation != edit.generation || mediaRevision != edit.mediaRevision ||
!unchanged || (floppy() && floppy()->snapshot().busy))
throw std::logic_error("The mounted disk or machine changed. Keep your edited copy and reopen the disk.");
return edit;
}
std::shared_ptr<VCC::Devices::HardDiskDevice> hardDevice = std::make_shared<VCC::Devices::HardDiskDevice>();
struct HardExport { uint64_t token; VCC::Devices::HardDiskImage::Save saved; };
std::array<std::optional<HardExport>,2> hardExports;
std::array<std::string,2> hardNames;
std::array<bool,2> hardReadOnly{};
void clearHardDrive(unsigned drive) { ++mediaRevision; hardExports[drive].reset(); hardNames[drive].clear(); hardReadOnly[drive] = false; }
std::shared_ptr<VCC::Devices::Fd502Device> diskDevice;
std::shared_ptr<VCC::Devices::RamDiskDevice> ramDevice;
std::array<int, 5> cartridgeKinds{2, 0, 0, 0, 0};
VCC::Devices::CartridgeBus::Slots cartridgeDevices;
std::array<std::string, 5> cartridgeNames;
void applyLayout(bool enabled, unsigned physical) {
shell.stop();
for (unsigned i = 0; i < 5; ++i)
if (cartridgeKinds[i] == 2) cartridgeDevices[i] = diskDevice;
machine.cartridges().configure(cartridgeDevices, enabled, physical);
}
VCC::Devices::Fd502Device* floppy() { return diskDevice.get(); }
VCC::Devices::Fd502Device& requireFloppy() {
auto* disk = floppy();
if (!disk) throw std::logic_error("Choose a disk ROM to enable the floppy controller");
return *disk;
}
void pauseForDisks() {
if (auto* disk = floppy(); disk && disk->snapshot().busy)
throw std::logic_error("Disk operation in progress. Press Run to let it finish, or reset the machine before changing disks.");
machine.pause();
}
void clearDrive(unsigned drive) { ++mediaRevision; exports[drive].reset(); diskNames[drive].clear(); readOnly[drive] = false; }
};
unsigned HardDriveIndex(NSInteger value) {
if (value < 0 || value > 1) throw std::invalid_argument("Hard disk drive must be 0 or 1");
return static_cast<unsigned>(value);
}
unsigned DriveIndex(NSInteger value) {
if (value < 0 || value > 3) throw std::invalid_argument("Floppy drive must be 0 through 3");
return static_cast<unsigned>(value);
}
std::vector<std::uint8_t> OwnedBytes(NSData* data, NSUInteger limit) {
if (data.length > limit) throw std::invalid_argument("Selected file is too large");
if (!data.length) return {};
const auto* begin = static_cast<const std::uint8_t*>(data.bytes);
return {begin, begin + data.length};
}
std::vector<VCC::Mac::DebugCodeGuard> CodeGuards(NSArray<NSNumber *> *addresses, NSArray<NSData *> *bytes) {
if (addresses.count != bytes.count || bytes.count > 65536)
throw std::invalid_argument("Code guard addresses and bytes must have matching bounded counts");
auto parsed = DebugAddresses(addresses, 65536);
std::vector<VCC::Mac::DebugCodeGuard> guards;
std::size_t total = 0;
for (NSUInteger i = 0; i < bytes.count; ++i) {
if (bytes[i].length > 65536 - total) throw std::invalid_argument("Code guards exceed address space");
total += bytes[i].length;
guards.push_back({parsed[i], OwnedBytes(bytes[i], 65536)});
}
return guards;
}
std::vector<VCC::Mac::DebugBankedModule> BankedModules(NSArray<NSDictionary<NSString *, id> *> *modules) {
if (!modules || !modules.count || modules.count > 256)
throw std::invalid_argument("Supply 1 to 256 banked modules");
std::vector<VCC::Mac::DebugBankedModule> result;
for (NSDictionary *module in modules) {
if (![module isKindOfClass:NSDictionary.class]) throw std::invalid_argument("Invalid banked module");
NSString *identifier = module[@"id"];
NSArray *pages = module[@"pages"], *addresses = module[@"addresses"], *bytes = module[@"bytes"];
if (![identifier isKindOfClass:NSString.class] || ![pages isKindOfClass:NSArray.class] ||
![addresses isKindOfClass:NSArray.class] || ![bytes isKindOfClass:NSArray.class])
throw std::invalid_argument("Banked modules require id, pages, addresses and bytes");
for (id address in addresses)
if (![address isKindOfClass:NSNumber.class]) throw std::invalid_argument("Invalid banked code address");
for (id data in bytes)
if (![data isKindOfClass:NSData.class]) throw std::invalid_argument("Invalid banked instruction bytes");
VCC::Mac::DebugBankedModule parsed;
parsed.identifier = identifier.UTF8String;
parsed.guards = CodeGuards(addresses, bytes);
if (id qualified = module[@"breakpoints"]) {
if (![qualified isKindOfClass:NSArray.class]) throw std::invalid_argument("Module breakpoints must be an array");
for (id point in qualified)
if (![point isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)point) == CFBooleanGetTypeID())
throw std::invalid_argument("Module breakpoints require logical integer addresses");
parsed.breakpointAddresses = DebugAddresses(qualified, 1024);
}
if (!pages.count || pages.count > 8) throw std::invalid_argument("Supply 1 to 8 page mappings per module");
for (NSDictionary *page in pages) {
if (![page isKindOfClass:NSDictionary.class]) throw std::invalid_argument("Invalid banked page mapping");
NSNumber *logical = page[@"logicalPage"], *physical = page[@"physicalPage"];
if (![logical isKindOfClass:NSNumber.class] || ![physical isKindOfClass:NSNumber.class])
throw std::invalid_argument("Banked pages require logicalPage and physicalPage");
const double l = logical.doubleValue, p = physical.doubleValue;
if (!std::isfinite(l) || !std::isfinite(p) || l < 0 || l > 7 || l != std::floor(l) ||
p < 0 || p > 1023 || p != std::floor(p))
throw std::invalid_argument("Invalid logical or physical RAM page");
parsed.pages.push_back({static_cast<std::uint8_t>(l), static_cast<std::uint32_t>(p)});
}
result.push_back(std::move(parsed));
}
return result;
}
VCC::Mac::Snapshot AssemblyIdentity(VCCMachineSnapshot *snapshot) {
VCC::Mac::Snapshot expected;
expected.generation = snapshot.generation;
expected.debuggerProgramRevision = snapshot.debuggerProgramRevision;
expected.debuggerMappingFingerprint = snapshot.debuggerMappingFingerprint;
expected.cpu.PC = snapshot.programCounter;
expected.cycles = snapshot.cycles;
return expected;
}
VCC::Devices::DiskImage LoadFloppyImage(NSData *data, NSString *name, bool protect) {
using namespace VCC::Devices;
auto image = DiskImage::load(OwnedBytes(data, DiskImage::maxBytes), protect);
NSString *ext = name.pathExtension.lowercaseString;
if (([ext isEqualToString:@"dmk"] && image.format() != DiskFormat::DMK) ||
([ext isEqualToString:@"vdk"] && image.format() != DiskFormat::VDK))
throw std::invalid_argument("The disk contents do not match the selected image format");
return image;
}
VCCMachineSnapshot *Capture(Worker& worker) {
const auto value = worker.machine.snapshot();
auto result = [VCCMachineSnapshot new];
result.diskEditorLocked = worker.diskEdit.has_value();
auto joystickInputs = [NSMutableArray<VCCJoystickInputSnapshot *> arrayWithCapacity:2];
for (const auto& port : value.joysticks) {
auto input = [VCCJoystickInputSnapshot new];
input.x = port.x; input.y = port.y; input.buttons = port.buttons; input.mode = port.mode;
[joystickInputs addObject:input];
}
result.joystickInputs = joystickInputs;
result.keyboardInputHeld = value.keyboardHeld;
switch (value.state) {
case VCC::Mac::RunState::Empty: result.state = VCCMachineStateEmpty; break;
case VCC::Mac::RunState::Paused: result.state = VCCMachineStatePaused; break;
case VCC::Mac::RunState::Running: result.state = VCCMachineStateRunning; break;
}
result.pasteRemaining = worker.machine.pasteRemaining();
const auto& printer = worker.machine.printer();
result.printerEnabled = printer.enabled(); result.printerRevision = printer.revision();
result.printerDroppedBytes = printer.droppedBytes(); result.printerByteCount = printer.bytes().size();
result.use6309 = value.configuration.processor == VCC::Mac::Processor::HD6309;
result.ramConfiguration = value.configuration.ram;
result.cpuOverclock = value.configuration.overclock;
result.frameInterval = value.configuration.frameInterval;
result.fastForward = worker.fastForward;
result.presentedFrame = value.frame ? value.frame->number : 0;
result.videoOutput = static_cast<NSInteger>(value.videoOutput);
result.audioEnabled = worker.audioEnabled;
result.driveWireEnabled = worker.machine.driveWireEnabled();
if (worker.shellGeneration != value.generation) {
worker.shell.stop();
worker.shellGeneration = value.generation;
}
result.macShellStatus = [NSString stringWithUTF8String:worker.shell.status().c_str()];
result.macShellRequestID = worker.shell.requestID();
result.audioConsumed = worker.audio.buffer().consumed.load();
result.audioSubmitted = worker.audio.buffer().submitted.load();
result.audioSignalSamples = worker.audio.buffer().signalSamples.load();
result.audioBuffered = worker.audio.buffer().size();
result.audioStarts = worker.audio.starts();
result.audioMaximumRequest = worker.audio.buffer().maximumRequest.load();
result.audioMaximumRefillGapNanoseconds = worker.maximumAudioGap;
result.audioUnderruns = worker.audio.buffer().underruns.load();
result.audioOverruns = worker.audio.buffer().overruns.load();
const auto tape = worker.machine.cassette().snapshot();
result.tapeMounted=tape.mounted; result.tapeMotor=tape.motor; result.tapeDirty=tape.dirty;
result.tapeFast=tape.fast; result.tapeWAV=tape.format==VCC::Mac::TapeFormat::WAV;
result.tapeMode=static_cast<NSInteger>(tape.mode); result.tapePosition=tape.position; result.tapeLength=tape.length;
result.tapeReadEvents = tape.readEvents; result.tapeWriteEvents = tape.writeEvents;
auto& bus = worker.machine.cartridges();
result.multiPakEnabled = bus.multiPak(); result.physicalSlot = bus.physicalSlot();
result.romSlot = bus.romSlot(); result.ioSlot = bus.ioSlot();
result.sdcDriveNames = @[@"", @""]; result.sdcDirectory = @""; result.sdcReadOnly = YES;
auto names = [NSMutableArray<NSString*> arrayWithCapacity:5];
for (unsigned i = 0; i < 5; ++i) {
[names addObject:bus.at(i) ? (worker.cartridgeKinds[i] == 2 ? @"Floppy controller" : worker.cartridgeKinds[i] == 3 ? @"Virtual hard disk" : worker.cartridgeKinds[i] == 4 ? @"RAM disk (512 KB)" : worker.cartridgeKinds[i] == 5 ? @"Orchestra-90" : worker.cartridgeKinds[i] == 6 ? @"Speech/Sound Cartridge" : worker.cartridgeKinds[i] == 7 ? @"CoCo SDC" : [NSString stringWithUTF8String:worker.cartridgeNames[i].c_str()]) : @""];
if (auto* sdc = dynamic_cast<VCC::Devices::SDCDevice*>(bus.at(i)); sdc && (bus.multiPak() ? i > 0 : i == 0)) {
const auto status = sdc->snapshot();
result.sdcDriveNames = @[[NSString stringWithUTF8String:status.drives[0].name.c_str()], [NSString stringWithUTF8String:status.drives[1].name.c_str()]];
result.sdcDirectory = [NSString stringWithUTF8String:status.currentDirectory.c_str()];
result.sdcReadOnly = status.writeProtected;
result.sdcReadCount = status.drives[0].reads + status.drives[1].reads;
result.sdcWriteCount = status.drives[0].writes + status.drives[1].writes;
if (!status.error.empty()) result.sdcError = [NSString stringWithUTF8String:status.error.c_str()];
}
if (bus.at(i) == worker.hardDevice.get() && (bus.multiPak() ? i > 0 : i == 0)) result.hardDiskConnected = YES;
if (bus.at(i) && bus.at(i) == worker.floppy() && (bus.multiPak() ? i > 0 : i == 0)) result.diskConnected = YES;
}
result.cartridgeNames = names;
auto kinds = [NSMutableArray<NSNumber*> arrayWithCapacity:5];
for (unsigned i = 0; i < 5; ++i) [kinds addObject:@(worker.cartridgeKinds[i])];
result.cartridgeKinds = kinds;
result.diskROMName = [NSString stringWithUTF8String:worker.diskROMName.c_str()];
result.diskSelectedDrive = -1;
auto* floppy = worker.floppy();
result.diskEnabled = floppy != nullptr;
if (floppy) {
const auto disk = floppy->snapshot();
result.diskBusy = disk.busy; result.diskMotor = disk.motor;
result.diskSelectedDrive = disk.drive; result.diskTrack = disk.head;
result.diskSector = disk.sector; result.diskSide = disk.side;
}
auto drives = [NSMutableArray<VCCDiskSnapshot*> arrayWithCapacity:4];
for (unsigned i = 0; i < 4; ++i) {
auto disk = [VCCDiskSnapshot new];
disk.name = [NSString stringWithUTF8String:worker.diskNames[i].c_str()];
disk.sourceReadOnly = worker.readOnly[i];
disk.readEvents = floppy ? floppy->readEvents(i) : 0; disk.writeEvents = floppy ? floppy->writeEvents(i) : 0;
if (const auto* image = floppy ? floppy->image(i) : nullptr) {
disk.mounted = YES; disk.dirty = image->dirty(); disk.writeProtected = image->writeProtected();
switch (image->format()) {
case VCC::Devices::DiskFormat::DMK: disk.floppyExtension = @"dmk"; break;
case VCC::Devices::DiskFormat::VDK: disk.floppyExtension = @"vdk"; break;
default: {
NSString *ext = disk.name.pathExtension.lowercaseString;
disk.floppyExtension = [@[@"dsk", @"os9", @"jvc"] containsObject:ext] ? ext : @"dsk";
}
}
disk.formatWriteProtected = image->formatWriteProtected();
disk.tracks = image->geometry().tracks; disk.sides = image->geometry().sides;
disk.byteCount = image->bytes().size();
}
[drives addObject:disk];
}
result.disks = drives;
auto hardDrives = [NSMutableArray<VCCDiskSnapshot*> arrayWithCapacity:2];
for (unsigned i = 0; i < 2; ++i) {
auto disk = [VCCDiskSnapshot new]; disk.name = [NSString stringWithUTF8String:worker.hardNames[i].c_str()];
disk.sourceReadOnly = worker.hardReadOnly[i];
disk.readEvents = worker.hardDevice->readEvents(i); disk.writeEvents = worker.hardDevice->writeEvents(i);
if (auto* image = worker.hardDevice->image(i)) {
disk.mounted = YES; disk.dirty = image->dirty(); disk.writeProtected = image->writeProtected(); disk.byteCount = image->bytes().size();
}
[hardDrives addObject:disk];
}
result.hardDisks = hardDrives; result.hardSelectedDrive = worker.hardDevice->selectedDrive();
result.hardSector = worker.hardDevice->selectedSector(); result.hardStatus = worker.hardDevice->result();
result.hardClockEnabled = worker.hardDevice->isClockEnabled(); result.hardClockReadOnly = worker.hardDevice->isClockReadOnly();
result.hardFlushRequests = worker.hardDevice->flushRequests();
if (worker.closed) result.state = VCCMachineStateClosed;
result.generation = value.generation; result.frames = value.frames;
result.debuggerProgramRevision = value.debuggerProgramRevision; result.debuggerMappingFingerprint = value.debuggerMappingFingerprint;
result.debuggerDevelopmentAttached = value.debuggerDevelopmentAttached;
result.debuggerBankedDevelopment = value.debuggerBankedDevelopment;
result.debuggerAssemblyAttached = value.debuggerAssemblyAttached;
result.assistantMediaRevision = worker.mediaRevision;
result.assistantCompiledReturned = worker.machine.sharedCompiledCallReturned();
result.debuggerSourceStepping = value.debuggerSourceStepping;
result.basicDebugAttached = value.basicDebugAttached; result.basicStoppedLine = value.basicStoppedLine;
result.basicSourceOffset = value.basicSourceOffset; result.basicSourceLength = value.basicSourceLength;
result.basicStepping = value.basicStepping;
result.basicCanStepOut = value.basicCanStepOut;
result.basicErrorLine = value.basicErrorLine;
result.basicErrorCode = [NSString stringWithUTF8String:value.basicErrorCode.c_str()];
result.basicDebugStatus = [NSString stringWithUTF8String:value.basicDebugStatus.c_str()];
result.cycles = value.cycles; result.programCounter = value.cpu.PC;
if (value.frame != worker.capturedFrame) {
worker.capturedPixels = value.frame ? [NSData dataWithBytes:value.frame->pixels.data()
length:value.frame->pixels.size() * sizeof(std::uint32_t)] : nil;
worker.capturedFrame = value.frame;
++worker.pixelRevision;
}
result.pixelRevision = worker.pixelRevision;
result.pixels = worker.capturedPixels;
const auto area = value.frame ? value.frame->activeArea : VCC::VideoRect{0, 0, 640, 480};
result.activeVideoRect = CGRectMake(area.x, area.y, area.width, area.height);
if (!worker.error.empty()) result.errorMessage = [NSString stringWithUTF8String:worker.error.c_str()];
return result;
}
void CheckAssistantGuestDevices(VCCMachineSnapshot *current) {
NSString *reason = current.assistantDeviceBlockers.firstObject;
if (reason) throw std::logic_error(reason.UTF8String);
}
void CheckCompiledRun(Worker& worker, VCCCompiledRunLease *lease, VCCMachineSnapshot *expected, bool assembly, bool finalScreen = false) {
if (!lease.valid) throw std::logic_error("stale_run");
auto current = Capture(worker);
if (!worker.assistantProgram || *worker.assistantProgram != std::make_pair(current.generation, current.debuggerProgramRevision) ||
current.generation != expected.generation || current.debuggerProgramRevision != expected.debuggerProgramRevision ||
current.debuggerMappingFingerprint != expected.debuggerMappingFingerprint || current.use6309 != expected.use6309 ||
!current.debuggerDevelopmentAttached || bool(current.debuggerAssemblyAttached) != assembly ||
(current.state != VCCMachineStateRunning && current.state != VCCMachineStatePaused))
throw std::logic_error("stale_run");
CheckAssistantGuestDevices(current);
if (expected.assistantMediaRevision != current.assistantMediaRevision)
throw std::logic_error("media_changed");
if (finalScreen) {
if (!worker.machine.sharedCompiledCallReturned()) throw std::logic_error("run_not_finished");
return;
}
if (!worker.machine.sharedCompiledCallActive())
throw std::logic_error(worker.machine.sharedCompiledCallReturned() ? "run_finished" : "unverified_program_entry");
}
void AdvanceWorker(Worker& worker) {
if (worker.compiledKeyLease) {
if (worker.machine.pasteRemaining()) {
try {
CheckCompiledRun(worker, worker.compiledKeyLease, worker.compiledKeyExpected, worker.compiledKeyAssembly);
} catch (const std::exception&) { worker.machine.cancelPaste(); }
}
if (!worker.machine.pasteRemaining()) {
worker.compiledKeyLease = nil;
worker.compiledKeyExpected = nil;
}
}
worker.machine.advance();
}
// Called inside the emulator queue before every assistant load, observation or key.
void CheckAssistantMachine(Worker& worker, VCCMachineSnapshot *expected, NSString *source,
const char *sourceChanged = "The program in BASIC memory changed. Review it before continuing.") {
auto current = Capture(worker);
if (current.generation != expected.generation || current.debuggerProgramRevision != expected.debuggerProgramRevision)
throw std::logic_error("The CoCo or its loaded program changed. Start a new reviewed run.");
if (current.assistantMediaRevision != expected.assistantMediaRevision)
throw std::logic_error("The mounted media changed. Start a new reviewed run.");
if (current.state != VCCMachineStateRunning && current.state != VCCMachineStatePaused)
throw std::logic_error("Start a supported CoCo BASIC system before running.");
CheckAssistantGuestDevices(current);
if (worker.machine.basicReadSource() != [source UTF8String])
throw std::logic_error(sourceChanged);
}
}
@implementation VCCMachineController {
dispatch_queue_t _queue;
dispatch_source_t _timer;
std::shared_ptr<Worker> _worker;
}
- (instancetype)init {
if ((self = [super init])) {
_worker = std::make_shared<Worker>();
// Audio production has a short deadline even when the window is inactive.
// Keep it off the main thread, with interactive scheduling priority.
auto attributes = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INTERACTIVE, 0);
_queue = dispatch_queue_create("com.brianholman.vccplus.mac.machine", attributes);
_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _queue);
// Refill on the owner queue; the real-time callback only consumes samples.
dispatch_source_set_timer(_timer, dispatch_time(DISPATCH_TIME_NOW, 0), 2*NSEC_PER_MSEC, NSEC_PER_MSEC/2);
auto worker = _worker;
dispatch_source_set_event_handler(_timer, ^{
if (worker->closed) return;
try {
if (worker->machine.snapshot().state != VCC::Mac::RunState::Running) {
if (worker->audio.running()) worker->audio.stop();
worker->pacer.reset(); worker->audioProgress.reset(); return;
}
if (worker->fastForward) {
// Yield after at most four frames or eight milliseconds so
// input, pause, and automatic media saves keep getting turns.
const auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(8);
for (unsigned i = 0; i < 4; ++i) {
AdvanceWorker(*worker); worker->machine.takeAudio();
if (std::chrono::steady_clock::now() >= deadline) break;
}
} else if (worker->audioEnabled) {
const auto tick = std::chrono::steady_clock::now();
if (worker->audio.running() && worker->previousAudioTick.time_since_epoch().count())
worker->maximumAudioGap = std::max(worker->maximumAudioGap, uint64_t(std::chrono::duration_cast<std::chrono::nanoseconds>(tick - worker->previousAudioTick).count()));
worker->previousAudioTick = tick;
if(worker->audio.needsRestart()) { worker->audio.stop(); worker->audioProgress.reset(); }
// Roughly 100 ms ahead, at most four frames per queue turn.
// The physical audio clock paces production; guest clocks stay fixed.
for(unsigned i=0;i<4 && worker->audio.buffer().size()<VCC::Mac::audioTargetSamples;++i) {
AdvanceWorker(*worker); auto samples=worker->machine.takeAudio();
worker->audio.buffer().write(samples.data(), samples.size());
if (worker->machine.snapshot().state != VCC::Mac::RunState::Running) break;
}
if (worker->machine.snapshot().state != VCC::Mac::RunState::Running) {
worker->audio.stop(); worker->pacer.reset(); worker->audioProgress.reset(); return;
}
const bool starting = !worker->audio.running();
if (!starting || worker->audio.buffer().size() >= VCC::Mac::audioTargetSamples) {
worker->audio.start();
// Graph creation precedes consumption; start both timing
// measurements only after the output graph is running.
if (starting) {
worker->previousAudioTick = std::chrono::steady_clock::now();
worker->audioProgress.reset();
}
}
if (worker->audioProgress.stalled(std::chrono::steady_clock::now(), worker->audio.buffer().consumed.load()))
throw std::runtime_error("Audio output stopped consuming samples. Emulation continues without sound; turn Sound on to retry.");
} else {
if (worker->pacer.ready(std::chrono::steady_clock::now())) {
AdvanceWorker(*worker); worker->machine.takeAudio();
}
}
} catch (const std::exception& error) {
worker->error=error.what(); worker->audio.stop(); worker->audioEnabled=false;
worker->pacer.reset(); worker->audioProgress.reset();
}
});
dispatch_resume(_timer);
}
return self;
}
- (void)perform:(void (^)(Worker&))operation completion:(VCCMachineCompletion)completion {
[self performAllowingDiskEditor:NO operation:operation completion:completion];
}
- (void)inspect:(void (^)(Worker&))operation completion:(VCCMachineCompletion)completion {
[self performAllowingDiskEditor:YES operation:operation completion:completion];
}
- (void)performAllowingDiskEditor:(BOOL)allow operation:(void (^)(Worker&))operation completion:(VCCMachineCompletion)completion {
auto worker = _worker;
dispatch_async(_queue, ^{
try { if (!allow) worker->requireNoDiskEditor(); operation(*worker); }
catch (const std::exception& error) { worker->error = error.what(); }
VCCMachineSnapshot *snapshot = Capture(*worker);
dispatch_async(dispatch_get_main_queue(), ^{ completion(snapshot); });
});
}
- (void)command:(void (^)(Worker&))operation completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear(); worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset(); operation(worker);
} completion:completion];
}
- (void)applyProfile:(VCCMachineProfile*)profile completion:(void (^)(BOOL, VCCMachineSnapshot*))completion {
VCCMachineProfile* p = [profile copy];
__block BOOL applied = NO;
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
if (p.ram < 0 || p.ram > 3 || p.overclock < 1 || p.overclock > 16 || p.frameInterval < 1 || p.frameInterval > 6 ||
p.videoOutput < 0 || p.videoOutput > 2 || p.physicalSlot < 1 || p.physicalSlot > 4 ||
!std::isfinite(p.volume) || p.volume < 0 || p.volume > 1 ||
p.kinds.count != 5 || p.cartridgeROMs.count != 5 || p.cartridgeNames.count != 5 ||
p.sdcFolders.count != 5 || p.sdcReadOnly.count != 5 ||
p.images.count != 6 || p.imageNames.count != 6 || p.readOnly.count != 6 || p.protectedImages.count != 6)
throw std::invalid_argument("Invalid profile configuration");
auto systemROM = OwnedBytes(p.systemROM, 32768);
if (p.systemROM && systemROM.size() != 32768) throw std::invalid_argument("A 32 KiB system ROM is required");
// Build disconnected replacements. Parsing failures leave the current
// CPU, media, dirty flags and save acknowledgement tokens untouched.
std::shared_ptr<VCC::Devices::Fd502Device> floppy;
if (p.diskROM) floppy = std::make_shared<VCC::Devices::Fd502Device>(OwnedBytes(p.diskROM, 16384));
auto hard = std::make_shared<VCC::Devices::HardDiskDevice>();
hard->configureClock(p.clockEnabled, p.clockReadOnly);
for (unsigned i = 0; i < 6; ++i) {
if (![p.images[i] length]) continue;
const bool protect = [p.readOnly[i] boolValue] || [p.protectedImages[i] boolValue];
if (i < 4) {
if (!floppy) throw std::invalid_argument("A floppy image requires a floppy ROM");
floppy->mount(i, LoadFloppyImage(p.images[i], p.imageNames[i], protect));
} else hard->mount(i - 4, VCC::Devices::HardDiskImage(OwnedBytes(p.images[i], VCC::Devices::HardDiskImage::maxBytes), protect));
}
VCC::Mac::CassetteDeck tape;
if (p.cassette) tape.mount(OwnedBytes(p.cassette, VCC::Mac::CassetteDeck::maxBytes),
p.cassetteWAV ? VCC::Mac::TapeFormat::WAV : VCC::Mac::TapeFormat::CAS);
tape.setFast(p.fastCassette);
VCC::Devices::CartridgeBus::Slots slots;
std::array<int,5> kinds; std::array<std::string,5> names;
unsigned floppyCount = 0, hardCount = 0, ramCount = 0, orchestraCount = 0, speechCount = 0, sdcCount = 0;
std::shared_ptr<VCC::Devices::RamDiskDevice> ram;
for (unsigned i = 0; i < 5; ++i) {
kinds[i] = [p.kinds[i] intValue]; names[i] = [p.cartridgeNames[i] UTF8String];
switch (kinds[i]) {
case 0: break;
case 1: slots[i] = std::make_shared<VCC::Devices::RomCartridge>(OwnedBytes(p.cartridgeROMs[i], 262144)); break;
case 2: slots[i] = floppy; if (i) ++floppyCount; break;
case 3: slots[i] = hard; if (i) ++hardCount; break;
case 4:
if (!ram) ram = std::make_shared<VCC::Devices::RamDiskDevice>();
slots[i] = ram; if (i) ++ramCount; break;
case 7:
if ([p.cartridgeROMs[i] length]) slots[i] = std::make_shared<VCC::Devices::SDCDevice>(
OwnedBytes(p.cartridgeROMs[i], 16384), [p.sdcFolders[i] UTF8String], [p.sdcReadOnly[i] boolValue]);
if (i) ++sdcCount; break;
case 6:
slots[i] = std::make_shared<VCC::Devices::SpeechSoundDevice>(OwnedBytes(p.cartridgeROMs[i], 6144));
if (i) ++speechCount; break;
case 5:
slots[i] = std::make_shared<VCC::Devices::Orchestra90Device>(OwnedBytes(p.cartridgeROMs[i], 8192));
if (i) ++orchestraCount; break;
default: throw std::invalid_argument("Unknown profile cartridge device");
}
}
if (floppyCount > 1 || hardCount > 1 || ramCount > 1 || orchestraCount > 1 || speechCount > 1 || sdcCount > 1) throw std::invalid_argument("Duplicate Multi-Pak devices");
auto* oldFloppy = worker.floppy();
if (oldFloppy && oldFloppy->snapshot().busy) throw std::logic_error("Finish the floppy operation before loading a profile");
for (unsigned i = 0; i < 4; ++i)
if (oldFloppy && oldFloppy->image(i) && oldFloppy->image(i)->dirty())
throw std::logic_error("Save or discard modified floppy images before loading a profile");
for (unsigned i = 0; i < 2; ++i)
if (worker.hardDevice->image(i) && worker.hardDevice->image(i)->dirty())
throw std::logic_error("Save or discard modified hard disks before loading a profile");
const auto oldTape = worker.machine.cassette().snapshot();
if (oldTape.dirty || oldTape.mode == VCC::Mac::TapeMode::Recording)
throw std::logic_error("Stop and export or discard the cassette recording before loading a profile");
worker.error.clear(); worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset(); worker.previousAudioTick = {};
worker.machine.shutdown();
worker.diskDevice = std::move(floppy); worker.hardDevice = std::move(hard);
worker.ramDevice = std::move(ram);
worker.cartridgeDevices = std::move(slots); worker.cartridgeKinds = kinds; worker.cartridgeNames = std::move(names);
worker.diskROMName = p.diskROMName.UTF8String;
for (unsigned i = 0; i < 4; ++i) {
worker.clearDrive(i); worker.diskNames[i] = [p.imageNames[i] UTF8String]; worker.readOnly[i] = [p.readOnly[i] boolValue];
}
for (unsigned i = 0; i < 2; ++i) {
worker.clearHardDrive(i); worker.hardNames[i] = [p.imageNames[i+4] UTF8String]; worker.hardReadOnly[i] = [p.readOnly[i+4] boolValue];
}
worker.machine.cassette() = std::move(tape);
worker.applyLayout(p.multiPak, unsigned(p.physicalSlot));
VCC::Mac::MachineConfiguration config;
config.processor = p.use6309 ? VCC::Mac::Processor::HD6309 : VCC::Mac::Processor::MC6809;
config.ram = unsigned(p.ram); config.overclock = unsigned(p.overclock); config.frameInterval = unsigned(p.frameInterval);
worker.machine.configure(config); worker.machine.setVideoOutput(static_cast<VCC::Mac::VideoOutput>(p.videoOutput));
worker.fastForward = p.fastForward; worker.audioEnabled = p.sound; worker.audio.buffer().gain.store(p.volume);
applied = YES;
if (p.systemROM) worker.machine.load(systemROM, config.processor);
} completion:^(VCCMachineSnapshot* snapshot) { completion(applied, snapshot); }];
}
- (void)configureMachineWith6309:(BOOL)use6309 ram:(NSInteger)ram overclock:(NSInteger)overclock frameInterval:(NSInteger)interval fastForward:(BOOL)fastForward completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
// Reject before touching audio, RAM, preferences, or media.
if (ram < 0 || ram > 3 || overclock < 1 || overclock > 16 || interval < 1 || interval > 6)
throw std::invalid_argument("Unsupported machine settings");
VCC::Mac::MachineConfiguration value;
value.processor = use6309 ? VCC::Mac::Processor::HD6309 : VCC::Mac::Processor::MC6809;
value.ram = unsigned(ram); value.overclock = unsigned(overclock); value.frameInterval = unsigned(interval);
const auto previous = worker.machine.snapshot().configuration;
const bool restart = previous.processor != value.processor || previous.ram != value.ram;
if (restart) {
if (auto* disk = worker.floppy(); disk && disk->snapshot().busy)
throw std::logic_error("Wait for the disk operation to finish before changing CPU or memory.");
if (worker.machine.cassette().snapshot().mode == VCC::Mac::TapeMode::Recording)
throw std::logic_error("Stop the cassette recording before changing CPU or memory.");
}
if (restart || worker.fastForward != bool(fastForward)) {
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
worker.previousAudioTick = {};
}
worker.machine.configure(value);
worker.fastForward = fastForward; worker.error.clear();
} completion:completion];
}
- (void)setVideoOutput:(NSInteger)output completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
if (output < 0 || output > 2) throw std::invalid_argument("Unsupported video output");
worker.machine.setVideoOutput(static_cast<VCC::Mac::VideoOutput>(output));
worker.error.clear();
} completion:completion];
}
- (void)loadDiagnosticWithCompletion:(VCCMachineCompletion)completion {
[self loadDiagnosticWith6309:NO completion:completion];
}
- (void)loadDiagnosticWith6309:(BOOL)use6309 completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
worker.machine.loadDiagnostic(use6309 ? VCC::Mac::Processor::HD6309 : VCC::Mac::Processor::MC6809);
} completion:completion];
}
- (void)loadROM:(NSData *)rom use6309:(BOOL)use6309 completion:(VCCMachineCompletion)completion {
NSData *owned = [rom copy];
[self command:^(Worker& worker) {
if (owned.length != 0x8000) throw std::invalid_argument("A 32 KiB CoCo 3 ROM image is required");
const auto *begin = static_cast<const std::uint8_t *>(owned.bytes);
worker.machine.load({begin, begin + owned.length}, use6309 ? VCC::Mac::Processor::HD6309 : VCC::Mac::Processor::MC6809);
} completion:completion];
}
- (void)setJoystick:(NSUInteger)port x:(NSUInteger)x y:(NSUInteger)y buttons:(NSUInteger)buttons mode:(NSUInteger)mode {
auto worker = _worker;
dispatch_async(_queue, ^{ if (!worker->closed && !worker->diskEdit) worker->machine.setJoystick((unsigned)port, (unsigned)MIN(x, 16383), (unsigned)MIN(y, 16383), (unsigned)buttons, (unsigned)mode); });
}
- (void)pasteChords:(NSArray<NSNumber*> *)chords completion:(VCCMachineCompletion)completion {
NSArray<NSNumber*> *owned = [chords copy];
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
if (owned.count > 65536) throw std::invalid_argument("Paste is too large");
std::vector<std::uint64_t> keys;
for (NSNumber* value in owned) keys.push_back(value.unsignedLongLongValue);
worker.machine.paste(keys);
worker.assistantPasteRun.clear();
worker.compiledKeyLease = nil; worker.compiledKeyExpected = nil;
} completion:completion];
}
- (void)assistantPaste:(NSArray<NSNumber*> *)chords runID:(NSString *)runID direct:(BOOL)direct expected:(VCCMachineSnapshot *)expected source:(NSString *)source completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
worker.error.clear();
CheckAssistantMachine(worker, expected, source);
if (worker.machine.pasteRemaining()) throw std::logic_error("Guest keyboard input is pending.");
if (worker.machine.snapshot().state != VCC::Mac::RunState::Running || chords.count < 1 || chords.count > 8 ||
(direct ? !worker.machine.basicAtDirectPrompt() : !worker.machine.basicExecutingStoredSource()))
throw std::logic_error("The guest is not at the expected BASIC input state.");
std::vector<std::uint64_t> keys;
for (NSNumber *value in chords) keys.push_back(value.unsignedLongLongValue);
worker.machine.paste(keys);
worker.assistantPasteRun = runID.UTF8String;
worker.compiledKeyLease = nil; worker.compiledKeyExpected = nil;
} completion:completion];
}
- (void)cancelAssistantPaste:(NSString *)runID {
auto worker = _worker;
dispatch_async(_queue, ^{
if (worker->assistantPasteRun == runID.UTF8String) {
worker->machine.cancelPaste();
worker->assistantPasteRun.clear();
}
});
}
- (void)compiledGuest:(VCCCompiledRunLease *)lease runID:(NSString *)runID expected:(VCCMachineSnapshot *)expected assembly:(BOOL)assembly key:(NSNumber *)key readScreen:(BOOL)readScreen finalScreen:(BOOL)finalScreen completion:(void (^)(NSString *, VCCMachineSnapshot *))completion {
__block NSString *text = nil;
[self perform:^(Worker& worker) {
worker.error.clear();
CheckCompiledRun(worker, lease, expected, assembly, finalScreen);
if (finalScreen) {
if (const auto *saved = worker.machine.sharedCompiledReturnScreen())
text = [NSString stringWithUTF8String:saved->c_str()];
return;
}
if (readScreen) text = [NSString stringWithUTF8String:worker.machine.copyScreenText().c_str()];
if (key) {
if (worker.machine.snapshot().state != VCC::Mac::RunState::Running) throw std::logic_error("run_paused");
if (worker.machine.pasteRemaining()) throw std::logic_error("input_busy");
worker.machine.pasteSharedCompiledKey(key.unsignedLongLongValue);
worker.assistantPasteRun = runID.UTF8String;
worker.compiledKeyLease = lease;
worker.compiledKeyExpected = expected;
worker.compiledKeyAssembly = assembly;
}
} completion:^(VCCMachineSnapshot *snapshot) { completion(text, snapshot); }];
}
- (void)checkReviewedBASIC:(VCCMachineSnapshot *)expected source:(NSString *)source completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { CheckAssistantMachine(worker, expected, source); } completion:completion];
}
- (void)assistantScreen:(VCCMachineSnapshot *)expected source:(NSString *)source completion:(void (^)(NSDictionary<NSString*,id>*, VCCMachineSnapshot*))completion {
__block NSDictionary *observation = nil;
[self perform:^(Worker& worker) {
worker.error.clear();
CheckAssistantMachine(worker, expected, source);
auto text = worker.machine.copyScreenText();
auto page = worker.machine.debuggerGraphicsPreview(true, true, 0, VCC::Mac::DebugGraphicsMode::SG4, false);
auto colors = [NSMutableArray array];
if (page.text && page.bytesPerCell == 2 && page.width && page.linesPerRow) {
// Sample the middle of an actual space between words in each text row.
// Its glyph is blank, so the renderer's pixel gives the background for
// this cell under the active RGB/composite signal and the live palette.
unsigned row = 0, previous = ~0u;
for (unsigned y = 0; y < page.height; ++y) {
unsigned offset = page.rowByteOffsets[y];
if (offset == previous) continue;
previous = offset;
unsigned columns = page.bytesPerRow / page.bytesPerCell;
bool word = false;
for (unsigned c = 0; c + 1 < columns; ++c) {
auto cell = offset + c * page.bytesPerCell;
if (page.bytes[cell] != ' ') { word = true; continue; }
if (!word || page.bytes[cell + page.bytesPerCell] == ' ') continue;
unsigned px = (2*c+1) * page.width / (2*columns);
unsigned py = std::min(y + page.linesPerRow/2, page.height-1);
unsigned rgb = page.pixels[py*page.width + px] & 0xffffff;
unsigned attribute = page.bytes[cell+1];
[colors addObject:@{@"row":@(row), @"column":@(c), @"rgb":@(rgb), @"attribute":@(attribute),
@"palette_index":@(attribute & 7), @"palette_value":@(page.palette[attribute & 7])}];
break;
}
++row;
}
}
observation = @{@"text":[NSString stringWithUTF8String:text.c_str()], @"colors":colors,
@"columns":@(page.bytesPerRow / page.bytesPerCell), @"direct_prompt":@(worker.machine.basicAtDirectPrompt())};
} completion:^(VCCMachineSnapshot *snapshot) { completion(observation, snapshot); }];
}
- (void)cancelPasteWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) { worker.machine.cancelPaste(); } completion:completion];
}
- (void)copyScreenTextWithCompletion:(void (^)(NSString*, VCCMachineSnapshot*))completion {
__block NSString* text = nil;
[self inspect:^(Worker& worker) {
worker.error.clear();
text = [NSString stringWithUTF8String:worker.machine.copyScreenText().c_str()];
} completion:^(VCCMachineSnapshot* snapshot) { completion(text, snapshot); }];
}
- (void)inspectScreenTextWithCompletion:(void (^)(NSString*, VCCMachineSnapshot*))completion {
__block NSString* text = nil;
[self inspect:^(Worker& worker) {
// Unlike Copy, this is a probe: boot and games may legitimately have no
// readable hardware text. Preserve any existing machine error as well.
try { text = [NSString stringWithUTF8String:worker.machine.copyScreenText().c_str()]; }
catch (const std::logic_error&) { }
} completion:^(VCCMachineSnapshot* snapshot) { completion(text, snapshot); }];
}
- (void)setPrinterEnabled:(BOOL)enabled completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear(); worker.machine.printer().setEnabled(enabled);
} completion:completion];
}
- (void)clearPrinterOutputWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear(); worker.machine.printer().clear();
} completion:completion];
}
- (void)printerOutputWithCompletion:(void (^)(VCCPrinterOutput *, VCCMachineSnapshot *))completion {
auto output = [VCCPrinterOutput new];
[self inspect:^(Worker& worker) {
const auto& printer = worker.machine.printer();
output.bytes = [NSData dataWithBytes:printer.bytes().data() length:printer.bytes().size()];
output.revision = printer.revision(); output.droppedBytes = printer.droppedBytes();
output.enabled = printer.enabled(); output.capacity = VCC::Mac::PrinterCapture::capacity;
} completion:^(VCCMachineSnapshot* snapshot) { completion(output, snapshot); }];
}
- (void)setKeyboardMask:(uint64_t)keys {
auto worker = _worker;
dispatch_async(_queue, ^{ if (!worker->closed && !worker->diskEdit) worker->machine.setKeyboard(keys); });
}
- (void)launchAssembly:(NSData *)binary points:(NSArray<NSNumber *> *)points addresses:(NSArray<NSNumber *> *)addresses bytes:(NSArray<NSData *> *)bytes pauseAtEntry:(BOOL)pauseAtEntry requires6309:(BOOL)requires6309 generation:(uint64_t)generation revision:(uint64_t)revision mapping:(uint64_t)mapping completion:(VCCMachineCompletion)completion {
[self launchAssembly:binary points:points addresses:addresses bytes:bytes pauseAtEntry:pauseAtEntry requires6309:requires6309
generation:generation revision:revision mapping:mapping shared:NO completion:completion];
}
- (void)launchAssembly:(NSData *)binary points:(NSArray<NSNumber *> *)points addresses:(NSArray<NSNumber *> *)addresses bytes:(NSArray<NSData *> *)bytes pauseAtEntry:(BOOL)pauseAtEntry requires6309:(BOOL)requires6309 generation:(uint64_t)generation revision:(uint64_t)revision mapping:(uint64_t)mapping shared:(BOOL)shared completion:(VCCMachineCompletion)completion {
NSData *image = [binary copy];
NSArray *stops = [points copy], *locations = [addresses copy];
NSArray *instructions = [[NSArray alloc] initWithArray:bytes copyItems:YES];
[self command:^(Worker& worker) {
if (shared) CheckAssistantGuestDevices(Capture(worker));
worker.machine.launchAssembly(OwnedBytes(image, VCC::Mac::BinaryImage::maxBytes), DebugAddresses(stops, 1024),
CodeGuards(locations, instructions), pauseAtEntry, requires6309, generation, revision, mapping);
if (shared) {
const auto active = worker.machine.snapshot();
worker.machine.armSharedCompiledCall();
worker.assistantProgram = std::make_pair(active.generation, active.debuggerProgramRevision);
}
} completion:completion];
}
- (void)pauseAssembly:(VCCMachineSnapshot *)expected completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.pauseAssembly(AssemblyIdentity(expected)); } completion:completion];
}
- (void)controlAssembly:(BOOL)step expected:(VCCMachineSnapshot *)expected completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.controlAssembly(step, AssemblyIdentity(expected)); } completion:completion];
}
- (void)updateAssembly:(NSArray<NSNumber *> *)points expected:(VCCMachineSnapshot *)expected completion:(VCCMachineCompletion)completion {
NSArray *stops = [points copy];
[self command:^(Worker& worker) { worker.machine.updateAssembly(DebugAddresses(stops, 1024), AssemblyIdentity(expected)); } completion:completion];
}
- (void)clearAssembly:(VCCMachineSnapshot *)expected completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.clearAssembly(AssemblyIdentity(expected)); } completion:completion];
}
- (void)startReviewedC:(NSData *)binary disk:(NSData *)disk name:(NSString *)name stop:(uint16_t)stop expected:(VCCMachineSnapshot *)expected completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
CheckAssistantMachine(worker, expected, @"", "occupied_basic_program");
auto current = Capture(worker);
if (disk && (current.disks.count < 1 || current.disks[0].mounted))
throw std::logic_error("Eject the disk in FD0 before running the Hello Disk example.");
if (current.basicDebugAttached || current.debuggerAssemblyAttached ||
(current.debuggerDevelopmentAttached && !worker.machine.sharedCompiledCallReturned()) || current.pasteRemaining)
throw std::logic_error("Finish the active debugging or paste session before running this C build.");
if (!worker.machine.basicAtDirectPrompt())
throw std::logic_error("Waiting for an empty Disk BASIC prompt.");
auto program = OwnedBytes(binary, VCC::Mac::BinaryImage::maxBytes);
if (disk) {
auto image = LoadFloppyImage(disk, name, true);
worker.requireFloppy().mount(0, std::move(image));
worker.clearDrive(0); worker.diskNames[0] = name.UTF8String; worker.readOnly[0] = true;
}
try {
worker.machine.debuggerLoadBinary(program, stop);
const auto active = worker.machine.snapshot();
worker.machine.armSharedCompiledCall();
worker.assistantProgram = std::make_pair(active.generation, active.debuggerProgramRevision);
} catch (...) {
if (disk) { worker.requireFloppy().eject(0, false); worker.clearDrive(0); }
throw;
}
} completion:completion];
}
- (void)continueReviewedC:(VCCMachineSnapshot *)expected name:(NSString *)name stop:(uint16_t)stop bytes:(NSData *)bytes completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
auto current = Capture(worker);
const NSUInteger byteCount = bytes.length;
CheckAssistantGuestDevices(current);
if (current.generation != expected.generation || current.debuggerProgramRevision != expected.debuggerProgramRevision ||
current.debuggerMappingFingerprint != expected.debuggerMappingFingerprint ||
current.state != VCCMachineStatePaused || current.programCounter != stop || !current.debuggerDevelopmentAttached ||
current.debuggerAssemblyAttached || !byteCount ||
(name.length && (!current.disks.firstObject.writeProtected || ![current.disks.firstObject.name isEqualToString:name])))
throw std::logic_error("The source stop, running program, or mounted project disk changed.");
if (byteCount > 65536u - stop)
throw std::invalid_argument("Memory range is outside the selected address space");
auto actual = worker.machine.debuggerMemoryRange(stop, static_cast<std::uint32_t>(byteCount), false);
if (actual.bytes.size() != byteCount || memcmp(actual.bytes.data(), bytes.bytes, byteCount) ||
std::find(actual.available.begin(), actual.available.end(), 0) != actual.available.end())
throw std::logic_error("The instruction in guest memory differs from the linked source map.");
if (name.length) { worker.machine.debuggerClearDevelopmentBreakpoints(); worker.machine.resume(); }
else worker.machine.debuggerContinueFromEntry(stop);
} completion:completion];
}
- (void)ejectReviewedCDisk:(NSString *)name completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
if (worker.readOnly[0] && worker.diskNames[0] == name.UTF8String) {
worker.requireFloppy().eject(0, false); worker.clearDrive(0);
}
} completion:completion];
}
- (void)debuggerLoadBinary:(NSData *)binary breakpoint:(uint16_t)breakpoint completion:(VCCMachineCompletion)completion {
NSData *owned = [binary copy];
[self command:^(Worker& worker) {
worker.machine.debuggerLoadBinary(OwnedBytes(owned, VCC::Mac::BinaryImage::maxBytes), breakpoint);
} completion:completion];
}
- (void)debuggerLoadBinary:(NSData *)binary breakpoints:(NSArray<NSNumber *> *)breakpoints completion:(VCCMachineCompletion)completion {
NSData *owned = [binary copy]; NSArray<NSNumber *> *points = [breakpoints copy];
[self command:^(Worker& worker) {
worker.machine.debuggerLoadBinary(OwnedBytes(owned, VCC::Mac::BinaryImage::maxBytes), DebugAddresses(points, 1024));
} completion:completion];
}
- (void)debuggerArmDevelopmentBreakpoints:(NSArray<NSNumber *> *)breakpoints guardAddresses:(NSArray<NSNumber *> *)guardAddresses guardBytes:(NSArray<NSData *> *)guardBytes completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *points = [breakpoints copy], *addresses = [guardAddresses copy];
NSArray<NSData *> *bytes = [[NSArray alloc] initWithArray:guardBytes copyItems:YES];
[self command:^(Worker& worker) {
auto guards = CodeGuards(addresses, bytes);
worker.machine.debuggerArmDevelopmentBreakpoints(DebugAddresses(points, 1024), guards);
} completion:completion];
}
- (void)debuggerArmBankedDevelopmentBreakpoints:(NSArray<NSNumber *> *)breakpoints modules:(NSArray<NSDictionary<NSString *, id> *> *)modules completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *points = [breakpoints copy];
// Freeze the nested arrays and NSData before crossing onto the machine queue.
NSArray *owned = CFBridgingRelease(CFPropertyListCreateDeepCopy(kCFAllocatorDefault, (__bridge CFPropertyListRef)modules, kCFPropertyListImmutable));
[self command:^(Worker& worker) {
worker.machine.debuggerArmBankedDevelopmentBreakpoints(DebugAddresses(points, 1024), BankedModules(owned));
} completion:completion];
}
- (void)debuggerClearDevelopmentBreakpointsWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.debuggerClearDevelopmentBreakpoints(); } completion:completion];
}
- (void)quickLoadBinary:(NSData *)binary completion:(VCCMachineCompletion)completion {
NSData *owned = [binary copy];
[self command:^(Worker& worker) {
worker.machine.quickLoad(OwnedBytes(owned, VCC::Mac::BinaryImage::maxBytes));
} completion:completion];
}
- (void)requestNitros9BootWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.machine.requestNitros9Boot();
} completion:completion];
}
- (void)resumeWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.resume(); } completion:completion];
}
- (void)debuggerSnapshotAtAddress:(uint16_t)address followPC:(BOOL)followPC memoryAddress:(uint16_t)memoryAddress completion:(void (^)(VCCDebuggerSnapshot *))completion {
[self debuggerSnapshotAtAddress:address followPC:followPC memoryAddress:memoryAddress physicalAddress:0 physicalMemory:NO completion:completion];
}
- (void)debuggerSnapshotAtAddress:(uint16_t)address followPC:(BOOL)followPC memoryAddress:(uint16_t)memoryAddress physicalAddress:(uint32_t)physicalAddress physicalMemory:(BOOL)physicalMemory completion:(void (^)(VCCDebuggerSnapshot *))completion {
auto result = [VCCDebuggerSnapshot new];
result.registers = @{}; result.instructions = @[]; result.breakpoints = @[]; result.disabledBreakpoints = @[];
result.memory = [NSData data]; result.memoryAvailable = [NSData data];
result.logicalMemory = [NSData data]; result.logicalMemoryAvailable = [NSData data];
result.memoryAddress = memoryAddress; result.stopReason = @"Load a machine to inspect it.";
result.physicalMemory = [NSData data];
result.mmu = [VCCMMUSnapshot new];
result.mmu.task0 = @[]; result.mmu.task1 = @[]; result.mmu.effective = @[];
[self inspect:^(Worker& worker) {
if (worker.closed) return;
if (worker.machine.snapshot().state == VCC::Mac::RunState::Empty) return;
// An inspector can outlive a profile/RAM-size change. Recover its
// physical cursor on this queue using the current installed capacity.
constexpr uint32_t capacities[] = {0x20000, 0x80000, 0x200000, 0x800000};
const auto capacity = capacities[worker.machine.snapshot().configuration.ram];
const auto physicalStart = physicalAddress < capacity ? physicalAddress : capacity - 256;
const auto debug = worker.machine.debuggerSnapshot(0, 65536, physicalStart, physicalMemory ? 256 : 0);
result.logicalMemory = [NSData dataWithBytes:debug.memory.data() length:debug.memory.size()];
result.logicalMemoryAvailable = [NSData dataWithBytes:debug.memoryAvailable.data() length:debug.memoryAvailable.size()];
const auto& mapping = debug.mmu;
auto mmu = result.mmu;
mmu.enabled = mapping.Enabled; mmu.activeTask = mapping.ActiveTask;
mmu.ramVectors = mapping.RamVectors; mmu.romMap = mapping.RomMap;
mmu.allRAM = mapping.AllRAM; mmu.prefix = mapping.Prefix;
mmu.ramByteCount = mapping.RAMBytes; mmu.vectorRAMAddress = mapping.RAMVectorAddress;
auto task0 = [NSMutableArray<NSNumber *> array], task1 = [NSMutableArray<NSNumber *> array];
auto effective = [NSMutableArray<VCCMemoryMapping *> array];
for (unsigned i = 0; i < 8; ++i) {
[task0 addObject:@(mapping.Task0[i])]; [task1 addObject:@(mapping.Task1[i])];
const auto& bank = mapping.Effective[i];
auto row = [VCCMemoryMapping new];
row.page = bank.Page; row.ramAddress = bank.RAMStart;
row.source = static_cast<NSInteger>(bank.Source); row.sourceAddress = bank.SourceStart;
[effective addObject:row];
}
mmu.task0 = task0; mmu.task1 = task1; mmu.effective = effective;
result.physicalAddress = debug.physicalAddress;
result.physicalMemory = [NSData dataWithBytes:debug.physicalMemory.data() length:debug.physicalMemory.size()];
const auto& cpu = debug.cpu;
auto registers = [NSMutableDictionary dictionaryWithDictionary:@{
@"A": @(cpu.A), @"B": @(cpu.B), @"DP": @(cpu.DP), @"CC": @(cpu.CC),
@"X": @(cpu.X), @"Y": @(cpu.Y), @"U": @(cpu.U), @"S": @(cpu.S), @"PC": @(cpu.PC)}];
const bool use6309 = worker.machine.snapshot().configuration.processor == VCC::Mac::Processor::HD6309;
if (use6309) [registers addEntriesFromDictionary:@{@"E": @(cpu.E), @"F": @(cpu.F), @"V": @(cpu.V), @"MD": @(cpu.MD)}];
result.registers = registers;
auto breakpoints = [NSMutableArray<NSNumber *> array];
for (auto pc : debug.breakpoints) [breakpoints addObject:@(pc)];
result.breakpoints = breakpoints;
auto disabled = [NSMutableArray<NSNumber *> array];
for (auto point : debug.disabledBreakpoints) [disabled addObject:@(point)];
result.disabledBreakpoints = disabled;
result.stopReason = [NSString stringWithUTF8String:debug.stopReason.c_str()];
auto instructions = [NSMutableArray<VCCDebugInstruction *> array];
uint16_t cursor = followPC ? cpu.PC : address;
for (unsigned row = 0; row < 48; ++row) {
const auto line = VCC::Mac::Disassemble(debug.memory, cpu, use6309, cursor, 1).front();
auto item = [VCCDebugInstruction new]; item.address = line.address;
bool available = true;
for (std::size_t i = 0; i < line.bytes.size(); ++i)
available &= debug.memoryAvailable[uint16_t(line.address + i)] != 0;
item.bytes = available ? [NSData dataWithBytes:line.bytes.data() length:line.bytes.size()] : [NSData data];
item.mnemonic = available ? [NSString stringWithUTF8String:line.mnemonic.c_str()] : @"—";
item.operand = available ? [NSString stringWithUTF8String:line.operand.c_str()] : @"I/O unavailable";
item.valid = available && line.valid; [instructions addObject:item];
// Unknown I/O bytes cannot determine an instruction's length.
// Advance one address so safe bytes on the far side remain visible.
cursor = uint16_t(cursor + (available ? line.bytes.size() : 1));
}
result.instructions = instructions;
uint8_t bytes[256], available[256];
for (unsigned i = 0; i < 256; ++i) {
const auto offset = uint16_t(memoryAddress + i);
bytes[i] = debug.memory[offset]; available[i] = debug.memoryAvailable[offset];
}
result.memory = [NSData dataWithBytes:bytes length:sizeof(bytes)];
result.memoryAvailable = [NSData dataWithBytes:available length:sizeof(available)];
} completion:^(VCCMachineSnapshot *snapshot) {
result.machine = snapshot; completion(result);
}];
}
- (void)debuggerMemoryAtAddress:(uint32_t)address count:(uint32_t)count physical:(BOOL)physical logicalAddress:(uint16_t)logicalAddress os9:(BOOL)os9 decode:(BOOL)decode completion:(void (^)(VCCDebugMemoryCapture *))completion {
auto result = [VCCDebugMemoryCapture new];
result.bytes = [NSData data]; result.available = [NSData data];
result.instructions = @[]; result.instructionOffsets = @[];
[self inspect:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
if (decode && count > 65536) throw std::invalid_argument("Decode at most 64 KiB at once");
const auto capture = worker.machine.debuggerMemoryRange(address, count, physical);
result.address = capture.address; result.capacity = capture.capacity;
result.bytes = [NSData dataWithBytes:capture.bytes.data() length:capture.bytes.size()];
result.available = [NSData dataWithBytes:capture.available.data() length:capture.available.size()];
if (decode) {
const bool use6309 = worker.machine.snapshot().configuration.processor == VCC::Mac::Processor::HD6309;
const auto decoded = VCC::Mac::DisassembleRange(capture.bytes, capture.available, use6309, physical ? logicalAddress : uint16_t(address), 128, os9);
auto rows = [NSMutableArray<VCCDebugInstruction *> array];
auto offsets = [NSMutableArray<NSNumber *> array];
unsigned offset = 0;
for (const auto& line : decoded) {
auto item = [VCCDebugInstruction new]; item.address = line.address;
item.bytes = line.available ? [NSData dataWithBytes:line.bytes.data() length:line.bytes.size()] : [NSData data];
item.mnemonic = [NSString stringWithUTF8String:line.mnemonic.c_str()];
item.operand = [NSString stringWithUTF8String:line.operand.c_str()]; item.valid = line.valid;
[rows addObject:item]; [offsets addObject:@(offset)]; offset += line.bytes.size();
}
result.instructions = rows; result.instructionOffsets = offsets;
}
} completion:^(VCCMachineSnapshot *snapshot) { result.machine = snapshot; completion(result); }];
}
- (void)debuggerGraphicsCurrentPage:(BOOL)currentPage address:(uint32_t)address physical:(BOOL)physical mode:(NSInteger)mode alternatePalette:(BOOL)alternatePalette completion:(void (^)(VCCDebugGraphicsCapture *))completion {
auto result = [VCCDebugGraphicsCapture new];
[self inspect:^(Worker& worker) {
// A preview failure belongs to this request. Preserve any existing machine error.
try {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
if (!currentPage && (mode < 0 || mode > 9)) throw std::invalid_argument("Unknown graphics mode");
auto preview = worker.machine.debuggerGraphicsPreview(currentPage, physical, address,
static_cast<VCC::Mac::DebugGraphicsMode>(currentPage ? 0 : mode), alternatePalette);
[result takePreview:preview];
} catch (const std::exception& error) {
result.errorMessage = [NSString stringWithUTF8String:error.what()];
}
} completion:^(VCCMachineSnapshot *snapshot) {
result.machine = snapshot; completion(result);
}];
}
- (void)debuggerStepWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.debuggerStep(); worker.machine.takeAudio(); } completion:completion];
}
- (void)debuggerStepSource:(NSInteger)mode addresses:(NSArray<NSNumber *> *)addresses locations:(NSArray<NSNumber *> *)locations bytes:(NSArray<NSData *> *)bytes generation:(uint64_t)generation programRevision:(uint64_t)programRevision mappingFingerprint:(uint64_t)mappingFingerprint programCounter:(uint16_t)programCounter completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *ownedAddresses = [addresses copy], *ownedLocations = [locations copy];
NSArray<NSData *> *ownedBytes = [[NSArray alloc] initWithArray:bytes copyItems:YES];
[self command:^(Worker& worker) {
if (mode < 0 || mode > 2 || ownedAddresses.count != ownedLocations.count || ownedAddresses.count != ownedBytes.count)
throw std::invalid_argument("Invalid C step mode or source locations");
const auto parsed = DebugAddresses(ownedAddresses, 65536);
std::vector<VCC::Mac::DebugSourceInstruction> instructions;
for (NSUInteger i = 0; i < parsed.size(); ++i) {
const double location = ownedLocations[i].doubleValue;
if (!std::isfinite(location) || location < 0 || location > UINT32_MAX || location != std::floor(location))
throw std::invalid_argument("Invalid C source location identity");
instructions.push_back({parsed[i], uint32_t(location), OwnedBytes(ownedBytes[i], 8)});
}
worker.machine.debuggerStepSource(static_cast<VCC::Mac::SourceStepMode>(mode), instructions,
generation, programRevision, mappingFingerprint, programCounter);
} completion:completion];
}
- (void)debuggerStepBankedSource:(NSInteger)mode addresses:(NSArray<NSNumber *> *)addresses locations:(NSArray<NSNumber *> *)locations bytes:(NSArray<NSData *> *)bytes moduleIdentifiers:(NSArray<NSString *> *)moduleIdentifiers generation:(uint64_t)generation programRevision:(uint64_t)programRevision mappingFingerprint:(uint64_t)mappingFingerprint programCounter:(uint16_t)programCounter completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *ownedAddresses = [addresses copy], *ownedLocations = [locations copy];
NSArray<NSData *> *ownedBytes = [[NSArray alloc] initWithArray:bytes copyItems:YES];
NSArray<NSString *> *identifiers = [[NSArray alloc] initWithArray:moduleIdentifiers copyItems:YES];
[self command:^(Worker& worker) {
if (mode < 0 || mode > 2 || ownedAddresses.count != ownedLocations.count ||
ownedAddresses.count != ownedBytes.count || ownedAddresses.count != identifiers.count)
throw std::invalid_argument("Invalid banked C step mode or source locations");
if (!worker.machine.snapshot().debuggerBankedDevelopment)
throw std::invalid_argument("Arm verified banked modules before banked C stepping");
const auto parsed = DebugAddresses(ownedAddresses, 65536);
std::vector<VCC::Mac::DebugSourceInstruction> instructions;
for (NSUInteger i = 0; i < parsed.size(); ++i) {
const double location = ownedLocations[i].doubleValue;
if (!std::isfinite(location) || location < 0 || location > UINT32_MAX || location != std::floor(location))
throw std::invalid_argument("Invalid C source location identity");
instructions.push_back({parsed[i], uint32_t(location), OwnedBytes(ownedBytes[i], 8), identifiers[i].UTF8String});
}
worker.machine.debuggerStepSource(static_cast<VCC::Mac::SourceStepMode>(mode), instructions,
generation, programRevision, mappingFingerprint, programCounter);
} completion:completion];
}
- (void)debuggerSetPC:(uint16_t)address completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear(); worker.machine.debuggerSetPC(address);
} completion:completion];
}
- (void)debuggerSetBreakpoints:(NSArray<NSNumber *> *)addresses completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *owned = [addresses copy];
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
if (owned.count > 1024) throw std::invalid_argument("Use at most 1,024 breakpoints");
std::vector<uint16_t> points;
for (NSNumber *value in owned) {
const double n = value.doubleValue;
if (!std::isfinite(n) || n < 0 || n > 65535 || n != std::floor(n))
throw std::invalid_argument("Breakpoint addresses must be hexadecimal 0000 through FFFF");
points.push_back(uint16_t(n));
}
worker.machine.debuggerSetBreakpoints(std::move(points));
} completion:completion];
}
- (void)debuggerConfigureBreakpoints:(NSArray<NSNumber *> *)enabled disabled:(NSArray<NSNumber *> *)disabled completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *on = [enabled copy], *off = [disabled copy];
[self perform:^(Worker& worker) {
worker.error.clear(); worker.machine.debuggerConfigureBreakpoints(DebugAddresses(on, 1024), DebugAddresses(off, 1024));
} completion:completion];
}
- (void)debuggerStartTrace:(NSUInteger)maximum starts:(NSArray<NSNumber *> *)starts stops:(NSArray<NSNumber *> *)stops screen:(BOOL)screen scheduler:(BOOL)scheduler completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *begin = [starts copy], *end = [stops copy];
[self perform:^(Worker& worker) {
worker.error.clear();
if (maximum > 100000) throw std::invalid_argument("Use at most 100,000 trace samples");
worker.machine.debuggerStartTrace(unsigned(maximum), DebugAddresses(begin, 32), DebugAddresses(end, 32), screen, scheduler);
} completion:completion];
}
- (void)debuggerStopTraceWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) { worker.error.clear(); worker.machine.debuggerStopTrace(); } completion:completion];
}
- (void)debuggerClearTraceWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) { worker.error.clear(); worker.machine.debuggerClearTrace(); } completion:completion];
}
- (void)debuggerTraceAtOffset:(NSUInteger)offset completion:(void (^)(VCCTraceSnapshot *, VCCMachineSnapshot *))completion {
auto result = [VCCTraceSnapshot new]; result.records = @[]; result.status = @"No trace";
[self inspect:^(Worker& worker) {
const auto trace = worker.machine.debuggerTrace(offset);
result.identifier = trace.identifier; result.armed = trace.armed; result.capturing = trace.capturing;
result.total = trace.total; result.offset = trace.offset; result.limit = trace.limit;
result.status = [NSString stringWithUTF8String:trace.status.c_str()];
auto rows = [NSMutableArray<VCCTraceRecord *> array];
std::vector<std::uint8_t> memory(65536);
for (std::size_t i = 0; i < trace.records.size(); ++i) {
const auto& row = trace.records[i]; auto item = [VCCTraceRecord new];
item.index = trace.offset + i; item.clock = row.clock; item.frame = row.frame;
item.address = row.before.PC; item.cycles = row.cycles; item.kind = TraceKind(row.event);
item.before = TraceRegisters(row.before, trace.use6309); item.after = TraceRegisters(row.after, trace.use6309);
item.instruction = @"";
item.detail = [NSString stringWithFormat:@"Line %u%@%s", row.line, row.detail.empty() ? @"" : @" · ", row.detail.c_str()];
if (row.event == VCC::TraceEvent::Instruction) {
for (unsigned byte = 0; byte < row.availableBytes; ++byte) memory[uint16_t(row.before.PC + byte)] = row.bytes[byte];
const auto instruction = VCC::Mac::Disassemble(memory, row.before, trace.use6309, row.before.PC, 1).front();
item.instruction = instruction.bytes.size() <= row.availableBytes ? [NSString stringWithFormat:@"%s %s", instruction.mnemonic.c_str(), instruction.operand.c_str()] : @"I/O bytes unavailable";
}
[rows addObject:item];
}
result.records = rows;
} completion:^(VCCMachineSnapshot* machine) { completion(result, machine); }];
}
- (void)debuggerExportTraceFrom:(NSUInteger)first count:(NSUInteger)count completion:(void (^)(NSString * _Nullable, VCCMachineSnapshot *))completion {
auto captured = std::make_shared<VCC::Mac::DebugTraceSnapshot>();
__block BOOL valid = NO;
[self inspect:^(Worker& worker) {
worker.error.clear(); *captured = worker.machine.debuggerTraceForExport(first, count); valid = YES;
} completion:^(VCCMachineSnapshot* initial) {
if (!valid) { completion(nil, initial); return; }
dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
NSString* text = nil; NSString* failure = nil;
try { const auto csv = VCC::Mac::FormatDebugTraceCSV(*captured); text = [NSString stringWithUTF8String:csv.c_str()]; }
catch (const std::exception& error) { failure = [NSString stringWithUTF8String:error.what()]; }
// Formatting never blocks the emulator queue. Deliver a current
// machine snapshot, not the stale state from export's beginning.
[self inspect:^(Worker& worker) { if (failure) worker.error = failure.UTF8String; }
completion:^(VCCMachineSnapshot* current) { completion(text, current); }];
});
}];
}
- (void)basicLoadSource:(NSString *)source run:(BOOL)run completion:(VCCMachineCompletion)completion {
[self basicLoadSource:source run:run breakpoints:@[] completion:completion];
}
- (void)basicLoadSource:(NSString *)source run:(BOOL)run breakpoints:(NSArray<NSNumber *> *)lines completion:(VCCMachineCompletion)completion {
[self loadBASICSource:source run:run points:lines expected:nil existing:nil completion:completion];
}
- (void)assistantLoadSource:(NSString *)source breakpoints:(NSArray<NSNumber *> *)lines expected:(VCCMachineSnapshot *)expected existing:(NSString *)existing completion:(VCCMachineCompletion)completion {
[self loadBASICSource:source run:YES points:lines expected:expected existing:existing completion:completion];
}
- (void)loadBASICSource:(NSString *)source run:(BOOL)run points:(NSArray<NSNumber *> *)lines expected:(VCCMachineSnapshot *)expected existing:(NSString *)existing completion:(VCCMachineCompletion)completion {
__block NSString *installed = nil;
NSString *owned = [source copy]; NSArray<NSNumber *> *points = [lines copy];
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
if (expected) CheckAssistantMachine(worker, expected, existing);
NSData *utf8 = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!utf8 || utf8.length > 1024 * 1024) throw std::invalid_argument("BASIC source must be at most 1 MB of text");
const std::string text(static_cast<const char *>(utf8.bytes), utf8.length);
std::vector<std::uint16_t> requested;
if (points.count > 1024) throw std::invalid_argument("At most 1024 BASIC breakpoints are supported");
for (NSNumber *point in points) {
if (point.integerValue < 0 || point.integerValue > 63999) throw std::invalid_argument("Invalid BASIC breakpoint number");
requested.push_back(point.unsignedShortValue);
}
worker.machine.basicLoadSource(text, run, requested);
if (expected) {
const auto active = worker.machine.snapshot();
worker.assistantProgram = std::make_pair(active.generation, active.debuggerProgramRevision);
installed = [NSString stringWithUTF8String:worker.machine.basicReadSource().c_str()];
}
// Reset host buffering only after a successful transfer. Rejected loads
// preserve the running program and its audio state.
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
} completion:^(VCCMachineSnapshot *snapshot) {
snapshot.assistantLoadedSource = installed;
completion(snapshot);
}];
}
- (void)basicSetBreakpoints:(NSArray<NSNumber *> *)lines source:(NSString *)source completion:(VCCMachineCompletion)completion {
NSArray<NSNumber *> *points = [lines copy]; NSString *owned = [source copy];
[self perform:^(Worker& worker) {
worker.error.clear();
if (worker.closed) throw std::logic_error("The machine controller has shut down");
NSData *data = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!data || data.length > 1024 * 1024 || points.count > 1024) throw std::invalid_argument("BASIC source or breakpoint limit exceeded");
std::vector<std::uint16_t> requested;
for (NSNumber *point in points) {
if (point.integerValue < 0 || point.integerValue > 63999) throw std::invalid_argument("Invalid BASIC breakpoint number");
requested.push_back(point.unsignedShortValue);
}
worker.machine.basicSetBreakpoints(std::string(static_cast<const char *>(data.bytes), data.length), requested);
} completion:completion];
}
- (void)basicContinueSource:(NSString *)source completion:(VCCMachineCompletion)completion {
NSString *owned = [source copy];
[self command:^(Worker& worker) {
NSData *data = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!data || data.length > 1024 * 1024) throw std::invalid_argument("BASIC source limit exceeded");
worker.machine.basicContinue(std::string(static_cast<const char *>(data.bytes), data.length));
} completion:completion];
}
- (void)basicStepSource:(NSString *)source over:(BOOL)over completion:(VCCMachineCompletion)completion {
NSString *owned = [source copy];
[self command:^(Worker& worker) {
NSData *data = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!data || data.length > 1024 * 1024) throw std::invalid_argument("BASIC source limit exceeded");
worker.machine.basicStep(std::string(static_cast<const char *>(data.bytes), data.length), over);
} completion:completion];
}
- (void)basicStepOutSource:(NSString *)source completion:(VCCMachineCompletion)completion {
NSString *owned = [source copy];
[self command:^(Worker& worker) {
NSData *data = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!data || data.length > 1024 * 1024) throw std::invalid_argument("BASIC source limit exceeded");
worker.machine.basicStepOut(std::string(static_cast<const char *>(data.bytes), data.length));
} completion:completion];
}
- (void)basicClearDebugWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) { worker.error.clear(); worker.machine.basicClearDebug(); } completion:completion];
}
- (void)basicExportSource:(NSString *)source name:(NSString *)name cassette:(BOOL)cassette completion:(void (^)(NSData *, VCCMachineSnapshot *))completion {
NSString *owned = [source copy], *filename = [name copy];
__block NSData *result = nil;
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
NSData *utf8 = [owned dataUsingEncoding:NSUTF8StringEncoding];
NSData *nameBytes = [filename dataUsingEncoding:NSUTF8StringEncoding];
if (!utf8 || utf8.length > 1024 * 1024 || !nameBytes || nameBytes.length > 8)
throw std::invalid_argument("Use BASIC source up to 1 MB and a name of 1–8 letters or digits");
const std::string text(utf8.length ? static_cast<const char *>(utf8.bytes) : "", utf8.length);
const std::string stem(nameBytes.length ? static_cast<const char *>(nameBytes.bytes) : "", nameBytes.length);
const auto bytes = worker.machine.basicExportSource(text, stem, cassette ? VCC::Mac::BasicExportFormat::Cassette : VCC::Mac::BasicExportFormat::Disk);
result = [NSData dataWithBytes:bytes.data() length:bytes.size()];
} completion:^(VCCMachineSnapshot *snapshot) { completion(result, snapshot); }];
}
- (void)basicInspectSource:(NSString *)source completion:(void (^)(NSArray<NSDictionary<NSString *, id> *> *, VCCMachineSnapshot *))completion {
NSString *owned = [source copy];
__block NSArray *result = nil;
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
NSData *data = [owned dataUsingEncoding:NSUTF8StringEncoding];
if (!data || data.length > 1024 * 1024) throw std::invalid_argument("BASIC source limit exceeded");
const auto variables = worker.machine.basicInspect(std::string(static_cast<const char *>(data.bytes), data.length));
NSMutableArray *rows = [NSMutableArray array];
for (const auto& v : variables) {
NSMutableArray *dimensions = [NSMutableArray array], *elements = [NSMutableArray array];
for (auto length : v.dimensions) [dimensions addObject:@(length)];
for (const auto& text : v.elements) [elements addObject:[NSString stringWithUTF8String:text.c_str()]];
[rows addObject:@{@"name": [NSString stringWithUTF8String:v.name.c_str()],
@"kind": [NSString stringWithUTF8String:v.kind.c_str()],
@"value": [NSString stringWithUTF8String:v.value.c_str()],
@"address": @(v.address), @"dimensions": dimensions, @"elements": elements}];
}
result = rows;
} completion:^(VCCMachineSnapshot *snapshot) { completion(result, snapshot); }];
}
- (void)basicReadSourceWithCompletion:(void (^)(NSString *, VCCMachineSnapshot *))completion {
__block NSString *source = nil;
[self inspect:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
const auto text = worker.machine.basicReadSource();
source = [[NSString alloc] initWithBytes:text.data() length:text.size() encoding:NSUTF8StringEncoding];
if (!source) throw std::runtime_error("The BASIC program cannot be represented as editable text");
} completion:^(VCCMachineSnapshot *snapshot) { completion(source, snapshot); }];
}
- (void)debuggerWriteMemoryAtAddress:(uint16_t)address data:(NSData *)data completion:(VCCMachineCompletion)completion {
NSData *owned = [data copy];
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear(); worker.machine.debuggerWriteMemory(address, OwnedBytes(owned, 256));
} completion:completion];
}
- (void)pauseWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.pause(); } completion:completion];
}
- (void)softResetWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.softReset(); } completion:completion];
}
- (void)resetWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.reset(); } completion:completion];
}
- (void)startMacShellWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed || !worker.machine.driveWireEnabled())
throw std::logic_error("Enable DriveWire networking before starting a Mac shell session.");
worker.shell.arm(); worker.error.clear();
} completion:completion];
}
- (void)stopMacShellWithCompletion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) { worker.shell.stop(); worker.error.clear(); } completion:completion];
}
- (void)decideMacShellRequest:(uint64_t)requestID allow:(BOOL)allow completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed || !worker.machine.driveWireEnabled() || !worker.shell.decide(requestID, allow))
throw std::logic_error("This guest shell request has ended.");
worker.error.clear();
} completion:completion];
}
- (void)setDriveWireEnabled:(BOOL)enabled completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
if (enabled && worker.assistantProgram) {
const auto active = worker.machine.snapshot();
if (std::make_pair(active.generation, active.debuggerProgramRevision) == *worker.assistantProgram &&
!worker.machine.basicAtDirectPrompt())
throw std::logic_error("Return the shared program to the BASIC prompt before enabling DriveWire.");
}
if (worker.machine.driveWireEnabled() != bool(enabled)) {
worker.shell.stop();
VCC::Devices::DriveWireFactory factory;
if (enabled) {
factory = [owner = &worker](const std::string& host, uint16_t port) {
return VCC::Mac::openDriveWireEndpoint(owner->shell, host, port);
};
}
worker.machine.setDriveWireFactory(std::move(factory));
}
worker.error.clear();
} completion:completion];
}
- (void)setAudioEnabled:(BOOL)enabled volume:(float)volume completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
// Gain/mute changes must not flush buffered sound or advance the guest
// to refill it. Only an actual output enable/disable changes the clock.
if (worker.audioEnabled != bool(enabled)) {
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
worker.audioEnabled = enabled; worker.error.clear();
}
worker.audio.buffer().gain.store(std::isfinite(volume) ? std::clamp(volume,0.0f,1.0f) : 0.0f);
} completion:completion];
}
- (void)mountTape:(NSData*)data wav:(BOOL)wav completion:(VCCMachineCompletion)completion {
NSData *owned=[data copy];
[self command:^(Worker& worker) {
if(worker.machine.cassette().snapshot().dirty) throw std::logic_error("Export or discard the recording first");
if(owned.length>VCC::Mac::CassetteDeck::maxBytes) throw std::invalid_argument("Tape exceeds 64 MiB");
const auto *begin=static_cast<const std::uint8_t*>(owned.bytes);
std::vector<std::uint8_t> bytes;
if(owned.length) bytes.assign(begin,begin+owned.length);
worker.machine.cassette().mount(bytes,wav?VCC::Mac::TapeFormat::WAV:VCC::Mac::TapeFormat::CAS);
++worker.mediaRevision;
} completion:completion];
}
- (void)tapeAction:(NSInteger)action completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
auto& tape=worker.machine.cassette();
if(action>=3 && tape.snapshot().dirty) throw std::logic_error("Export or discard the recording first");
switch(action) {
case 0: tape.stop(); break;
case 1: tape.play(); break;
case 2: tape.rewind(); break;
case 3: tape.eject(); ++worker.mediaRevision; break;
case 4: tape.record(VCC::Mac::TapeFormat::CAS); ++worker.mediaRevision; break;
case 5: tape.record(VCC::Mac::TapeFormat::WAV); ++worker.mediaRevision; break;
default: throw std::invalid_argument("Unknown tape action");
}
} completion:completion];
}
- (void)seekTape:(uint64_t)position completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.cassette().seek(position); } completion:completion];
}
- (void)setTapeFast:(BOOL)enabled completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.cassette().setFast(enabled); } completion:completion];
}
- (void)exportTapeWithCompletion:(void (^)(NSData*,VCCMachineSnapshot*))completion {
__block NSData *data=nil;
[self command:^(Worker& worker) {
auto bytes=worker.machine.cassette().exportImage();
data=[NSData dataWithBytes:bytes.data() length:bytes.size()];
} completion:^(VCCMachineSnapshot *snapshot) { completion(data,snapshot); }];
}
- (void)discardTapeWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
// One queue operation: a recording tick cannot make it dirty again
// between confirming discard and ejecting the in-memory image.
auto& tape=worker.machine.cassette(); tape.stop(); tape.markSaved(); tape.eject(); ++worker.mediaRevision;
} completion:completion];
}
- (void)markTapeSavedWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.machine.cassette().markSaved(); } completion:completion];
}
- (void)configureCartridges:(NSArray<NSNumber*>*)kinds roms:(NSArray<NSData*>*)roms names:(NSArray<NSString*>*)names multiPak:(BOOL)enabled physicalSlot:(NSInteger)slot completion:(VCCMachineCompletion)completion {
[self configureCartridges:kinds roms:roms names:names multiPak:enabled physicalSlot:slot
sdcFolders:@[@"",@"",@"",@"",@""] sdcReadOnly:@[@YES,@YES,@YES,@YES,@YES] completion:completion];
}
- (void)configureCartridges:(NSArray<NSNumber*>*)kinds roms:(NSArray<NSData*>*)roms names:(NSArray<NSString*>*)names multiPak:(BOOL)enabled physicalSlot:(NSInteger)slot sdcFolders:(NSArray<NSString*>*)folders sdcReadOnly:(NSArray<NSNumber*>*)readOnly completion:(VCCMachineCompletion)completion {
NSArray *roots = [[NSArray alloc] initWithArray:folders copyItems:YES];
NSArray *protectedCards = [[NSArray alloc] initWithArray:readOnly copyItems:YES];
// Copy each payload, not only the container, before crossing the queue.
NSMutableArray<NSData*> *bytes = [NSMutableArray new];
for (NSData* data in roms) [bytes addObject:[data copy]];
NSArray *types = [kinds copy]; NSArray *labels = [[NSArray alloc] initWithArray:names copyItems:YES];
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.error.clear();
if (types.count != 5 || bytes.count != 5 || labels.count != 5 || roots.count != 5 || protectedCards.count != 5 || slot < 1 || slot > 4)
throw std::invalid_argument("Invalid cartridge layout");
VCC::Devices::CartridgeBus::Slots next;
std::array<int, 5> nextKinds; std::array<std::string, 5> nextNames;
unsigned floppyCount = 0, hardCount = 0, ramCount = 0, orchestraCount = 0, speechCount = 0, sdcCount = 0;
std::shared_ptr<VCC::Devices::RamDiskDevice> ram;
for (unsigned i = 0; i < 5; ++i) {
int kind = [types[i] intValue];
if (kind < 0 || kind > 7) throw std::invalid_argument("Unknown cartridge device");
nextKinds[i] = kind; nextNames[i] = [labels[i] UTF8String];
if (kind == 1 && [bytes[i] length]) next[i] = std::make_shared<VCC::Devices::RomCartridge>(OwnedBytes(bytes[i], 262144));
if (kind == 7) {
if ([bytes[i] length]) next[i] = std::make_shared<VCC::Devices::SDCDevice>(
OwnedBytes(bytes[i], 16384), [roots[i] UTF8String], [protectedCards[i] boolValue]);
if (i) ++sdcCount;
}
if (kind == 6) {
next[i] = std::make_shared<VCC::Devices::SpeechSoundDevice>(OwnedBytes(bytes[i], 6144));
if (i) ++speechCount;
}
if (kind == 5) {
auto rom = OwnedBytes(bytes[i], 8192);
// Retain DAC latches on reset, slot moves and unrelated changes.
// Retained single/MPI modes may have different optional ROMs.
// Prefer this assignment, then an MPI slot move, before the
// retained single mode (which may have its own playback state).
for (unsigned previous : {i, 1u, 2u, 3u, 4u, 0u}) {
auto device = std::dynamic_pointer_cast<VCC::Devices::Orchestra90Device>(worker.cartridgeDevices[previous]);
if (device && device->hasROM(rom)) { next[i] = device; break; }
}
if (!next[i]) next[i] = std::make_shared<VCC::Devices::Orchestra90Device>(std::move(rom));
if (i > 0) ++orchestraCount;
}
if (kind == 4) {
if (!ram) ram = worker.ramDevice ? worker.ramDevice : std::make_shared<VCC::Devices::RamDiskDevice>();
next[i] = ram; if (i > 0) ++ramCount;
}
if (kind == 3) { next[i] = worker.hardDevice; if (i > 0) ++hardCount; }
if (kind == 2) { next[i] = worker.diskDevice; if (i > 0) ++floppyCount; }
}
if (sdcCount > 1) throw std::invalid_argument("Only one CoCo SDC is supported in the Multi-Pak");
if (speechCount > 1) throw std::invalid_argument("Only one Speech/Sound Cartridge is supported in the Multi-Pak");
if (orchestraCount > 1) throw std::invalid_argument("Only one Orchestra-90 is supported in the Multi-Pak");
if (ramCount > 1) throw std::invalid_argument("Only one RAM disk is supported in the Multi-Pak");
if (hardCount > 1) throw std::invalid_argument("Only one virtual hard-disk controller is supported in the Multi-Pak");
if (floppyCount > 1) throw std::invalid_argument("Only one floppy controller is supported in the Multi-Pak");
worker.pauseForDisks();
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
worker.machine.cartridges().configure(next, enabled, static_cast<unsigned>(slot));
worker.ramDevice = std::move(ram);
worker.cartridgeDevices = std::move(next); worker.cartridgeKinds = nextKinds; worker.cartridgeNames = std::move(nextNames);
if (worker.machine.snapshot().state != VCC::Mac::RunState::Empty) worker.machine.reset();
} completion:completion];
}
- (void)pauseForDiskChangeWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.pauseForDisks(); } completion:completion];
}
- (void)loadDiskROM:(NSData*)rom name:(NSString*)name completion:(VCCMachineCompletion)completion {
NSData *owned = [rom copy]; NSString *label = [name copy];
[self command:^(Worker& worker) {
auto bytes = OwnedBytes(owned, 16384);
// Construct/validate first, preserving the previous device on failure.
auto next = VCC::Devices::makeDevice(VCC::Devices::DeviceKind::FD502, bytes);
worker.pauseForDisks();
if (auto* existing = worker.floppy()) existing->setROM(bytes);
else worker.diskDevice = std::shared_ptr<VCC::Devices::Fd502Device>(static_cast<VCC::Devices::Fd502Device*>(next.release()));
worker.applyLayout(worker.machine.cartridges().multiPak(), worker.machine.cartridges().physicalSlot());
worker.diskROMName = label.UTF8String;
if (worker.machine.snapshot().state != VCC::Mac::RunState::Empty) worker.machine.reset();
} completion:completion];
}
- (void)disableDisksWithCompletion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
auto& floppy = worker.requireFloppy();
for (unsigned i = 0; i < 4; ++i)
if (floppy.image(i) && floppy.image(i)->dirty())
throw std::logic_error("Save or discard all modified disks before disabling the controller");
worker.pauseForDisks(); worker.diskDevice.reset();
worker.applyLayout(worker.machine.cartridges().multiPak(), worker.machine.cartridges().physicalSlot());
worker.diskROMName.clear(); for (unsigned i = 0; i < 4; ++i) worker.clearDrive(i);
if (worker.machine.snapshot().state != VCC::Mac::RunState::Empty) worker.machine.reset();
} completion:completion];
}
- (void)mountDisk:(NSData*)data drive:(NSInteger)drive name:(NSString*)name readOnly:(BOOL)readOnly completion:(VCCMachineCompletion)completion {
[self mountDisk:data drive:drive name:name readOnly:readOnly reset:VCCDiskInsertionResetNone completion:completion];
}
- (void)mountDisk:(NSData*)data drive:(NSInteger)drive name:(NSString*)name readOnly:(BOOL)readOnly reset:(VCCDiskInsertionReset)reset completion:(VCCMachineCompletion)completion {
NSData *owned = [data copy]; NSString *label = [name copy];
[self command:^(Worker& worker) {
if (reset < VCCDiskInsertionResetNone || reset > VCCDiskInsertionResetColdRestart)
throw std::invalid_argument("Unknown disk insertion reset option");
const auto index = DriveIndex(drive);
auto image = LoadFloppyImage(owned, label, readOnly);
auto& floppy = worker.requireFloppy();
if (const auto* current = floppy.image(index); current && current->dirty())
throw std::logic_error("Save or discard the modified disk before replacing it");
worker.pauseForDisks();
if (reset == VCCDiskInsertionResetSoftReset) worker.machine.softReset();
else if (reset == VCCDiskInsertionResetColdRestart) worker.machine.reset();
floppy.mount(index, std::move(image));
worker.clearDrive(index); worker.diskNames[index] = label.UTF8String; worker.readOnly[index] = readOnly;
} completion:completion];
}
- (void)createDiskInDrive:(NSInteger)drive completion:(VCCMachineCompletion)completion {
[self createDiskInDrive:drive format:VCCFloppyFormatStandard completion:completion];
}
- (void)createDiskInDrive:(NSInteger)drive format:(VCCFloppyFormat)format completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
using VCC::Devices::DiskFormat;
DiskFormat kind;
std::string name;
switch (format) {
case VCCFloppyFormatStandard: kind = DiskFormat::JVC; name = "Untitled.dsk"; break;
case VCCFloppyFormatTrackDMK: kind = DiskFormat::DMK; name = "Untitled.dmk"; break;
case VCCFloppyFormatSectorVDK: kind = DiskFormat::VDK; name = "Untitled.vdk"; break;
default: throw std::invalid_argument("Unknown floppy image format");
}
const auto index = DriveIndex(drive);
auto disk = VCC::Devices::DiskImage::blank({}, kind);
worker.pauseForDisks(); worker.requireFloppy().mount(index, std::move(disk));
worker.clearDrive(index); worker.diskNames[index] = name;
} completion:completion];
}
- (void)ejectDiskInDrive:(NSInteger)drive discard:(BOOL)discard completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
const auto index = DriveIndex(drive); worker.pauseForDisks();
worker.requireFloppy().eject(index, discard); worker.clearDrive(index);
} completion:completion];
}
- (void)setDiskWriteProtected:(BOOL)enabled drive:(NSInteger)drive completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
const auto index = DriveIndex(drive);
if (!enabled && worker.readOnly[index]) throw std::logic_error("This image was opened from a read-only file");
auto& floppy = worker.requireFloppy();
auto* image = floppy.image(index);
if (!enabled && image && image->formatWriteProtected())
throw std::logic_error("The disk image header specifies write protection");
worker.pauseForDisks();
const bool changed = image && image->writeProtected() != bool(enabled);
floppy.setWriteProtected(index, enabled);
if (changed) ++worker.mediaRevision;
} completion:completion];
}
- (void)exportDiskInDrive:(NSInteger)drive completion:(void (^)(NSData*,uint64_t,VCCMachineSnapshot*))completion {
__block NSData *data = nil; __block uint64_t token = 0;
[self command:^(Worker& worker) {
const auto index = DriveIndex(drive); worker.pauseForDisks();
auto* image = worker.requireFloppy().image(index);
if (!image) throw std::logic_error("Insert a disk first");
token = ++worker.nextExport;
worker.exports[index] = Worker::Export{token, image->bytes()};
data = [NSData dataWithBytes:image->bytes().data() length:image->bytes().size()];
} completion:^(VCCMachineSnapshot *snapshot) { completion(data,token,snapshot); }];
}
- (void)snapshotDiskCopyInDrive:(NSInteger)drive completion:(void (^)(NSData*,VCCMachineSnapshot*))completion {
__block NSData *data = nil;
[self perform:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
const auto index = DriveIndex(drive);
auto* floppy = worker.floppy();
if (!floppy || !floppy->image(index)) throw std::logic_error("Insert a disk first");
if (floppy->snapshot().busy) throw std::logic_error("Wait for the current disk transfer to finish before copying this disk");
worker.error.clear();
const auto& bytes = floppy->image(index)->bytes();
data = [NSData dataWithBytes:bytes.data() length:bytes.size()];
} completion:^(VCCMachineSnapshot *snapshot) { completion(data, snapshot); }];
}
- (void)markDiskSavedInDrive:(NSInteger)drive token:(uint64_t)token name:(NSString*)name completion:(VCCMachineCompletion)completion {
NSString *label = [name copy];
[self command:^(Worker& worker) {
const auto index = DriveIndex(drive);
auto& floppy = worker.requireFloppy(); auto* image = floppy.image(index);
const auto& exported = worker.exports[index];
if (!exported || exported->token != token || !image || floppy.snapshot().busy || image->bytes() != exported->bytes)
throw std::logic_error("Disk changed while saving; the current disk still needs to be saved");
floppy.markSaved(index); worker.exports[index].reset(); worker.diskNames[index] = label.UTF8String;
} completion:completion];
}
- (void)beginDiskEditorInDrive:(NSInteger)drive completion:(void (^)(VCCDiskEditCapture *, VCCMachineSnapshot *))completion {
__block VCCDiskEditCapture *capture = nil;
[self inspect:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.requireNoDiskEditor();
const auto index = DriveIndex(drive);
auto& floppy = worker.requireFloppy();
const auto* image = floppy.image(index);
if (!image) throw std::logic_error("Insert a disk before opening its editor.");
if (floppy.snapshot().busy) throw std::logic_error("Wait for the floppy operation to finish before editing. A paused transfer must finish before opening the editor.");
if (worker.machine.pasteRemaining()) throw std::logic_error("Finish or cancel the current paste before editing a disk.");
worker.error.clear(); worker.machine.pause(); worker.machine.setKeyboard(0);
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
const auto token = ++worker.nextDiskEdit;
worker.diskEdit = Worker::DiskEdit{token, worker.machine.snapshot().generation, worker.mediaRevision, index, image->bytes(), {}};
capture = [VCCDiskEditCapture new]; capture.token = token; capture.drive = drive;
capture.data = [NSData dataWithBytes:image->bytes().data() length:image->bytes().size()];
capture.name = [NSString stringWithUTF8String:worker.diskNames[index].c_str()];
capture.canApply = !image->writeProtected() && !worker.readOnly[index];
} completion:^(VCCMachineSnapshot *snapshot) { completion(capture, snapshot); }];
}
- (void)beginHardDiskEditorInDrive:(NSInteger)drive completion:(void (^)(VCCDiskEditCapture *, VCCMachineSnapshot *))completion {
__block VCCDiskEditCapture *capture = nil;
[self inspect:^(Worker& worker) {
if (worker.closed) throw std::logic_error("The machine controller has shut down");
worker.requireNoDiskEditor();
const auto index = HardDriveIndex(drive);
const auto* image = worker.hardDevice->image(index);
if (!image) throw std::logic_error("Insert a hard disk before opening its editor.");
if (worker.floppy() && worker.floppy()->snapshot().busy)
throw std::logic_error("Wait for the floppy operation to finish before editing. A paused transfer must finish before opening the editor.");
if (worker.machine.pasteRemaining()) throw std::logic_error("Finish or cancel the current paste before editing a disk.");
worker.error.clear(); worker.machine.pause(); worker.machine.setKeyboard(0);
worker.audio.stop(); worker.pacer.reset(); worker.audioProgress.reset();
const auto token = ++worker.nextDiskEdit;
worker.diskEdit = Worker::DiskEdit{token, worker.machine.snapshot().generation, worker.mediaRevision, index, image->bytes(), {}, true, {}};
capture = [VCCDiskEditCapture new]; capture.token = token; capture.drive = drive;
capture.data = [NSData dataWithBytes:image->bytes().data() length:image->bytes().size()];
capture.name = [NSString stringWithUTF8String:worker.hardNames[index].c_str()];
capture.canApply = !image->writeProtected() && !worker.hardReadOnly[index];
} completion:^(VCCMachineSnapshot *snapshot) { completion(capture, snapshot); }];
}
- (void)prepareDiskEditorToken:(uint64_t)token data:(NSData *)data completion:(void (^)(BOOL, VCCMachineSnapshot *))completion {
NSData *owned = [data copy]; __block BOOL prepared = NO;
[self inspect:^(Worker& worker) {
auto& edit = worker.requireDiskEditor(token);
edit.prepared.reset(); edit.preparedHard.reset();
if (edit.hardDisk) {
const auto* current = worker.hardDevice->image(edit.drive);
if (current->writeProtected() || worker.hardReadOnly[edit.drive]) throw std::logic_error("This hard disk is write protected. Save an edited copy instead.");
auto next = VCC::Devices::HardDiskImage(OwnedBytes(owned, VCC::Devices::HardDiskImage::maxBytes));
if (next.bytes().size() != current->bytes().size()) throw std::logic_error("Editing must preserve this hard disk's image size. Save a separate image for conversion.");
const auto tape = worker.machine.cassette().snapshot();
if (tape.dirty || tape.mode == VCC::Mac::TapeMode::Recording) throw std::logic_error("Export the cassette recording before applying disk edits and restarting the CoCo.");
for (unsigned i = 0; i < 4; ++i) if (worker.floppy() && worker.floppy()->image(i) && worker.floppy()->image(i)->dirty())
throw std::logic_error("Save changes on the floppy drives before applying edits and restarting the CoCo.");
for (unsigned i = 0; i < 2; ++i) if (i != edit.drive && worker.hardDevice->image(i) && worker.hardDevice->image(i)->dirty())
throw std::logic_error("Save changes on the other hard disk before applying edits and restarting the CoCo.");
// Preserve existing unsaved-sector revisions and temporary-mode
// bytes, then track every editor change through the normal image
// write path so a later automatic save has a complete patch plan.
auto replacement = *current;
for (std::size_t offset = 0; offset < next.bytes().size(); offset += 256) {
if (std::equal(next.bytes().begin() + offset, next.bytes().begin() + offset + 256,
current->bytes().begin() + offset)) continue;
std::array<std::uint8_t, 256> sector;
std::copy_n(next.bytes().begin() + offset, 256, sector.begin());
if (!replacement.write(static_cast<std::uint32_t>(offset / 256), sector))
throw std::logic_error("The edited hard disk could not be prepared.");
}
edit.preparedHard = std::move(replacement); worker.error.clear(); prepared = YES;
return;
}
const auto* current = worker.requireFloppy().image(edit.drive);
if (current->writeProtected() || worker.readOnly[edit.drive]) throw std::logic_error("This disk is write protected. Save an edited copy instead.");
auto next = LoadFloppyImage(owned, [NSString stringWithUTF8String:worker.diskNames[edit.drive].c_str()], false);
const auto& before = current->geometry(); const auto& after = next.geometry();
if (next.format() != current->format() || next.bytes().size() != current->bytes().size() ||
next.formatWriteProtected() != current->formatWriteProtected() ||
next.containerHeaderBytes() != current->containerHeaderBytes() ||
!std::equal(current->bytes().begin(), current->bytes().begin() + current->containerHeaderBytes(), next.bytes().begin()) ||
before.tracks != after.tracks ||
before.sides != after.sides || before.sectors != after.sectors || before.sizeCode != after.sizeCode || before.firstSector != after.firstSector)
throw std::logic_error("Editing must preserve this disk's image format, geometry and protection header. Save a separate image for conversion.");
const auto tape = worker.machine.cassette().snapshot();
if (tape.dirty || tape.mode == VCC::Mac::TapeMode::Recording) throw std::logic_error("Export the cassette recording before applying disk edits and restarting the CoCo.");
for (unsigned i = 0; i < 4; ++i) if (i != edit.drive && worker.requireFloppy().image(i) && worker.requireFloppy().image(i)->dirty())
throw std::logic_error("Save changes on the other floppy drives before applying edits and restarting the CoCo.");
for (unsigned i = 0; i < 2; ++i) if (worker.hardDevice->image(i) && worker.hardDevice->image(i)->dirty())
throw std::logic_error("Save changes on the hard disks before applying edits and restarting the CoCo.");
edit.prepared = std::move(next); worker.error.clear(); prepared = YES;
} completion:^(VCCMachineSnapshot *snapshot) { completion(prepared, snapshot); }];
}
- (void)commitDiskEditorToken:(uint64_t)token restartConfirmed:(BOOL)restartConfirmed sourceSaved:(BOOL)sourceSaved completion:(void (^)(BOOL, VCCMachineSnapshot *))completion {
__block BOOL applied = NO;
[self inspect:^(Worker& worker) {
auto& edit = worker.requireDiskEditor(token);
if (!restartConfirmed) throw std::logic_error("Confirm the cold restart before applying filesystem changes.");
const auto index = edit.drive;
if (edit.hardDisk) {
if (!edit.preparedHard) throw std::logic_error("Validate the edited hard disk before applying it.");
if (worker.hardDevice->image(index)->writeProtected() || worker.hardReadOnly[index]) throw std::logic_error("This hard disk is write protected. Save an edited copy instead.");
} else {
if (!edit.prepared) throw std::logic_error("Validate the edited disk before applying it.");
if (worker.requireFloppy().image(index)->writeProtected() || worker.readOnly[index]) throw std::logic_error("This disk is write protected. Save an edited copy instead.");
}
// Reset while old media remain mounted; no guest instruction can run
// between reset and replacement. All replacement bytes were validated.
if (worker.machine.snapshot().state != VCC::Mac::RunState::Empty) worker.machine.reset();
worker.machine.pause(); worker.machine.setKeyboard(0);
if (edit.hardDisk) {
auto replacement = std::move(*edit.preparedHard);
if (sourceSaved) replacement.acknowledge(replacement.capture());
worker.hardDevice->eject(index, true);
worker.hardDevice->mount(index, std::move(replacement));
worker.hardExports[index].reset();
} else {
auto replacement = std::move(*edit.prepared);
if (sourceSaved) replacement.markSaved(); else replacement.markDirty();
worker.requireFloppy().mount(index, std::move(replacement), true);
worker.exports[index].reset();
}
++worker.mediaRevision; worker.assistantProgram.reset();
worker.compiledKeyLease = nil; worker.compiledKeyExpected = nil; worker.assistantPasteRun.clear();
worker.diskEdit.reset(); worker.error.clear(); applied = YES;
} completion:^(VCCMachineSnapshot *snapshot) { completion(applied, snapshot); }];
}
- (void)cancelDiskEditorToken:(uint64_t)token completion:(VCCMachineCompletion)completion {
[self inspect:^(Worker& worker) {
worker.requireDiskEditor(token);
worker.machine.pause(); worker.machine.setKeyboard(0); worker.diskEdit.reset(); worker.error.clear();
} completion:completion];
}
- (void)assistantReadinessWithCompletion:(VCCMachineCompletion)completion {
__block NSNumber *prompt = nil, *empty = nil;
[self inspect:^(Worker& worker) {
if (worker.closed) return;
try {
// Unsupported ROMs and transient memory maps leave these fields unknown.
empty = @(worker.machine.basicReadSource().empty());
prompt = @(worker.machine.basicAtDirectPrompt());
} catch (const std::exception&) { }
} completion:^(VCCMachineSnapshot *snapshot) {
snapshot.assistantDirectPrompt = prompt;
snapshot.assistantEmptyBASIC = empty;
completion(snapshot);
}];
}
- (void)snapshotWithCompletion:(VCCMachineCompletion)completion {
[self inspect:^(Worker&) {} completion:completion];
}
- (void)captureDiskForSavingInDrive:(NSInteger)drive completion:(void (^)(NSData*,uint64_t,VCCMachineSnapshot*))completion {
__block NSData *data = nil; __block uint64_t token = 0;
[self perform:^(Worker& worker) {
const auto index = DriveIndex(drive);
auto* floppy = worker.floppy();
if (worker.closed || !floppy || floppy->snapshot().busy) return;
auto* image = floppy->image(index);
if (!image || !image->dirty() || image->writeProtected() || worker.readOnly[index]) return;
token = ++worker.nextExport;
worker.exports[index] = Worker::Export{token, image->bytes()};
data = [NSData dataWithBytes:image->bytes().data() length:image->bytes().size()];
} completion:^(VCCMachineSnapshot *snapshot) { completion(data,token,snapshot); }];
}
- (void)acknowledgeDiskSaveInDrive:(NSInteger)drive token:(uint64_t)token completion:(VCCMachineCompletion)completion {
[self perform:^(Worker& worker) {
const auto index = DriveIndex(drive);
auto* floppy = worker.floppy();
if (worker.closed || !floppy) return;
auto* image = floppy->image(index);
const auto& exported = worker.exports[index];
if (!exported || exported->token != token) return;
// Partial transfers have not changed image bytes yet; their eventual
// commit will mark dirty again even if this acknowledgement clears it.
if (image && image->bytes() == exported->bytes) floppy->markSaved(index);
worker.exports[index].reset();
} completion:completion];
}
- (void)mountHardDisk:(NSData*)data drive:(NSInteger)drive name:(NSString*)name readOnly:(BOOL)readOnly completion:(VCCMachineCompletion)completion {
NSData* owned = [data copy]; NSString* label = [name copy];
[self command:^(Worker& worker) {
auto index = HardDriveIndex(drive);
auto image = VCC::Devices::HardDiskImage(OwnedBytes(owned, VCC::Devices::HardDiskImage::maxBytes), readOnly);
worker.pauseForDisks(); worker.hardDevice->mount(index, std::move(image)); worker.clearHardDrive(index);
worker.hardNames[index] = label.UTF8String; worker.hardReadOnly[index] = readOnly;
} completion:completion];
}
- (void)createHardDiskInDrive:(NSInteger)drive size:(NSUInteger)size completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
auto index = HardDriveIndex(drive); auto image = VCC::Devices::HardDiskImage::blank(size);
worker.pauseForDisks(); worker.hardDevice->mount(index, std::move(image)); worker.clearHardDrive(index); worker.hardNames[index] = "Untitled.vhd";
} completion:completion];
}
- (void)hardDiskAction:(NSInteger)action drive:(NSInteger)drive completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) {
auto index = HardDriveIndex(drive); worker.pauseForDisks();
if (action == 0 || action == 1) { worker.hardDevice->eject(index, action == 1); worker.clearHardDrive(index); }
else if (action == 2 || action == 3) {
auto* image = worker.hardDevice->image(index);
if (!image) throw std::logic_error("No hard disk is mounted");
if (action == 3 && worker.hardReadOnly[index]) throw std::logic_error("This file is read-only. Save a writable copy first");
if (image->writeProtected() != (action == 2)) ++worker.mediaRevision;
image->protect(action == 2);
} else throw std::invalid_argument("Unknown hard disk action");
} completion:completion];
}
- (void)configureHardClock:(BOOL)enabled readOnly:(BOOL)readOnly completion:(VCCMachineCompletion)completion {
[self command:^(Worker& worker) { worker.pauseForDisks(); worker.hardDevice->configureClock(enabled, readOnly); } completion:completion];
}
- (void)captureHardDiskInDrive:(NSInteger)drive full:(BOOL)full completion:(void (^)(VCCHardDiskSave*,VCCMachineSnapshot*))completion {
__block VCCHardDiskSave* result = nil;
void (^capture)(Worker&) = ^(Worker& worker) {
if (worker.closed) return;
auto index = HardDriveIndex(drive); auto* image = worker.hardDevice->image(index);
if (!image) return;
if (full) worker.pauseForDisks();
else if (!image->dirty() || image->writeProtected() || worker.hardReadOnly[index]) return;
auto saved = image->capture(); result = [VCCHardDiskSave new];
result.token = ++worker.nextExport; result.byteCount = saved.length;
if (full) result.data = [NSData dataWithBytes:image->bytes().data() length:image->bytes().size()];
else {
NSMutableData* patches = [NSMutableData dataWithCapacity:saved.records.size() * 260];
for (const auto& record : saved.records) {
std::uint8_t indexBytes[4]{std::uint8_t(record.sector), std::uint8_t(record.sector >> 8), std::uint8_t(record.sector >> 16), std::uint8_t(record.sector >> 24)};
[patches appendBytes:indexBytes length:4]; [patches appendBytes:record.bytes.data() length:256];
}
result.data = patches;
}
worker.hardExports[index] = Worker::HardExport{result.token, std::move(saved)};
};
VCCMachineCompletion finish = ^(VCCMachineSnapshot* snapshot) { completion(result, snapshot); };
if (full) [self command:capture completion:finish]; else [self perform:capture completion:finish];
}
- (void)acknowledgeHardDiskInDrive:(NSInteger)drive token:(uint64_t)token name:(NSString*)name completion:(VCCMachineCompletion)completion {
NSString* label = [name copy];
[self perform:^(Worker& worker) {
auto index = HardDriveIndex(drive); auto* image = worker.hardDevice->image(index); auto& saved = worker.hardExports[index];
if (worker.closed || !image || !saved || saved->token != token) return;
image->acknowledge(saved->saved); saved.reset();
if (label) { worker.hardNames[index] = label.UTF8String; worker.hardReadOnly[index] = false; }
} completion:completion];
}
- (void)shutdownWithCompletion:(VCCMachineCompletion)completion {
dispatch_source_cancel(_timer);
[self inspect:^(Worker& worker) {
worker.diskEdit.reset();
worker.closed = true; worker.shell.stop(); worker.audio.stop(); worker.machine.shutdown(); worker.error.clear();
} completion:completion];
}
- (void)dealloc {
dispatch_source_cancel(_timer);
auto worker = _worker;
// Worker blocks never retain self; deallocation cannot originate on _queue.
dispatch_sync(_queue, ^{ worker->closed = true; worker->audio.stop(); worker->machine.shutdown(); });
}
@end