Merge pull request #1427 from TomHarte/CommodoreAnalyser

Improve analysis of Commodore BASIC

Analyser/Static/Acorn/Target.hpp

@@ -23,14 +23,16 @@ struct ElectronTarget: public ::Analyser::Static::Target, public Reflection::Str
 	bool should_shift_restart = false;
 	std::string loading_command;
 
-	ElectronTarget() : Analyser::Static::Target(Machine::Electron) {
-		if(needs_declare()) {
-			DeclareField(has_pres_adfs);
-			DeclareField(has_acorn_adfs);
-			DeclareField(has_dfs);
-			DeclareField(has_ap6_rom);
-			DeclareField(has_sideways_ram);
-		}
+	ElectronTarget() : Analyser::Static::Target(Machine::Electron) {}
+
+private:
+	friend Reflection::StructImpl<ElectronTarget>;
+	void declare_fields() {
+		DeclareField(has_pres_adfs);
+		DeclareField(has_acorn_adfs);
+		DeclareField(has_dfs);
+		DeclareField(has_ap6_rom);
+		DeclareField(has_sideways_ram);
 	}
 };
 

Analyser/Static/Amiga/Target.hpp

@@ -28,13 +28,15 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	ChipRAM chip_ram = ChipRAM::FiveHundredAndTwelveKilobytes;
 	FastRAM fast_ram = FastRAM::EightMegabytes;
 
-	Target() : Analyser::Static::Target(Machine::Amiga) {
-		if(needs_declare()) {
-			DeclareField(fast_ram);
-			DeclareField(chip_ram);
-			AnnounceEnum(FastRAM);
-			AnnounceEnum(ChipRAM);
-		}
+	Target() : Analyser::Static::Target(Machine::Amiga) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(fast_ram);
+		DeclareField(chip_ram);
+		AnnounceEnum(FastRAM);
+		AnnounceEnum(ChipRAM);
 	}
 };
 

Analyser/Static/AmstradCPC/Target.hpp

@@ -26,13 +26,15 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	// This is used internally for testing; it therefore isn't exposed reflectively.
 	bool catch_ssm_codes = false;
 
-	Target() : Analyser::Static::Target(Machine::AmstradCPC) {
-		if(needs_declare()) {
-			DeclareField(model);
-			DeclareField(crtc_type);
-			AnnounceEnum(Model);
-			AnnounceEnum(CRTCType);
-		}
+	Target() : Analyser::Static::Target(Machine::AmstradCPC) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(model);
+		DeclareField(crtc_type);
+		AnnounceEnum(Model);
+		AnnounceEnum(CRTCType);
 	}
 };
 

Analyser/Static/AppleII/Target.hpp

@@ -36,17 +36,19 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	SCSIController scsi_controller = SCSIController::None;
 	bool has_mockingboard = true;
 
-	Target() : Analyser::Static::Target(Machine::AppleII) {
-		if(needs_declare()) {
-			DeclareField(model);
-			DeclareField(disk_controller);
-			DeclareField(scsi_controller);
-			DeclareField(has_mockingboard);
+	Target() : Analyser::Static::Target(Machine::AppleII) {}
 
-			AnnounceEnum(Model);
-			AnnounceEnum(DiskController);
-			AnnounceEnum(SCSIController);
-		}
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(model);
+		DeclareField(disk_controller);
+		DeclareField(scsi_controller);
+		DeclareField(has_mockingboard);
+
+		AnnounceEnum(Model);
+		AnnounceEnum(DiskController);
+		AnnounceEnum(SCSIController);
 	}
 };
 

Analyser/Static/AppleIIgs/Target.hpp

@@ -29,13 +29,15 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	Model model = Model::ROM01;
 	MemoryModel memory_model = MemoryModel::EightMB;
 
-	Target() : Analyser::Static::Target(Machine::AppleIIgs) {
-		if(needs_declare()) {
-			DeclareField(model);
-			DeclareField(memory_model);
-			AnnounceEnum(Model);
-			AnnounceEnum(MemoryModel);
-		}
+	Target() : Analyser::Static::Target(Machine::AppleIIgs) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(model);
+		DeclareField(memory_model);
+		AnnounceEnum(Model);
+		AnnounceEnum(MemoryModel);
 	}
 };
 

Analyser/Static/AtariST/Target.hpp

@@ -20,11 +20,13 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 		FourMegabytes);
 	MemorySize memory_size = MemorySize::OneMegabyte;
 
-	Target() : Analyser::Static::Target(Machine::AtariST) {
-		if(needs_declare()) {
-			DeclareField(memory_size);
-			AnnounceEnum(MemorySize);
-		}
+	Target() : Analyser::Static::Target(Machine::AtariST) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(memory_size);
+		AnnounceEnum(MemorySize);
 	}
 };
 

Analyser/Static/Commodore/Disk.cpp

@@ -171,18 +171,16 @@ private:
 
 std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	std::vector<File> files;
-	CommodoreGCRParser parser;
-	parser.set_disk(disk);
+	auto parser = std::make_unique<CommodoreGCRParser>();
+	parser->set_disk(disk);
 
-	// find any sector whatsoever to establish the current track
-	std::shared_ptr<CommodoreGCRParser::Sector> sector;
-
-	// assemble directory
+	// Assemble directory.
 	std::vector<uint8_t> directory;
 	uint8_t next_track = 18;
 	uint8_t next_sector = 1;
+	directory.reserve(20 * 1024);	// Probably more than plenty.
 	while(true) {
-		sector = parser.sector(next_track, next_sector);
+		auto sector = parser->sector(next_track, next_sector);
 		if(!sector) break;
 		directory.insert(directory.end(), sector->data.begin(), sector->data.end());
 		next_track = sector->data[0];
@@ -224,7 +222,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 
 			bool is_first_sector = true;
 			while(next_track) {
-				sector = parser.sector(next_track, next_sector);
+				auto sector = parser->sector(next_track, next_sector);
 				if(!sector) break;
 
 				next_track = sector->data[0];

Analyser/Static/Commodore/File.cpp

@@ -1,47 +0,0 @@
-//
-//  File.cpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 10/09/2016.
-//  Copyright 2016 Thomas Harte. All rights reserved.
-//
-
-#include "File.hpp"
-
-bool Analyser::Static::Commodore::File::is_basic() {
-	// BASIC files are always relocatable (?)
-	if(type != File::RelocatableProgram) return false;
-
-	uint16_t line_address = starting_address;
-	int line_number = -1;
-
-	// decide whether this is a BASIC file based on the proposition that:
-	//	(1) they're always relocatable; and
-	//	(2) they have a per-line structure of:
-	//		[4 bytes: address of start of next line]
-	//		[4 bytes: this line number]
-	//		... null-terminated code ...
-	//	(with a next line address of 0000 indicating end of program)
-	while(1) {
-		if(size_t(line_address - starting_address) + 1 >= data.size()) break;
-
-		uint16_t next_line_address = data[line_address - starting_address];
-		next_line_address |= data[line_address - starting_address + 1] << 8;
-
-		if(!next_line_address) {
-			return true;
-		}
-		if(next_line_address < line_address + 5) break;
-
-		if(size_t(line_address - starting_address) + 3 >= data.size()) break;
-		uint16_t next_line_number = data[line_address - starting_address + 2];
-		next_line_number |= data[line_address - starting_address + 3] << 8;
-
-		if(next_line_number <= line_number) break;
-
-		line_number = uint16_t(next_line_number);
-		line_address = next_line_address;
-	}
-
-	return false;
-}

Analyser/Static/Commodore/File.hpp

@@ -29,8 +29,6 @@ struct File {
 		Relative
 	} type;
 	std::vector<uint8_t> data;
-
-	bool is_basic();
 };
 
 }

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -15,23 +15,29 @@
 #include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
 #include "../../../Outputs/Log.hpp"
 
+#include "../Disassembler/6502.hpp"
+#include "../Disassembler/AddressMapper.hpp"
+
 #include <algorithm>
 #include <cstring>
 #include <sstream>
+#include <unordered_set>
 
 using namespace Analyser::Static::Commodore;
 
-static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+namespace {
+
+std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 Vic20CartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
 	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> vic20_cartridges;
 
 	for(const auto &cartridge : cartridges) {
 		const auto &segments = cartridge->get_segments();
 
-		// only one mapped item is allowed
+		// Only one mapped item is allowed ...
 		if(segments.size() != 1) continue;
 
-		// which must be 16 kb in size
+		// ... which must be 16 kb in size.
 		Storage::Cartridge::Cartridge::Segment segment = segments.front();
 		if(segment.start_address != 0xa000) continue;
 		if(!Storage::Cartridge::Encodings::CommodoreROM::isROM(segment.data)) continue;
@@ -39,123 +45,250 @@ Vic20CartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartri
 		vic20_cartridges.push_back(cartridge);
 	}
 
+	// TODO: other machines?
+
 	return vic20_cartridges;
 }
 
+struct BASICAnalysis {
+	enum class Version {
+		NotBASIC,
+		BASIC2,
+		BASIC4,
+		BASIC3_5,
+	} minimum_version = Version::NotBASIC;
+	std::vector<uint16_t> machine_code_addresses;
+};
+
+std::optional<BASICAnalysis> analyse(const File &file) {
+	BASICAnalysis analysis;
+
+	switch(file.type) {
+		// For 'program' types, proceed with analysis below.
+		case File::RelocatableProgram:
+		case File::NonRelocatableProgram:
+		break;
+
+		// For sequential and relative data stop right now.
+		case File::DataSequence:
+		case File::Relative:
+		return std::nullopt;
+
+		// For user data, try decoding from the starting point.
+		case File::User:
+			analysis.machine_code_addresses.push_back(file.starting_address);
+		return analysis;
+	}
+
+	// Don't form an opinion if file is empty.
+	if(file.data.empty()) {
+		return std::nullopt;
+	}
+
+	uint16_t line_address = file.starting_address;
+	int previous_line_number = -1;
+
+	const auto byte = [&](uint16_t address) {
+		return file.data[address - file.starting_address];
+	};
+	const auto word = [&](uint16_t address) {
+		return uint16_t(byte(address) | byte(address + 1) << 8);
+	};
+
+	// BASIC programs have a per-line structure of:
+	//		[2 bytes: address of start of next line]
+	//		[2 bytes: this line number]
+	//		... null-terminated code ...
+	//	(with a next line address of 0000 indicating end of program)
+	//
+	// If a SYS is encountered that jumps into the BASIC program then treat that as
+	// a machine code entry point.
+
+	std::unordered_set<uint16_t> visited_lines;
+	while(true) {
+		// Analysis has failed if there isn't at least one complete BASIC line from here.
+		// Fall back on guessing the start address as a machine code entrypoint.
+		if(size_t(line_address - file.starting_address) + 5 >= file.data.size()) {
+			analysis.machine_code_addresses.push_back(file.starting_address);
+			break;
+		}
+
+		const auto next_line_address = word(line_address);
+		const auto line_number = word(line_address + 2);
+
+		uint16_t code = line_address + 4;
+		const auto next = [&]() -> uint8_t {
+			if(code >= file.starting_address + file.data.size()) {
+				return 0;
+			}
+			return byte(code++);
+		};
+
+		// TODO: sanity check on apparent line contents.
+		// TODO: observe token set (and possibly parameters?) to guess BASIC version.
+		while(true) {
+			const auto token = next();
+			if(!token || token == 0x8f) break;
+
+			switch(token) {
+				case 0x9e: {	// SYS; parse following ASCII argument.
+					uint16_t address = 0;
+					while(true) {
+						const auto c = next();
+						if(c < '0' || c > '9') {
+							break;
+						}
+						address = (address * 10) + (c - '0');
+					};
+					analysis.machine_code_addresses.push_back(address);
+				} break;
+			}
+		}
+
+		// Exit if a formal end of the program has been declared or if, as some copy protections do,
+		// the linked list of line contents has been made circular.
+		visited_lines.insert(line_address);
+		if(!next_line_address || visited_lines.find(next_line_address) != visited_lines.end()) {
+			break;
+		}
+
+		previous_line_number = line_number;
+		line_address = next_line_address;
+	}
+
+	return analysis;
+}
+
+}
+
 Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(
 	const Media &media,
 	const std::string &file_name,
 	TargetPlatform::IntType
 ) {
 	TargetList destination;
-
 	auto target = std::make_unique<Target>();
-	target->machine = Machine::Vic20;	// TODO: machine estimation
-	target->confidence = 0.5; // TODO: a proper estimation
 
 	int device = 0;
 	std::vector<File> files;
 	bool is_disk = false;
 
-	// strip out inappropriate cartridges
+	// Strip out inappropriate cartridges.
 	target->media.cartridges = Vic20CartridgesFrom(media.cartridges);
 
-	// check disks
+	// Find all valid Commodore files on disks.
 	for(auto &disk : media.disks) {
 		std::vector<File> disk_files = GetFiles(disk);
 		if(!disk_files.empty()) {
 			is_disk = true;
-			files.insert(files.end(), disk_files.begin(), disk_files.end());
+			files.insert(
+				files.end(),
+				std::make_move_iterator(disk_files.begin()),
+				std::make_move_iterator(disk_files.end())
+			);
 			target->media.disks.push_back(disk);
 			if(!device) device = 8;
 		}
 	}
 
-	// check tapes
+	// Find all valid Commodore files on tapes.
 	for(auto &tape : media.tapes) {
 		std::vector<File> tape_files = GetFiles(tape);
 		tape->reset();
 		if(!tape_files.empty()) {
-			files.insert(files.end(), tape_files.begin(), tape_files.end());
+			files.insert(
+				files.end(),
+				std::make_move_iterator(tape_files.begin()),
+				std::make_move_iterator(tape_files.end())
+			);
 			target->media.tapes.push_back(tape);
 			if(!device) device = 1;
 		}
 	}
 
-	if(!files.empty()) {
-		auto memory_model = Target::MemoryModel::Unexpanded;
+	// Inspect discovered files to try to divine machine and memory model.
+	auto vic_memory_model = Target::MemoryModel::Unexpanded;
+
+	if(files.size() > 1) {
+		printf("");
+	}
+
+	auto it = files.begin();
+	while(it != files.end()) {
+		const auto &file = *it;
+
 		std::ostringstream string_stream;
-		string_stream << "LOAD\"" << (is_disk ? "*" : "") << "\"," << device << ",";
-		if(files.front().is_basic()) {
-			string_stream << "0";
-		} else {
-			string_stream << "1";
-		}
-		string_stream << "\nRUN\n";
-		target->loading_command = string_stream.str();
+		string_stream << "LOAD\"" << (is_disk ? "*" : "") << "\"," << device;
 
-		// make a first guess based on loading address
-		switch(files.front().starting_address) {
-			default:
-				Log::Logger<Log::Source::CommodoreStaticAnalyser>().error().append(
-					"Unrecognised loading address for Commodore program: %04x", files.front().starting_address);
-				[[fallthrough]];
-			case 0x1001:
-				memory_model = Target::MemoryModel::Unexpanded;
-			break;
-			case 0x1201:
-				memory_model = Target::MemoryModel::ThirtyTwoKB;
-			break;
-			case 0x0401:
-				memory_model = Target::MemoryModel::EightKB;
-			break;
+		const auto analysis = analyse(file);
+		if(analysis && !analysis->machine_code_addresses.empty()) {
+			string_stream << ",1";
 
-			case 0x1c01:
-				Log::Logger<Log::Source::CommodoreStaticAnalyser>().info().append("Unimplemented: C128");
-			break;
-		}
+			// Disassemble.
+			const auto disassembly = Analyser::Static::MOS6502::Disassemble(
+				file.data,
+				Analyser::Static::Disassembler::OffsetMapper(file.starting_address),
+				analysis->machine_code_addresses
+			);
 
-		target->set_memory_model(memory_model);
-
-		// General approach: increase memory size conservatively such that the largest file found will fit.
-//		for(File &file : files) {
-//			std::size_t file_size = file.data.size();
-//			bool is_basic = file.is_basic();
-
-			/*if(is_basic)
-			{
-				// BASIC files may be relocated, so the only limit is size.
-				//
-				// An unexpanded machine has 3583 bytes free for BASIC;
-				// a 3kb expanded machine has 6655 bytes free.
-				if(file_size > 6655)
-					target->vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
-				else if(target->vic20.memory_model == Vic20MemoryModel::Unexpanded && file_size > 3583)
-					target->vic20.memory_model = Vic20MemoryModel::EightKB;
+			// If FF3E or FF3F is touched, this is for the +4.
+			// TODO: probably require a very early touch.
+			for(const auto address: {0xff3e, 0xff3f}) {
+				for(const auto &collection: {
+					disassembly.external_loads,
+					disassembly.external_stores,
+					disassembly.external_modifies
+				}) {
+					if(collection.find(uint16_t(address)) != collection.end()) {
+						target->machine = Machine::Plus4;	// TODO: use a better target?
+					}
+				}
 			}
-			else
-			{*/
-//			if(!file.type == File::NonRelocatableProgram)
-//			{
-				// Non-BASIC files may be relocatable but, if so, by what logic?
-				// Given that this is unknown, take starting address as literal
-				// and check against memory windows.
-				//
-				// (ignoring colour memory...)
-				// An unexpanded Vic has memory between 0x0000 and 0x0400; and between 0x1000 and 0x2000.
-				// A 3kb expanded Vic fills in the gap and has memory between 0x0000 and 0x2000.
-				// A 32kb expanded Vic has memory in the entire low 32kb.
-//				uint16_t starting_address = file.starting_address;
+		}
 
-				// If anything above the 8kb mark is touched, mark as a 32kb machine; otherwise if the
-				// region 0x0400 to 0x1000 is touched and this is an unexpanded machine, mark as 3kb.
-//				if(starting_address + file_size > 0x2000)
-//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
-//				else if(target->memory_model == Target::MemoryModel::Unexpanded &&
-//					!(starting_address >= 0x1000 || starting_address+file_size < 0x0400))
-//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
-//			}
-//		}
+		string_stream << "\nRUN\n";
+		if(it == files.begin()) {
+			target->loading_command = string_stream.str();
+
+			// Make a guess for the Vic-20, if ultimately selected, based on loading address.
+			// TODO: probably also discount other machines if starting address isn't 0x1001?
+			switch(files.front().starting_address) {
+				default:
+					Log::Logger<Log::Source::CommodoreStaticAnalyser>().error().append(
+						"Unrecognised loading address for Commodore program: %04x", files.front().starting_address);
+					[[fallthrough]];
+				case 0x1001:
+					vic_memory_model = Target::MemoryModel::Unexpanded;
+					// TODO: could be Vic-20 or Plus4.
+				break;
+
+				case 0x1201:
+					vic_memory_model = Target::MemoryModel::ThirtyTwoKB;
+					target->machine = Machine::Vic20;
+				break;
+				case 0x0401:
+					vic_memory_model = Target::MemoryModel::EightKB;
+					target->machine = Machine::Vic20;
+				break;
+
+				case 0x0801:
+					// TODO: assume C64.
+				break;
+				case 0x1c01:
+					// TODO: assume C128.
+				break;
+			}
+		}
+
+
+		// The Vic-20 never has RAM after 0x8000.
+		if(file.ending_address >= 0x8000) {
+			target->machine = Machine::Plus4;
+		}
+
+		target->set_memory_model(vic_memory_model);
+
+		++it;
 	}
 
 	if(!target->media.empty()) {

Analyser/Static/Commodore/Tape.cpp

@@ -26,7 +26,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 
 		switch(header->type) {
 			case Storage::Tape::Commodore::Header::DataSequenceHeader: {
-				File new_file;
+				File &new_file = file_list.emplace_back();
 				new_file.name = header->name;
 				new_file.raw_name = header->raw_name;
 				new_file.starting_address = header->starting_address;
@@ -40,8 +40,6 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 					if(header->type != Storage::Tape::Commodore::Header::DataBlock) break;
 					std::copy(header->data.begin(), header->data.end(), std::back_inserter(new_file.data));
 				}
-
-				file_list.push_back(new_file);
 			}
 			break;
 
@@ -49,7 +47,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 			case Storage::Tape::Commodore::Header::NonRelocatableProgram: {
 				std::unique_ptr<Storage::Tape::Commodore::Data> data = parser.get_next_data(tape);
 				if(data) {
-					File new_file;
+					File &new_file = file_list.emplace_back();
 					new_file.name = header->name;
 					new_file.raw_name = header->raw_name;
 					new_file.starting_address = header->starting_address;
@@ -58,8 +56,6 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 					new_file.type =
 						header->type == Storage::Tape::Commodore::Header::RelocatableProgram
 							? File::RelocatableProgram : File::NonRelocatableProgram;
-
-					file_list.push_back(new_file);
 				}
 
 				header = parser.get_next_header(tape);

Analyser/Static/Commodore/Target.hpp

@@ -54,17 +54,19 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	bool has_c1540 = false;
 	std::string loading_command;
 
-	Target() : Analyser::Static::Target(Machine::Vic20) {
-		if(needs_declare()) {
-			DeclareField(enabled_ram.bank0);
-			DeclareField(enabled_ram.bank1);
-			DeclareField(enabled_ram.bank2);
-			DeclareField(enabled_ram.bank3);
-			DeclareField(enabled_ram.bank5);
-			DeclareField(region);
-			DeclareField(has_c1540);
-			AnnounceEnum(Region);
-		}
+	Target() : Analyser::Static::Target(Machine::Vic20) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(enabled_ram.bank0);
+		DeclareField(enabled_ram.bank1);
+		DeclareField(enabled_ram.bank2);
+		DeclareField(enabled_ram.bank3);
+		DeclareField(enabled_ram.bank5);
+		DeclareField(region);
+		DeclareField(has_c1540);
+		AnnounceEnum(Region);
 	}
 };
 

Analyser/Static/Enterprise/Target.hpp

@@ -30,20 +30,22 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	Speed speed = Speed::FourMHz;
 	std::string loading_command;
 
-	Target() : Analyser::Static::Target(Machine::Enterprise) {
-		if(needs_declare()) {
-			AnnounceEnum(Model);
-			AnnounceEnum(EXOSVersion);
-			AnnounceEnum(BASICVersion);
-			AnnounceEnum(DOS);
-			AnnounceEnum(Speed);
+	Target() : Analyser::Static::Target(Machine::Enterprise) {}
 
-			DeclareField(model);
-			DeclareField(exos_version);
-			DeclareField(basic_version);
-			DeclareField(dos);
-			DeclareField(speed);
-		}
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		AnnounceEnum(Model);
+		AnnounceEnum(EXOSVersion);
+		AnnounceEnum(BASICVersion);
+		AnnounceEnum(DOS);
+		AnnounceEnum(Speed);
+
+		DeclareField(model);
+		DeclareField(exos_version);
+		DeclareField(basic_version);
+		DeclareField(dos);
+		DeclareField(speed);
 	}
 };
 

Analyser/Static/MSX/Target.hpp

@@ -33,15 +33,17 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	);
 	Region region = Region::USA;
 
-	Target(): Analyser::Static::Target(Machine::MSX) {
-		if(needs_declare()) {
-			DeclareField(has_disk_drive);
-			DeclareField(has_msx_music);
-			DeclareField(region);
-			AnnounceEnum(Region);
-			DeclareField(model);
-			AnnounceEnum(Model);
-		}
+	Target(): Analyser::Static::Target(Machine::MSX) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(has_disk_drive);
+		DeclareField(has_msx_music);
+		DeclareField(region);
+		AnnounceEnum(Region);
+		DeclareField(model);
+		AnnounceEnum(Model);
 	}
 };
 

Analyser/Static/Macintosh/Target.hpp

@@ -18,12 +18,13 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	ReflectableEnum(Model, Mac128k, Mac512k, Mac512ke, MacPlus);
 	Model model = Model::MacPlus;
 
-	Target() : Analyser::Static::Target(Machine::Macintosh) {
-		// Boilerplate for declaring fields and potential values.
-		if(needs_declare()) {
-			DeclareField(model);
-			AnnounceEnum(Model);
-		}
+	Target() : Analyser::Static::Target(Machine::Macintosh) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(model);
+		AnnounceEnum(Model);
 	}
 };
 

Analyser/Static/Oric/Target.hpp

@@ -41,15 +41,17 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	std::string loading_command;
 	bool should_start_jasmin = false;
 
-	Target(): Analyser::Static::Target(Machine::Oric) {
-		if(needs_declare()) {
-			DeclareField(rom);
-			DeclareField(disk_interface);
-			DeclareField(processor);
-			AnnounceEnum(ROM);
-			AnnounceEnum(DiskInterface);
-			AnnounceEnum(Processor);
-		}
+	Target(): Analyser::Static::Target(Machine::Oric) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(rom);
+		DeclareField(disk_interface);
+		DeclareField(processor);
+		AnnounceEnum(ROM);
+		AnnounceEnum(DiskInterface);
+		AnnounceEnum(Processor);
 	}
 };
 

Analyser/Static/PCCompatible/Target.hpp

@@ -24,13 +24,15 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 		Fast);
 	Speed speed = Speed::Fast;
 
-	Target() : Analyser::Static::Target(Machine::PCCompatible) {
-		if(needs_declare()) {
-			AnnounceEnum(VideoAdaptor);
-			AnnounceEnum(Speed);
-			DeclareField(adaptor);
-			DeclareField(speed);
-		}
+	Target() : Analyser::Static::Target(Machine::PCCompatible) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		AnnounceEnum(VideoAdaptor);
+		AnnounceEnum(Speed);
+		DeclareField(adaptor);
+		DeclareField(speed);
 	}
 };
 

Analyser/Static/Sega/Target.hpp

@@ -37,11 +37,13 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	Region region = Region::Japan;
 	PagingScheme paging_scheme = PagingScheme::Sega;
 
-	Target() : Analyser::Static::Target(Machine::MasterSystem) {
-		if(needs_declare()) {
-			DeclareField(region);
-			AnnounceEnum(Region);
-		}
+	Target() : Analyser::Static::Target(Machine::MasterSystem) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(region);
+		AnnounceEnum(Region);
 	}
 };
 

Analyser/Static/StaticAnalyser.cpp

@@ -342,7 +342,11 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 			return;
 		}
 		auto new_targets = evaluator(media, file_name, potential_platforms);
-		std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));
+		targets.insert(
+			targets.end(),
+			std::make_move_iterator(new_targets.begin()),
+			std::make_move_iterator(new_targets.end())
+		);
 	};
 
 	append(TargetPlatform::Acorn, Acorn::GetTargets);

Analyser/Static/StaticAnalyser.hpp

@@ -64,7 +64,7 @@ struct Target {
 
 	Machine machine;
 	Media media;
-	float confidence = 0.0f;
+	float confidence = 0.5f;
 };
 typedef std::vector<std::unique_ptr<Target>> TargetList;
 

Analyser/Static/ZX8081/Target.hpp

@@ -27,13 +27,15 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	bool ZX80_uses_ZX81_ROM = false;
 	std::string loading_command;
 
-	Target(): Analyser::Static::Target(Machine::ZX8081) {
-		if(needs_declare()) {
-			DeclareField(memory_model);
-			DeclareField(is_ZX81);
-			DeclareField(ZX80_uses_ZX81_ROM);
-			AnnounceEnum(MemoryModel);
-		}
+	Target(): Analyser::Static::Target(Machine::ZX8081) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(memory_model);
+		DeclareField(is_ZX81);
+		DeclareField(ZX80_uses_ZX81_ROM);
+		AnnounceEnum(MemoryModel);
 	}
 };
 

Analyser/Static/ZXSpectrum/Target.hpp

@@ -27,11 +27,13 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	Model model = Model::Plus2;
 	bool should_hold_enter = false;
 
-	Target(): Analyser::Static::Target(Machine::ZXSpectrum) {
-		if(needs_declare()) {
-			DeclareField(model);
-			AnnounceEnum(Model);
-		}
+	Target(): Analyser::Static::Target(Machine::ZXSpectrum) {}
+
+private:
+	friend Reflection::StructImpl<Target>;
+	void declare_fields() {
+		DeclareField(model);
+		AnnounceEnum(Model);
 	}
 };
 

Components/AY38910/AY38910.hpp

@@ -223,13 +223,6 @@ struct State: public Reflection::StructImpl<State> {
 
 	// TODO: all audio-production thread state.
 
-	State() {
-		if(needs_declare()) {
-			DeclareField(registers);
-			DeclareField(selected_register);
-		}
-	}
-
 	template <typename AY> void apply(AY &target) {
 		// Establish emulator-thread state
 		for(uint8_t c = 0; c < 16; c++) {
@@ -238,6 +231,13 @@ struct State: public Reflection::StructImpl<State> {
 		}
 		target.select_register(selected_register);
 	}
+
+private:
+	friend Reflection::StructImpl<State>;
+	void declare_fields() {
+		DeclareField(registers);
+		DeclareField(selected_register);
+	}
 };
 
 }

Machines/Acorn/Archimedes/Archimedes.hpp

@@ -17,24 +17,25 @@
 
 namespace Archimedes {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> Archimedes(
-			const Analyser::Static::Target *target,
-			const ROMMachine::ROMFetcher &rom_fetcher
-		);
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> Archimedes(
+		const Analyser::Static::Target *target,
+		const ROMMachine::ROMFetcher &rom_fetcher
+	);
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_quickload_option();
-					}
-				}
-		};
+	class Options: public Reflection::StructImpl<Options>, public Configurable::QuickloadOption<Options> {
+		friend Configurable::QuickloadOption<Options>;
+	public:
+		Options(Configurable::OptionsType type) :
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_quickload_option();
+		}
+	};
 };
 
 }

Machines/Acorn/Electron/Electron.hpp

@@ -23,28 +23,31 @@ namespace Electron {
 	@discussion An instance of Electron::Machine represents the current state of an
 	Acorn Electron.
 */
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	/// Creates and returns an Electron.
+	static std::unique_ptr<Machine> Electron(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+
+	/// Defines the runtime options available for an Electron.
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
 
-		/// Creates and returns an Electron.
-		static std::unique_ptr<Machine> Electron(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		/// Defines the runtime options available for an Electron.
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_display_option();
-						declare_quickload_option();
-						limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, Configurable::Display::CompositeMonochrome, -1);
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			declare_quickload_option();
+			limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, Configurable::Display::CompositeMonochrome, -1);
+		}
+	};
 };
 
 }

Machines/Amiga/Amiga.hpp

@@ -15,12 +15,11 @@
 
 namespace Amiga {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
+struct Machine {
+	virtual ~Machine() = default;
 
-		/// Creates and returns an Amiga.
-		static std::unique_ptr<Machine> Amiga(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	/// Creates and returns an Amiga.
+	static std::unique_ptr<Machine> Amiga(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 };
 
 }

Machines/AmstradCPC/AmstradCPC.hpp

@@ -20,41 +20,44 @@ namespace AmstradCPC {
 /*!
 	Models an Amstrad CPC.
 */
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	/// Creates and returns an Amstrad CPC.
+	static std::unique_ptr<Machine> AmstradCPC(
+		const Analyser::Static::Target *target,
+		const ROMMachine::ROMFetcher &rom_fetcher
+	);
+
+	/// Defines the runtime options available for an Amstrad CPC.
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>,
+		public Configurable::QuickloadOption<Options>
+	{
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(Configurable::Display::RGB),
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
 
-		/// Creates and returns an Amstrad CPC.
-		static std::unique_ptr<Machine> AmstradCPC(
-			const Analyser::Static::Target *target,
-			const ROMMachine::ROMFetcher &rom_fetcher
-		);
+	private:
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
 
-		/// Defines the runtime options available for an Amstrad CPC.
-		class Options:
-			public Reflection::StructImpl<Options>,
-			public Configurable::DisplayOption<Options>,
-			public Configurable::QuickloadOption<Options>
-		{
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(Configurable::Display::RGB),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly)
-				{
-					if(needs_declare()) {
-						declare_display_option();
-						declare_quickload_option();
-						limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		struct SSMDelegate {
-			virtual void perform(uint16_t) = 0;
-		};
-		virtual void set_ssm_delegate(SSMDelegate *) = 0;
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			declare_quickload_option();
+			limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
+		}
+	};
+
+	struct SSMDelegate {
+		virtual void perform(uint16_t) = 0;
+	};
+	virtual void set_ssm_delegate(SSMDelegate *) = 0;
 };
 
 }

Machines/Apple/AppleII/AppleII.hpp

@@ -17,27 +17,30 @@
 
 namespace Apple::II {
 
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	/// Creates and returns an AppleII.
+	static std::unique_ptr<Machine> AppleII(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	/// Defines the runtime options available for an Apple II.
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
+		friend Configurable::DisplayOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		bool use_square_pixels = false;
 
-		/// Creates and returns an AppleII.
-		static std::unique_ptr<Machine> AppleII(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+		Options(Configurable::OptionsType) :
+			Configurable::DisplayOption<Options>(Configurable::Display::CompositeColour) {}
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		/// Defines the runtime options available for an Apple II.
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			public:
-				bool use_square_pixels = false;
-
-				Options(Configurable::OptionsType) : Configurable::DisplayOption<Options>(Configurable::Display::CompositeColour) {
-					if(needs_declare()) {
-						DeclareField(use_square_pixels);
-						declare_display_option();
-						limit_enum(&output, Configurable::Display::CompositeMonochrome, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			DeclareField(use_square_pixels);
+			declare_display_option();
+			limit_enum(&output, Configurable::Display::CompositeMonochrome, Configurable::Display::CompositeColour, -1);
+		}
+	};
 };
 
 }

Machines/Apple/AppleIIgs/AppleIIgs.hpp

@@ -17,12 +17,11 @@
 
 namespace Apple::IIgs {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
+struct Machine {
+	virtual ~Machine() = default;
 
-		/// Creates and returns an AppleIIgs.
-		static std::unique_ptr<Machine> AppleIIgs(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	/// Creates and returns an AppleIIgs.
+	static std::unique_ptr<Machine> AppleIIgs(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 };
 
 }

Machines/Apple/Macintosh/Macintosh.hpp

@@ -15,23 +15,25 @@
 
 namespace Apple::Macintosh {
 
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	/// Creates and returns a Macintosh.
+	static std::unique_ptr<Machine> Macintosh(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	class Options: public Reflection::StructImpl<Options>, public Configurable::QuickbootOption<Options> {
+		friend Configurable::QuickbootOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType type) :
+			Configurable::QuickbootOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		/// Creates and returns a Macintosh.
-		static std::unique_ptr<Machine> Macintosh(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
-
-		class Options: public Reflection::StructImpl<Options>, public Configurable::QuickbootOption<Options> {
-			friend Configurable::QuickbootOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::QuickbootOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_quickboot_option();
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_quickboot_option();
+		}
+	};
 };
 
 }

Machines/Atari/2600/Atari2600.hpp

@@ -21,8 +21,7 @@ namespace Atari2600 {
 /*!
 	Models an Atari 2600.
 */
-class Machine {
-public:
+struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Atari 2600 on the heap.

Machines/Atari/ST/AtariST.hpp

@@ -17,23 +17,27 @@
 
 namespace Atari::ST {
 
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	static std::unique_ptr<Machine> AtariST(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
+		friend Configurable::DisplayOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType type) : Configurable::DisplayOption<Options>(
+			type == Configurable::OptionsType::UserFriendly ?
+				Configurable::Display::RGB : Configurable::Display::CompositeColour) {}
 
-		static std::unique_ptr<Machine> AtariST(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) : Configurable::DisplayOption<Options>(
-					type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour) {
-					if(needs_declare()) {
-						declare_display_option();
-						limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
+		}
+	};
 };
 
 }

Machines/AudioProducer.hpp

@@ -15,10 +15,9 @@ namespace MachineTypes {
 /*!
 	An AudioProducer is any machine that **might** produce audio. This isn't always knowable statically.
 */
-class AudioProducer {
-	public:
-		/// @returns The speaker that receives this machine's output, or @c nullptr if this machine is mute.
-		virtual Outputs::Speaker::Speaker *get_speaker() = 0;
+struct AudioProducer {
+	/// @returns The speaker that receives this machine's output, or @c nullptr if this machine is mute.
+	virtual Outputs::Speaker::Speaker *get_speaker() = 0;
 };
 
 }

Machines/ColecoVision/ColecoVision.hpp

@@ -17,22 +17,26 @@
 
 namespace Coleco::Vision {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> ColecoVision(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> ColecoVision(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::SVideo : Configurable::Display::CompositeColour) {
-					if(needs_declare()) {
-						declare_display_option();
-						limit_enum(&output, Configurable::Display::SVideo, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
+		friend Configurable::DisplayOption<Options>;
+		public:
+			Options(Configurable::OptionsType type) :
+				Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ?
+					Configurable::Display::SVideo : Configurable::Display::CompositeColour) {}
+
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			limit_enum(&output, Configurable::Display::SVideo, Configurable::Display::CompositeColour, -1);
+		}
+	};
 };
 
 }

Machines/Commodore/Plus4/Plus4.cpp

@@ -0,0 +1,49 @@
+//
+//  Plus4.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 06/12/2024.
+//  Copyright © 2024 Thomas Harte. All rights reserved.
+//
+
+#include "Plus4.hpp"
+
+#include "../../MachineTypes.hpp"
+
+#include "../../../Analyser/Static/Commodore/Target.hpp"
+
+using namespace Commodore::Plus4;
+
+namespace {
+
+class ConcreteMachine:
+	public MachineTypes::TimedMachine,
+	public MachineTypes::ScanProducer,
+	public Machine {
+public:
+	ConcreteMachine(const Analyser::Static::Commodore::Target &target, const ROMMachine::ROMFetcher &rom_fetcher) {
+		(void)target;
+		(void)rom_fetcher;
+	}
+
+private:
+	void set_scan_target(Outputs::Display::ScanTarget *const) final {
+	}
+
+	Outputs::Display::ScanStatus get_scaled_scan_status() const final {
+		return {};
+	}
+
+	void run_for(const Cycles) final {
+	}
+};
+
+}
+std::unique_ptr<Machine> Machine::Plus4(
+	const Analyser::Static::Target *target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
+	using Target = Analyser::Static::Commodore::Target;
+	const Target *const commodore_target = dynamic_cast<const Target *>(target);
+	return std::make_unique<ConcreteMachine>(*commodore_target, rom_fetcher);
+}

Machines/Commodore/Plus4/Plus4.hpp

@@ -0,0 +1,24 @@
+//
+//  Plus4.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 06/12/2024.
+//  Copyright © 2024 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include "../../../Analyser/Static/StaticAnalyser.hpp"
+#include "../../ROMMachine.hpp"
+
+#include <memory>
+
+namespace Commodore::Plus4 {
+
+struct Machine {
+	virtual ~Machine() = default;
+
+	static std::unique_ptr<Machine> Plus4(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+};
+
+}

Machines/Commodore/Vic-20/Vic20.hpp

@@ -20,27 +20,35 @@ namespace Commodore::Vic20 {
 /// @returns The options available for a Vic-20.
 std::unique_ptr<Reflection::Struct> get_options();
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
+struct Machine {
+	virtual ~Machine() = default;
 
-		/// Creates and returns a Vic-20.
-		static std::unique_ptr<Machine> Vic20(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	/// Creates and returns a Vic-20.
+	static std::unique_ptr<Machine> Vic20(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::SVideo : Configurable::Display::CompositeColour),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_display_option();
-						declare_quickload_option();
-						limit_enum(&output, Configurable::Display::SVideo, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>,
+		public Configurable::QuickloadOption<Options>
+	{
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
+		public:
+			Options(Configurable::OptionsType type) :
+				Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ?
+					Configurable::Display::SVideo : Configurable::Display::CompositeColour),
+				Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
+			}
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			declare_quickload_option();
+			limit_enum(&output, Configurable::Display::SVideo, Configurable::Display::CompositeColour, -1);
+		}
+	};
 };
 
 }

Machines/Enterprise/Enterprise.hpp

@@ -23,23 +23,26 @@ namespace Enterprise {
 	@discussion An instance of Enterprise::Machine represents the current state of an
 	Elan Enterprise.
 */
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> Enterprise(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	/// Defines the runtime options available for an Enterprise.
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
+		friend Configurable::DisplayOption<Options>;
 	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> Enterprise(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour) {}
 
-		/// Defines the runtime options available for an Enterprise.
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour) {
-					if(needs_declare()) {
-						declare_display_option();
-						limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, Configurable::Display::CompositeMonochrome, -1);
-					}
-				}
-		};
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, Configurable::Display::CompositeMonochrome, -1);
+		}
+	};
 };
 
 };

Machines/JoystickMachine.hpp

@@ -13,9 +13,8 @@
 
 namespace MachineTypes {
 
-class JoystickMachine {
-	public:
-		virtual const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() = 0;
+struct JoystickMachine {
+	virtual const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() = 0;
 };
 
 }

Machines/KeyboardMachine.hpp

@@ -41,70 +41,75 @@ struct KeyActions {
 /*!
 	Describes an emulated machine which exposes a keyboard and accepts a typed string.
 */
-class KeyboardMachine: public KeyActions {
-	public:
-		/*!
-			Causes the machine to attempt to type the supplied string.
+struct KeyboardMachine: public KeyActions {
+	/*!
+		Causes the machine to attempt to type the supplied string.
 
-			This is best effort. Success or failure is permitted to be a function of machine and current state.
-		*/
-		virtual void type_string(const std::string &);
+		This is best effort. Success or failure is permitted to be a function of machine and current state.
+	*/
+	virtual void type_string(const std::string &);
 
-		/*!
-			@returns @c true if this machine can type the character @c c as part of a @c type_string; @c false otherwise.
-		*/
-		virtual bool can_type([[maybe_unused]] char c) const { return false; }
+	/*!
+		@returns @c true if this machine can type the character @c c as part of a @c type_string; @c false otherwise.
+	*/
+	virtual bool can_type([[maybe_unused]] char c) const { return false; }
 
-		/*!
-			Provides a destination for keyboard input.
-		*/
-		virtual Inputs::Keyboard &get_keyboard() = 0;
+	/*!
+		Provides a destination for keyboard input.
+	*/
+	virtual Inputs::Keyboard &get_keyboard() = 0;
 
-		/*!
-			Provides a standard bundle of logic for hosts that are able to correlate typed symbols
-			with keypresses. Specifically:
+	/*!
+		Provides a standard bundle of logic for hosts that are able to correlate typed symbols
+		with keypresses. Specifically:
 
-			If map_logically is false:
+		If map_logically is false:
 
-				(i) initially try to set @c key as @c is_pressed;
-				(ii) if this machine doesn't map @c key to anything but @c symbol is a printable ASCII character, attempt to @c type_string it.
+			(i) initially try to set @c key as @c is_pressed;
+			(ii) if this machine doesn't map @c key to anything but @c symbol is a printable ASCII character, attempt to @c type_string it.
 
-			If map_logically is true:
+		If map_logically is true:
 
-				(i) if @c symbol can be typed and this is a key down, @c type_string it;
-				(ii) if @c symbol cannot be typed, set @c key as @c is_pressed
-		*/
-		bool apply_key(Inputs::Keyboard::Key key, char symbol, bool is_pressed, bool is_repeat, bool map_logically) {
-			Inputs::Keyboard &keyboard = get_keyboard();
+			(i) if @c symbol can be typed and this is a key down, @c type_string it;
+			(ii) if @c symbol cannot be typed, set @c key as @c is_pressed
+	*/
+	bool apply_key(
+		const Inputs::Keyboard::Key key,
+		const char symbol,
+		const bool is_pressed,
+		const bool is_repeat,
+		const bool map_logically
+	) {
+		Inputs::Keyboard &keyboard = get_keyboard();
 
-			if(!map_logically) {
-				// Try a regular keypress first, and stop if that works.
-				if(keyboard.set_key_pressed(key, symbol, is_pressed, is_repeat)) {
-					return true;
-				}
-
-				// That having failed, if a symbol has been supplied then try typing it.
-				if(is_pressed && symbol && can_type(symbol)) {
-					char string[2] = { symbol, 0 };
-					type_string(string);
-					return true;
-				}
-
-				return false;
-			} else {
-				// Try to type first.
-				if(is_pressed && symbol && can_type(symbol)) {
-					char string[2] = { symbol, 0 };
-					type_string(string);
-					return true;
-				}
-
-				// That didn't work. Forward as a keypress. As, either:
-				//	(i) this is a key down, but doesn't have a symbol, or is an untypeable symbol; or
-				//	(ii) this is a key up, which it won't be an issue to miscommunicate.
-				return keyboard.set_key_pressed(key, symbol, is_pressed, is_repeat);
+		if(!map_logically) {
+			// Try a regular keypress first, and stop if that works.
+			if(keyboard.set_key_pressed(key, symbol, is_pressed, is_repeat)) {
+				return true;
 			}
+
+			// That having failed, if a symbol has been supplied then try typing it.
+			if(is_pressed && symbol && can_type(symbol)) {
+				char string[2] = { symbol, 0 };
+				type_string(string);
+				return true;
+			}
+
+			return false;
+		} else {
+			// Try to type first.
+			if(is_pressed && symbol && can_type(symbol)) {
+				char string[2] = { symbol, 0 };
+				type_string(string);
+				return true;
+			}
+
+			// That didn't work. Forward as a keypress. As, either:
+			//	(i) this is a key down, but doesn't have a symbol, or is an untypeable symbol; or
+			//	(ii) this is a key up, which it won't be an issue to miscommunicate.
+			return keyboard.set_key_pressed(key, symbol, is_pressed, is_repeat);
 		}
+	}
 };
 
 /*!
@@ -119,9 +124,8 @@ public:
 		A keyboard mapper attempts to provide a physical mapping between host keys and emulated keys.
 		See the character mapper for logical mapping.
 	*/
-	class KeyboardMapper {
-		public:
-			virtual uint16_t mapped_key_for_key(Inputs::Keyboard::Key key) const = 0;
+	struct KeyboardMapper {
+		virtual uint16_t mapped_key_for_key(Inputs::Keyboard::Key) const = 0;
 	};
 
 	/// Terminates a key sequence from the character mapper.
@@ -146,8 +150,8 @@ public:
 	virtual Inputs::Keyboard &get_keyboard() override;
 
 private:
-	bool keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) override;
-	void reset_all_keys(Inputs::Keyboard *keyboard) override;
+	bool keyboard_did_change_key(Inputs::Keyboard *, Inputs::Keyboard::Key, bool is_pressed) override;
+	void reset_all_keys(Inputs::Keyboard *) override;
 	Inputs::Keyboard keyboard_;
 };
 

Machines/MSX/MSX.hpp

@@ -17,24 +17,31 @@
 
 namespace MSX {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> MSX(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> MSX(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_display_option();
-						declare_quickload_option();
-					}
-				}
-		};
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>,
+		public Configurable::QuickloadOption<Options>
+	{
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
+	public:
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
+
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			declare_quickload_option();
+		}
+	};
 };
 
 }

Machines/MasterSystem/MasterSystem.hpp

@@ -17,21 +17,25 @@
 
 namespace Sega::MasterSystem {
 
-class Machine {
-	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> MasterSystem(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> MasterSystem(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour) {
-					if(needs_declare()) {
-						declare_display_option();
-					}
-				}
-		};
+	class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options> {
+		friend Configurable::DisplayOption<Options>;
+		public:
+			Options(Configurable::OptionsType type) :
+				Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ?
+					Configurable::Display::RGB : Configurable::Display::CompositeColour) {}
+
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
+
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+		}
+	};
 };
 
 }

Machines/MediaTarget.hpp

@@ -18,14 +18,13 @@ namespace MachineTypes {
 /*!
 	A MediaTarget::Machine is anything that can accept new media while running.
 */
-class MediaTarget {
-	public:
-		/*!
-			Requests that the machine insert @c media as a modification to current state
+struct MediaTarget {
+	/*!
+		Requests that the machine insert @c media as a modification to current state
 
-			@returns @c true if any media was inserted; @c false otherwise.
-		*/
-		virtual bool insert_media(const Analyser::Static::Media &media) = 0;
+		@returns @c true if any media was inserted; @c false otherwise.
+	*/
+	virtual bool insert_media(const Analyser::Static::Media &) = 0;
 };
 
 }

Machines/MouseMachine.hpp

@@ -12,10 +12,9 @@
 
 namespace MachineTypes {
 
-class MouseMachine {
-	public:
-		// TODO: support multiple mice?
-		virtual Inputs::Mouse &get_mouse() = 0;
+struct MouseMachine {
+	// TODO: support multiple mice?
+	virtual Inputs::Mouse &get_mouse() = 0;
 };
 
 }

Machines/Oric/Oric.hpp

@@ -20,26 +20,32 @@ namespace Oric {
 /*!
 	Models an Oric 1/Atmos with or without a Microdisc.
 */
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> Oric(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>,
+		public Configurable::QuickloadOption<Options>
+	{
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ?
+				Configurable::Display::RGB : Configurable::Display::CompositeColour),
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {}
 
-		/// Creates and returns an Oric.
-		static std::unique_ptr<Machine> Oric(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly) {
-					if(needs_declare()) {
-						declare_display_option();
-						declare_quickload_option();
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			declare_quickload_option();
+		}
+	};
 };
 
 }

Machines/PCCompatible/PCCompatible.hpp

@@ -18,32 +18,34 @@ namespace PCCompatible {
 /*!
 	Models a PC compatible.
 */
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+
+	/// Creates and returns a PC Compatible.
+	static std::unique_ptr<Machine> PCCompatible(
+		const Analyser::Static::Target *target,
+		const ROMMachine::ROMFetcher &rom_fetcher
+	);
+
+	/// Defines the runtime options [sometimes] available for a PC.
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>
+	{
+		friend Configurable::DisplayOption<Options>;
 	public:
-		virtual ~Machine() = default;
+		Options(Configurable::OptionsType) :
+			Configurable::DisplayOption<Options>(Configurable::Display::RGB) {}
 
-		/// Creates and returns a PC Compatible.
-		static std::unique_ptr<Machine> PCCompatible(
-			const Analyser::Static::Target *target,
-			const ROMMachine::ROMFetcher &rom_fetcher
-		);
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-		/// Defines the runtime options [sometimes] available for a PC.
-		class Options:
-			public Reflection::StructImpl<Options>,
-			public Configurable::DisplayOption<Options>
-		{
-			friend Configurable::DisplayOption<Options>;
-			public:
-				Options(Configurable::OptionsType) :
-					Configurable::DisplayOption<Options>(Configurable::Display::RGB)
-				{
-					if(needs_declare()) {
-						declare_display_option();
-						limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			declare_display_option();
+			limit_enum(&output, Configurable::Display::RGB, Configurable::Display::CompositeColour, -1);
+		}
+	};
 };
 
 }

Machines/ROMMachine.hpp

@@ -27,10 +27,10 @@ namespace ROMMachine {
 	return a vector of unique_ptrs that either contain the contents of the ROM from @c names that corresponds by
 	index, or else are @c nullptr.
 */
-typedef std::function<ROM::Map(const ROM::Request &request)> ROMFetcher;
+typedef std::function<ROM::Map(const ROM::Request &)> ROMFetcher;
 
 enum class Error {
-	MissingROMs
+	MissingROMs,
 };
 
 }

Machines/ScanProducer.hpp

@@ -20,82 +20,82 @@ namespace MachineTypes {
 	by a ScanTarget.
 */
 class ScanProducer {
-	public:
-		/*!
-			Causes the machine to set up its display and, if it has one, speaker.
+public:
+	/*!
+		Causes the machine to set up its display and, if it has one, speaker.
 
-			The @c scan_target will receive all video output; the caller guarantees
-			that it is non-null.
-		*/
-		virtual void set_scan_target(Outputs::Display::ScanTarget *scan_target) = 0;
+		The @c scan_target will receive all video output; the caller guarantees
+		that it is non-null.
+	*/
+	virtual void set_scan_target(Outputs::Display::ScanTarget *) = 0;
 
-		/*!
-			@returns The current scan status.
-		*/
-		virtual Outputs::Display::ScanStatus get_scan_status() const {
-			// There's an implicit assumption here that anything which produces scans
-			// is also a timed machine. And, also, that this function will be called infrequently.
-			const TimedMachine *timed_machine = dynamic_cast<const TimedMachine *>(this);
-			return get_scaled_scan_status() / float(timed_machine->get_clock_rate());
+	/*!
+		@returns The current scan status.
+	*/
+	virtual Outputs::Display::ScanStatus get_scan_status() const {
+		// There's an implicit assumption here that anything which produces scans
+		// is also a timed machine. And, also, that this function will be called infrequently.
+		const TimedMachine *timed_machine = dynamic_cast<const TimedMachine *>(this);
+		return get_scaled_scan_status() / float(timed_machine->get_clock_rate());
+	}
+
+protected:
+	virtual Outputs::Display::ScanStatus get_scaled_scan_status() const {
+		// This deliberately sets up an infinite loop if the user hasn't
+		// overridden at least one of this or get_scan_status.
+		//
+		// Most likely you want to override this, and let the base class
+		// throw in a divide-by-clock-rate at the end for you.
+		return get_scan_status();
+	}
+
+	/*!
+		Maps from Configurable::Display to Outputs::Display::VideoSignal and calls
+		@c set_display_type with the result.
+	*/
+	void set_video_signal_configurable(const Configurable::Display type) {
+		Outputs::Display::DisplayType display_type;
+		switch(type) {
+			default:
+			case Configurable::Display::RGB:
+				display_type = Outputs::Display::DisplayType::RGB;
+			break;
+			case Configurable::Display::SVideo:
+				display_type = Outputs::Display::DisplayType::SVideo;
+			break;
+			case Configurable::Display::CompositeColour:
+				display_type = Outputs::Display::DisplayType::CompositeColour;
+			break;
+			case Configurable::Display::CompositeMonochrome:
+				display_type = Outputs::Display::DisplayType::CompositeMonochrome;
+			break;
 		}
+		set_display_type(display_type);
+	}
 
-	protected:
-		virtual Outputs::Display::ScanStatus get_scaled_scan_status() const {
-			// This deliberately sets up an infinite loop if the user hasn't
-			// overridden at least one of this or get_scan_status.
-			//
-			// Most likely you want to override this, and let the base class
-			// throw in a divide-by-clock-rate at the end for you.
-			return get_scan_status();
+	/*!
+		Maps back from Outputs::Display::VideoSignal to Configurable::Display,
+		calling @c get_display_type for the input.
+	*/
+	Configurable::Display get_video_signal_configurable() const {
+		switch(get_display_type()) {
+			default:
+			case Outputs::Display::DisplayType::RGB:					return Configurable::Display::RGB;
+			case Outputs::Display::DisplayType::SVideo:					return Configurable::Display::SVideo;
+			case Outputs::Display::DisplayType::CompositeColour:		return Configurable::Display::CompositeColour;
+			case Outputs::Display::DisplayType::CompositeMonochrome:	return Configurable::Display::CompositeMonochrome;
 		}
+	}
 
-		/*!
-			Maps from Configurable::Display to Outputs::Display::VideoSignal and calls
-			@c set_display_type with the result.
-		*/
-		void set_video_signal_configurable(Configurable::Display type) {
-			Outputs::Display::DisplayType display_type;
-			switch(type) {
-				default:
-				case Configurable::Display::RGB:
-					display_type = Outputs::Display::DisplayType::RGB;
-				break;
-				case Configurable::Display::SVideo:
-					display_type = Outputs::Display::DisplayType::SVideo;
-				break;
-				case Configurable::Display::CompositeColour:
-					display_type = Outputs::Display::DisplayType::CompositeColour;
-				break;
-				case Configurable::Display::CompositeMonochrome:
-					display_type = Outputs::Display::DisplayType::CompositeMonochrome;
-				break;
-			}
-			set_display_type(display_type);
-		}
+	/*!
+		Sets the display type.
+	*/
+	virtual void set_display_type(Outputs::Display::DisplayType) {}
 
-		/*!
-			Maps back from Outputs::Display::VideoSignal to Configurable::Display,
-			calling @c get_display_type for the input.
-		*/
-		Configurable::Display get_video_signal_configurable() const {
-			switch(get_display_type()) {
-				default:
-				case Outputs::Display::DisplayType::RGB:					return Configurable::Display::RGB;
-				case Outputs::Display::DisplayType::SVideo:					return Configurable::Display::SVideo;
-				case Outputs::Display::DisplayType::CompositeColour:		return Configurable::Display::CompositeColour;
-				case Outputs::Display::DisplayType::CompositeMonochrome:	return Configurable::Display::CompositeMonochrome;
-			}
-		}
-
-		/*!
-			Sets the display type.
-		*/
-		virtual void set_display_type(Outputs::Display::DisplayType) {}
-
-		/*!
-			Gets the display type.
-		*/
-		virtual Outputs::Display::DisplayType get_display_type() const { return Outputs::Display::DisplayType::RGB; }
+	/*!
+		Gets the display type.
+	*/
+	virtual Outputs::Display::DisplayType get_display_type() const { return Outputs::Display::DisplayType::RGB; }
 };
 
 }

Machines/Sinclair/ZX8081/ZX8081.hpp

@@ -18,31 +18,32 @@
 namespace Sinclair::ZX8081 {
 
 /// The ZX80/81 machine.
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> ZX8081(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+
+	virtual void set_tape_is_playing(bool is_playing) = 0;
+	virtual bool get_tape_is_playing() = 0;
+
+	/// Defines the runtime options available for a ZX80/81.
+	class Options: public Reflection::StructImpl<Options>, public Configurable::QuickloadOption<Options> {
+		friend Configurable::QuickloadOption<Options>;
 	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> ZX8081(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+		bool automatic_tape_motor_control = true;
 
-		virtual void set_tape_is_playing(bool is_playing) = 0;
-		virtual bool get_tape_is_playing() = 0;
+		Options(Configurable::OptionsType type):
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly),
+			automatic_tape_motor_control(type == Configurable::OptionsType::UserFriendly) {}
 
-		/// Defines the runtime options available for a ZX80/81.
-		class Options: public Reflection::StructImpl<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				bool automatic_tape_motor_control = true;
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-				Options(Configurable::OptionsType type):
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly),
-					automatic_tape_motor_control(type == Configurable::OptionsType::UserFriendly) {
-
-					// Declare fields if necessary.
-					if(needs_declare()) {
-						DeclareField(automatic_tape_motor_control);
-						declare_quickload_option();
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			DeclareField(automatic_tape_motor_control);
+			declare_quickload_option();
+		}
+	};
 };
 
 }

Machines/Sinclair/ZXSpectrum/State.hpp

@@ -32,15 +32,15 @@ struct State: public Reflection::StructImpl<State> {
 	// Meaningful for the +2a and +3 only.
 	uint8_t last_1ffd = 0;
 
-	State() {
-		if(needs_declare()) {
-			DeclareField(z80);
-			DeclareField(video);
-			DeclareField(ram);
-			DeclareField(last_7ffd);
-			DeclareField(last_1ffd);
-			DeclareField(ay);
-		}
+private:
+	friend Reflection::StructImpl<State>;
+	void declare_fields() {
+		DeclareField(z80);
+		DeclareField(video);
+		DeclareField(ram);
+		DeclareField(last_7ffd);
+		DeclareField(last_1ffd);
+		DeclareField(ay);
 	}
 };
 

Machines/Sinclair/ZXSpectrum/Video.hpp

@@ -455,15 +455,7 @@ struct State: public Reflection::StructImpl<State> {
 	int flash_counter = 0;
 	bool is_alternate_line = false;
 
-	State() {
-		if(needs_declare()) {
-			DeclareField(border_colour);
-			DeclareField(half_cycles_since_interrupt);
-			DeclareField(flash);
-			DeclareField(flash_counter);
-			DeclareField(is_alternate_line);
-		}
-	}
+	State() {}
 
 	template <typename Video> State(const Video &source) : State() {
 		border_colour = source.border_byte_;
@@ -480,6 +472,16 @@ struct State: public Reflection::StructImpl<State> {
 		target.is_alternate_line_ = is_alternate_line;
 		target.set_time_since_interrupt(HalfCycles(half_cycles_since_interrupt));
 	}
+
+private:
+	friend Reflection::StructImpl<State>;
+	void declare_fields() {
+		DeclareField(border_colour);
+		DeclareField(half_cycles_since_interrupt);
+		DeclareField(flash);
+		DeclareField(flash_counter);
+		DeclareField(is_alternate_line);
+	}
 };
 
 }

Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp

@@ -17,32 +17,38 @@
 
 namespace Sinclair::ZXSpectrum {
 
-class Machine {
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> ZXSpectrum(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+
+	virtual void set_tape_is_playing(bool is_playing) = 0;
+	virtual bool get_tape_is_playing() = 0;
+
+	class Options:
+		public Reflection::StructImpl<Options>,
+		public Configurable::DisplayOption<Options>,
+		public Configurable::QuickloadOption<Options>
+	{
+		friend Configurable::DisplayOption<Options>;
+		friend Configurable::QuickloadOption<Options>;
 	public:
-		virtual ~Machine() = default;
-		static std::unique_ptr<Machine> ZXSpectrum(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+		bool automatic_tape_motor_control = true;
 
-		virtual void set_tape_is_playing(bool is_playing) = 0;
-		virtual bool get_tape_is_playing() = 0;
+		Options(Configurable::OptionsType type) :
+			Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
+			Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly),
+			automatic_tape_motor_control(type == Configurable::OptionsType::UserFriendly) {}
 
-		class Options: public Reflection::StructImpl<Options>, public Configurable::DisplayOption<Options>, public Configurable::QuickloadOption<Options> {
-			friend Configurable::DisplayOption<Options>;
-			friend Configurable::QuickloadOption<Options>;
-			public:
-				bool automatic_tape_motor_control = true;
+	private:
+		Options() : Options(Configurable::OptionsType::UserFriendly) {}
 
-				Options(Configurable::OptionsType type) :
-					Configurable::DisplayOption<Options>(type == Configurable::OptionsType::UserFriendly ? Configurable::Display::RGB : Configurable::Display::CompositeColour),
-					Configurable::QuickloadOption<Options>(type == Configurable::OptionsType::UserFriendly),
-					automatic_tape_motor_control(type == Configurable::OptionsType::UserFriendly)
-				{
-					if(needs_declare()) {
-						DeclareField(automatic_tape_motor_control);
-						declare_display_option();
-						declare_quickload_option();
-					}
-				}
-		};
+		friend Reflection::StructImpl<Options>;
+		void declare_fields() {
+			DeclareField(automatic_tape_motor_control);
+			declare_display_option();
+			declare_quickload_option();
+		}
+	};
 };
 
 }

Machines/TimedMachine.hpp

@@ -25,7 +25,7 @@ namespace MachineTypes {
 class TimedMachine {
 public:
 	/// Runs the machine for @c duration seconds.
-	virtual void run_for(Time::Seconds duration) {
+	virtual void run_for(const Time::Seconds duration) {
 		const double cycles = (duration * clock_rate_ * speed_multiplier_) + clock_conversion_error_;
 		clock_conversion_error_ = std::fmod(cycles, 1.0);
 		run_for(Cycles(int(cycles)));
@@ -36,7 +36,7 @@ public:
 		emulated machine to run 50% faster than a real machine. This speed-up is an emulation
 		fiction: it will apply across the system, including to the CRT.
 	*/
-	virtual void set_speed_multiplier(double multiplier) {
+	virtual void set_speed_multiplier(const double multiplier) {
 		if(speed_multiplier_ == multiplier) {
 			return;
 		}
@@ -75,10 +75,10 @@ public:
 
 protected:
 	/// Runs the machine for @c cycles.
-	virtual void run_for(const Cycles cycles) = 0;
+	virtual void run_for(const Cycles) = 0;
 
 	/// Sets this machine's clock rate.
-	void set_clock_rate(double clock_rate) {
+	void set_clock_rate(const double clock_rate) {
 		clock_rate_ = clock_rate;
 	}
 

Machines/Utility/MachineForTarget.cpp

@@ -21,6 +21,7 @@
 #include "../Atari/2600/Atari2600.hpp"
 #include "../Atari/ST/AtariST.hpp"
 #include "../ColecoVision/ColecoVision.hpp"
+#include "../Commodore/Plus4/Plus4.hpp"
 #include "../Commodore/Vic-20/Vic20.hpp"
 #include "../Enterprise/Enterprise.hpp"
 #include "../MasterSystem/MasterSystem.hpp"
@@ -68,6 +69,7 @@ std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTarget(const Analyse
 			Bind(Atari2600)
 			BindD(Atari::ST, AtariST)
 			BindD(Coleco::Vision, ColecoVision)
+			BindD(Commodore::Plus4, Plus4)
 			BindD(Commodore::Vic20, Vic20)
 			Bind(Electron)
 			Bind(Enterprise)
@@ -145,6 +147,7 @@ std::string Machine::ShortNameForTargetMachine(const Analyser::Machine machine)
 		case Analyser::Machine::MasterSystem:	return "MasterSystem";
 		case Analyser::Machine::MSX:			return "MSX";
 		case Analyser::Machine::Oric:			return "Oric";
+		case Analyser::Machine::Plus4:			return "Plus4";
 		case Analyser::Machine::PCCompatible:	return "PCCompatible";
 		case Analyser::Machine::Vic20:			return "Vic20";
 		case Analyser::Machine::ZX8081:			return "ZX8081";
@@ -170,6 +173,7 @@ std::string Machine::LongNameForTargetMachine(Analyser::Machine machine) {
 		case Analyser::Machine::MasterSystem:	return "Sega Master System";
 		case Analyser::Machine::MSX:			return "MSX";
 		case Analyser::Machine::Oric:			return "Oric";
+		case Analyser::Machine::Plus4:			return "Commodore C16+4";
 		case Analyser::Machine::PCCompatible:	return "PC Compatible";
 		case Analyser::Machine::Vic20:			return "Vic 20";
 		case Analyser::Machine::ZX8081:			return "ZX80/81";
@@ -202,6 +206,7 @@ std::vector<std::string> Machine::AllMachines(Type type, bool long_names) {
 		AddName(Macintosh);
 		AddName(MSX);
 		AddName(Oric);
+		AddName(Plus4);
 		AddName(PCCompatible);
 		AddName(Vic20);
 		AddName(ZX8081);
@@ -230,6 +235,7 @@ std::map<std::string, std::unique_ptr<Reflection::Struct>> Machine::AllOptionsBy
 	Emplace(MasterSystem, Sega::MasterSystem::Machine);
 	Emplace(MSX, MSX::Machine);
 	Emplace(Oric, Oric::Machine);
+//	Emplace(Plus4, Commodore::Plus4::Machine);		// There are no options yet.
 	Emplace(PCCompatible, PCCompatible::Machine);
 	Emplace(Vic20, Commodore::Vic20::Machine);
 	Emplace(ZX8081, Sinclair::ZX8081::Machine);
@@ -258,6 +264,7 @@ std::map<std::string, std::unique_ptr<Analyser::Static::Target>> Machine::Target
 	Add(Macintosh);
 	Add(MSX);
 	Add(Oric);
+	AddMapped(Plus4, Commodore);
 	Add(PCCompatible);
 	AddMapped(Vic20, Commodore);
 	Add(ZX8081);

OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj

@@ -385,6 +385,9 @@
 		4B59199C1DAC6C46005BB85C /* OricTAP.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B59199A1DAC6C46005BB85C /* OricTAP.cpp */; };
 		4B595FAD2086DFBA0083CAA8 /* AudioToggle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B595FAC2086DFBA0083CAA8 /* AudioToggle.cpp */; };
 		4B595FAE2086DFBA0083CAA8 /* AudioToggle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B595FAC2086DFBA0083CAA8 /* AudioToggle.cpp */; };
+		4B596EB22D037E8800FBF4B1 /* Plus4.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B596EB02D037E8800FBF4B1 /* Plus4.cpp */; };
+		4B596EB32D037E8800FBF4B1 /* Plus4.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B596EB02D037E8800FBF4B1 /* Plus4.cpp */; };
+		4B596EB42D04B8C700FBF4B1 /* Plus4.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B596EB02D037E8800FBF4B1 /* Plus4.cpp */; };
 		4B5B37312777C7FC0047F238 /* IPF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5B372F2777C7FC0047F238 /* IPF.cpp */; };
 		4B5B37322777C7FC0047F238 /* IPF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5B372F2777C7FC0047F238 /* IPF.cpp */; };
 		4B5D497C28513F870076E2F9 /* IPF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5B372F2777C7FC0047F238 /* IPF.cpp */; };
@@ -565,7 +568,6 @@
 		4B778F5E23A5F3230000D260 /* Oric.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805F91DCFF807003085B1 /* Oric.cpp */; };
 		4B778F6023A5F3460000D260 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944EC201967B4007DE474 /* Disk.cpp */; };
 		4B778F6123A5F3560000D260 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; };
-		4B778F6223A5F35F0000D260 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; };
 		4B778F6323A5F3630000D260 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; };
 		4B7962A02819681F008130F9 /* Decoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B79629F2819681F008130F9 /* Decoder.cpp */; };
 		4B7962A12819681F008130F9 /* Decoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B79629F2819681F008130F9 /* Decoder.cpp */; };
@@ -639,8 +641,6 @@
 		4B894527201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FA201967B4007DE474 /* StaticAnalyser.cpp */; };
 		4B894528201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; };
 		4B894529201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; };
-		4B89452A201967B4007DE474 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; };
-		4B89452B201967B4007DE474 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; };
 		4B89452C201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; };
 		4B89452D201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; };
 		4B89452E201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894503201967B4007DE474 /* StaticAnalyser.cpp */; };
@@ -1602,6 +1602,8 @@
 		4B59199B1DAC6C46005BB85C /* OricTAP.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = OricTAP.hpp; sourceTree = "<group>"; };
 		4B595FAB2086DFBA0083CAA8 /* AudioToggle.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = AudioToggle.hpp; sourceTree = "<group>"; };
 		4B595FAC2086DFBA0083CAA8 /* AudioToggle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AudioToggle.cpp; sourceTree = "<group>"; };
+		4B596EAF2D037E8800FBF4B1 /* Plus4.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Plus4.hpp; sourceTree = "<group>"; };
+		4B596EB02D037E8800FBF4B1 /* Plus4.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Plus4.cpp; sourceTree = "<group>"; };
 		4B5B372F2777C7FC0047F238 /* IPF.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = IPF.cpp; sourceTree = "<group>"; };
 		4B5B37302777C7FC0047F238 /* IPF.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = IPF.hpp; sourceTree = "<group>"; };
 		4B5D5C9525F56FC7001B4623 /* Spectrum.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Spectrum.cpp; path = Parsers/Spectrum.cpp; sourceTree = "<group>"; };
@@ -1756,7 +1758,6 @@
 		4B8944FD201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = "<group>"; };
 		4B8944FE201967B4007DE474 /* File.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = File.hpp; sourceTree = "<group>"; };
 		4B8944FF201967B4007DE474 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = "<group>"; };
-		4B894500201967B4007DE474 /* File.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = File.cpp; sourceTree = "<group>"; };
 		4B894501201967B4007DE474 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = "<group>"; };
 		4B894502201967B4007DE474 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Disk.hpp; sourceTree = "<group>"; };
 		4B894503201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = "<group>"; };
@@ -3273,10 +3274,11 @@
 		4B4DC81D1D2C2425003C5BF8 /* Commodore */ = {
 			isa = PBXGroup;
 			children = (
-				4B4DC8251D2C2470003C5BF8 /* 1540 */,
-				4B4DC81E1D2C2425003C5BF8 /* Vic-20 */,
 				4B4DC8291D2C27A4003C5BF8 /* SerialBus.cpp */,
 				4B4DC82A1D2C27A4003C5BF8 /* SerialBus.hpp */,
+				4B4DC8251D2C2470003C5BF8 /* 1540 */,
+				4B596EB12D037E8800FBF4B1 /* Plus4 */,
+				4B4DC81E1D2C2425003C5BF8 /* Vic-20 */,
 			);
 			path = Commodore;
 			sourceTree = "<group>";
@@ -3386,6 +3388,15 @@
 			path = AudioToggle;
 			sourceTree = "<group>";
 		};
+		4B596EB12D037E8800FBF4B1 /* Plus4 */ = {
+			isa = PBXGroup;
+			children = (
+				4B596EAF2D037E8800FBF4B1 /* Plus4.hpp */,
+				4B596EB02D037E8800FBF4B1 /* Plus4.cpp */,
+			);
+			path = Plus4;
+			sourceTree = "<group>";
+		};
 		4B643F3B1D77AD6D00D431D6 /* StaticAnalyser */ = {
 			isa = PBXGroup;
 			children = (
@@ -3810,7 +3821,6 @@
 			isa = PBXGroup;
 			children = (
 				4B8944FC201967B4007DE474 /* Disk.cpp */,
-				4B894500201967B4007DE474 /* File.cpp */,
 				4B894503201967B4007DE474 /* StaticAnalyser.cpp */,
 				4B894501201967B4007DE474 /* Tape.cpp */,
 				4B894502201967B4007DE474 /* Disk.hpp */,
@@ -6006,7 +6016,6 @@
 				4B055AA31FAE85DF0060FFFF /* ImplicitSectors.cpp in Sources */,
 				4B8318B322D3E540006DB630 /* Audio.cpp in Sources */,
 				4B055AAE1FAE85FD0060FFFF /* TrackSerialiser.cpp in Sources */,
-				4B89452B201967B4007DE474 /* File.cpp in Sources */,
 				4B6AAEAC230E40250078E864 /* SCSI.cpp in Sources */,
 				4B055A981FAE85C50060FFFF /* Drive.cpp in Sources */,
 				4BD424E62193B5830097291A /* Shader.cpp in Sources */,
@@ -6143,6 +6152,7 @@
 				4B8318B822D3E566006DB630 /* IWM.cpp in Sources */,
 				4B0333B02094081A0050B93D /* AppleDSK.cpp in Sources */,
 				4B055AD41FAE9B0B0060FFFF /* Oric.cpp in Sources */,
+				4B596EB22D037E8800FBF4B1 /* Plus4.cpp in Sources */,
 				4B055A921FAE85B50060FFFF /* PRG.cpp in Sources */,
 				4B055AAF1FAE85FD0060FFFF /* UnformattedTrack.cpp in Sources */,
 				4B055A7E1FAE84AA0060FFFF /* main.cpp in Sources */,
@@ -6249,6 +6259,7 @@
 				4B051C97266EF5F600CA44E8 /* CSAppleII.mm in Sources */,
 				4B0ACC2A23775819008902D0 /* Video.cpp in Sources */,
 				4B54C0BF1F8D8F450050900F /* Keyboard.cpp in Sources */,
+				4B596EB32D037E8800FBF4B1 /* Plus4.cpp in Sources */,
 				4B3FE75E1F3CF68B00448EE4 /* CPM.cpp in Sources */,
 				423820112B17CBC800964EFE /* StaticAnalyser.cpp in Sources */,
 				4BC6236D26F4235400F83DFE /* Copper.cpp in Sources */,
@@ -6331,7 +6342,6 @@
 				4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */,
 				4BCD634922D6756400F567F1 /* MacintoshDoubleDensityDrive.cpp in Sources */,
 				4B0F94FE208C1A1600FE41D9 /* NIB.cpp in Sources */,
-				4B89452A201967B4007DE474 /* File.cpp in Sources */,
 				4BC080D026A257A200D03FD8 /* StaticAnalyser.cpp in Sources */,
 				4B4DC8211D2C2425003C5BF8 /* Vic20.cpp in Sources */,
 				4B71368E1F788112008B8ED9 /* Parser.cpp in Sources */,
@@ -6448,6 +6458,7 @@
 			files = (
 				4B06AAEA2C645FDD0034D014 /* Bus.cpp in Sources */,
 				4B778EF623A5EB600000D260 /* WOZ.cpp in Sources */,
+				4B596EB42D04B8C700FBF4B1 /* Plus4.cpp in Sources */,
 				42EB812F2B4700B800429AF4 /* MemoryMap.cpp in Sources */,
 				4B778F1423A5EC960000D260 /* Z80Storage.cpp in Sources */,
 				4B778F1F23A5EDC70000D260 /* Audio.cpp in Sources */,
@@ -6581,7 +6592,6 @@
 				4BEDA3BB25B25563000C2DBD /* Decoder.cpp in Sources */,
 				4B778F2423A5EDEE0000D260 /* PRG.cpp in Sources */,
 				4B778F5A23A5F2D50000D260 /* 6502.cpp in Sources */,
-				4B778F6223A5F35F0000D260 /* File.cpp in Sources */,
 				4B06AB0F2C6461780034D014 /* MultiProducer.cpp in Sources */,
 				4B778F3523A5F1040000D260 /* SCSI.cpp in Sources */,
 				4BD388882239E198002D14B5 /* 68000Tests.mm in Sources */,

OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme

@@ -24,8 +24,8 @@
    </BuildAction>
    <TestAction
       buildConfiguration = "Debug"
-      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
-      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      selectedDebuggerIdentifier = ""
+      selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
       shouldUseLaunchSchemeArgsEnv = "YES"
       disableMainThreadChecker = "YES"
       codeCoverageEnabled = "YES">

OSBindings/Mac/Clock SignalTests/CommodoreStaticAnalyserTests.mm

@@ -12,6 +12,8 @@
 #include "../../../Analyser/Static/StaticAnalyser.hpp"
 #include "../../../Analyser/Static/Commodore/Target.hpp"
 
+#include <atomic>
+
 // This test runs through a whole bunch of files somewhere on disk. These files are not included in the repository
 // because they are not suitably licensed. So this path is specific to my local system, at the time I happen to be
 // writing these tests. Update in the future, as necessary.
@@ -37,30 +39,50 @@ struct HitRate {
 @implementation CommodoreStaticAnalyserTests
 
 - (HitRate)hitRateBeneathPath:(NSString *)path forMachine:(Analyser::Machine)machine {
-	HitRate hits{};
+	__block std::atomic<int> files_source = 0;
+	__block std::atomic<int> matches_source = 0;
+	auto &files = files_source;
+	auto &matches = matches_source;
 
 	NSDirectoryEnumerator<NSString *> *enumerator = [[NSFileManager defaultManager] enumeratorAtPath:path];
+	NSMutableArray<NSString *> *items = [[NSMutableArray alloc] init];
 	while(NSString *diskItem = [enumerator nextObject]) {
-		const NSString *type = [[enumerator fileAttributes] objectForKey:NSFileType];
-		if(![type isEqual:NSFileTypeRegular]) {
-			continue;
-		}
-
-		const auto list = Analyser::Static::GetTargets([path stringByAppendingPathComponent:diskItem].UTF8String);
-		if(list.empty()) {
-			continue;
-		}
-
-		++hits.files;
-		if(list.size() != 1) {
-			continue;
-		}
-
-		const auto &first = *list.begin();
-		hits.matches += first->machine == machine;
+		[items addObject:[path stringByAppendingPathComponent:diskItem]];
 	}
 
-	return hits;
+	static constexpr int BatchSize = 10;
+	dispatch_apply(
+		([items count] + BatchSize - 1) / BatchSize,
+		dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0),
+		^(size_t iteration) {
+
+		const auto base = iteration * BatchSize;
+		for(size_t index = base; index < base + BatchSize && index < [items count]; index++) {
+			NSString *const fullPath = [items objectAtIndex:index];
+
+			NSLog(@"Starting %@", fullPath);
+			const auto list = Analyser::Static::GetTargets(fullPath.UTF8String);
+			NSLog(@"Ending %@", fullPath);
+			if(list.empty()) {
+				return;
+			}
+
+			++files;
+			if(list.size() != 1) {
+				return;
+			}
+
+			const auto &first = *list.begin();
+			matches += first->machine == machine;
+		}
+		NSLog(@"Currently %d in %d, i.e. %0.2f",
+			matches.load(), files.load(), float(matches.load()) / float(files.load()));
+	});
+
+	return HitRate {
+		.files = files,
+		.matches = matches,
+	};
 }
 
 - (void)testPlus4 {

OSBindings/Qt/clksignal.pro

@@ -99,6 +99,7 @@ SOURCES += \
 	$$SRC/Machines/ColecoVision/*.cpp \
 	$$SRC/Machines/Commodore/*.cpp \
 	$$SRC/Machines/Commodore/1540/Implementation/*.cpp \
+	$$SRC/Machines/Commodore/Plus4/*.cpp \
 	$$SRC/Machines/Commodore/Vic-20/*.cpp \
 	$$SRC/Machines/Enterprise/*.cpp \
 	$$SRC/Machines/MasterSystem/*.cpp \
@@ -235,6 +236,7 @@ HEADERS += \
 	$$SRC/Machines/ColecoVision/*.hpp \
 	$$SRC/Machines/Commodore/*.hpp \
 	$$SRC/Machines/Commodore/1540/Implementation/*.hpp \
+	$$SRC/Machines/Commodore/Plus4/*.hpp \
 	$$SRC/Machines/Commodore/Vic-20/*.hpp \
 	$$SRC/Machines/Electron/*.hpp \
 	$$SRC/Machines/Enterprise/*.hpp \

OSBindings/SDL/SConstruct

@@ -87,6 +87,7 @@ SOURCES += glob.glob('../../Machines/ColecoVision/*.cpp')
 SOURCES += glob.glob('../../Machines/Commodore/*.cpp')
 SOURCES += glob.glob('../../Machines/Commodore/1540/Implementation/*.cpp')
 SOURCES += glob.glob('../../Machines/Commodore/Vic-20/*.cpp')
+SOURCES += glob.glob('../../Machines/Commodore/Plus4/*.cpp')
 SOURCES += glob.glob('../../Machines/Enterprise/*.cpp')
 SOURCES += glob.glob('../../Machines/MasterSystem/*.cpp')
 SOURCES += glob.glob('../../Machines/MSX/*.cpp')

Processors/6502/State/State.cpp

@@ -83,43 +83,35 @@ void State::apply(ProcessorBase &target) {
 }
 
 // Boilerplate follows here, to establish 'reflection'.
-State::State() {
-	if(needs_declare()) {
-		DeclareField(registers);
-		DeclareField(execution_state);
-		DeclareField(inputs);
-	}
+void State::declare_fields() {
+	DeclareField(registers);
+	DeclareField(execution_state);
+	DeclareField(inputs);
 }
 
-State::Registers::Registers() {
-	if(needs_declare()) {
-		DeclareField(program_counter);
-		DeclareField(stack_pointer);
-		DeclareField(flags);
-		DeclareField(a);
-		DeclareField(x);
-		DeclareField(y);
-	}
+void State::Registers::declare_fields() {
+	DeclareField(program_counter);
+	DeclareField(stack_pointer);
+	DeclareField(flags);
+	DeclareField(a);
+	DeclareField(x);
+	DeclareField(y);
 }
 
-State::ExecutionState::ExecutionState() {
-	if(needs_declare()) {
-		AnnounceEnum(Phase);
-		DeclareField(phase);
-		DeclareField(micro_program);
-		DeclareField(micro_program_offset);
-		DeclareField(operation);
-		DeclareField(operand);
-		DeclareField(address);
-		DeclareField(next_address);
-	}
+void State::ExecutionState::declare_fields() {
+	AnnounceEnum(Phase);
+	DeclareField(phase);
+	DeclareField(micro_program);
+	DeclareField(micro_program_offset);
+	DeclareField(operation);
+	DeclareField(operand);
+	DeclareField(address);
+	DeclareField(next_address);
 }
 
-State::Inputs::Inputs() {
-	if(needs_declare()) {
-		DeclareField(ready);
-		DeclareField(irq);
-		DeclareField(nmi);
-		DeclareField(reset);
-	}
+void State::Inputs::declare_fields() {
+	DeclareField(ready);
+	DeclareField(irq);
+	DeclareField(nmi);
+	DeclareField(reset);
 }

Processors/6502/State/State.hpp

@@ -31,7 +31,9 @@ struct State: public Reflection::StructImpl<State> {
 		uint8_t flags;
 		uint8_t a, x, y;
 
-		Registers();
+	private:
+		friend Reflection::StructImpl<Registers>;
+		void declare_fields();
 	} registers;
 
 	/*!
@@ -44,7 +46,9 @@ struct State: public Reflection::StructImpl<State> {
 		bool nmi;
 		bool reset;
 
-		Inputs();
+	private:
+		friend Reflection::StructImpl<Inputs>;
+		void declare_fields();
 	} inputs;
 
 	/*!
@@ -74,17 +78,22 @@ struct State: public Reflection::StructImpl<State> {
 		uint8_t operation, operand;
 		uint16_t address, next_address;
 
-		ExecutionState();
+	private:
+		friend Reflection::StructImpl<ExecutionState>;
+		void declare_fields();
 	} execution_state;
 
-	/// Default constructor; makes no guarantees as to field values beyond those given above.
-	State();
+	State() {}
 
 	/// Instantiates a new State based on the processor @c src.
-	State(const ProcessorBase &src);
+	State(const ProcessorBase &);
 
 	/// Applies this state to @c target.
-	void apply(ProcessorBase &target);
+	void apply(ProcessorBase &);
+
+private:
+	friend Reflection::StructImpl<State>;
+	void declare_fields();
 };
 
 }

Processors/65816/65816.hpp

@@ -71,9 +71,7 @@ public:
 	Processor(BusHandler &bus_handler) : bus_handler_(bus_handler) {}
 
 	/*!
-		Runs the 6502 for a supplied number of cycles.
-
-		@param cycles The number of cycles to run the 6502 for.
+		Runs the 6502 for a number of cycles.
 	*/
 	void run_for(const Cycles);
 

Processors/Z80/State/State.cpp

@@ -164,62 +164,54 @@ void State::apply(ProcessorBase &target) {
 }
 
 // Boilerplate follows here, to establish 'reflection'.
-State::State() {
-	if(needs_declare()) {
-		DeclareField(registers);
-		DeclareField(execution_state);
-		DeclareField(inputs);
-	}
+void State::declare_fields() {
+	DeclareField(registers);
+	DeclareField(execution_state);
+	DeclareField(inputs);
 }
 
-State::Registers::Registers() {
-	if(needs_declare()) {
-		DeclareField(a);
-		DeclareField(flags);
-		DeclareField(bc);
-		DeclareField(de);
-		DeclareField(hl);
-		DeclareField(af_dash);	// TODO: is there any disadvantage to declaring these for reflective
-		DeclareField(bc_dash);	// purposes as AF', BC', etc?
-		DeclareField(de_dash);
-		DeclareField(hl_dash);
-		DeclareField(ix);
-		DeclareField(iy);
-		DeclareField(ir);
-		DeclareField(program_counter);
-		DeclareField(stack_pointer);
-		DeclareField(interrupt_mode);
-		DeclareField(iff1);
-		DeclareField(iff2);
-		DeclareField(memptr);
-	}
+void State::Registers::declare_fields() {
+	DeclareField(a);
+	DeclareField(flags);
+	DeclareField(bc);
+	DeclareField(de);
+	DeclareField(hl);
+	DeclareField(af_dash);	// TODO: is there any disadvantage to declaring these for reflective
+	DeclareField(bc_dash);	// purposes as AF', BC', etc?
+	DeclareField(de_dash);
+	DeclareField(hl_dash);
+	DeclareField(ix);
+	DeclareField(iy);
+	DeclareField(ir);
+	DeclareField(program_counter);
+	DeclareField(stack_pointer);
+	DeclareField(interrupt_mode);
+	DeclareField(iff1);
+	DeclareField(iff2);
+	DeclareField(memptr);
 }
 
-State::ExecutionState::ExecutionState() {
-	if(needs_declare()) {
-		DeclareField(is_halted);
-		DeclareField(requests);
-		DeclareField(last_requests);
-		DeclareField(temp8);
-		DeclareField(operation);
-		DeclareField(temp16);
-		DeclareField(flag_adjustment_history);
-		DeclareField(pc_increment);
-		DeclareField(refresh_address);
+void State::ExecutionState::declare_fields() {
+	DeclareField(is_halted);
+	DeclareField(requests);
+	DeclareField(last_requests);
+	DeclareField(temp8);
+	DeclareField(operation);
+	DeclareField(temp16);
+	DeclareField(flag_adjustment_history);
+	DeclareField(pc_increment);
+	DeclareField(refresh_address);
 
-		AnnounceEnum(Phase);
-		DeclareField(phase);
-		DeclareField(half_cycles_into_step);
-		DeclareField(steps_into_phase);
-		DeclareField(instruction_page);
-	}
+	AnnounceEnum(Phase);
+	DeclareField(phase);
+	DeclareField(half_cycles_into_step);
+	DeclareField(steps_into_phase);
+	DeclareField(instruction_page);
 }
 
-State::Inputs::Inputs() {
-	if(needs_declare()) {
-		DeclareField(irq);
-		DeclareField(nmi);
-		DeclareField(bus_request);
-		DeclareField(wait);
-	}
+void State::Inputs::declare_fields() {
+	DeclareField(irq);
+	DeclareField(nmi);
+	DeclareField(bus_request);
+	DeclareField(wait);
 }

Processors/Z80/State/State.hpp

@@ -37,7 +37,9 @@ struct State: public Reflection::StructImpl<State> {
 		int interrupt_mode;
 		bool iff1, iff2;
 
-		Registers();
+	private:
+		friend Reflection::StructImpl<Registers>;
+		void declare_fields();
 	} registers;
 
 	/*!
@@ -50,7 +52,9 @@ struct State: public Reflection::StructImpl<State> {
 		bool bus_request = false;
 		bool wait = false;
 
-		Inputs();
+	private:
+		friend Reflection::StructImpl<Inputs>;
+		void declare_fields();
 	} inputs;
 
 	/*!
@@ -80,17 +84,22 @@ struct State: public Reflection::StructImpl<State> {
 		int steps_into_phase = 0;
 		uint16_t instruction_page = 0;
 
-		ExecutionState();
+	private:
+		friend Reflection::StructImpl<ExecutionState>;
+		void declare_fields();
 	} execution_state;
 
-	/// Default constructor; makes no guarantees as to field values beyond those given above.
-	State();
+	State() {}
 
 	/// Instantiates a new State based on the processor @c src.
 	State(const ProcessorBase &src);
 
 	/// Applies this state to @c target.
 	void apply(ProcessorBase &target);
+
+private:
+	friend Reflection::StructImpl<State>;
+	void declare_fields();
 };
 
 }

Processors/Z80/Z80.hpp

@@ -505,7 +505,7 @@ public:
 
 		@param cycles The number of cycles to run for.
 	*/
-	void run_for(const HalfCycles);
+	void run_for(const HalfCycles cycles);
 
 	/*!
 		Sets the logical value of the bus request line, having asserted that this Z80 supports the bus request line.

Reflection/Struct.hpp

@@ -242,9 +242,8 @@ protected:
 		declare_field(&field1, "field1");
 		declare_field(&field2, "field2");
 
-		Fields are registered in class storage. So callers can use needs_declare()
-		to determine whether a class of this type has already established the
-		reflective fields.
+		They should provide a default constructor and implement the method
+		declare_fields() to perform all declarations.
 	*/
 
 	/*!
@@ -297,13 +296,6 @@ protected:
 		permitted_enum_values_.emplace(name, permitted_values);
 	}
 
-	/*!
-		@returns @c true if this subclass of @c Struct has not yet declared any fields.
-	*/
-	bool needs_declare() {
-		return contents_.empty();
-	}
-
 	/*!
 		Performs a reverse lookup from field to name.
 	*/
@@ -352,6 +344,15 @@ private:
 	};
 	static inline std::unordered_map<std::string, Field> contents_;
 	static inline std::unordered_map<std::string, std::vector<bool>> permitted_enum_values_;
+
+	// Ensure fields are declared at startup.
+	struct Declarer {
+		Declarer() {
+			Owner o;
+			o.declare_fields();
+		}
+	};
+	static Declarer declarer;
 };
 
 

Storage/Cartridge/Formats/PRG.cpp

@@ -29,11 +29,11 @@ PRG::PRG(const std::string &file_name) {
 	int loading_address = fgetc(file);
 	loading_address |= fgetc(file) << 8;
 
-	std::size_t data_length = size_t(file_stats.st_size) - 2;
+	const std::size_t data_length = size_t(file_stats.st_size) - 2;
 	std::size_t padded_data_length = 1;
 	while(padded_data_length < data_length) padded_data_length <<= 1;
 	std::vector<uint8_t> contents(padded_data_length);
-	std::size_t length = std::fread(contents.data(), 1, size_t(data_length), file);
+	const std::size_t length = std::fread(contents.data(), 1, size_t(data_length), file);
 	std::fclose(file);
 
 	// accept only files intended to load at 0xa000

Storage/Disk/DiskImage/Formats/D64.cpp

@@ -19,16 +19,15 @@ using namespace Storage::Disk;
 
 D64::D64(const std::string &file_name) :
 		file_(file_name) {
-	// in D64, this is it for validation without imposing potential false-negative tests: check that
-	// the file size appears to be correct. Stone-age stuff.
+	// In D64, this is it for validation without imposing potential false-negative tests:
+	// check that the file size appears to be correct. Stone-age stuff.
 	if(file_.stats().st_size != 174848 && file_.stats().st_size != 196608)
 		throw Error::InvalidFormat;
 
 	number_of_tracks_ = (file_.stats().st_size == 174848) ? 35 : 40;
 
-	// then, ostensibly, this is a valid file. Hmmm. Pick a disk ID as a function of the file_name,
-	// being the most stable thing available
-	disk_id_ = 0;
+	// Then, ostensibly, this is a valid file. Pick a disk ID as a
+	// function of the file_name, being the most stable thing available.
 	for(const auto &character: file_name) {
 		disk_id_ ^= character;
 		disk_id_ = uint16_t((disk_id_ << 2) ^ (disk_id_ >> 13));
@@ -39,8 +38,8 @@ HeadPosition D64::get_maximum_head_position() {
 	return HeadPosition(number_of_tracks_);
 }
 
-std::shared_ptr<Track> D64::get_track_at_position(Track::Address address) {
-	// figure out where this track starts on the disk
+std::shared_ptr<Track> D64::get_track_at_position(const Track::Address address) {
+	// Figure out where this track starts on the disk.
 	int offset_to_track = 0;
 	int tracks_to_traverse = address.position.as_int();
 
@@ -54,12 +53,12 @@ std::shared_ptr<Track> D64::get_track_at_position(Track::Address address) {
 		if(tracks_in_this_zone == zone_sizes[current_zone]) zone++;
 	}
 
-	// seek to start of data
+	// Seek to start of data.
 	file_.seek(offset_to_track * 256, SEEK_SET);
 
-	// build up a PCM sampling of the GCR version of this track
+	// Build up a PCM sampling of the GCR version of this track.
 
-	// format per sector:
+	// Format per sector:
 	//
 	// syncronisation: three $FFs directly in GCR
 	// value $08 to announce a header
@@ -86,39 +85,39 @@ std::shared_ptr<Track> D64::get_track_at_position(Track::Address address) {
 		uint8_t *sector_data = &data[size_t(sector) * 349];
 		sector_data[0] = sector_data[1] = sector_data[2] = 0xff;
 
-		uint8_t sector_number = uint8_t(sector);						// sectors count from 0
-		uint8_t track_number = uint8_t(address.position.as_int() + 1);	// tracks count from 1
+		uint8_t sector_number = uint8_t(sector);						// Sectors count from 0.
+		uint8_t track_number = uint8_t(address.position.as_int() + 1);	// Tracks count from 1.
 		uint8_t checksum = uint8_t(sector_number ^ track_number ^ disk_id_ ^ (disk_id_ >> 8));
 		uint8_t header_start[4] = {
 			0x08, checksum, sector_number, track_number
 		};
 		Encodings::CommodoreGCR::encode_block(&sector_data[3], header_start);
 
-		uint8_t header_end[4] = {
+		const uint8_t header_end[4] = {
 			uint8_t(disk_id_ & 0xff), uint8_t(disk_id_ >> 8), 0, 0
 		};
 		Encodings::CommodoreGCR::encode_block(&sector_data[8], header_end);
 
-		// pad out post-header parts
+		// Pad out post-header parts.
 		uint8_t zeros[4] = {0, 0, 0, 0};
 		Encodings::CommodoreGCR::encode_block(&sector_data[13], zeros);
 		sector_data[18] = 0x52;
 		sector_data[19] = 0x94;
 		sector_data[20] = 0xaf;
 
-		// get the actual contents
+		// Get the actual contents.
 		uint8_t source_data[256];
 		file_.read(source_data, sizeof(source_data));
 
-		// compute the latest checksum
+		// Compute the latest checksum.
 		checksum = 0;
 		for(int c = 0; c < 256; c++)
 			checksum ^= source_data[c];
 
-		// put in another sync
+		// Put in another sync.
 		sector_data[21] = sector_data[22] = sector_data[23] = 0xff;
 
-		// now start writing in the actual data
+		// Now start writing in the actual data.
 		uint8_t start_of_data[4] = {
 			0x07, source_data[0], source_data[1], source_data[2]
 		};

Storage/Disk/DiskImage/Formats/D64.hpp

@@ -26,9 +26,7 @@ public:
 	*/
 	D64(const std::string &file_name);
 
-	// implemented to satisfy @c Disk
 	HeadPosition get_maximum_head_position() final;
-	using DiskImage::get_is_read_only;
 	std::shared_ptr<Track> get_track_at_position(Track::Address address) final;
 
 private:

Storage/Disk/Encodings/CommodoreGCR.cpp

@@ -11,12 +11,12 @@
 
 using namespace Storage;
 
-Time Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(unsigned int time_zone) {
+Time Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(const unsigned int time_zone) {
 	// the speed zone divides a 4Mhz clock by 13, 14, 15 or 16, with higher-numbered zones being faster (i.e. each bit taking less time)
 	return Time(16 - time_zone, 4000000u);
 }
 
-unsigned int Storage::Encodings::CommodoreGCR::encoding_for_nibble(uint8_t nibble) {
+unsigned int Storage::Encodings::CommodoreGCR::encoding_for_nibble(const uint8_t nibble) {
 	switch(nibble & 0xf) {
 		case 0x0:	return 0x0a;		case 0x1:	return 0x0b;
 		case 0x2:	return 0x12;		case 0x3:	return 0x13;
@@ -32,7 +32,7 @@ unsigned int Storage::Encodings::CommodoreGCR::encoding_for_nibble(uint8_t nibbl
 	}
 }
 
-unsigned int Storage::Encodings::CommodoreGCR::decoding_from_quintet(unsigned int quintet) {
+unsigned int Storage::Encodings::CommodoreGCR::decoding_from_quintet(const unsigned int quintet) {
 	switch(quintet & 0x1f) {
 		case 0x0a:	return 0x0;			case 0x0b:	return 0x1;
 		case 0x12:	return 0x2;			case 0x13:	return 0x3;
@@ -47,15 +47,15 @@ unsigned int Storage::Encodings::CommodoreGCR::decoding_from_quintet(unsigned in
 	}
 }
 
-unsigned int Storage::Encodings::CommodoreGCR::encoding_for_byte(uint8_t byte) {
+unsigned int Storage::Encodings::CommodoreGCR::encoding_for_byte(const uint8_t byte) {
 	return encoding_for_nibble(byte) | (encoding_for_nibble(byte >> 4) << 5);
 }
 
-unsigned int Storage::Encodings::CommodoreGCR::decoding_from_dectet(unsigned int dectet) {
+unsigned int Storage::Encodings::CommodoreGCR::decoding_from_dectet(const unsigned int dectet) {
 	return decoding_from_quintet(dectet) | (decoding_from_quintet(dectet >> 5) << 4);
 }
 
-void Storage::Encodings::CommodoreGCR::encode_block(uint8_t *destination, uint8_t *source) {
+void Storage::Encodings::CommodoreGCR::encode_block(uint8_t *const destination, const uint8_t *const source) {
 	unsigned int encoded_bytes[4] = {
 		encoding_for_byte(source[0]),
 		encoding_for_byte(source[1]),

Storage/Disk/Encodings/CommodoreGCR.hpp

@@ -33,7 +33,7 @@ namespace CommodoreGCR {
 	/*!
 		A block is defined to be four source bytes, which encodes to five GCR bytes.
 	*/
-	void encode_block(uint8_t *destination, uint8_t *source);
+	void encode_block(uint8_t *destination, const uint8_t *source);
 
 	/*!
 		@returns the four bit nibble for the five-bit GCR @c quintet if a valid GCR value; INT_MAX otherwise.

cmake/CLK_SOURCES.cmake

@@ -21,7 +21,6 @@ set(CLK_SOURCES
 	Analyser/Static/AtariST/StaticAnalyser.cpp
 	Analyser/Static/Coleco/StaticAnalyser.cpp
 	Analyser/Static/Commodore/Disk.cpp
-	Analyser/Static/Commodore/File.cpp
 	Analyser/Static/Commodore/StaticAnalyser.cpp
 	Analyser/Static/Commodore/Tape.cpp
 	Analyser/Static/Disassembler/6502.cpp
@@ -119,6 +118,7 @@ set(CLK_SOURCES
 	Machines/Atari/ST/Video.cpp
 	Machines/ColecoVision/ColecoVision.cpp
 	Machines/Commodore/1540/Implementation/C1540.cpp
+	Machines/Commodore/Plus4/Plus4.cpp
 	Machines/Commodore/SerialBus.cpp
 	Machines/Commodore/Vic-20/Keyboard.cpp
 	Machines/Commodore/Vic-20/Vic20.cpp