diff --git a/Analyser/Static/Acorn/Target.hpp b/Analyser/Static/Acorn/Target.hpp
index bcb63b217..556468fbd 100644
--- a/Analyser/Static/Acorn/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Amiga/Target.hpp b/Analyser/Static/Amiga/Target.hpp
index f3bead884..15156235c 100644
--- a/Analyser/Static/Amiga/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/AmstradCPC/Target.hpp b/Analyser/Static/AmstradCPC/Target.hpp
index 6db95805c..a2e1c91ba 100644
--- a/Analyser/Static/AmstradCPC/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/AppleII/Target.hpp b/Analyser/Static/AppleII/Target.hpp
index fd3cb6892..5b459b8d4 100644
--- a/Analyser/Static/AppleII/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/AppleIIgs/Target.hpp b/Analyser/Static/AppleIIgs/Target.hpp
index 99ba12028..cf81eeae2 100644
--- a/Analyser/Static/AppleIIgs/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/AtariST/Target.hpp b/Analyser/Static/AtariST/Target.hpp
index 490342f87..01599a254 100644
--- a/Analyser/Static/AtariST/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Commodore/Disk.cpp b/Analyser/Static/Commodore/Disk.cpp
index 658b0e938..94d3a3b52 100644
--- a/Analyser/Static/Commodore/Disk.cpp
+++ b/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];
diff --git a/Analyser/Static/Commodore/File.cpp b/Analyser/Static/Commodore/File.cpp
deleted file mode 100644
index 6bcb9bfa6..000000000
--- a/Analyser/Static/Commodore/File.cpp
+++ /dev/null
@@ -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;
-}
diff --git a/Analyser/Static/Commodore/File.hpp b/Analyser/Static/Commodore/File.hpp
index e84b00d50..35394ce11 100644
--- a/Analyser/Static/Commodore/File.hpp
+++ b/Analyser/Static/Commodore/File.hpp
@@ -29,8 +29,6 @@ struct File {
 		Relative
 	} type;
 	std::vector<uint8_t> data;
-
-	bool is_basic();
 };
 
 }
diff --git a/Analyser/Static/Commodore/StaticAnalyser.cpp b/Analyser/Static/Commodore/StaticAnalyser.cpp
index dbe78bbc5..f07734888 100644
--- a/Analyser/Static/Commodore/StaticAnalyser.cpp
+++ b/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()) {
diff --git a/Analyser/Static/Commodore/Tape.cpp b/Analyser/Static/Commodore/Tape.cpp
index b7891614d..08ee5b109 100644
--- a/Analyser/Static/Commodore/Tape.cpp
+++ b/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);
diff --git a/Analyser/Static/Commodore/Target.hpp b/Analyser/Static/Commodore/Target.hpp
index 78d4fdbfe..7f0e6dcd0 100644
--- a/Analyser/Static/Commodore/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Enterprise/Target.hpp b/Analyser/Static/Enterprise/Target.hpp
index b6238bf92..dba0d4614 100644
--- a/Analyser/Static/Enterprise/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/MSX/Target.hpp b/Analyser/Static/MSX/Target.hpp
index a322ce83c..3f57dcda0 100644
--- a/Analyser/Static/MSX/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Macintosh/Target.hpp b/Analyser/Static/Macintosh/Target.hpp
index 372d212bf..ba56a6186 100644
--- a/Analyser/Static/Macintosh/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Oric/Target.hpp b/Analyser/Static/Oric/Target.hpp
index 28bfcc598..4871b0f71 100644
--- a/Analyser/Static/Oric/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/PCCompatible/Target.hpp b/Analyser/Static/PCCompatible/Target.hpp
index 5c954306f..4129d65a2 100644
--- a/Analyser/Static/PCCompatible/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/Sega/Target.hpp b/Analyser/Static/Sega/Target.hpp
index 3b33d4d7d..9eef479a5 100644
--- a/Analyser/Static/Sega/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/StaticAnalyser.cpp b/Analyser/Static/StaticAnalyser.cpp
index a48b4d5e8..8348cf805 100644
--- a/Analyser/Static/StaticAnalyser.cpp
+++ b/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);
diff --git a/Analyser/Static/StaticAnalyser.hpp b/Analyser/Static/StaticAnalyser.hpp
index 8e8a1648a..acfe1d9f9 100644
--- a/Analyser/Static/StaticAnalyser.hpp
+++ b/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;
 
diff --git a/Analyser/Static/ZX8081/Target.hpp b/Analyser/Static/ZX8081/Target.hpp
index 2f83bbdb1..30adde55f 100644
--- a/Analyser/Static/ZX8081/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Analyser/Static/ZXSpectrum/Target.hpp b/Analyser/Static/ZXSpectrum/Target.hpp
index 72ee008d1..ff07ec4d7 100644
--- a/Analyser/Static/ZXSpectrum/Target.hpp
+++ b/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);
 	}
 };
 
diff --git a/Components/AY38910/AY38910.hpp b/Components/AY38910/AY38910.hpp
index b9619687e..216ae45b5 100644
--- a/Components/AY38910/AY38910.hpp
+++ b/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);
+	}
 };
 
 }
diff --git a/Machines/Acorn/Archimedes/Archimedes.hpp b/Machines/Acorn/Archimedes/Archimedes.hpp
index 658e1c2ab..e2ee5d8f1 100644
--- a/Machines/Acorn/Archimedes/Archimedes.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/Acorn/Electron/Electron.hpp b/Machines/Acorn/Electron/Electron.hpp
index f1333c2d4..04142d90b 100644
--- a/Machines/Acorn/Electron/Electron.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/Amiga/Amiga.hpp b/Machines/Amiga/Amiga.hpp
index 7e24b4e5b..8379d99dc 100644
--- a/Machines/Amiga/Amiga.hpp
+++ b/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 &);
 };
 
 }
diff --git a/Machines/AmstradCPC/AmstradCPC.hpp b/Machines/AmstradCPC/AmstradCPC.hpp
index e29b46285..a595959a4 100644
--- a/Machines/AmstradCPC/AmstradCPC.hpp
+++ b/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;
 };
 
 }
diff --git a/Machines/Apple/AppleII/AppleII.hpp b/Machines/Apple/AppleII/AppleII.hpp
index fb569118a..09056cdeb 100644
--- a/Machines/Apple/AppleII/AppleII.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/Apple/AppleIIgs/AppleIIgs.hpp b/Machines/Apple/AppleIIgs/AppleIIgs.hpp
index 841d1fbf6..261d35525 100644
--- a/Machines/Apple/AppleIIgs/AppleIIgs.hpp
+++ b/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 &);
 };
 
 }
diff --git a/Machines/Apple/Macintosh/Macintosh.hpp b/Machines/Apple/Macintosh/Macintosh.hpp
index a2553bbfe..b60a80292 100644
--- a/Machines/Apple/Macintosh/Macintosh.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/Atari/2600/Atari2600.hpp b/Machines/Atari/2600/Atari2600.hpp
index 24d72b7fa..bec1cfec5 100644
--- a/Machines/Atari/2600/Atari2600.hpp
+++ b/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.
diff --git a/Machines/Atari/ST/AtariST.hpp b/Machines/Atari/ST/AtariST.hpp
index 88d782c03..15970e936 100644
--- a/Machines/Atari/ST/AtariST.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/AudioProducer.hpp b/Machines/AudioProducer.hpp
index 0d5ad5dc3..4c72da239 100644
--- a/Machines/AudioProducer.hpp
+++ b/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;
 };
 
 }
diff --git a/Machines/ColecoVision/ColecoVision.hpp b/Machines/ColecoVision/ColecoVision.hpp
index 85a816460..180907541 100644
--- a/Machines/ColecoVision/ColecoVision.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/Commodore/Plus4/Plus4.cpp b/Machines/Commodore/Plus4/Plus4.cpp
new file mode 100644
index 000000000..7832c35d7
--- /dev/null
+++ b/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);
+}
diff --git a/Machines/Commodore/Plus4/Plus4.hpp b/Machines/Commodore/Plus4/Plus4.hpp
new file mode 100644
index 000000000..3e10c6904
--- /dev/null
+++ b/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 &);
+};
+
+}
diff --git a/Machines/Commodore/Vic-20/Vic20.cpp b/Machines/Commodore/Vic-20/Vic20.cpp
index dfc0462c4..e7f9e9eb9 100644
--- a/Machines/Commodore/Vic-20/Vic20.cpp
+++ b/Machines/Commodore/Vic-20/Vic20.cpp
@@ -46,7 +46,7 @@ enum ROMSlot {
 	Kernel = 0,
 	BASIC,
 	Characters,
-	Drive
+	Drive,
 };
 
 enum JoystickInput {
@@ -54,7 +54,7 @@ enum JoystickInput {
 	Down = 0x08,
 	Left = 0x10,
 	Right = 0x80,
-	Fire = 0x20
+	Fire = 0x20,
 };
 
 /*!
@@ -63,67 +63,67 @@ enum JoystickInput {
 	state from its serial port. Most of the joystick input is also exposed here.
 */
 class UserPortVIA: public MOS::MOS6522::IRQDelegatePortHandler {
-	public:
-		UserPortVIA() : port_a_(0xbf) {}
+public:
+	UserPortVIA() : port_a_(0xbf) {}
 
-		/// Reports the current input to the 6522 port @c port.
-		uint8_t get_port_input(MOS::MOS6522::Port port) {
-			// Port A provides information about the presence or absence of a tape, and parts of
-			// the joystick and serial port state, both of which have been statefully collected
-			// into port_a_.
-			if(!port) {
-				return port_a_ | (tape_->has_tape() ? 0x00 : 0x40);
-			}
-			return 0xff;
+	/// Reports the current input to the 6522 port @c port.
+	uint8_t get_port_input(const MOS::MOS6522::Port port) {
+		// Port A provides information about the presence or absence of a tape, and parts of
+		// the joystick and serial port state, both of which have been statefully collected
+		// into port_a_.
+		if(!port) {
+			return port_a_ | (tape_->has_tape() ? 0x00 : 0x40);
 		}
+		return 0xff;
+	}
 
-		/// Receives announcements of control line output change from the 6522.
-		void set_control_line_output(MOS::MOS6522::Port port, MOS::MOS6522::Line line, bool value) {
-			// The CA2 output is used to control the tape motor.
-			if(port == MOS::MOS6522::Port::A && line == MOS::MOS6522::Line::Two) {
-				tape_->set_motor_control(!value);
-			}
+	/// Receives announcements of control line output change from the 6522.
+	void set_control_line_output(const MOS::MOS6522::Port port, const MOS::MOS6522::Line line, const bool value) {
+		// The CA2 output is used to control the tape motor.
+		if(port == MOS::MOS6522::Port::A && line == MOS::MOS6522::Line::Two) {
+			tape_->set_motor_control(!value);
 		}
+	}
 
-		/// Receives announcements of changes in the serial bus connected to the serial port and propagates them into Port A.
-		void set_serial_line_state(::Commodore::Serial::Line line, bool value) {
-			switch(line) {
-				default: break;
-				case ::Commodore::Serial::Line::Data: port_a_ = (port_a_ & ~0x02) | (value ? 0x02 : 0x00);	break;
-				case ::Commodore::Serial::Line::Clock: port_a_ = (port_a_ & ~0x01) | (value ? 0x01 : 0x00);	break;
-			}
+	/// Receives announcements of changes in the serial bus connected to the serial port and propagates them into Port A.
+	void set_serial_line_state(const ::Commodore::Serial::Line line, const bool value) {
+		switch(line) {
+			default: break;
+			case ::Commodore::Serial::Line::Data: port_a_ = (port_a_ & ~0x02) | (value ? 0x02 : 0x00);	break;
+			case ::Commodore::Serial::Line::Clock: port_a_ = (port_a_ & ~0x01) | (value ? 0x01 : 0x00);	break;
 		}
+	}
 
-		/// Allows the current joystick input to be set.
-		void set_joystick_state(JoystickInput input, bool value) {
-			if(input != JoystickInput::Right) {
-				port_a_ = (port_a_ & ~input) | (value ? 0 : input);
-			}
+	/// Allows the current joystick input to be set.
+	void set_joystick_state(const JoystickInput input, const bool value) {
+		if(input != JoystickInput::Right) {
+			port_a_ = (port_a_ & ~input) | (value ? 0 : input);
 		}
+	}
 
-		/// Receives announcements from the 6522 of user-port output, which might affect what's currently being presented onto the serial bus.
-		void set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t) {
-			// Line 7 of port A is inverted and output as serial ATN.
-			if(!port) {
-				std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
-				if(serialPort) serialPort->set_output(::Commodore::Serial::Line::Attention, (::Commodore::Serial::LineLevel)!(value&0x80));
-			}
+	/// Receives announcements from the 6522 of user-port output, which might affect what's currently being presented onto the serial bus.
+	void set_port_output(const MOS::MOS6522::Port port, const uint8_t value, uint8_t) {
+		// Line 7 of port A is inverted and output as serial ATN.
+		if(!port) {
+			std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
+			if(serialPort) serialPort->set_output(::Commodore::Serial::Line::Attention, (::Commodore::Serial::LineLevel)!(value&0x80));
 		}
+	}
 
-		/// Sets @serial_port as this VIA's connection to the serial bus.
-		void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serial_port) {
-			serial_port_ = serial_port;
-		}
+	/// Sets @serial_port as this VIA's connection to the serial bus.
+	void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serial_port) {
+		serial_port_ = serial_port;
+	}
 
-		/// Sets @tape as the tape player connected to this VIA.
-		void set_tape(std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape) {
-			tape_ = tape;
-		}
+	/// Sets @tape as the tape player connected to this VIA.
+	void set_tape(std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape) {
+		tape_ = tape;
+	}
 
-	private:
-		uint8_t port_a_;
-		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
-		std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
+private:
+	uint8_t port_a_;
+	std::weak_ptr<::Commodore::Serial::Port> serial_port_;
+	std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
 };
 
 /*!
@@ -131,146 +131,147 @@ class UserPortVIA: public MOS::MOS6522::IRQDelegatePortHandler {
 	and for the small portion of joystick input not connected to the user-port VIA.
 */
 class KeyboardVIA: public MOS::MOS6522::IRQDelegatePortHandler {
-	public:
-		KeyboardVIA() : port_b_(0xff) {
-			clear_all_keys();
-		}
+public:
+	KeyboardVIA() : port_b_(0xff) {
+		clear_all_keys();
+	}
 
-		/// Sets whether @c key @c is_pressed.
-		void set_key_state(uint16_t key, bool is_pressed) {
-			if(is_pressed)
-				columns_[key & 7] &= ~(key >> 3);
-			else
-				columns_[key & 7] |= (key >> 3);
-		}
+	/// Sets whether @c key @c is_pressed.
+	void set_key_state(const uint16_t key, const bool is_pressed) {
+		if(is_pressed)
+			columns_[key & 7] &= ~(key >> 3);
+		else
+			columns_[key & 7] |= (key >> 3);
+	}
 
-		/// Sets all keys as unpressed.
-		void clear_all_keys() {
-			memset(columns_, 0xff, sizeof(columns_));
-		}
+	/// Sets all keys as unpressed.
+	void clear_all_keys() {
+		memset(columns_, 0xff, sizeof(columns_));
+	}
 
-		/// Called by the 6522 to get input. Reads the keyboard on Port A, returns a small amount of joystick state on Port B.
-		uint8_t get_port_input(MOS::MOS6522::Port port) {
-			if(!port) {
-				uint8_t result = 0xff;
-				for(int c = 0; c < 8; c++) {
-					if(!(activation_mask_&(1 << c)))
-						result &= columns_[c];
-				}
-				return result;
+	/// Called by the 6522 to get input. Reads the keyboard on Port A, returns a small amount of joystick state on Port B.
+	uint8_t get_port_input(const MOS::MOS6522::Port port) {
+		if(!port) {
+			uint8_t result = 0xff;
+			for(int c = 0; c < 8; c++) {
+				if(!(activation_mask_&(1 << c)))
+					result &= columns_[c];
 			}
-
-			return port_b_;
+			return result;
 		}
 
-		/// Called by the 6522 to set output. The value of Port B selects which part of the keyboard to read.
-		void set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t mask) {
-			if(port) activation_mask_ = (value & mask) | (~mask);
-		}
+		return port_b_;
+	}
 
-		/// Called by the 6522 to set control line output. Which affects the serial port.
-		void set_control_line_output(MOS::MOS6522::Port port, MOS::MOS6522::Line line, bool value) {
-			if(line == MOS::MOS6522::Line::Two) {
-				std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
-				if(serialPort) {
-					// CB2 is inverted to become serial data; CA2 is inverted to become serial clock
-					if(port == MOS::MOS6522::Port::A)
-						serialPort->set_output(::Commodore::Serial::Line::Clock, (::Commodore::Serial::LineLevel)!value);
-					else
-						serialPort->set_output(::Commodore::Serial::Line::Data, (::Commodore::Serial::LineLevel)!value);
-				}
+	/// Called by the 6522 to set output. The value of Port B selects which part of the keyboard to read.
+	void set_port_output(const MOS::MOS6522::Port port, const uint8_t value, const uint8_t mask) {
+		if(port) activation_mask_ = (value & mask) | (~mask);
+	}
+
+	/// Called by the 6522 to set control line output. Which affects the serial port.
+	void set_control_line_output(const MOS::MOS6522::Port port, const MOS::MOS6522::Line line, const bool value) {
+		if(line == MOS::MOS6522::Line::Two) {
+			std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
+			if(serialPort) {
+				// CB2 is inverted to become serial data; CA2 is inverted to become serial clock
+				if(port == MOS::MOS6522::Port::A)
+					serialPort->set_output(::Commodore::Serial::Line::Clock, (::Commodore::Serial::LineLevel)!value);
+				else
+					serialPort->set_output(::Commodore::Serial::Line::Data, (::Commodore::Serial::LineLevel)!value);
 			}
 		}
+	}
 
-		/// Sets whether the joystick input @c input is pressed.
-		void set_joystick_state(JoystickInput input, bool value) {
-			if(input == JoystickInput::Right) {
-				port_b_ = (port_b_ & ~input) | (value ? 0 : input);
-			}
+	/// Sets whether the joystick input @c input is pressed.
+	void set_joystick_state(const JoystickInput input, const bool value) {
+		if(input == JoystickInput::Right) {
+			port_b_ = (port_b_ & ~input) | (value ? 0 : input);
 		}
+	}
 
-		/// Sets the serial port to which this VIA is connected.
-		void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serialPort) {
-			serial_port_ = serialPort;
-		}
+	/// Sets the serial port to which this VIA is connected.
+	void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serialPort) {
+		serial_port_ = serialPort;
+	}
 
-	private:
-		uint8_t port_b_;
-		uint8_t columns_[8];
-		uint8_t activation_mask_;
-		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
+private:
+	uint8_t port_b_;
+	uint8_t columns_[8];
+	uint8_t activation_mask_;
+	std::weak_ptr<::Commodore::Serial::Port> serial_port_;
 };
 
 /*!
 	Models the Vic's serial port, providing the receipticle for input.
 */
 class SerialPort : public ::Commodore::Serial::Port {
-	public:
-		/// Receives an input change from the base serial port class, and communicates it to the user-port VIA.
-		void set_input(::Commodore::Serial::Line line, ::Commodore::Serial::LineLevel level) {
-			std::shared_ptr<UserPortVIA> userPortVIA = user_port_via_.lock();
-			if(userPortVIA) userPortVIA->set_serial_line_state(line, bool(level));
-		}
+public:
+	/// Receives an input change from the base serial port class, and communicates it to the user-port VIA.
+	void set_input(const ::Commodore::Serial::Line line, const ::Commodore::Serial::LineLevel level) {
+		std::shared_ptr<UserPortVIA> userPortVIA = user_port_via_.lock();
+		if(userPortVIA) userPortVIA->set_serial_line_state(line, bool(level));
+	}
 
-		/// Sets the user-port VIA with which this serial port communicates.
-		void set_user_port_via(std::shared_ptr<UserPortVIA> userPortVIA) {
-			user_port_via_ = userPortVIA;
-		}
+	/// Sets the user-port VIA with which this serial port communicates.
+	void set_user_port_via(const std::shared_ptr<UserPortVIA> userPortVIA) {
+		user_port_via_ = userPortVIA;
+	}
 
-	private:
-		std::weak_ptr<UserPortVIA> user_port_via_;
+private:
+	std::weak_ptr<UserPortVIA> user_port_via_;
 };
 
 /*!
 	Provides the bus over which the Vic 6560 fetches memory in a Vic-20.
 */
-class Vic6560BusHandler {
-	public:
-		/// Performs a read on behalf of the 6560; in practice uses @c video_memory_map and @c colour_memory to find data.
-		forceinline void perform_read(uint16_t address, uint8_t *pixel_data, uint8_t *colour_data) {
-			*pixel_data = video_memory_map[address >> 10] ? video_memory_map[address >> 10][address & 0x3ff] : 0xff; // TODO
-			*colour_data = colour_memory[address & 0x03ff];
-		}
+struct Vic6560BusHandler {
+	/// Performs a read on behalf of the 6560; in practice uses @c video_memory_map and @c colour_memory to find data.
+	forceinline void perform_read(const uint16_t address, uint8_t *const pixel_data, uint8_t *const colour_data) {
+		*pixel_data = video_memory_map[address >> 10] ? video_memory_map[address >> 10][address & 0x3ff] : 0xff; // TODO
+		*colour_data = colour_memory[address & 0x03ff];
+	}
 
-		// It is assumed that these pointers have been filled in by the machine.
-		uint8_t *video_memory_map[16]{};	// Segments video memory into 1kb portions.
-		uint8_t *colour_memory{};			// Colour memory must be contiguous.
+	// It is assumed that these pointers have been filled in by the machine.
+	uint8_t *video_memory_map[16]{};	// Segments video memory into 1kb portions.
+	uint8_t *colour_memory{};			// Colour memory must be contiguous.
+
+	// TODO: make the above const.
 };
 
 /*!
 	Interfaces a joystick to the two VIAs.
 */
 class Joystick: public Inputs::ConcreteJoystick {
-	public:
-		Joystick(UserPortVIA &user_port_via_port_handler, KeyboardVIA &keyboard_via_port_handler) :
-			ConcreteJoystick({
-				Input(Input::Up),
-				Input(Input::Down),
-				Input(Input::Left),
-				Input(Input::Right),
-				Input(Input::Fire)
-			}),
-			user_port_via_port_handler_(user_port_via_port_handler),
-			keyboard_via_port_handler_(keyboard_via_port_handler) {}
+public:
+	Joystick(UserPortVIA &user_port_via_port_handler, KeyboardVIA &keyboard_via_port_handler) :
+		ConcreteJoystick({
+			Input(Input::Up),
+			Input(Input::Down),
+			Input(Input::Left),
+			Input(Input::Right),
+			Input(Input::Fire)
+		}),
+		user_port_via_port_handler_(user_port_via_port_handler),
+		keyboard_via_port_handler_(keyboard_via_port_handler) {}
 
-		void did_set_input(const Input &digital_input, bool is_active) final {
-			JoystickInput mapped_input;
-			switch(digital_input.type) {
-				default: return;
-				case Input::Up:		mapped_input = Up;		break;
-				case Input::Down:	mapped_input = Down;	break;
-				case Input::Left:	mapped_input = Left;	break;
-				case Input::Right:	mapped_input = Right;	break;
-				case Input::Fire:	mapped_input = Fire;	break;
-			}
-
-			user_port_via_port_handler_.set_joystick_state(mapped_input, is_active);
-			keyboard_via_port_handler_.set_joystick_state(mapped_input, is_active);
+	void did_set_input(const Input &digital_input, const bool is_active) final {
+		JoystickInput mapped_input;
+		switch(digital_input.type) {
+			default: return;
+			case Input::Up:		mapped_input = Up;		break;
+			case Input::Down:	mapped_input = Down;	break;
+			case Input::Left:	mapped_input = Left;	break;
+			case Input::Right:	mapped_input = Right;	break;
+			case Input::Fire:	mapped_input = Fire;	break;
 		}
 
-	private:
-		UserPortVIA &user_port_via_port_handler_;
-		KeyboardVIA &keyboard_via_port_handler_;
+		user_port_via_port_handler_.set_joystick_state(mapped_input, is_active);
+		keyboard_via_port_handler_.set_joystick_state(mapped_input, is_active);
+	}
+
+private:
+	UserPortVIA &user_port_via_port_handler_;
+	KeyboardVIA &keyboard_via_port_handler_;
 };
 
 class ConcreteMachine:
@@ -288,481 +289,488 @@ class ConcreteMachine:
 	public Machine,
 	public ClockingHint::Observer,
 	public Activity::Source {
-	public:
-		ConcreteMachine(const Analyser::Static::Commodore::Target &target, const ROMMachine::ROMFetcher &rom_fetcher) :
-				m6502_(*this),
-				mos6560_(mos6560_bus_handler_),
-				user_port_via_port_handler_(new UserPortVIA),
-				keyboard_via_port_handler_(new KeyboardVIA),
-				serial_port_(new SerialPort),
-				serial_bus_(new ::Commodore::Serial::Bus),
-				user_port_via_(*user_port_via_port_handler_),
-				keyboard_via_(*keyboard_via_port_handler_),
-				tape_(new Storage::Tape::BinaryTapePlayer(1022727)) {
-			// communicate the tape to the user-port VIA
-			user_port_via_port_handler_->set_tape(tape_);
+public:
+	ConcreteMachine(const Analyser::Static::Commodore::Target &target, const ROMMachine::ROMFetcher &rom_fetcher) :
+			m6502_(*this),
+			mos6560_(mos6560_bus_handler_),
+			user_port_via_port_handler_(new UserPortVIA),
+			keyboard_via_port_handler_(new KeyboardVIA),
+			serial_port_(new SerialPort),
+			serial_bus_(new ::Commodore::Serial::Bus),
+			user_port_via_(*user_port_via_port_handler_),
+			keyboard_via_(*keyboard_via_port_handler_),
+			tape_(new Storage::Tape::BinaryTapePlayer(1022727)) {
+		// communicate the tape to the user-port VIA
+		user_port_via_port_handler_->set_tape(tape_);
 
-			// wire up the serial bus and serial port
-			Commodore::Serial::AttachPortAndBus(serial_port_, serial_bus_);
+		// wire up the serial bus and serial port
+		Commodore::Serial::AttachPortAndBus(serial_port_, serial_bus_);
 
-			// wire up 6522s and serial port
-			user_port_via_port_handler_->set_serial_port(serial_port_);
-			keyboard_via_port_handler_->set_serial_port(serial_port_);
-			serial_port_->set_user_port_via(user_port_via_port_handler_);
+		// wire up 6522s and serial port
+		user_port_via_port_handler_->set_serial_port(serial_port_);
+		keyboard_via_port_handler_->set_serial_port(serial_port_);
+		serial_port_->set_user_port_via(user_port_via_port_handler_);
 
-			// wire up the 6522s, tape and machine
-			user_port_via_port_handler_->set_interrupt_delegate(this);
-			keyboard_via_port_handler_->set_interrupt_delegate(this);
-			tape_->set_delegate(this);
-			tape_->set_clocking_hint_observer(this);
+		// wire up the 6522s, tape and machine
+		user_port_via_port_handler_->set_interrupt_delegate(this);
+		keyboard_via_port_handler_->set_interrupt_delegate(this);
+		tape_->set_delegate(this);
+		tape_->set_clocking_hint_observer(this);
 
-			// Install a joystick.
-			joysticks_.emplace_back(new Joystick(*user_port_via_port_handler_, *keyboard_via_port_handler_));
+		// Install a joystick.
+		joysticks_.emplace_back(new Joystick(*user_port_via_port_handler_, *keyboard_via_port_handler_));
 
-			ROM::Request request(ROM::Name::Vic20BASIC);
-			ROM::Name kernel, character;
-			switch(target.region) {
-				default:
-					character = ROM::Name::Vic20EnglishCharacters;
-					kernel = ROM::Name::Vic20EnglishPALKernel;
-				break;
-				case Analyser::Static::Commodore::Target::Region::American:
-					character = ROM::Name::Vic20EnglishCharacters;
-					kernel = ROM::Name::Vic20EnglishNTSCKernel;
-				break;
-				case Analyser::Static::Commodore::Target::Region::Danish:
-					character = ROM::Name::Vic20DanishCharacters;
-					kernel = ROM::Name::Vic20DanishKernel;
-				break;
-				case Analyser::Static::Commodore::Target::Region::Japanese:
-					character = ROM::Name::Vic20JapaneseCharacters;
-					kernel = ROM::Name::Vic20JapaneseKernel;
-				break;
-				case Analyser::Static::Commodore::Target::Region::Swedish:
-					character = ROM::Name::Vic20SwedishCharacters;
-					kernel = ROM::Name::Vic20SwedishKernel;
-				break;
-			}
+		ROM::Request request(ROM::Name::Vic20BASIC);
+		ROM::Name kernel, character;
+		switch(target.region) {
+			default:
+				character = ROM::Name::Vic20EnglishCharacters;
+				kernel = ROM::Name::Vic20EnglishPALKernel;
+			break;
+			case Analyser::Static::Commodore::Target::Region::American:
+				character = ROM::Name::Vic20EnglishCharacters;
+				kernel = ROM::Name::Vic20EnglishNTSCKernel;
+			break;
+			case Analyser::Static::Commodore::Target::Region::Danish:
+				character = ROM::Name::Vic20DanishCharacters;
+				kernel = ROM::Name::Vic20DanishKernel;
+			break;
+			case Analyser::Static::Commodore::Target::Region::Japanese:
+				character = ROM::Name::Vic20JapaneseCharacters;
+				kernel = ROM::Name::Vic20JapaneseKernel;
+			break;
+			case Analyser::Static::Commodore::Target::Region::Swedish:
+				character = ROM::Name::Vic20SwedishCharacters;
+				kernel = ROM::Name::Vic20SwedishKernel;
+			break;
+		}
 
-			if(target.has_c1540) {
-				request = request && Commodore::C1540::Machine::rom_request(Commodore::C1540::Personality::C1540);
-			}
-			request = request && ROM::Request(character) && ROM::Request(kernel);
+		if(target.has_c1540) {
+			request = request && Commodore::C1540::Machine::rom_request(Commodore::C1540::Personality::C1540);
+		}
+		request = request && ROM::Request(character) && ROM::Request(kernel);
 
-			auto roms = rom_fetcher(request);
-			if(!request.validate(roms)) {
-				throw ROMMachine::Error::MissingROMs;
-			}
+		auto roms = rom_fetcher(request);
+		if(!request.validate(roms)) {
+			throw ROMMachine::Error::MissingROMs;
+		}
 
-			basic_rom_ = std::move(roms.find(ROM::Name::Vic20BASIC)->second);
-			character_rom_ = std::move(roms.find(character)->second);
-			kernel_rom_ = std::move(roms.find(kernel)->second);
+		basic_rom_ = std::move(roms.find(ROM::Name::Vic20BASIC)->second);
+		character_rom_ = std::move(roms.find(character)->second);
+		kernel_rom_ = std::move(roms.find(kernel)->second);
 
-			if(target.has_c1540) {
-				// construct the 1540
-				c1540_ = std::make_unique<::Commodore::C1540::Machine>(Commodore::C1540::Personality::C1540, roms);
+		if(target.has_c1540) {
+			// construct the 1540
+			c1540_ = std::make_unique<::Commodore::C1540::Machine>(Commodore::C1540::Personality::C1540, roms);
 
-				// attach it to the serial bus
-				c1540_->set_serial_bus(serial_bus_);
+			// attach it to the serial bus
+			c1540_->set_serial_bus(serial_bus_);
 
-				// give it a little warm up
-				c1540_->run_for(Cycles(2000000));
-			}
+			// give it a little warm up
+			c1540_->run_for(Cycles(2000000));
+		}
 
-			// Determine PAL/NTSC
-			if(target.region == Analyser::Static::Commodore::Target::Region::American || target.region == Analyser::Static::Commodore::Target::Region::Japanese) {
-				// NTSC
-				set_clock_rate(1022727);
-				mos6560_.set_output_mode(MOS::MOS6560::OutputMode::NTSC);
-			} else {
-				// PAL
-				set_clock_rate(1108404);
-				mos6560_.set_output_mode(MOS::MOS6560::OutputMode::PAL);
-			}
+		// Determine PAL/NTSC
+		if(target.region == Analyser::Static::Commodore::Target::Region::American || target.region == Analyser::Static::Commodore::Target::Region::Japanese) {
+			// NTSC
+			set_clock_rate(1022727);
+			mos6560_.set_output_mode(MOS::MOS6560::OutputMode::NTSC);
+		} else {
+			// PAL
+			set_clock_rate(1108404);
+			mos6560_.set_output_mode(MOS::MOS6560::OutputMode::PAL);
+		}
 
-			mos6560_.set_high_frequency_cutoff(1600);	// There is a 1.6Khz low-pass filter in the Vic-20.
-			mos6560_.set_clock_rate(get_clock_rate());
+		mos6560_.set_high_frequency_cutoff(1600);	// There is a 1.6Khz low-pass filter in the Vic-20.
+		mos6560_.set_clock_rate(get_clock_rate());
 
-			// Initialise the memory maps as all pointing to nothing
-			memset(processor_read_memory_map_, 0, sizeof(processor_read_memory_map_));
-			memset(processor_write_memory_map_, 0, sizeof(processor_write_memory_map_));
-			memset(mos6560_bus_handler_.video_memory_map, 0, sizeof(mos6560_bus_handler_.video_memory_map));
+		// Initialise the memory maps as all pointing to nothing
+		memset(processor_read_memory_map_, 0, sizeof(processor_read_memory_map_));
+		memset(processor_write_memory_map_, 0, sizeof(processor_write_memory_map_));
+		memset(mos6560_bus_handler_.video_memory_map, 0, sizeof(mos6560_bus_handler_.video_memory_map));
 
 #define set_ram(baseaddr, length)	{ \
-		write_to_map(processor_read_memory_map_, &ram_[baseaddr], baseaddr, length);	\
-		write_to_map(processor_write_memory_map_, &ram_[baseaddr], baseaddr, length);	\
-	}
+	write_to_map(processor_read_memory_map_, &ram_[baseaddr], baseaddr, length);	\
+	write_to_map(processor_write_memory_map_, &ram_[baseaddr], baseaddr, length);	\
+}
 
-			// Add 6502-visible RAM as requested.
-			set_ram(0x0000, 0x0400);
-			set_ram(0x1000, 0x1000);	// Built-in RAM.
-			if(target.enabled_ram.bank0) set_ram(0x0400, 0x0c00);	// Bank 0:	0x0400 -> 0x1000.
-			if(target.enabled_ram.bank1) set_ram(0x2000, 0x2000);	// Bank 1:	0x2000 -> 0x4000.
-			if(target.enabled_ram.bank2) set_ram(0x4000, 0x2000);	// Bank 2:	0x4000 -> 0x6000.
-			if(target.enabled_ram.bank3) set_ram(0x6000, 0x2000);	// Bank 3:	0x6000 -> 0x8000.
-			if(target.enabled_ram.bank5) set_ram(0xa000, 0x2000);	// Bank 5:	0xa000 -> 0xc000.
+		// Add 6502-visible RAM as requested.
+		set_ram(0x0000, 0x0400);
+		set_ram(0x1000, 0x1000);	// Built-in RAM.
+		if(target.enabled_ram.bank0) set_ram(0x0400, 0x0c00);	// Bank 0:	0x0400 -> 0x1000.
+		if(target.enabled_ram.bank1) set_ram(0x2000, 0x2000);	// Bank 1:	0x2000 -> 0x4000.
+		if(target.enabled_ram.bank2) set_ram(0x4000, 0x2000);	// Bank 2:	0x4000 -> 0x6000.
+		if(target.enabled_ram.bank3) set_ram(0x6000, 0x2000);	// Bank 3:	0x6000 -> 0x8000.
+		if(target.enabled_ram.bank5) set_ram(0xa000, 0x2000);	// Bank 5:	0xa000 -> 0xc000.
 
 #undef set_ram
 
-			// all expansions also have colour RAM visible at 0x9400.
-			write_to_map(processor_read_memory_map_, colour_ram_, 0x9400, sizeof(colour_ram_));
-			write_to_map(processor_write_memory_map_, colour_ram_, 0x9400, sizeof(colour_ram_));
+		// all expansions also have colour RAM visible at 0x9400.
+		write_to_map(processor_read_memory_map_, colour_ram_, 0x9400, sizeof(colour_ram_));
+		write_to_map(processor_write_memory_map_, colour_ram_, 0x9400, sizeof(colour_ram_));
 
-			// also push memory resources into the 6560 video memory map; the 6560 has only a
-			// 14-bit address bus and the top bit is invested and used as bit 15 for the main
-			// memory bus. It can access only internal memory, so the first 1kb, then the 4kb from 0x1000.
-			struct Range {
-				const std::size_t start, end;
-				Range(std::size_t start, std::size_t end) : start(start), end(end) {}
-			};
-			const std::array<Range, 2> video_ranges = {{
-				Range(0x0000, 0x0400),
-				Range(0x1000, 0x2000),
-			}};
-			for(const auto &video_range : video_ranges) {
-				for(auto addr = video_range.start; addr < video_range.end; addr += 0x400) {
-					auto destination_address = (addr & 0x1fff) | (((addr & 0x8000) >> 2) ^ 0x2000);
-					if(processor_read_memory_map_[addr >> 10]) {
-						write_to_map(mos6560_bus_handler_.video_memory_map, &ram_[addr], uint16_t(destination_address), 0x400);
-					}
+		// also push memory resources into the 6560 video memory map; the 6560 has only a
+		// 14-bit address bus and the top bit is invested and used as bit 15 for the main
+		// memory bus. It can access only internal memory, so the first 1kb, then the 4kb from 0x1000.
+		struct Range {
+			const std::size_t start, end;
+			Range(std::size_t start, std::size_t end) : start(start), end(end) {}
+		};
+		const std::array<Range, 2> video_ranges = {{
+			Range(0x0000, 0x0400),
+			Range(0x1000, 0x2000),
+		}};
+		for(const auto &video_range : video_ranges) {
+			for(auto addr = video_range.start; addr < video_range.end; addr += 0x400) {
+				auto destination_address = (addr & 0x1fff) | (((addr & 0x8000) >> 2) ^ 0x2000);
+				if(processor_read_memory_map_[addr >> 10]) {
+					write_to_map(mos6560_bus_handler_.video_memory_map, &ram_[addr], uint16_t(destination_address), 0x400);
 				}
 			}
-			mos6560_bus_handler_.colour_memory = colour_ram_;
+		}
+		mos6560_bus_handler_.colour_memory = colour_ram_;
 
-			// install the BASIC ROM
-			write_to_map(processor_read_memory_map_, basic_rom_.data(), 0xc000, uint16_t(basic_rom_.size()));
+		// install the BASIC ROM
+		write_to_map(processor_read_memory_map_, basic_rom_.data(), 0xc000, uint16_t(basic_rom_.size()));
 
-			// install the system ROM
-			write_to_map(processor_read_memory_map_, character_rom_.data(), 0x8000, uint16_t(character_rom_.size()));
-			write_to_map(mos6560_bus_handler_.video_memory_map, character_rom_.data(), 0x0000, uint16_t(character_rom_.size()));
-			write_to_map(processor_read_memory_map_, kernel_rom_.data(), 0xe000, uint16_t(kernel_rom_.size()));
+		// install the system ROM
+		write_to_map(processor_read_memory_map_, character_rom_.data(), 0x8000, uint16_t(character_rom_.size()));
+		write_to_map(mos6560_bus_handler_.video_memory_map, character_rom_.data(), 0x0000, uint16_t(character_rom_.size()));
+		write_to_map(processor_read_memory_map_, kernel_rom_.data(), 0xe000, uint16_t(kernel_rom_.size()));
 
-			// The insert_media occurs last, so if there's a conflict between cartridges and RAM,
-			// the cartridge wins.
-			insert_media(target.media);
-			if(!target.loading_command.empty()) {
-				type_string(target.loading_command);
-			}
+		// The insert_media occurs last, so if there's a conflict between cartridges and RAM,
+		// the cartridge wins.
+		insert_media(target.media);
+		if(!target.loading_command.empty()) {
+			type_string(target.loading_command);
+		}
+	}
+
+	bool insert_media(const Analyser::Static::Media &media) final {
+		if(!media.tapes.empty()) {
+			tape_->set_tape(media.tapes.front());
 		}
 
-		bool insert_media(const Analyser::Static::Media &media) final {
-			if(!media.tapes.empty()) {
-				tape_->set_tape(media.tapes.front());
-			}
-
-			if(!media.disks.empty() && c1540_) {
-				c1540_->set_disk(media.disks.front());
-			}
-
-			if(!media.cartridges.empty()) {
-				rom_address_ = 0xa000;
-				std::vector<uint8_t> rom_image = media.cartridges.front()->get_segments().front().data;
-				rom_length_ = uint16_t(rom_image.size());
-
-				rom_ = rom_image;
-				rom_.resize(0x2000);
-				write_to_map(processor_read_memory_map_, rom_.data(), rom_address_, rom_length_);
-			}
-
-			set_use_fast_tape();
-
-			return !media.tapes.empty() || (!media.disks.empty() && c1540_ != nullptr) || !media.cartridges.empty();
+		if(!media.disks.empty() && c1540_) {
+			c1540_->set_disk(media.disks.front());
 		}
 
-		void set_key_state(uint16_t key, bool is_pressed) final {
-			if(key < 0xfff0) {
-				keyboard_via_port_handler_->set_key_state(key, is_pressed);
-			} else {
-				switch(key) {
-					case KeyRestore:
-						user_port_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !is_pressed);
-					break;
+		if(!media.cartridges.empty()) {
+			rom_address_ = 0xa000;
+			std::vector<uint8_t> rom_image = media.cartridges.front()->get_segments().front().data;
+			rom_length_ = uint16_t(rom_image.size());
+
+			rom_ = rom_image;
+			rom_.resize(0x2000);
+			write_to_map(processor_read_memory_map_, rom_.data(), rom_address_, rom_length_);
+		}
+
+		set_use_fast_tape();
+
+		return !media.tapes.empty() || (!media.disks.empty() && c1540_ != nullptr) || !media.cartridges.empty();
+	}
+
+	void set_key_state(const uint16_t key, const bool is_pressed) final {
+		if(key < 0xfff0) {
+			keyboard_via_port_handler_->set_key_state(key, is_pressed);
+		} else {
+			switch(key) {
+				case KeyRestore:
+					user_port_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !is_pressed);
+				break;
 #define ShiftedMap(source, target)	\
-					case source:	\
-						keyboard_via_port_handler_->set_key_state(KeyLShift, is_pressed);	\
-						keyboard_via_port_handler_->set_key_state(target, is_pressed);	\
-					break;
+				case source:	\
+					keyboard_via_port_handler_->set_key_state(KeyLShift, is_pressed);	\
+					keyboard_via_port_handler_->set_key_state(target, is_pressed);	\
+				break;
 
-					ShiftedMap(KeyUp, KeyDown);
-					ShiftedMap(KeyLeft, KeyRight);
-					ShiftedMap(KeyF2, KeyF1);
-					ShiftedMap(KeyF4, KeyF3);
-					ShiftedMap(KeyF6, KeyF5);
-					ShiftedMap(KeyF8, KeyF7);
+				ShiftedMap(KeyUp, KeyDown);
+				ShiftedMap(KeyLeft, KeyRight);
+				ShiftedMap(KeyF2, KeyF1);
+				ShiftedMap(KeyF4, KeyF3);
+				ShiftedMap(KeyF6, KeyF5);
+				ShiftedMap(KeyF8, KeyF7);
 #undef ShiftedMap
-				}
 			}
 		}
+	}
 
-		void clear_all_keys() final {
-			keyboard_via_port_handler_->clear_all_keys();
-		}
+	void clear_all_keys() final {
+		keyboard_via_port_handler_->clear_all_keys();
+	}
 
-		const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() final {
-			return joysticks_;
-		}
+	const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() final {
+		return joysticks_;
+	}
 
-		// to satisfy CPU::MOS6502::Processor
-		forceinline Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
-			// run the phase-1 part of this cycle, in which the VIC accesses memory
-			cycles_since_mos6560_update_++;
+	// to satisfy CPU::MOS6502::Processor
+	forceinline Cycles perform_bus_operation(
+		const CPU::MOS6502::BusOperation operation,
+		const uint16_t address,
+		uint8_t *const value
+	) {
+		// run the phase-1 part of this cycle, in which the VIC accesses memory
+		cycles_since_mos6560_update_++;
 
-			// run the phase-2 part of the cycle, which is whatever the 6502 said it should be
-			if(isReadOperation(operation)) {
-				uint8_t result = processor_read_memory_map_[address >> 10] ? processor_read_memory_map_[address >> 10][address & 0x3ff] : 0xff;
-				if((address&0xfc00) == 0x9000) {
-					if(!(address&0x100)) {
-						update_video();
-						result &= mos6560_.read(address);
-					}
-					if(address & 0x10) result &= user_port_via_.read(address);
-					if(address & 0x20) result &= keyboard_via_.read(address);
+		// run the phase-2 part of the cycle, which is whatever the 6502 said it should be
+		if(isReadOperation(operation)) {
+			uint8_t result = processor_read_memory_map_[address >> 10] ? processor_read_memory_map_[address >> 10][address & 0x3ff] : 0xff;
+			if((address&0xfc00) == 0x9000) {
+				if(!(address&0x100)) {
+					update_video();
+					result &= mos6560_.read(address);
 				}
-				*value = result;
+				if(address & 0x10) result &= user_port_via_.read(address);
+				if(address & 0x20) result &= keyboard_via_.read(address);
+			}
+			*value = result;
 
-				// Consider applying the fast tape hack.
-				if(use_fast_tape_hack_ && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
-					if(address == 0xf7b2) {
-						// Address 0xf7b2 contains a JSR to 0xf8c0 that will fill the tape buffer with the next header.
-						// So cancel that via a double NOP and fill in the next header programmatically.
+			// Consider applying the fast tape hack.
+			if(use_fast_tape_hack_ && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
+				if(address == 0xf7b2) {
+					// Address 0xf7b2 contains a JSR to 0xf8c0 that will fill the tape buffer with the next header.
+					// So cancel that via a double NOP and fill in the next header programmatically.
+					Storage::Tape::Commodore::Parser parser;
+					std::unique_ptr<Storage::Tape::Commodore::Header> header = parser.get_next_header(tape_->tape());
+
+					const auto tape_position = tape_->tape()->offset();
+					if(header) {
+						// serialise to wherever b2:b3 points
+						const uint16_t tape_buffer_pointer = uint16_t(ram_[0xb2]) | uint16_t(ram_[0xb3] << 8);
+						header->serialise(&ram_[tape_buffer_pointer], 0x8000 - tape_buffer_pointer);
+						hold_tape_ = true;
+						logger.info().append("Found header");
+					} else {
+						// no header found, so pretend this hack never interceded
+						tape_->tape()->set_offset(tape_position);
+						hold_tape_ = false;
+						logger.info().append("Didn't find header");
+					}
+
+					// clear status and the verify flag
+					ram_[0x90] = 0;
+					ram_[0x93] = 0;
+
+					*value = 0x0c;	// i.e. NOP abs, to swallow the entire JSR
+				} else if(address == 0xf90b) {
+					uint8_t x = uint8_t(m6502_.value_of(CPU::MOS6502::Register::X));
+					if(x == 0xe) {
 						Storage::Tape::Commodore::Parser parser;
-						std::unique_ptr<Storage::Tape::Commodore::Header> header = parser.get_next_header(tape_->tape());
-
 						const auto tape_position = tape_->tape()->offset();
-						if(header) {
-							// serialise to wherever b2:b3 points
-							const uint16_t tape_buffer_pointer = uint16_t(ram_[0xb2]) | uint16_t(ram_[0xb3] << 8);
-							header->serialise(&ram_[tape_buffer_pointer], 0x8000 - tape_buffer_pointer);
+						const std::unique_ptr<Storage::Tape::Commodore::Data> data = parser.get_next_data(tape_->tape());
+						if(data) {
+							uint16_t start_address, end_address;
+							start_address = uint16_t(ram_[0xc1] | (ram_[0xc2] << 8));
+							end_address = uint16_t(ram_[0xae] | (ram_[0xaf] << 8));
+
+							// perform a via-processor_write_memory_map_ memcpy
+							uint8_t *data_ptr = data->data.data();
+							std::size_t data_left = data->data.size();
+							while(data_left && start_address != end_address) {
+								uint8_t *page = processor_write_memory_map_[start_address >> 10];
+								if(page) page[start_address & 0x3ff] = *data_ptr;
+								data_ptr++;
+								start_address++;
+								data_left--;
+							}
+
+							// set tape status, carry and flag
+							ram_[0x90] |= 0x40;
+							uint8_t	flags = uint8_t(m6502_.value_of(CPU::MOS6502::Register::Flags));
+							flags &= ~uint8_t((CPU::MOS6502::Flag::Carry | CPU::MOS6502::Flag::Interrupt));
+							m6502_.set_value_of(CPU::MOS6502::Register::Flags, flags);
+
+							// to ensure that execution proceeds to 0xfccf, pretend a NOP was here and
+							// ensure that the PC leaps to 0xfccf
+							m6502_.set_value_of(CPU::MOS6502::Register::ProgramCounter, 0xfccf);
+							*value = 0xea;	// i.e. NOP implied
 							hold_tape_ = true;
-							logger.info().append("Found header");
+							logger.info().append("Found data");
 						} else {
-							// no header found, so pretend this hack never interceded
 							tape_->tape()->set_offset(tape_position);
 							hold_tape_ = false;
-							logger.info().append("Didn't find header");
-						}
-
-						// clear status and the verify flag
-						ram_[0x90] = 0;
-						ram_[0x93] = 0;
-
-						*value = 0x0c;	// i.e. NOP abs, to swallow the entire JSR
-					} else if(address == 0xf90b) {
-						uint8_t x = uint8_t(m6502_.value_of(CPU::MOS6502::Register::X));
-						if(x == 0xe) {
-							Storage::Tape::Commodore::Parser parser;
-							const auto tape_position = tape_->tape()->offset();
-							const std::unique_ptr<Storage::Tape::Commodore::Data> data = parser.get_next_data(tape_->tape());
-							if(data) {
-								uint16_t start_address, end_address;
-								start_address = uint16_t(ram_[0xc1] | (ram_[0xc2] << 8));
-								end_address = uint16_t(ram_[0xae] | (ram_[0xaf] << 8));
-
-								// perform a via-processor_write_memory_map_ memcpy
-								uint8_t *data_ptr = data->data.data();
-								std::size_t data_left = data->data.size();
-								while(data_left && start_address != end_address) {
-									uint8_t *page = processor_write_memory_map_[start_address >> 10];
-									if(page) page[start_address & 0x3ff] = *data_ptr;
-									data_ptr++;
-									start_address++;
-									data_left--;
-								}
-
-								// set tape status, carry and flag
-								ram_[0x90] |= 0x40;
-								uint8_t	flags = uint8_t(m6502_.value_of(CPU::MOS6502::Register::Flags));
-								flags &= ~uint8_t((CPU::MOS6502::Flag::Carry | CPU::MOS6502::Flag::Interrupt));
-								m6502_.set_value_of(CPU::MOS6502::Register::Flags, flags);
-
-								// to ensure that execution proceeds to 0xfccf, pretend a NOP was here and
-								// ensure that the PC leaps to 0xfccf
-								m6502_.set_value_of(CPU::MOS6502::Register::ProgramCounter, 0xfccf);
-								*value = 0xea;	// i.e. NOP implied
-								hold_tape_ = true;
-								logger.info().append("Found data");
-							} else {
-								tape_->tape()->set_offset(tape_position);
-								hold_tape_ = false;
-								logger.info().append("Didn't find data");
-							}
+							logger.info().append("Didn't find data");
 						}
 					}
 				}
-			} else {
-				uint8_t *ram = processor_write_memory_map_[address >> 10];
-				if(ram) {
-					update_video();
-					ram[address & 0x3ff] = *value;
-				}
-				// Anything between 0x9000 and 0x9400 is the IO area.
-				if((address&0xfc00) == 0x9000) {
-					// The VIC is selected by bit 8 = 0
-					if(!(address&0x100)) {
-						update_video();
-						mos6560_.write(address, *value);
-					}
-					// The first VIA is selected by bit 4 = 1.
-					if(address & 0x10) user_port_via_.write(address, *value);
-					// The second VIA is selected by bit 5 = 1.
-					if(address & 0x20) keyboard_via_.write(address, *value);
-				}
 			}
-
-			user_port_via_.run_for(Cycles(1));
-			keyboard_via_.run_for(Cycles(1));
-			if(typer_ && address == 0xeb1e && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
-				if(!typer_->type_next_character()) {
-					clear_all_keys();
-					typer_.reset();
-				}
-			}
-			if(!tape_is_sleeping_ && !hold_tape_) tape_->run_for(Cycles(1));
-			if(c1540_) c1540_->run_for(Cycles(1));
-
-			return Cycles(1);
-		}
-
-		void flush_output(int outputs) final {
-			if(outputs & Output::Video) {
+		} else {
+			uint8_t *ram = processor_write_memory_map_[address >> 10];
+			if(ram) {
 				update_video();
+				ram[address & 0x3ff] = *value;
 			}
-			if(outputs & Output::Audio) {
-				mos6560_.flush();
+			// Anything between 0x9000 and 0x9400 is the IO area.
+			if((address&0xfc00) == 0x9000) {
+				// The VIC is selected by bit 8 = 0
+				if(!(address&0x100)) {
+					update_video();
+					mos6560_.write(address, *value);
+				}
+				// The first VIA is selected by bit 4 = 1.
+				if(address & 0x10) user_port_via_.write(address, *value);
+				// The second VIA is selected by bit 5 = 1.
+				if(address & 0x20) keyboard_via_.write(address, *value);
 			}
 		}
 
-		void run_for(const Cycles cycles) final {
-			m6502_.run_for(cycles);
-		}
-
-		void set_scan_target(Outputs::Display::ScanTarget *scan_target) final {
-			mos6560_.set_scan_target(scan_target);
-		}
-
-		Outputs::Display::ScanStatus get_scaled_scan_status() const final {
-			return mos6560_.get_scaled_scan_status();
-		}
-
-		void set_display_type(Outputs::Display::DisplayType display_type) final {
-			mos6560_.set_display_type(display_type);
-		}
-
-		Outputs::Display::DisplayType get_display_type() const final {
-			return mos6560_.get_display_type();
-		}
-
-		Outputs::Speaker::Speaker *get_speaker() final {
-			return mos6560_.get_speaker();
-		}
-
-		void mos6522_did_change_interrupt_status(void *) final {
-			m6502_.set_nmi_line(user_port_via_.get_interrupt_line());
-			m6502_.set_irq_line(keyboard_via_.get_interrupt_line());
-		}
-
-		void type_string(const std::string &string) final {
-			Utility::TypeRecipient<CharacterMapper>::add_typer(string);
-		}
-
-		bool can_type(char c) const final {
-			return Utility::TypeRecipient<CharacterMapper>::can_type(c);
-		}
-
-		void tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape) final {
-			keyboard_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !tape->input());
-		}
-
-		KeyboardMapper *get_keyboard_mapper() final {
-			return &keyboard_mapper_;
-		}
-
-		// MARK: - Configuration options.
-		std::unique_ptr<Reflection::Struct> get_options() const final {
-			auto options = std::make_unique<Options>(Configurable::OptionsType::UserFriendly);
-			options->output = get_video_signal_configurable();
-			options->quickload = allow_fast_tape_hack_;
-			return options;
-		}
-
-		void set_options(const std::unique_ptr<Reflection::Struct> &str) final {
-			const auto options = dynamic_cast<Options *>(str.get());
-
-			set_video_signal_configurable(options->output);
-			allow_fast_tape_hack_ = options->quickload;
-			set_use_fast_tape();
-		}
-
-		void set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference clocking) final {
-			tape_is_sleeping_ = clocking == ClockingHint::Preference::None;
-			set_use_fast_tape();
-		}
-
-		// MARK: - Activity Source
-		void set_activity_observer(Activity::Observer *observer) final {
-			if(c1540_) c1540_->set_activity_observer(observer);
-		}
-
-	private:
-		void update_video() {
-			mos6560_.run_for(cycles_since_mos6560_update_.flush<Cycles>());
-		}
-		CPU::MOS6502::Processor<CPU::MOS6502::Personality::P6502, ConcreteMachine, false> m6502_;
-
-		std::vector<uint8_t> character_rom_;
-		std::vector<uint8_t> basic_rom_;
-		std::vector<uint8_t> kernel_rom_;
-
-		std::vector<uint8_t> rom_;
-		uint16_t rom_address_, rom_length_;
-		uint8_t ram_[0x10000];
-		uint8_t colour_ram_[0x0400];
-
-		uint8_t *processor_read_memory_map_[64];
-		uint8_t *processor_write_memory_map_[64];
-		void write_to_map(uint8_t **map, uint8_t *area, uint16_t address, uint16_t length) {
-			address >>= 10;
-			length >>= 10;
-			while(length--) {
-				map[address] = area;
-				area += 0x400;
-				address++;
+		user_port_via_.run_for(Cycles(1));
+		keyboard_via_.run_for(Cycles(1));
+		if(typer_ && address == 0xeb1e && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
+			if(!typer_->type_next_character()) {
+				clear_all_keys();
+				typer_.reset();
 			}
 		}
+		if(!tape_is_sleeping_ && !hold_tape_) tape_->run_for(Cycles(1));
+		if(c1540_) c1540_->run_for(Cycles(1));
 
-		Commodore::Vic20::KeyboardMapper keyboard_mapper_;
-		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+		return Cycles(1);
+	}
 
-		Cycles cycles_since_mos6560_update_;
-		Vic6560BusHandler mos6560_bus_handler_;
-		MOS::MOS6560::MOS6560<Vic6560BusHandler> mos6560_;
-		std::shared_ptr<UserPortVIA> user_port_via_port_handler_;
-		std::shared_ptr<KeyboardVIA> keyboard_via_port_handler_;
-		std::shared_ptr<SerialPort> serial_port_;
-		std::shared_ptr<::Commodore::Serial::Bus> serial_bus_;
-
-		MOS::MOS6522::MOS6522<UserPortVIA> user_port_via_;
-		MOS::MOS6522::MOS6522<KeyboardVIA> keyboard_via_;
-
-		// Tape
-		std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
-		bool use_fast_tape_hack_ = false;
-		bool hold_tape_ = false;
-		bool allow_fast_tape_hack_ = false;
-		bool tape_is_sleeping_ = true;
-		void set_use_fast_tape() {
-			use_fast_tape_hack_ = !tape_is_sleeping_ && allow_fast_tape_hack_ && tape_->has_tape();
+	void flush_output(const int outputs) final {
+		if(outputs & Output::Video) {
+			update_video();
 		}
+		if(outputs & Output::Audio) {
+			mos6560_.flush();
+		}
+	}
 
-		// Disk
-		std::shared_ptr<::Commodore::C1540::Machine> c1540_;
+	void run_for(const Cycles cycles) final {
+		m6502_.run_for(cycles);
+	}
+
+	void set_scan_target(Outputs::Display::ScanTarget *const scan_target) final {
+		mos6560_.set_scan_target(scan_target);
+	}
+
+	Outputs::Display::ScanStatus get_scaled_scan_status() const final {
+		return mos6560_.get_scaled_scan_status();
+	}
+
+	void set_display_type(const Outputs::Display::DisplayType display_type) final {
+		mos6560_.set_display_type(display_type);
+	}
+
+	Outputs::Display::DisplayType get_display_type() const final {
+		return mos6560_.get_display_type();
+	}
+
+	Outputs::Speaker::Speaker *get_speaker() final {
+		return mos6560_.get_speaker();
+	}
+
+	void mos6522_did_change_interrupt_status(void *) final {
+		m6502_.set_nmi_line(user_port_via_.get_interrupt_line());
+		m6502_.set_irq_line(keyboard_via_.get_interrupt_line());
+	}
+
+	void type_string(const std::string &string) final {
+		Utility::TypeRecipient<CharacterMapper>::add_typer(string);
+	}
+
+	bool can_type(const char c) const final {
+		return Utility::TypeRecipient<CharacterMapper>::can_type(c);
+	}
+
+	void tape_did_change_input(Storage::Tape::BinaryTapePlayer *const tape) final {
+		keyboard_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !tape->input());
+	}
+
+	KeyboardMapper *get_keyboard_mapper() final {
+		return &keyboard_mapper_;
+	}
+
+	// MARK: - Configuration options.
+	std::unique_ptr<Reflection::Struct> get_options() const final {
+		auto options = std::make_unique<Options>(Configurable::OptionsType::UserFriendly);
+		options->output = get_video_signal_configurable();
+		options->quickload = allow_fast_tape_hack_;
+		return options;
+	}
+
+	void set_options(const std::unique_ptr<Reflection::Struct> &str) final {
+		const auto options = dynamic_cast<Options *>(str.get());
+
+		set_video_signal_configurable(options->output);
+		allow_fast_tape_hack_ = options->quickload;
+		set_use_fast_tape();
+	}
+
+	void set_component_prefers_clocking(ClockingHint::Source *, const ClockingHint::Preference clocking) final {
+		tape_is_sleeping_ = clocking == ClockingHint::Preference::None;
+		set_use_fast_tape();
+	}
+
+	// MARK: - Activity Source
+	void set_activity_observer(Activity::Observer *const observer) final {
+		if(c1540_) c1540_->set_activity_observer(observer);
+	}
+
+private:
+	void update_video() {
+		mos6560_.run_for(cycles_since_mos6560_update_.flush<Cycles>());
+	}
+	CPU::MOS6502::Processor<CPU::MOS6502::Personality::P6502, ConcreteMachine, false> m6502_;
+
+	std::vector<uint8_t> character_rom_;
+	std::vector<uint8_t> basic_rom_;
+	std::vector<uint8_t> kernel_rom_;
+
+	std::vector<uint8_t> rom_;
+	uint16_t rom_address_, rom_length_;
+	uint8_t ram_[0x10000];
+	uint8_t colour_ram_[0x0400];
+
+	uint8_t *processor_read_memory_map_[64];
+	uint8_t *processor_write_memory_map_[64];
+	void write_to_map(uint8_t **map, uint8_t *area, uint16_t address, uint16_t length) {
+		address >>= 10;
+		length >>= 10;
+		while(length--) {
+			map[address] = area;
+			area += 0x400;
+			address++;
+		}
+	}
+
+	Commodore::Vic20::KeyboardMapper keyboard_mapper_;
+	std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+
+	Cycles cycles_since_mos6560_update_;
+	Vic6560BusHandler mos6560_bus_handler_;
+	MOS::MOS6560::MOS6560<Vic6560BusHandler> mos6560_;
+	std::shared_ptr<UserPortVIA> user_port_via_port_handler_;
+	std::shared_ptr<KeyboardVIA> keyboard_via_port_handler_;
+	std::shared_ptr<SerialPort> serial_port_;
+	std::shared_ptr<::Commodore::Serial::Bus> serial_bus_;
+
+	MOS::MOS6522::MOS6522<UserPortVIA> user_port_via_;
+	MOS::MOS6522::MOS6522<KeyboardVIA> keyboard_via_;
+
+	// Tape
+	std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
+	bool use_fast_tape_hack_ = false;
+	bool hold_tape_ = false;
+	bool allow_fast_tape_hack_ = false;
+	bool tape_is_sleeping_ = true;
+	void set_use_fast_tape() {
+		use_fast_tape_hack_ = !tape_is_sleeping_ && allow_fast_tape_hack_ && tape_->has_tape();
+	}
+
+	// Disk
+	std::shared_ptr<::Commodore::C1540::Machine> c1540_;
 };
 
 }
 
 using namespace Commodore::Vic20;
 
-std::unique_ptr<Machine> Machine::Vic20(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::Vic20(
+	const Analyser::Static::Target *const 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<Vic20::ConcreteMachine>(*commodore_target, rom_fetcher);
diff --git a/Machines/Commodore/Vic-20/Vic20.hpp b/Machines/Commodore/Vic-20/Vic20.hpp
index e21ae244f..1467ab8c6 100644
--- a/Machines/Commodore/Vic-20/Vic20.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/Enterprise/Enterprise.hpp b/Machines/Enterprise/Enterprise.hpp
index fda8df3fb..d7673588e 100644
--- a/Machines/Enterprise/Enterprise.hpp
+++ b/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);
+		}
+	};
 };
 
 };
diff --git a/Machines/JoystickMachine.hpp b/Machines/JoystickMachine.hpp
index b7712b778..d38144553 100644
--- a/Machines/JoystickMachine.hpp
+++ b/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;
 };
 
 }
diff --git a/Machines/KeyboardMachine.hpp b/Machines/KeyboardMachine.hpp
index dee9d2a5e..d13d3967b 100644
--- a/Machines/KeyboardMachine.hpp
+++ b/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_;
 };
 
diff --git a/Machines/MSX/MSX.hpp b/Machines/MSX/MSX.hpp
index 4effe68ad..9e3ff5ac4 100644
--- a/Machines/MSX/MSX.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/MasterSystem/MasterSystem.hpp b/Machines/MasterSystem/MasterSystem.hpp
index faabdfa6e..9c2832b0c 100644
--- a/Machines/MasterSystem/MasterSystem.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/MediaTarget.hpp b/Machines/MediaTarget.hpp
index f10586c3a..63e066230 100644
--- a/Machines/MediaTarget.hpp
+++ b/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;
 };
 
 }
diff --git a/Machines/MouseMachine.hpp b/Machines/MouseMachine.hpp
index 10b6aa846..56cf5f2b7 100644
--- a/Machines/MouseMachine.hpp
+++ b/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;
 };
 
 }
diff --git a/Machines/Oric/Oric.hpp b/Machines/Oric/Oric.hpp
index 83b203559..c6cddcbe4 100644
--- a/Machines/Oric/Oric.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/PCCompatible/PCCompatible.hpp b/Machines/PCCompatible/PCCompatible.hpp
index 302f3b120..b891998f9 100644
--- a/Machines/PCCompatible/PCCompatible.hpp
+++ b/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);
+		}
+	};
 };
 
 }
diff --git a/Machines/ROMMachine.hpp b/Machines/ROMMachine.hpp
index 232f3a548..6fcaf9b1f 100644
--- a/Machines/ROMMachine.hpp
+++ b/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,
 };
 
 }
diff --git a/Machines/ScanProducer.hpp b/Machines/ScanProducer.hpp
index b63649497..892514eee 100644
--- a/Machines/ScanProducer.hpp
+++ b/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; }
 };
 
 }
diff --git a/Machines/Sinclair/ZX8081/ZX8081.hpp b/Machines/Sinclair/ZX8081/ZX8081.hpp
index deba561fc..9c53f9a23 100644
--- a/Machines/Sinclair/ZX8081/ZX8081.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/Sinclair/ZXSpectrum/State.hpp b/Machines/Sinclair/ZXSpectrum/State.hpp
index 253f6a01e..7eeb13d14 100644
--- a/Machines/Sinclair/ZXSpectrum/State.hpp
+++ b/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);
 	}
 };
 
diff --git a/Machines/Sinclair/ZXSpectrum/Video.hpp b/Machines/Sinclair/ZXSpectrum/Video.hpp
index fc380b84a..10ef12302 100644
--- a/Machines/Sinclair/ZXSpectrum/Video.hpp
+++ b/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);
+	}
 };
 
 }
diff --git a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp
index b0203400a..edb88c2f3 100644
--- a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp
+++ b/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();
+		}
+	};
 };
 
 }
diff --git a/Machines/TimedMachine.hpp b/Machines/TimedMachine.hpp
index d92da9b38..a13a42233 100644
--- a/Machines/TimedMachine.hpp
+++ b/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;
 	}
 
diff --git a/Machines/Utility/MachineForTarget.cpp b/Machines/Utility/MachineForTarget.cpp
index 3aea25755..493fffd73 100644
--- a/Machines/Utility/MachineForTarget.cpp
+++ b/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);
diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index aae7c1a32..5fd7733d7 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/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 */,
diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index 1dec5b8a5..dbea90fe3 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/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">
diff --git a/OSBindings/Mac/Clock SignalTests/CommodoreStaticAnalyserTests.mm b/OSBindings/Mac/Clock SignalTests/CommodoreStaticAnalyserTests.mm
index f2dc2e2c0..fb9b8a26c 100644
--- a/OSBindings/Mac/Clock SignalTests/CommodoreStaticAnalyserTests.mm	
+++ b/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 {
diff --git a/OSBindings/Qt/clksignal.pro b/OSBindings/Qt/clksignal.pro
index 93ed5b54d..f1644ee29 100644
--- a/OSBindings/Qt/clksignal.pro
+++ b/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 \
diff --git a/OSBindings/SDL/SConstruct b/OSBindings/SDL/SConstruct
index 3e4cb0f9b..13ecd966f 100644
--- a/OSBindings/SDL/SConstruct
+++ b/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')
diff --git a/Processors/6502/State/State.cpp b/Processors/6502/State/State.cpp
index def2e6fdc..8d1f42768 100644
--- a/Processors/6502/State/State.cpp
+++ b/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);
 }
diff --git a/Processors/6502/State/State.hpp b/Processors/6502/State/State.hpp
index 3af11f401..b1d230891 100644
--- a/Processors/6502/State/State.hpp
+++ b/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();
 };
 
 }
diff --git a/Processors/65816/65816.hpp b/Processors/65816/65816.hpp
index a27012734..d06b1f6e0 100644
--- a/Processors/65816/65816.hpp
+++ b/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);
 
diff --git a/Processors/Z80/State/State.cpp b/Processors/Z80/State/State.cpp
index 4f6f83fae..3398a6ff2 100644
--- a/Processors/Z80/State/State.cpp
+++ b/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);
 }
diff --git a/Processors/Z80/State/State.hpp b/Processors/Z80/State/State.hpp
index c7ff77e6b..7d034b21a 100644
--- a/Processors/Z80/State/State.hpp
+++ b/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();
 };
 
 }
diff --git a/Processors/Z80/Z80.hpp b/Processors/Z80/Z80.hpp
index 4eff3ff27..461788d91 100644
--- a/Processors/Z80/Z80.hpp
+++ b/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.
diff --git a/Reflection/Struct.hpp b/Reflection/Struct.hpp
index 2ba8b47cc..67b76288e 100644
--- a/Reflection/Struct.hpp
+++ b/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;
 };
 
 
diff --git a/Storage/Cartridge/Formats/PRG.cpp b/Storage/Cartridge/Formats/PRG.cpp
index 0bcc4af28..de94446ac 100644
--- a/Storage/Cartridge/Formats/PRG.cpp
+++ b/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
diff --git a/Storage/Disk/DiskImage/Formats/D64.cpp b/Storage/Disk/DiskImage/Formats/D64.cpp
index 370266b7a..ea36fb46c 100644
--- a/Storage/Disk/DiskImage/Formats/D64.cpp
+++ b/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]
 		};
diff --git a/Storage/Disk/DiskImage/Formats/D64.hpp b/Storage/Disk/DiskImage/Formats/D64.hpp
index ffe448024..8f7a537af 100644
--- a/Storage/Disk/DiskImage/Formats/D64.hpp
+++ b/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:
diff --git a/Storage/Disk/Encodings/CommodoreGCR.cpp b/Storage/Disk/Encodings/CommodoreGCR.cpp
index 5aeca485f..ac9081f95 100644
--- a/Storage/Disk/Encodings/CommodoreGCR.cpp
+++ b/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]),
diff --git a/Storage/Disk/Encodings/CommodoreGCR.hpp b/Storage/Disk/Encodings/CommodoreGCR.hpp
index f55ef580d..3e16077ed 100644
--- a/Storage/Disk/Encodings/CommodoreGCR.hpp
+++ b/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.
diff --git a/cmake/CLK_SOURCES.cmake b/cmake/CLK_SOURCES.cmake
index 4a621669f..6e2a770e5 100644
--- a/cmake/CLK_SOURCES.cmake
+++ b/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