// SPDX-License-Identifier: GPL-3.0-or-later // App-owned disposable machine. STDIO is private to the parent app; no sockets, // credentials, user settings, host paths, or externally mounted media are read. #import #import #include "../../../../src/core/MachineSession.h" #include "../../../../src/devices/FD502/Fd502Device.h" #include #include #include #include #include #include #include #include #include #include // The class is implemented in Swift and shares CoCoVideoEncoder with the app. @interface VCCPlaytestVideoWriter : NSObject - (instancetype)initWithDirectory:(NSURL *)directory includeAudio:(BOOL)includeAudio error:(NSError **)error; - (BOOL)appendPixels:(NSData *)pixels area:(CGRect)area samples:(NSData *)samples error:(NSError **)error; - (NSURL *)finishAndReturnError:(NSError **)error; @end using namespace VCC::Mac; namespace { constexpr size_t wireLimit = 1024 * 1024; constexpr uint64_t fieldBudget = 216000; constexpr size_t maximumDiskBytes = 512 * 1024; constexpr unsigned audioFieldLimit = 120; constexpr size_t audioSampleFrameLimit = 131072; constexpr uint64_t videoByteLimit = 64 * 1024 * 1024; void little16(std::vector& bytes, uint16_t value) { bytes.push_back(value & 255); bytes.push_back(value >> 8); } void little32(std::vector& bytes, uint32_t value) { little16(bytes, value & 65535); little16(bytes, value >> 16); } NSString *sha256(const std::vector& bytes) { unsigned char digest[CC_SHA256_DIGEST_LENGTH]; CC_SHA256(bytes.data(), static_cast(bytes.size()), digest); NSMutableString *text = [NSMutableString string]; for (auto byte : digest) [text appendFormat:@"%02x",byte]; return text; } std::vector wave(const std::vector& samples) { // No host gain or device/microphone path is involved. Preserve both guest // channels, quantized to standard signed 16-bit little-endian PCM. if (samples.size() > audioSampleFrameLimit) throw std::runtime_error("playtest_audio_limit"); const uint32_t dataBytes = uint32_t(samples.size() * 4); std::vector bytes; bytes.reserve(44 + dataBytes); bytes.insert(bytes.end(), {'R','I','F','F'}); little32(bytes, 36 + dataBytes); bytes.insert(bytes.end(), {'W','A','V','E','f','m','t',' '}); little32(bytes, 16); little16(bytes, 1); little16(bytes, 2); little32(bytes, CassetteDeck::rate); little32(bytes, CassetteDeck::rate * 4); little16(bytes, 4); little16(bytes, 16); bytes.insert(bytes.end(), {'d','a','t','a'}); little32(bytes, dataBytes); for (const auto& sample : samples) { for (float value : {sample.left, sample.right}) { if (!std::isfinite(value)) throw std::runtime_error("playtest_audio_invalid_sample"); const long quantized = std::lround(std::clamp(value, -1.0f, 1.0f) * 32768.0f); little16(bytes, uint16_t(int16_t(std::clamp(quantized, -32768L, 32767L)))); } } return bytes; } int number(id value, int low, int high) { if (![value isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments"); double n = [value doubleValue]; if (!std::isfinite(n) || n < low || n > high || std::floor(n) != n) throw std::invalid_argument("invalid_arguments"); return int(n); } NSString *mediaIdentifier(id value) { if (![value isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_media_id"); const auto count = [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding]; if (!count || count > 64 || count != [value length]) throw std::invalid_argument("invalid_media_id"); const char *text = [value UTF8String]; for (NSUInteger i = 0; i < count; ++i) { const auto c = static_cast(text[i]); if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_')) throw std::invalid_argument("invalid_media_id"); } return value; } struct InputStep { uint64_t keys = 0; unsigned fields = 0; std::array joysticks{}; }; std::vector inputPlan(id value, unsigned& total) { if (![value isKindOfClass:NSArray.class] || [value count] == 0 || [value count] > 64) throw std::invalid_argument("invalid_arguments"); std::vector plan; total = 0; for (id raw in (NSArray *)value) { if (![raw isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_arguments"); NSDictionary *step = raw; for (NSString *key in step) if (![@[@"mask", @"fields", @"joysticks"] containsObject:key]) throw std::invalid_argument("invalid_arguments"); NSNumber *mask = step[@"mask"]; if (![mask isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)mask) == CFBooleanGetTypeID() || !std::isfinite(mask.doubleValue) || mask.doubleValue < 0 || std::floor(mask.doubleValue) != mask.doubleValue || mask.unsignedLongLongValue >> 56) throw std::invalid_argument("invalid_arguments"); InputStep item; item.keys = mask.unsignedLongLongValue; item.fields = number(step[@"fields"], 1, 600); total += item.fields; if (total > 3600) throw std::invalid_argument("invalid_arguments"); if (step[@"joysticks"]) { id ports = step[@"joysticks"]; if (![ports isKindOfClass:NSArray.class] || [ports count] > 2) throw std::invalid_argument("invalid_arguments"); bool seen[2] = {}; for (id rawPort in (NSArray *)ports) { if (![rawPort isKindOfClass:NSDictionary.class] || [rawPort count] != 4) throw std::invalid_argument("invalid_arguments"); NSDictionary *port = rawPort; for (NSString *key in port) if (![@[@"port", @"x", @"y", @"buttons"] containsObject:key]) throw std::invalid_argument("invalid_arguments"); unsigned index; if ([port[@"port"] isEqual:@"right"]) index = 0; else if ([port[@"port"] isEqual:@"left"]) index = 1; else throw std::invalid_argument("invalid_arguments"); if (seen[index]) throw std::invalid_argument("invalid_arguments"); seen[index] = true; auto& input = item.joysticks[index]; input.x = number(port[@"x"], 0, 16383); input.y = number(port[@"y"], 0, 16383); id buttons = port[@"buttons"]; if (![buttons isKindOfClass:NSArray.class] || [buttons count] > 2) throw std::invalid_argument("invalid_arguments"); for (id button in (NSArray *)buttons) { unsigned bit; if ([button isEqual:@"fire1"]) bit = 1; else if ([button isEqual:@"fire2"]) bit = 2; else throw std::invalid_argument("invalid_arguments"); if (input.buttons & bit) throw std::invalid_argument("invalid_arguments"); input.buttons |= bit; } } } plan.push_back(item); } return plan; } struct ReleaseInput { MachineSession *machine; ~ReleaseInput() { machine->releaseInputs(); } }; NSDictionary *inputMetadata(const Snapshot& snapshot) { NSMutableArray *ports = [NSMutableArray arrayWithCapacity:2]; bool neutral = !snapshot.keyboardHeld; for (unsigned index = 0; index < snapshot.joysticks.size(); ++index) { const auto& port = snapshot.joysticks[index]; NSMutableArray *buttons = [NSMutableArray array]; if (port.buttons & 1) [buttons addObject:@"fire1"]; if (port.buttons & 2) [buttons addObject:@"fire2"]; neutral = neutral && port.x == 8191 && port.y == 8191 && port.buttons == 0; [ports addObject:@{@"port":index == 0 ? @"right" : @"left", @"x":@(port.x), @"y":@(port.y), @"buttons":buttons, @"interface":@[@"standard",@"software",@"tandy",@"coco_max"][std::min(port.mode, 3u)]}]; } return @{@"source":@"owned_playtest", @"interface":@"standard", @"axis_min":@0, @"axis_max":@16383, @"axis_center":@8191, @"x_direction":@"increases_right", @"y_direction":@"increases_down", @"ports":ports, @"keyboard_held":@(snapshot.keyboardHeld), @"neutral":@(neutral)}; } std::vector bytes(id value, size_t maximum, size_t exact = 0) { if (![value isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments"); NSData *data = [[NSData alloc] initWithBase64EncodedString:value options:0]; if (!data || !data.length || data.length > maximum || (exact && data.length != exact)) throw std::invalid_argument("invalid_bytes"); auto p = static_cast(data.bytes); return {p, p + data.length}; } NSArray *array(const std::vector& data) { NSMutableArray *out = [NSMutableArray arrayWithCapacity:data.size()]; for (auto b : data) [out addObject:@(b)]; return out; } DebugGraphicsMode graphicsMode(NSString *name) { if (![name isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_graphics_buffer_mode"); const std::pair modes[] = { {"sg4", DebugGraphicsMode::SG4}, {"pmode0", DebugGraphicsMode::PMODE0}, {"pmode1", DebugGraphicsMode::PMODE1}, {"pmode2", DebugGraphicsMode::PMODE2}, {"pmode3", DebugGraphicsMode::PMODE3}, {"pmode4", DebugGraphicsMode::PMODE4}, {"hscreen1", DebugGraphicsMode::HSCREEN1}, {"hscreen2", DebugGraphicsMode::HSCREEN2}, {"hscreen3", DebugGraphicsMode::HSCREEN3}, {"hscreen4", DebugGraphicsMode::HSCREEN4}, {"current_gime", DebugGraphicsMode::CurrentGime}}; for (const auto& [text, mode] : modes) if ([name isEqualToString:[NSString stringWithUTF8String:text]]) return mode; throw std::invalid_argument("invalid_graphics_buffer_mode"); } NSString *png(const std::vector& pixels, unsigned width, unsigned height, size_t maximum) { if (!width || !height || width > Frame::width || height > Frame::height || pixels.size() != size_t(width) * height) throw std::runtime_error("playtest_capture_failed"); NSBitmapImageRep *image = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:nullptr pixelsWide:width pixelsHigh:height bitsPerSample:8 samplesPerPixel:4 hasAlpha:YES isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace bytesPerRow:width * 4 bitsPerPixel:32]; if (!image) throw std::runtime_error("playtest_capture_failed"); auto p = image.bitmapData; for (size_t i = 0; i < pixels.size(); ++i) { const auto rgb = pixels[i]; p[i*4] = rgb >> 16; p[i*4+1] = rgb >> 8; p[i*4+2] = rgb; p[i*4+3] = 255; } NSData *data = [image representationUsingType:NSBitmapImageFileTypePNG properties:@{}]; if (!data || data.length > maximum) throw std::runtime_error("playtest_capture_limit"); return [data base64EncodedStringWithOptions:0]; } NSMutableDictionary *graphicsMetadata(const DebugGraphicsPreview& preview, NSString *identity) { NSMutableArray *ranges = [NSMutableArray array], *palette = [NSMutableArray array]; for (auto color : preview.palette) [palette addObject:@(color)]; bool contiguous = !preview.byteAddresses.empty(); for (size_t i = 0; i < preview.byteAddresses.size();) { const auto begin = preview.byteAddresses[i]; size_t count = 1; while (i + count < preview.byteAddresses.size() && preview.byteAddresses[i + count] == begin + count) ++count; [ranges addObject:@{@"address":@(begin),@"count":@(count)}]; if (ranges.count > 1024) throw std::runtime_error("playtest_capture_limit"); i += count; } contiguous = contiguous && ranges.count == 1; NSMutableDictionary *metadata = [@{@"id":identity, @"selection":@"current_video_registers", @"physical_address":@(preview.address), @"byte_count":@(preview.bytes.size()), @"contiguous":@(contiguous), @"physical_ranges":ranges, @"mode":[NSString stringWithUTF8String:preview.modeName.c_str()], @"width":@(preview.width), @"height":@(preview.height), @"bytes_per_row":@(preview.bytesPerRow), @"pixels_per_byte":@(preview.pixelsPerByte), @"lines_per_row":@(preview.linesPerRow), @"palette":palette, @"video_origin":@(preview.videoOrigin), @"row_stride_bytes":@(preview.rowStrideBytes), @"horizontal_offset_bytes":@(preview.horizontalOffsetBytes), @"vertical_scroll_lines":@(preview.verticalScrollLines), @"generation":@(preview.generation), @"cycles":@(preview.cycles)} mutableCopy]; if (!preview.canvasIdentifier.empty()) { metadata[@"canvas_id"] = [NSString stringWithUTF8String:preview.canvasIdentifier.c_str()]; metadata[@"canvas_address"] = @(preview.canvasAddress); metadata[@"canvas_bytes"] = @(preview.canvasBytes); metadata[@"viewport_offset"] = @(preview.viewportOffset); } return metadata; } class Playtest { std::unique_ptr machine; std::shared_ptr floppy; std::vector rom; std::vector bootKeys; std::vector modules; std::vector flatGuards; std::vector graphicsBuffers; std::vector stops; std::string stopModule; void armEvidence(const std::vector& points, const std::string& selectedModule) { if (!flatGuards.empty()) { if (!selectedModule.empty()) throw std::invalid_argument("unverified_stop_module"); auto guards = flatGuards; // The native flat guard API expects each stop at the beginning of // a verified range. Split retained byte ranges without inventing // instruction boundaries; stop addresses are verified by the host. for (auto point : points) { const auto found = std::find_if(guards.begin(), guards.end(), [&](const auto& guard) { return point >= guard.address && size_t(point - guard.address) < guard.bytes.size(); }); if (found == guards.end()) throw std::invalid_argument("unverified_stop"); const auto offset = size_t(point - found->address); if (offset) { DebugCodeGuard tail{point, std::vector(found->bytes.begin() + offset, found->bytes.end())}; found->bytes.resize(offset); guards.push_back(std::move(tail)); } } std::sort(guards.begin(), guards.end(), [](const auto& lhs, const auto& rhs) { return lhs.address < rhs.address; }); machine->debuggerArmDevelopmentBreakpoints(points, guards); return; } if (modules.empty()) { if (!points.empty()) throw std::invalid_argument("unverified_stop_module"); machine->debuggerClearDevelopmentBreakpoints(); return; } auto registered = modules; bool selected = points.empty(); for (auto& module : registered) { if (!points.empty() && module.identifier == selectedModule) { module.breakpointAddresses = points; selected = true; } else module.breakpointAddresses = std::vector{}; } if (!selected) throw std::invalid_argument("unverified_stop_module"); // Keep every verified module available for pauses and steps after a // bank switch; only the selected module owns the requested stop points. machine->debuggerArmBankedDevelopmentBreakpoints(points, registered); } void armStop() { armEvidence(stops, stopModule); } void armInspection() { armEvidence({}, {}); } uint64_t consumed = 0, fieldClock = 0, bootNumber = 0; std::array mediaGenerations{}, mountReadBases{}, mountWriteBases{}; bool multiDrive = false, frozenForRetention = false; unsigned drainedDrives = 0; VCCPlaytestVideoWriter *videoWriter = nil; NSMutableDictionary *videoInfo = nil; NSURL *videoDirectory = nil; unsigned videoMaximumFields = 0; uint64_t videoFirstField = 0, videoSamples = 0; void finishVideo(NSString *reason) { if (!videoWriter) return; NSError *error = nil; NSURL *output = nil; if (videoSamples) output = [videoWriter finishAndReturnError:&error]; videoWriter = nil; videoInfo[@"field_end"] = @(fieldClock); videoInfo[@"fields_recorded"] = @(fieldClock - videoFirstField); videoInfo[@"sample_frames"] = @(videoSamples); videoInfo[@"truncated"] = @(![reason isEqual:@"stopped"] && ![reason isEqual:@"run_stopped"]); videoInfo[@"reason"] = reason; videoInfo[@"status"] = @"failed"; videoInfo[@"completed"] = @NO; if (!output) { videoInfo[@"error"] = error.localizedDescription ?: @"No emulated audio/video interval was recorded."; return; } NSData *data = [NSData dataWithContentsOfURL:output options:NSDataReadingMappedIfSafe error:&error]; if (!data || data.length == 0 || data.length > videoByteLimit) { videoInfo[@"error"] = error.localizedDescription ?: @"playtest_video_byte_limit"; return; } std::vector bytes(static_cast(data.bytes), static_cast(data.bytes) + data.length); videoInfo[@"status"] = @"complete"; videoInfo[@"completed"] = @YES; videoInfo[@"byte_count"] = @(data.length); videoInfo[@"sha256"] = sha256(bytes); videoInfo[@"mime_type"] = @"video/mp4"; videoInfo[@"filename"] = @"Clip.mp4"; } void recordVideo(const std::vector& samples) { if (!videoWriter || samples.empty()) return; const auto snapshot = machine->snapshot(); const auto frame = snapshot.frame; if (!frame || frame->pixels.size() != Frame::width * Frame::height) { finishVideo(@"picture_unavailable"); return; } const auto area = frame->activeArea; NSError *error = nil; const BOOL ok = [videoWriter appendPixels:[NSData dataWithBytes:frame->pixels.data() length:frame->pixels.size() * sizeof(uint32_t)] area:CGRectMake(area.x, area.y, area.width, area.height) samples:[NSData dataWithBytes:samples.data() length:samples.size() * sizeof(StereoSample)] error:&error]; if (!ok) { videoWriter = nil; videoInfo[@"status"] = @"failed"; videoInfo[@"completed"] = @NO; videoInfo[@"error"] = error.localizedDescription ?: @"playtest_video_writer_failed"; return; } videoSamples += samples.size(); videoInfo[@"field_end"] = @(fieldClock); videoInfo[@"fields_recorded"] = @(fieldClock - videoFirstField); NSDictionary *attributes = [NSFileManager.defaultManager attributesOfItemAtPath:[videoDirectory URLByAppendingPathComponent:@"Working.mov"].path error:nil]; if ([attributes fileSize] >= videoByteLimit - 1024 * 1024) finishVideo(@"byte_limit"); else if (fieldClock - videoFirstField >= videoMaximumFields) finishVideo(@"field_limit"); } Processor processor = Processor::MC6809; NSMutableArray *originalDiskHashes = [NSMutableArray arrayWithObjects:@"", @"", @"", @"", nil]; NSMutableArray *currentMediaIDs = [NSMutableArray arrayWithObjects:NSNull.null, NSNull.null, NSNull.null, NSNull.null, nil]; NSString *mediaID(unsigned drive) const { id value = currentMediaIDs[drive]; return [value isKindOfClass:NSString.class] ? value : nil; } NSString *diskHash(unsigned drive = 0) const { const auto *image = floppy ? floppy->image(drive) : nullptr; return image ? sha256(image->bytes()) : @""; } NSDictionary *driveStatus(unsigned drive) const { const auto *image = floppy->image(drive); return @{@"drive": @(drive), @"label": [NSString stringWithFormat:@"FD%u", drive], @"inserted": @(image != nullptr), @"disk_present": @(image != nullptr), @"media_id": mediaID(drive) ?: (id)NSNull.null, @"disk_original_sha256": originalDiskHashes[drive], @"disk_sha256": diskHash(drive), @"media_generation": @(mediaGenerations[drive]), @"byte_count": @(image ? image->bytes().size() : 0), @"disk_dirty": @(image && image->dirty()), @"write_protected": @(image && image->writeProtected()), @"disk_reads": @(floppy->readEvents(drive)), @"disk_writes": @(floppy->writeEvents(drive)), @"mount_read_bytes": @(floppy->readEvents(drive) - mountReadBases[drive]), @"mount_write_bytes": @(floppy->writeEvents(drive) - mountWriteBases[drive])}; } void requireMediaExchangeState() const { if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped"); // A pending command on ANY drive protects the shared controller. if (floppy->snapshot().busy) throw std::runtime_error("playtest_media_busy"); } NSDictionary *exportMedia(unsigned drive = 0) { if (!frozenForRetention) requireMediaExchangeState(); NSMutableDictionary *out = [status() mutableCopy]; if (multiDrive) out[@"exported_drive"] = driveStatus(drive); if (const auto *image = floppy->image(drive)) { const auto& data = image->bytes(); out[@"disk_base64"] = [[NSData dataWithBytes:data.data() length:data.size()] base64EncodedStringWithOptions:0]; } if (frozenForRetention) drainedDrives |= 1u << drive; return out; } NSDictionary *exchangeMedia(NSDictionary *request) { const unsigned drive = request[@"drive"] ? number(request[@"drive"], 0, 3) : 0; for (NSString *key in request) if (![@[@"op", @"expected_media_generation", @"expected_disk_sha256", @"media_id", @"disk_base64", @"drive", @"write_protected"] containsObject:key]) throw std::invalid_argument("invalid_arguments"); if (!multiDrive && request[@"drive"]) throw std::invalid_argument("invalid_arguments"); const bool inserting = request[@"media_id"] != nil; const NSUInteger optional = (request[@"drive"] ? 1 : 0) + (request[@"write_protected"] ? 1 : 0); if ((request[@"disk_base64"] != nil) != inserting || request.count != (inserting ? 5u : 3u) + optional || (!inserting && request[@"write_protected"])) throw std::invalid_argument("invalid_arguments"); if (request[@"write_protected"] && CFGetTypeID((__bridge CFTypeRef)request[@"write_protected"]) != CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments"); const auto expected = number(request[@"expected_media_generation"], 0, INT32_MAX); if (![request[@"expected_disk_sha256"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments"); NSString *nextID = nil; std::optional replacement; // Validate container and effective protection before changing any drive. if (inserting) { nextID = mediaIdentifier(request[@"media_id"]); for (unsigned other = 0; other < 4; ++other) if (other != drive && [nextID isEqual:mediaID(other)]) throw std::invalid_argument("playtest_media_already_inserted"); replacement.emplace(VCC::Devices::DiskImage::load(bytes(request[@"disk_base64"], maximumDiskBytes), [request[@"write_protected"] boolValue])); } requireMediaExchangeState(); NSString *oldHash = diskHash(drive), *oldID = mediaID(drive); if (uint64_t(expected) != mediaGenerations[drive] || ![request[@"expected_disk_sha256"] isEqual:oldHash]) throw std::runtime_error("stale_media_exchange"); if (mediaGenerations[drive] == INT32_MAX) throw std::runtime_error("playtest_media_limit"); if (replacement) floppy->mount(drive, std::move(*replacement), true); else floppy->eject(drive, true); currentMediaIDs[drive] = nextID ?: (id)NSNull.null; originalDiskHashes[drive] = diskHash(drive); ++mediaGenerations[drive]; mountReadBases[drive] = floppy->readEvents(drive); mountWriteBases[drive] = floppy->writeEvents(drive); NSMutableDictionary *out = [status() mutableCopy]; out[@"target_drive"] = @(drive); out[@"previous_media_id"] = oldID ?: (id)NSNull.null; out[@"previous_disk_sha256"] = oldHash; out[@"advances_execution"] = @NO; return out; } void fields(unsigned n) { if (consumed + n > fieldBudget) throw std::runtime_error("playtest_field_limit"); for (unsigned i = 0; i < n && machine->snapshot().state == RunState::Running; ++i) { const auto before = machine->snapshot().frames; machine->advance(); ++consumed; fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); } } void boot() { if (++bootNumber > 16) throw std::runtime_error("playtest_restart_limit"); machine->releaseInputs(); machine->cancelPaste(); machine->reset(); machine->resume(); fields(300); if (!machine->basicAtDirectPrompt()) throw std::runtime_error("playtest_basic_unavailable"); if (!modules.empty() || !flatGuards.empty()) { armStop(); machine->resume(); } machine->paste(bootKeys); for (unsigned n = 0; machine->pasteRemaining() && n < 3600; ++n) { if (machine->snapshot().state == RunState::Paused) { machine->cancelPaste(); break; } fields(1); } if (machine->pasteRemaining()) throw std::runtime_error("playtest_boot_timeout"); fields(600); } NSDictionary *status() const { auto s = machine->snapshot(); const bool hd6309 = s.configuration.processor == Processor::HD6309; const auto *image = floppy->image(0); NSMutableDictionary *out = [@{ @"cpu": hd6309 ? @"6309" : @"6809", @"processor": hd6309 ? @"HD6309" : @"MC6809", @"execution_mode": hd6309 ? (s.cpu.IsNative6309 ? @"native" : @"emulation") : @"not_applicable", @"md_register": hd6309 ? (id)@(s.cpu.MD) : NSNull.null, @"ram_kb": @512, @"fields": @(fieldClock), @"field_clock": @(fieldClock), @"boot": @(bootNumber), @"machine_frame": @(s.frames), @"remaining_field_budget": @(fieldBudget - std::min(fieldBudget, consumed)), @"remaining_boots": @(bootNumber < 16 ? 16 - bootNumber : 0), @"cycles": @(s.cycles), @"generation": @(s.generation), @"pc": @(s.cpu.PC), @"state": s.state == RunState::Paused ? @"paused" : @"running", @"disk_original_sha256": originalDiskHashes[0], @"disk_sha256": diskHash(), @"disk_present": @(image != nullptr), @"media_id": mediaID(0) ?: (id)NSNull.null, @"media_generation": @(mediaGenerations[0]), @"floppy_busy": @(floppy->snapshot().busy), @"disk_dirty": @(image && image->dirty()), @"disk_write_protected": @(image && image->writeProtected()), @"disk_reads": @(floppy->readEvents(0)), @"disk_writes": @(floppy->writeEvents(0)), @"isolated": @YES, @"input":inputMetadata(s) } mutableCopy]; if (multiDrive) { NSMutableArray *drives = [NSMutableArray array]; for (unsigned drive = 0; drive < 4; ++drive) [drives addObject:driveStatus(drive)]; out[@"drives"] = drives; out[@"media_contract_version"] = @2; out[@"drive_activity_units"] = @"transferred_data_bytes"; out[@"drive_activity_lifetime"] = @"worker lifetime; mount_* fields reset on each media generation"; } if (videoInfo) out[@"video_recording"] = [videoInfo copy]; return out; } NSDictionary *capture() const { NSMutableDictionary *out = [status() mutableCopy]; out[@"frame_snapshot_kind"] = @"last_published_frame"; try { out[@"display_buffer"] = graphicsMetadata(machine->debuggerGraphicsPreview(true, true, 0, DebugGraphicsMode::HSCREEN2, false, graphicsBuffers), @"displayed"); } catch (const std::exception& error) { out[@"display_buffer"] = @{@"selection":@"current_video_registers", @"unavailable":[NSString stringWithUTF8String:error.what()]}; } try { out[@"screen_text"] = [NSString stringWithUTF8String:machine->copyScreenText().c_str()]; } catch (const std::exception&) { out[@"screen_text_unavailable"] = @"Guest display is in graphics mode."; } auto frame = machine->snapshot().frame; if (frame && frame->pixels.size() == Frame::width * Frame::height) { out[@"png_base64"] = png(frame->pixels, Frame::width, Frame::height, 650000); out[@"width"] = @(Frame::width); out[@"height"] = @(Frame::height); out[@"frame_number"] = @(frame->number); } return out; } NSDictionary *captureAudio(unsigned requested) { if (consumed + requested > fieldBudget) throw std::runtime_error("playtest_field_limit"); const auto before = machine->snapshot(); const auto firstField = fieldClock; std::vector samples; samples.reserve(std::min(size_t(requested) * 1024, audioSampleFrameLimit)); auto collect = [&] { auto next = machine->takeAudio(); if (next.size() > audioSampleFrameLimit - samples.size()) throw std::runtime_error("playtest_audio_limit"); samples.insert(samples.end(), next.begin(), next.end()); recordVideo(next); }; // Discard audio from earlier input/steps. A capture owns only this // explicit interval, including any normal leave-breakpoint CPU slice. machine->takeAudio(); machine->releaseInputs(); try { if (before.state == RunState::Paused) { machine->resume(); const auto resumedFields = machine->snapshot().frames - before.frames; fieldClock += resumedFields; consumed += resumedFields; collect(); } for (unsigned attempt = 0; attempt < requested && fieldClock - firstField < requested && machine->snapshot().state == RunState::Running; ++attempt) { const auto previous = machine->snapshot().frames; machine->advance(); ++consumed; fieldClock += machine->snapshot().frames - previous; collect(); } } catch (...) { machine->releaseInputs(); machine->pause(); throw; } machine->releaseInputs(); machine->pause(); const auto after = machine->snapshot(); const auto data = wave(samples); NSMutableDictionary *out = [status() mutableCopy]; out[@"audio_wav_base64"] = [[NSData dataWithBytes:data.data() length:data.size()] base64EncodedStringWithOptions:0]; out[@"audio"] = @{@"mime_type":@"audio/wav", @"sample_rate":@(CassetteDeck::rate), @"channels":@2, @"encoding":@"pcm_s16le", @"bits_per_sample":@16, @"sample_frames":@(samples.size()), @"sample_count":@(samples.size() * 2), @"byte_count":@(data.size()), @"sha256":sha256(data), @"field_start":@(firstField), @"field_end":@(fieldClock), @"fields_requested":@(requested), @"fields_advanced":@(fieldClock - firstField), @"cycles_start":@(before.cycles), @"cycles_end":@(after.cycles), @"advances_execution":@YES, @"completed":@(fieldClock - firstField == requested), @"truncated":@NO}; return out; } public: bool stopped = false; NSDictionary *reply(NSDictionary *r) { NSString *op = r[@"op"]; if (![op isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_arguments"); if ([op isEqual:@"init"]) { if (machine) throw std::runtime_error("already_started"); rom = bytes(r[@"system_rom"], 32768, 32768); auto diskROM = bytes(r[@"disk_rom"], 8192, 8192), disk = bytes(r[@"disk"], maximumDiskBytes); NSString *initialMediaID = mediaIdentifier(r[@"media_id"] ?: @"primary"); if (r[@"multi_drive"] && CFGetTypeID((__bridge CFTypeRef)r[@"multi_drive"]) != CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments"); multiDrive = [r[@"multi_drive"] boolValue]; if (r[@"write_protected"] && CFGetTypeID((__bridge CFTypeRef)r[@"write_protected"]) != CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments"); NSArray *keys = r[@"boot_keys"]; if (![keys isKindOfClass:NSArray.class] || keys.count == 0 || keys.count > 256) throw std::invalid_argument("invalid_boot_keys"); for (NSNumber *n in keys) { if (![n isKindOfClass:NSNumber.class] || n.unsignedLongLongValue >> 56) throw std::invalid_argument("invalid_boot_keys"); bootKeys.push_back(n.unsignedLongLongValue); } if ([r[@"cpu"] isEqual:@"6309"]) processor = Processor::HD6309; else if (r[@"cpu"] && ![r[@"cpu"] isEqual:@"6809"]) throw std::invalid_argument("invalid_cpu"); NSArray *declared = r[@"modules"] ?: @[]; if (![declared isKindOfClass:NSArray.class] || declared.count > 256) throw std::invalid_argument("invalid_modules"); size_t guardTotal = 0; for (NSDictionary *item in declared) { if (![item isKindOfClass:NSDictionary.class] || ![item[@"id"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_modules"); DebugBankedModule module; module.identifier = [item[@"id"] UTF8String]; id overlayGroup = item[@"overlay_group"], overlayOwner = item[@"overlay_owner"]; if (overlayGroup || overlayOwner) { if (![overlayGroup isKindOfClass:NSString.class] || ![overlayOwner isKindOfClass:NSString.class] || ![overlayGroup length] || ![overlayOwner length] || [overlayGroup lengthOfBytesUsingEncoding:NSUTF8StringEncoding] > 128 || [overlayOwner lengthOfBytesUsingEncoding:NSUTF8StringEncoding] > 128) throw std::invalid_argument("invalid_overlay_identity"); const char *groupText = [overlayGroup UTF8String], *ownerText = [overlayOwner UTF8String]; if (!groupText || !ownerText || std::strlen(groupText) != [overlayGroup lengthOfBytesUsingEncoding:NSUTF8StringEncoding] || std::strlen(ownerText) != [overlayOwner lengthOfBytesUsingEncoding:NSUTF8StringEncoding]) throw std::invalid_argument("invalid_overlay_identity"); module.overlayGroup = groupText; module.overlayOwner = ownerText; } NSArray *pages = item[@"pages"], *guards = item[@"guards"]; if (![pages isKindOfClass:NSArray.class] || pages.count == 0 || pages.count > 8 || ![guards isKindOfClass:NSArray.class] || guards.count == 0 || guards.count > 8192) throw std::invalid_argument("invalid_modules"); for (NSDictionary *page in pages) { if (![page isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_modules"); module.pages.push_back({uint8_t(number(page[@"logical_page"],0,7)),uint32_t(number(page[@"physical_page"],0,63))}); } for (NSDictionary *guard in guards) { if (![guard isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_modules"); int address = number(guard[@"address"],0,65535); auto value = bytes(guard[@"bytes_base64"], 65536); guardTotal += value.size(); if (value.size() > 65536 - address || guardTotal > 512*1024) throw std::invalid_argument("invalid_modules"); module.guards.push_back({uint16_t(address),std::move(value)}); } modules.push_back(std::move(module)); } NSArray *declaredFlat = r[@"flat_guards"] ?: @[]; if (![declaredFlat isKindOfClass:NSArray.class] || declaredFlat.count > 8192 || (declaredFlat.count && !modules.empty())) throw std::invalid_argument("invalid_flat_guards"); std::vector occupied(65536, false); size_t flatTotal = 0; for (NSDictionary *guard in declaredFlat) { if (![guard isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_flat_guards"); const auto address = number(guard[@"address"], 0, 0xfdff); auto value = bytes(guard[@"bytes_base64"], 65536); flatTotal += value.size(); if (value.size() > 0xfe00 - address || flatTotal > 65536) throw std::invalid_argument("invalid_flat_guards"); for (size_t i = 0; i < value.size(); ++i) { if (occupied[address + i]) throw std::invalid_argument("invalid_flat_guards"); occupied[address + i] = true; } flatGuards.push_back({uint16_t(address), std::move(value)}); } NSArray *buffers = r[@"graphics_buffers"] ?: @[]; if (![buffers isKindOfClass:NSArray.class] || buffers.count > 4) throw std::invalid_argument("invalid_graphics_buffers"); for (NSDictionary *item in buffers) { if (![item isKindOfClass:NSDictionary.class] || ![item[@"id"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_graphics_buffers"); const std::string identifier = [item[@"id"] UTF8String]; if (identifier.empty() || identifier.size() > 64 || identifier.size() != [item[@"id"] lengthOfBytesUsingEncoding:NSUTF8StringEncoding] || identifier == "displayed" || !std::all_of(identifier.begin(), identifier.end(), [](unsigned char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-'; }) || std::any_of(graphicsBuffers.begin(), graphicsBuffers.end(), [&](const auto& buffer) { return buffer.identifier == identifier; })) throw std::invalid_argument("invalid_graphics_buffer_id"); const auto mode = graphicsMode(item[@"mode"]); const auto origin = uint32_t(number(item[@"physical_address"],0,512*1024-1)); uint32_t span = 0; if (mode == DebugGraphicsMode::CurrentGime) { span = uint32_t(number(item[@"canvas_bytes"],8192,512*1024)); if ((span & (span - 1)) || origin % span || span > 512*1024 - origin) throw std::invalid_argument("invalid_graphics_canvas_span"); for (const auto& other : graphicsBuffers) if (other.mode == DebugGraphicsMode::CurrentGime && origin < other.physicalAddress + other.canvasBytes && other.physicalAddress < origin + span) throw std::invalid_argument("ambiguous_graphics_canvases"); } else if (item[@"canvas_bytes"]) throw std::invalid_argument("unexpected_graphics_canvas_span"); graphicsBuffers.push_back({identifier, origin, mode, false, span}); } if (r[@"stop_at"]) { if (modules.empty() && flatGuards.empty()) throw std::invalid_argument("unverified_stop"); stops.push_back(uint16_t(number(r[@"stop_at"],0,65535))); if (!flatGuards.empty()) { if (r[@"stop_module"]) throw std::invalid_argument("unverified_stop_module"); } else { if (![r[@"stop_module"] isKindOfClass:NSString.class]) throw std::invalid_argument("unverified_stop_module"); stopModule = [r[@"stop_module"] UTF8String]; } } machine = std::make_unique(); MachineConfiguration config; config.processor = processor; config.ram = 1; config.frameInterval = 1; machine->configure(config); floppy = std::make_shared(diskROM); floppy->mount(0,VCC::Devices::DiskImage::load(disk, [r[@"write_protected"] boolValue])); originalDiskHashes[0] = diskHash(); currentMediaIDs[0] = initialMediaID; machine->cartridges().configure({nullptr,nullptr,nullptr,nullptr,floppy},true,4); machine->load(rom,processor); for (const auto& buffer : graphicsBuffers) if (buffer.mode != DebugGraphicsMode::CurrentGime) (void)machine->debuggerGraphicsPreview(false, true, buffer.physicalAddress, buffer.mode); boot(); return status(); } if (!machine || stopped) throw std::runtime_error("stale_run"); if (frozenForRetention && ![@[@"media_status", @"export_media", @"finish_stop"] containsObject:op]) throw std::runtime_error("playtest_retention_pending"); if ([op isEqual:@"finish_stop"]) { if (!multiDrive || !frozenForRetention || r.count != 1 || drainedDrives != 15) throw std::runtime_error("playtest_disk_export_incomplete"); stopped = true; return status(); } if ([op isEqual:@"media_status"]) { if (r.count != 1) throw std::invalid_argument("invalid_arguments"); return status(); } if ([op isEqual:@"export_media"]) { if (r.count != 1 + (r[@"drive"] ? 1u : 0u) || (!multiDrive && r[@"drive"])) throw std::invalid_argument("invalid_arguments"); const unsigned drive = r[@"drive"] ? number(r[@"drive"], 0, 3) : 0; return exportMedia(drive); } if ([op isEqual:@"exchange_media"]) return exchangeMedia(r); if ([op isEqual:@"video_start"]) { if (r.count != 5 || ![r[@"clip_id"] isKindOfClass:NSString.class] || ![r[@"directory"] isKindOfClass:NSString.class] || !r[@"include_audio"] || CFGetTypeID((__bridge CFTypeRef)r[@"include_audio"]) != CFBooleanGetTypeID()) throw std::invalid_argument("invalid_arguments"); if (videoWriter) throw std::runtime_error("playtest_video_active"); NSUUID *identifier = [[NSUUID alloc] initWithUUIDString:r[@"clip_id"]]; NSURL *directory = [NSURL fileURLWithPath:r[@"directory"] isDirectory:YES]; if (!identifier || ![directory.lastPathComponent isEqual:identifier.UUIDString] || ![NSFileManager.defaultManager fileExistsAtPath:directory.path]) throw std::invalid_argument("invalid_arguments"); videoMaximumFields = number(r[@"max_fields"], 1, 3600); NSError *error = nil; videoWriter = [[VCCPlaytestVideoWriter alloc] initWithDirectory:directory includeAudio:[r[@"include_audio"] boolValue] error:&error]; if (!videoWriter) throw std::runtime_error((error.localizedDescription ?: @"playtest_video_start_failed").UTF8String); videoDirectory = directory; videoFirstField = fieldClock; videoSamples = 0; machine->takeAudio(); videoInfo = [@{@"clip_id":identifier.UUIDString, @"status":@"recording", @"include_audio":r[@"include_audio"], @"max_fields":@(videoMaximumFields), @"field_start":@(fieldClock), @"field_end":@(fieldClock), @"fields_recorded":@0, @"completed":@NO, @"truncated":@NO, @"boot":@(bootNumber), @"ui_cues_included":@NO, @"microphone_included":@NO, @"host_audio_included":@NO} mutableCopy]; return status(); } if ([op isEqual:@"video_stop"]) { if (r.count != 1 || !videoInfo) throw std::runtime_error("playtest_video_unavailable"); finishVideo(@"stopped"); NSMutableDictionary *out = [status() mutableCopy]; out[@"video"] = [videoInfo copy]; return out; } if ([op isEqual:@"input"]) { if (r.count != 2) throw std::invalid_argument("invalid_arguments"); unsigned total = 0; const auto plan = inputPlan(r[@"steps"], total); if (consumed + total > fieldBudget) throw std::runtime_error("playtest_field_limit"); ReleaseInput cleanup{machine.get()}; NSMutableArray *trace = [NSMutableArray arrayWithCapacity:plan.size()]; for (unsigned index = 0; index < plan.size(); ++index) { const auto& step = plan[index]; const auto before = machine->snapshot(); if (before.state != RunState::Running && index != 0) break; const auto first = fieldClock; Snapshot applied; if (before.state == RunState::Paused) { armInspection(); // Input is staged through the same setters before the // normal leave-breakpoint slice can sample the PIA. applied = machine->resumeWithInput(step.keys, step.joysticks); const auto advanced = machine->snapshot().frames - before.frames; fieldClock += advanced; consumed += advanced; auto samples = machine->takeAudio(); recordVideo(samples); if (advanced > step.fields) throw std::runtime_error("playtest_input_timing"); } else { machine->setKeyboard(step.keys); for (unsigned port = 0; port < step.joysticks.size(); ++port) { const auto& input = step.joysticks[port]; machine->setJoystick(port, input.x, input.y, input.buttons, 0); } applied = machine->snapshot(); } fields(step.fields - unsigned(fieldClock - first)); [trace addObject:@{@"step_index":@(index), @"fields_requested":@(step.fields), @"fields_advanced":@(fieldClock - first), @"field_start":@(first), @"field_end":@(fieldClock), @"input":inputMetadata(applied)}]; } machine->releaseInputs(); NSMutableDictionary *result = [status() mutableCopy]; result[@"input_trace"] = trace; return result; } if ([op isEqual:@"input_status"]) { if (r.count != 1) throw std::invalid_argument("invalid_arguments"); return status(); } if ([op isEqual:@"capture"]) return capture(); if ([op isEqual:@"audio_capture"]) { if (r.count != 2 || !r[@"fields"]) throw std::invalid_argument("invalid_arguments"); return captureAudio(number(r[@"fields"], 1, audioFieldLimit)); } if ([op isEqual:@"graphics_capture"]) { if (r.count > 2) throw std::invalid_argument("invalid_arguments"); for (NSString *key in r) if (![key isEqualToString:@"op"] && ![key isEqualToString:@"buffer_id"]) throw std::invalid_argument("invalid_arguments"); std::optional selected; if (r[@"buffer_id"]) { if (![r[@"buffer_id"] isKindOfClass:NSString.class]) throw std::invalid_argument("invalid_graphics_buffer_id"); const std::string id = [r[@"buffer_id"] UTF8String]; if (id.size() != [r[@"buffer_id"] lengthOfBytesUsingEncoding:NSUTF8StringEncoding]) throw std::invalid_argument("invalid_graphics_buffer_id"); const auto found = std::find_if(graphicsBuffers.begin(), graphicsBuffers.end(), [&](const auto& buffer) { return buffer.identifier == id; }); if (found == graphicsBuffers.end()) throw std::invalid_argument("unknown_graphics_buffer"); selected = *found; } const auto captured = machine->debuggerGraphicsCapture(selected, graphicsBuffers); NSMutableDictionary *out = [status() mutableCopy]; out[@"paused"] = @YES; out[@"snapshot_kind"] = @"paused_register_preview"; auto displayed = graphicsMetadata(captured.displayed, @"displayed"); out[@"display_buffer"] = [displayed copy]; displayed[@"kind"] = @"current_register_preview"; displayed[@"png_base64"] = png(captured.displayed.pixels,captured.displayed.width,captured.displayed.height,350000); NSMutableArray *images = [NSMutableArray arrayWithObject:displayed]; if (captured.declared) { auto other = graphicsMetadata(*captured.declared,[NSString stringWithUTF8String:captured.declaredIdentifier.c_str()]); other[@"selection"] = @"project_declaration"; other[@"kind"] = @"declared_buffer_preview"; other[@"png_base64"] = png(captured.declared->pixels,captured.declared->width,captured.declared->height,350000); [images addObject:other]; } out[@"buffers"] = images; return out; } if ([op isEqual:@"restart"]) { if (videoWriter) throw std::runtime_error("playtest_video_active: stop the recording before restarting"); if (floppy->snapshot().busy) throw std::runtime_error("disk_busy"); boot(); return status(); } if ([op isEqual:@"continue"]) { armInspection(); const auto before = machine->snapshot().frames; machine->resume(); fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); return status(); } if ([op isEqual:@"pause"]) { machine->releaseInputs(); machine->pause(); return status(); } if ([op isEqual:@"step"]) { if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped"); const auto before = machine->snapshot().frames; machine->debuggerStep(); fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); return status(); } if ([op isEqual:@"stop_at"]) { if (modules.empty() && flatGuards.empty()) throw std::runtime_error("unverified_stop"); const auto nextPoint = uint16_t(number(r[@"address"],0,65535)); std::string nextModule; if (!flatGuards.empty()) { if (r[@"module_id"]) throw std::invalid_argument("unverified_stop_module"); } else { if (![r[@"module_id"] isKindOfClass:NSString.class]) throw std::invalid_argument("unverified_stop_module"); nextModule = [r[@"module_id"] UTF8String]; } armEvidence({nextPoint}, nextModule); stops = {nextPoint}; stopModule = nextModule; const auto before = machine->snapshot().frames; machine->resume(); fieldClock += machine->snapshot().frames - before; auto samples = machine->takeAudio(); recordVideo(samples); return status(); } if ([op isEqual:@"debug"]) { if (machine->snapshot().state != RunState::Paused) throw std::runtime_error("playtest_not_stopped"); auto d = machine->debuggerSnapshot(0,65536); auto c = d.cpu; NSMutableDictionary *out = [status() mutableCopy]; NSMutableDictionary *registers = [@{ @"A":@(c.A), @"B":@(c.B), @"X":@(c.X), @"Y":@(c.Y), @"U":@(c.U), @"S":@(c.S), @"PC":@(c.PC), @"DP":@(c.DP), @"CC":@(c.CC) } mutableCopy]; if (machine->snapshot().configuration.processor == Processor::HD6309) { registers[@"E"] = @(c.E); registers[@"F"] = @(c.F); registers[@"W"] = @((unsigned(c.E) << 8) | unsigned(c.F)); registers[@"V"] = @(c.V); registers[@"MD"] = @(c.MD); } out[@"registers"] = registers; out[@"mapping_fingerprint"] = [NSString stringWithFormat:@"%llu",(unsigned long long)machine->snapshot().debuggerMappingFingerprint]; out[@"program_revision"] = @(machine->snapshot().debuggerProgramRevision); out[@"residency_fingerprint"] = [NSString stringWithFormat:@"%llu",(unsigned long long)machine->snapshot().debuggerResidencyFingerprint]; out[@"attached"] = @(machine->snapshot().debuggerDevelopmentAttached); out[@"paused"] = @YES; out[@"logical_memory"] = [[NSData dataWithBytes:d.memory.data() length:d.memory.size()] base64EncodedStringWithOptions:0]; out[@"available"] = [[NSData dataWithBytes:d.memoryAvailable.data() length:d.memoryAvailable.size()] base64EncodedStringWithOptions:0]; NSMutableDictionary *pages = [NSMutableDictionary dictionary]; NSMutableArray *sources = [NSMutableArray array]; for (size_t i = 0; i < d.mmu.Effective.size(); ++i) { const auto& page = d.mmu.Effective[i]; if (page.Source == VCC::MMUSource::RAM) pages[[NSString stringWithFormat:@"%zu",i]] = @(page.SourceStart / 8192); [sources addObject:@(int(page.Source))]; } out[@"physical_pages"] = pages; out[@"page_sources"] = sources; out[@"mmu_enabled"] = @(d.mmu.Enabled); out[@"active_task"] = @(d.mmu.ActiveTask); out[@"verified_banked_program"] = @(machine->snapshot().debuggerBankedDevelopment); return out; } if ([op isEqual:@"read_memory"]) { auto d = machine->debuggerMemoryRange(number(r[@"address"],0,65535),number(r[@"count"],1,256),false); for (auto b : d.available) if (!b) throw std::runtime_error("memory_unavailable"); NSMutableDictionary *out = [status() mutableCopy]; out[@"address"] = @(d.address); out[@"bytes"] = array(d.bytes); out[@"cycles"] = @(d.cycles); out[@"generation"] = @(d.generation); return out; } if ([op isEqual:@"stop"]) { machine->releaseInputs(); machine->pause(); finishVideo(@"run_stopped"); NSMutableDictionary *out = [status() mutableCopy]; if (videoInfo) out[@"video"] = [videoInfo copy]; if (multiDrive) { frozenForRetention = true; drainedDrives = 0; out[@"media_frozen"] = @YES; return out; // Drain four bounded per-drive replies before finish_stop. } if (const auto *image = floppy->image(0)) { const auto& disk = image->bytes(); out[@"disk_base64"] = [[NSData dataWithBytes:disk.data() length:disk.size()] base64EncodedStringWithOptions:0]; } stopped = true; return out; } throw std::invalid_argument("unknown_operation"); } }; } int main() { @autoreleasepool { Playtest test; for (;;) { std::string line; char c; while (std::cin.get(c) && c != '\n') { if (line.size() >= wireLimit) return 2; line.push_back(c); } if (line.empty() && !std::cin) break; @autoreleasepool { NSDictionary *result; try { NSData *data = [NSData dataWithBytes:line.data() length:line.size()]; id request = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil]; if (![request isKindOfClass:NSDictionary.class]) throw std::invalid_argument("invalid_request"); result = @{ @"result": test.reply(request) }; } catch (const std::exception& error) { result = @{ @"error": [NSString stringWithUTF8String:error.what()] ?: @"playtest_failed" }; } NSData *data = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingSortedKeys error:nil]; if (!data || data.length > wireLimit) return 3; std::cout.write(static_cast(data.bytes),data.length); std::cout << '\n' << std::flush; } if (test.stopped) break; } } return 0; }