Update version number.

CRT: accept data during retrace.

.github/workflows/build.yml

@@ -0,0 +1,87 @@
+name: Build
+on: [pull_request]
+jobs:
+  build-mac-xcodebuild:
+    name: Mac UI / xcodebuild / ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-12, macos-13, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Make
+      working-directory: OSBindings/Mac
+      run: xcodebuild CODE_SIGN_IDENTITY=-
+  build-sdl-cmake:
+    name: SDL UI / cmake / ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install dependencies
+      shell: bash
+      run: |
+        case $RUNNER_OS in
+          Linux)
+            sudo apt-get --allow-releaseinfo-change update
+            sudo apt-get --fix-missing install cmake gcc-10 libsdl2-dev
+            ;;
+          macOS)
+            brew install cmake sdl2
+            ;;
+        esac
+    - name: Make
+      shell: bash
+      run: |
+        case $RUNNER_OS in
+          Linux)
+            jobs=$(nproc --all)
+            ;;
+          macOS)
+            jobs=$(sysctl -n hw.activecpu)
+            ;;
+          *)
+            jobs=1
+        esac
+        cmake -S. -Bbuild -DCLK_UI=SDL -DCMAKE_BUILD_TYPE=Release
+        cmake --build build -v -j"$jobs"
+  build-sdl-scons:
+    name: SDL UI / scons / ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-14, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Install dependencies
+      shell: bash
+      run: |
+        case $RUNNER_OS in
+          Linux)
+            sudo apt-get --allow-releaseinfo-change update
+            sudo apt-get --fix-missing install gcc-10 libsdl2-dev scons
+            ;;
+          macOS)
+            brew install scons sdl2
+            ;;
+        esac
+    - name: Make
+      working-directory: OSBindings/SDL
+      shell: bash
+      run: |
+        case $RUNNER_OS in
+          Linux)
+            jobs=$(nproc --all)
+            ;;
+          macOS)
+            jobs=$(sysctl -n hw.activecpu)
+            ;;
+          *)
+            jobs=1
+        esac
+        scons -j"$jobs"

.github/workflows/ccpp.yml

@@ -1,16 +0,0 @@
-name: SDL/Ubuntu
-
-on: [push, pull_request]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Install dependencies
-      run: sudo apt-get --allow-releaseinfo-change update && sudo apt-get --fix-missing install libsdl2-dev scons
-    - name: Make
-      working-directory: OSBindings/SDL
-      run: scons -j$(nproc --all)

Activity/Observer.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ActivityObserver_h
-#define ActivityObserver_h
+#pragma once
 
 #include <cstdint>
 #include <string>
@@ -24,6 +23,8 @@ namespace Activity {
 */
 class Observer {
 	public:
+		virtual ~Observer() = default;
+
 		/// Provides hints as to the sort of information presented on an LED.
 		enum LEDPresentation: uint8_t {
 			/// This LED informs the user of some sort of persistent state, e.g. scroll lock.
@@ -56,5 +57,3 @@ class Observer {
 };
 
 }
-
-#endif /* ActivityObserver_h */

Activity/Source.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ActivitySource_h
-#define ActivitySource_h
+#pragma once
 
 #include "Observer.hpp"
 
@@ -19,6 +18,3 @@ class Source {
 };
 
 }
-
-
-#endif /* ActivitySource_h */

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ConfidenceCounter_hpp
-#define ConfidenceCounter_hpp
+#pragma once
 
 #include "ConfidenceSource.hpp"
 
@@ -41,5 +40,3 @@ class ConfidenceCounter: public ConfidenceSource {
 };
 
 }
-
-#endif /* ConfidenceCounter_hpp */

Analyser/Dynamic/ConfidenceSource.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ConfidenceSource_hpp
-#define ConfidenceSource_hpp
+#pragma once
 
 namespace Analyser::Dynamic {
 
@@ -22,5 +21,3 @@ struct ConfidenceSource {
 };
 
 }
-
-#endif /* ConfidenceSource_hpp */

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef ConfidenceSummary_hpp
-#define ConfidenceSummary_hpp
+#pragma once
 
 #include "ConfidenceSource.hpp"
 
@@ -40,5 +39,3 @@ class ConfidenceSummary: public ConfidenceSource {
 };
 
 }
-
-#endif /* ConfidenceSummary_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiConfigurable_hpp
-#define MultiConfigurable_hpp
+#pragma once
 
 #include "../../../../Machines/DynamicMachine.hpp"
 #include "../../../../Configurable/Configurable.hpp"
@@ -36,5 +35,3 @@ class MultiConfigurable: public Configurable::Device {
 };
 
 }
-
-#endif /* MultiConfigurable_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiJoystickMachine_hpp
-#define MultiJoystickMachine_hpp
+#pragma once
 
 #include "../../../../Machines/DynamicMachine.hpp"
 
@@ -34,5 +33,3 @@ class MultiJoystickMachine: public MachineTypes::JoystickMachine {
 };
 
 }
-
-#endif /* MultiJoystickMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -56,10 +56,10 @@ MultiKeyboardMachine::MultiKeyboard::MultiKeyboard(const std::vector<::MachineTy
 	}
 }
 
-bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed) {
+bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed, bool is_repeat) {
 	bool was_consumed = false;
 	for(const auto &machine: machines_) {
-		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed);
+		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed, is_repeat);
 	}
 	return was_consumed;
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiKeyboardMachine_hpp
-#define MultiKeyboardMachine_hpp
+#pragma once
 
 #include "../../../../Machines/DynamicMachine.hpp"
 #include "../../../../Machines/KeyboardMachine.hpp"
@@ -31,7 +30,7 @@ class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
 			public:
 				MultiKeyboard(const std::vector<MachineTypes::KeyboardMachine *> &machines);
 
-				bool set_key_pressed(Key key, char value, bool is_pressed) final;
+				bool set_key_pressed(Key key, char value, bool is_pressed, bool is_repeat) final;
 				void reset_all_keys() final;
 				const std::set<Key> &observed_keys() const final;
 				bool is_exclusive() const final;
@@ -55,5 +54,3 @@ class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
 };
 
 }
-
-#endif /* MultiKeyboardMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiMediaTarget_hpp
-#define MultiMediaTarget_hpp
+#pragma once
 
 #include "../../../../Machines/MediaTarget.hpp"
 #include "../../../../Machines/DynamicMachine.hpp"
@@ -35,5 +34,3 @@ struct MultiMediaTarget: public MachineTypes::MediaTarget {
 };
 
 }
-
-#endif /* MultiMediaTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiProducer_hpp
-#define MultiProducer_hpp
+#pragma once
 
 #include "../../../../Concurrency/AsyncTaskQueue.hpp"
 #include "../../../../Machines/MachineTypes.hpp"
@@ -115,5 +114,3 @@ class MultiAudioProducer: public MultiInterface<MachineTypes::AudioProducer>, pu
 */
 
 }
-
-#endif /* MultiProducer_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -61,7 +61,7 @@ void MultiSpeaker::set_output_volume(float volume) {
 }
 
 void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) {
-	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
 		std::lock_guard lock_guard(front_speaker_mutex_);
@@ -71,7 +71,7 @@ void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vec
 }
 
 void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
-	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
 		std::lock_guard lock_guard(front_speaker_mutex_);
@@ -85,7 +85,7 @@ void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *machine) {
 		std::lock_guard lock_guard(front_speaker_mutex_);
 		front_speaker_ = machine->audio_producer()->get_speaker();
 	}
-	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(delegate) {
 		delegate->speaker_did_change_input_clock(this);
 	}

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiSpeaker_hpp
-#define MultiSpeaker_hpp
+#pragma once
 
 #include "../../../../Machines/DynamicMachine.hpp"
 #include "../../../../Outputs/Speaker/Speaker.hpp"
@@ -55,5 +54,3 @@ class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker:
 };
 
 }
-
-#endif /* MultiSpeaker_hpp */

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -11,6 +11,12 @@
 
 #include <algorithm>
 
+namespace {
+
+Log::Logger<Log::Source::MultiMachine> logger;
+
+}
+
 using namespace Analyser::Dynamic;
 
 MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines) :
@@ -61,13 +67,14 @@ bool MultiMachine::would_collapse(const std::vector<std::unique_ptr<DynamicMachi
 
 void MultiMachine::did_run_machines(MultiTimedMachine *) {
 	std::lock_guard machines_lock(machines_mutex_);
-#ifndef NDEBUG
-	for(const auto &machine: machines_) {
-		auto timed_machine = machine->timed_machine();
-		LOGNBR(PADHEX(2) << timed_machine->get_confidence() << " " << timed_machine->debug_type() << "; ");
+
+	if constexpr (logger.enabled) {
+		auto line = logger.info();
+		for(const auto &machine: machines_) {
+			auto timed_machine = machine->timed_machine();
+			line.append("%0.4f %s; ", timed_machine->get_confidence(), timed_machine->debug_type().c_str());
+		}
 	}
-	LOGNBR(std::endl);
-#endif
 
 	DynamicMachine *front = machines_.front().get();
 	std::stable_sort(machines_.begin(), machines_.end(),

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiMachine_hpp
-#define MultiMachine_hpp
+#pragma once
 
 #include "../../../Machines/DynamicMachine.hpp"
 
@@ -80,5 +79,3 @@ class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::
 };
 
 }
-
-#endif /* MultiMachine_hpp */

Analyser/Machines.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Machines_h
-#define Machines_h
+#pragma once
 
 namespace Analyser {
 
@@ -18,6 +17,7 @@ enum class Machine {
 	Atari2600,
 	AtariST,
 	Amiga,
+	Archimedes,
 	ColecoVision,
 	Electron,
 	Enterprise,
@@ -25,11 +25,10 @@ enum class Machine {
 	MasterSystem,
 	MSX,
 	Oric,
+	PCCompatible,
 	Vic20,
 	ZX8081,
 	ZXSpectrum,
 };
 
 }
-
-#endif /* Machines_h */

Analyser/Static/Acorn/Disk.cpp

@@ -13,16 +13,17 @@
 #include "../../../Numeric/CRC.hpp"
 
 #include <algorithm>
+#include <cstring>
 
 using namespace Analyser::Static::Acorn;
 
 std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	// c.f. http://beebwiki.mdfs.net/Acorn_DFS_disc_format
 	auto catalogue = std::make_unique<Catalogue>();
-	Storage::Encodings::MFM::Parser parser(false, disk);
+	Storage::Encodings::MFM::Parser parser(Storage::Encodings::MFM::Density::Single, disk);
 
-	const Storage::Encodings::MFM::Sector *const names = parser.get_sector(0, 0, 0);
-	const Storage::Encodings::MFM::Sector *const details = parser.get_sector(0, 0, 1);
+	const Storage::Encodings::MFM::Sector *const names = parser.sector(0, 0, 0);
+	const Storage::Encodings::MFM::Sector *const details = parser.sector(0, 0, 1);
 
 	if(!names || !details) return nullptr;
 	if(names->samples.empty() || details->samples.empty()) return nullptr;
@@ -65,7 +66,7 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 			uint8_t track = uint8_t(start_sector / 10);
 			start_sector++;
 
-			Storage::Encodings::MFM::Sector *next_sector = parser.get_sector(0, track, sector);
+			const Storage::Encodings::MFM::Sector *next_sector = parser.sector(0, track, sector);
 			if(!next_sector) break;
 
 			long length_from_sector = std::min(data_length, 256l);
@@ -84,36 +85,58 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 */
 std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	auto catalogue = std::make_unique<Catalogue>();
-	Storage::Encodings::MFM::Parser parser(true, disk);
+	Storage::Encodings::MFM::Parser parser(Storage::Encodings::MFM::Density::Double, disk);
 
-	Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.get_sector(0, 0, 1);
+	// Grab the second half of the free-space map because it has the boot option in it.
+	const Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.sector(0, 0, 1);
 	if(!free_space_map_second_half) return nullptr;
+	catalogue->has_large_sectors = free_space_map_second_half->samples[0].size() == 1024;
+
+	// Possibility: this is a large-sector disk with an old-style free space map. In which
+	// case the above just read the start of the root directory.
+	uint8_t first_directory_sector = 2;
+	if(catalogue->has_large_sectors && !memcmp(&free_space_map_second_half->samples[0][1], "Hugo", 4)) {
+		free_space_map_second_half = parser.sector(0, 0, 0);
+		if(!free_space_map_second_half) return nullptr;
+		first_directory_sector = 1;
+	}
 
 	std::vector<uint8_t> root_directory;
-	root_directory.reserve(5 * 256);
-	for(uint8_t c = 2; c < 7; c++) {
-		const Storage::Encodings::MFM::Sector *const sector = parser.get_sector(0, 0, c);
+	root_directory.reserve(catalogue->has_large_sectors ? 2*1024 : 5*256);
+
+	for(uint8_t c = first_directory_sector; c < first_directory_sector + (catalogue->has_large_sectors ? 2 : 5); c++) {
+		const Storage::Encodings::MFM::Sector *const sector = parser.sector(0, 0, c);
 		if(!sector) return nullptr;
 		root_directory.insert(root_directory.end(), sector->samples[0].begin(), sector->samples[0].end());
 	}
 
-	// Quick sanity checks.
-	if(root_directory[0x4cb]) return nullptr;
-	if(root_directory[1] != 'H' || root_directory[2] != 'u' || root_directory[3] != 'g' || root_directory[4] != 'o') return nullptr;
-	if(root_directory[0x4FB] != 'H' || root_directory[0x4FC] != 'u' || root_directory[0x4FD] != 'g' || root_directory[0x4FE] != 'o') return nullptr;
+	// Check for end of directory marker.
+	if(root_directory[catalogue->has_large_sectors ? 0x7d7 : 0x4cb]) return nullptr;
 
-	switch(free_space_map_second_half->samples[0][0xfd]) {
-		default: catalogue->bootOption = Catalogue::BootOption::None;		break;
-		case 1: catalogue->bootOption = Catalogue::BootOption::LoadBOOT;	break;
-		case 2: catalogue->bootOption = Catalogue::BootOption::RunBOOT;		break;
-		case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
+	// Check for both directory identifiers.
+	const uint8_t *const start_id = &root_directory[1];
+	const uint8_t *const end_id = &root_directory[root_directory.size() - 5];
+	catalogue->is_hugo = !memcmp(start_id, "Hugo", 4) && !memcmp(end_id, "Hugo", 4);
+	const bool is_nick = !memcmp(start_id, "Nick", 4) && !memcmp(end_id, "Nick", 4);
+	if(!catalogue->is_hugo && !is_nick) {
+		return nullptr;
+	}
+
+	if(!catalogue->has_large_sectors) {
+		// TODO: I don't know where the boot option rests with large sectors.
+		switch(free_space_map_second_half->samples[0][0xfd]) {
+			default: catalogue->bootOption = Catalogue::BootOption::None;		break;
+			case 1: catalogue->bootOption = Catalogue::BootOption::LoadBOOT;	break;
+			case 2: catalogue->bootOption = Catalogue::BootOption::RunBOOT;		break;
+			case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
+		}
 	}
 
 	// Parse the root directory, at least.
-	for(std::size_t file_offset = 0x005; file_offset < 0x4cb; file_offset += 0x1a) {
+	for(std::size_t file_offset = 0x005; file_offset < (catalogue->has_large_sectors ? 0x7d7 : 0x4cb); file_offset += 0x1a) {
 		// Obtain the name, which will be at most ten characters long, and will
 		// be terminated by either a NULL character or a \r.
-		char name[11];
+		char name[11]{};
 		std::size_t c = 0;
 		for(; c < 10; c++) {
 			const char next = root_directory[file_offset + c] & 0x7f;
@@ -122,8 +145,9 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::
 		}
 		name[c] = '\0';
 
-		// Skip if the name is empty.
-		if(name[0] == '\0') continue;
+		// An empty name implies the directory has ended; files are always listed in case-insensitive
+		// sorted order, with that list being terminated by a '\0'.
+		if(name[0] == '\0') break;
 
 		// Populate a file then.
 		File new_file;
@@ -166,7 +190,7 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::
 
 		new_file.data.reserve(size);
 		while(new_file.data.size() < size) {
-			const Storage::Encodings::MFM::Sector *const sector = parser.get_sector(start_sector / (80 * 16), (start_sector / 16) % 80, start_sector % 16);
+			const Storage::Encodings::MFM::Sector *const sector = parser.sector(start_sector / (80 * 16), (start_sector / 16) % 80, start_sector % 16);
 			if(!sector) break;
 
 			const auto length_from_sector = std::min(size - new_file.data.size(), sector->samples[0].size());
@@ -177,5 +201,20 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::
 		catalogue->files.push_back(std::move(new_file));
 	}
 
+	// Include the directory title.
+	const char *title, *name;
+	if(catalogue->has_large_sectors) {
+		title = reinterpret_cast<const char *>(&root_directory[0x7dd]);
+		name = reinterpret_cast<const char *>(&root_directory[0x7f0]);
+	} else {
+		title = reinterpret_cast<const char *>(&root_directory[0x4d9]);
+		name = reinterpret_cast<const char *>(&root_directory[0x4cc]);
+	}
+
+	catalogue->name = std::string(title, strnlen(title, 19));
+	if(catalogue->name.empty() || catalogue->name == "$") {
+		catalogue->name = std::string(name, strnlen(name, 10));
+	}
+
 	return catalogue;
 }

Analyser/Static/Acorn/Disk.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Acorn_Disk_hpp
-#define StaticAnalyser_Acorn_Disk_hpp
+#pragma once
 
 #include "File.hpp"
 #include "../../../Storage/Disk/Disk.hpp"
@@ -16,6 +15,8 @@ namespace Analyser::Static::Acorn {
 
 /// Describes a DFS- or ADFS-format catalogue(/directory): the list of files available and the catalogue's boot option.
 struct Catalogue {
+	bool is_hugo = false;
+	bool has_large_sectors = false;
 	std::string name;
 	std::vector<File> files;
 	enum class BootOption {
@@ -30,5 +31,3 @@ std::unique_ptr<Catalogue> GetDFSCatalogue(const std::shared_ptr<Storage::Disk::
 std::unique_ptr<Catalogue> GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
 }
-
-#endif /* Disk_hpp */

Analyser/Static/Acorn/File.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Acorn_File_hpp
-#define StaticAnalyser_Acorn_File_hpp
+#pragma once
 
 #include <memory>
 #include <string>
@@ -59,5 +58,3 @@ struct File {
 };
 
 }
-
-#endif /* File_hpp */

Analyser/Static/Acorn/StaticAnalyser.cpp

@@ -12,7 +12,10 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 
+#include "../../../Numeric/StringSimilarity.hpp"
+
 #include <algorithm>
+#include <map>
 
 using namespace Analyser::Static::Acorn;
 
@@ -59,13 +62,14 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	return acorn_cartridges;
 }
 
-Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
-	auto target = std::make_unique<Target>();
+Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType) {
+	auto target8bit = std::make_unique<ElectronTarget>();
+	auto targetArchimedes = std::make_unique<ArchimedesTarget>();
 
-	// strip out inappropriate cartridges
-	target->media.cartridges = AcornCartridgesFrom(media.cartridges);
+	// Copy appropriate cartridges to the 8-bit target.
+	target8bit->media.cartridges = AcornCartridgesFrom(media.cartridges);
 
-	// if there are any tapes, attempt to get data from the first
+	// If there are any tapes, attempt to get data from the first.
 	if(!media.tapes.empty()) {
 		std::shared_ptr<Storage::Tape::Tape> tape = media.tapes.front();
 		std::vector<File> files = GetFiles(tape);
@@ -94,30 +98,34 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &me
 
 			// Inspect first file. If it's protected or doesn't look like BASIC
 			// then the loading command is *RUN. Otherwise it's CHAIN"".
-			target->loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
+			target8bit->loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
 
-			target->media.tapes = media.tapes;
+			target8bit->media.tapes = media.tapes;
 		}
 	}
 
 	if(!media.disks.empty()) {
 		std::shared_ptr<Storage::Disk::Disk> disk = media.disks.front();
 		std::unique_ptr<Catalogue> dfs_catalogue, adfs_catalogue;
+
+		// Get any sort of catalogue that can be found.
 		dfs_catalogue = GetDFSCatalogue(disk);
 		if(dfs_catalogue == nullptr) adfs_catalogue = GetADFSCatalogue(disk);
-		if(dfs_catalogue || adfs_catalogue) {
+
+		// 8-bit options: DFS and Hugo-style ADFS.
+		if(dfs_catalogue || (adfs_catalogue && !adfs_catalogue->has_large_sectors && adfs_catalogue->is_hugo)) {
 			// Accept the disk and determine whether DFS or ADFS ROMs are implied.
 			// Use the Pres ADFS if using an ADFS, as it leaves Page at &EOO.
-			target->media.disks = media.disks;
-			target->has_dfs = bool(dfs_catalogue);
-			target->has_pres_adfs = bool(adfs_catalogue);
+			target8bit->media.disks = media.disks;
+			target8bit->has_dfs = bool(dfs_catalogue);
+			target8bit->has_pres_adfs = bool(adfs_catalogue);
 
 			// Check whether a simple shift+break will do for loading this disk.
 			Catalogue::BootOption bootOption = (dfs_catalogue ?: adfs_catalogue)->bootOption;
 			if(bootOption != Catalogue::BootOption::None) {
-				target->should_shift_restart = true;
+				target8bit->should_shift_restart = true;
 			} else {
-				target->loading_command = "*CAT\n";
+				target8bit->loading_command = "*CAT\n";
 			}
 
 			// Check whether adding the AP6 ROM is justified.
@@ -133,39 +141,79 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &me
 					"VERIFY", "ZERO"
 				}) {
 					if(std::search(file.data.begin(), file.data.end(), command, command+strlen(command)) != file.data.end()) {
-						target->has_ap6_rom = true;
-						target->has_sideways_ram = true;
+						target8bit->has_ap6_rom = true;
+						target8bit->has_sideways_ram = true;
 					}
 				}
 			}
+		} else if(adfs_catalogue) {
+			// Archimedes options, implicitly: ADFS, non-Hugo.
+			targetArchimedes->media.disks = media.disks;
+
+			// Also look for the best possible startup program name, if it can be discerned.
+			std::multimap<double, std::string, std::greater<double>> options;
+			for(const auto &file: adfs_catalogue->files) {
+				// Skip non-Pling files.
+				if(file.name[0] != '!') continue;
+
+				// Take whatever else comes with a preference for things that don't
+				// have 'boot' or 'read' in them (the latter of which will tend to be
+				// read_me or read_this or similar).
+				constexpr char read[] = "read";
+				constexpr char boot[] = "boot";
+				const auto has = [&](const char *begin, const char *end) {
+					return  std::search(
+						file.name.begin(), file.name.end(),
+						begin, end - 1, // i.e. don't compare the trailing NULL.
+						[](char lhs, char rhs) {
+							return std::tolower(lhs) == rhs;
+						}
+					) != file.name.end();
+				};
+				const auto has_read = has(std::begin(read), std::end(read));
+				const auto has_boot = has(std::begin(boot), std::end(boot));
+
+				const auto probability =
+					Numeric::similarity(file.name, adfs_catalogue->name) +
+					Numeric::similarity(file.name, file_name) -
+					((has_read || has_boot) ? 0.2 : 0.0);
+				options.emplace(probability, file.name);
+			}
+
+			if(!options.empty()) {
+				targetArchimedes->main_program = options.begin()->second;
+			}
 		}
 	}
 
 	// Enable the Acorn ADFS if a mass-storage device is attached;
 	// unlike the Pres ADFS it retains SCSI logic.
 	if(!media.mass_storage_devices.empty()) {
-		target->has_pres_adfs = false;	// To override a floppy selection, if one was made.
-		target->has_acorn_adfs = true;
+		target8bit->has_pres_adfs = false;	// To override a floppy selection, if one was made.
+		target8bit->has_acorn_adfs = true;
 
 		// Assume some sort of later-era Acorn work is likely to happen;
 		// so ensure *TYPE, etc are present.
-		target->has_ap6_rom = true;
-		target->has_sideways_ram = true;
+		target8bit->has_ap6_rom = true;
+		target8bit->has_sideways_ram = true;
 
-		target->media.mass_storage_devices = media.mass_storage_devices;
+		target8bit->media.mass_storage_devices = media.mass_storage_devices;
 
 		// Check for a boot option.
-		const auto sector = target->media.mass_storage_devices.front()->get_block(1);
+		const auto sector = target8bit->media.mass_storage_devices.front()->get_block(1);
 		if(sector[0xfd]) {
-			target->should_shift_restart = true;
+			target8bit->should_shift_restart = true;
 		} else {
-			target->loading_command = "*CAT\n";
+			target8bit->loading_command = "*CAT\n";
 		}
 	}
 
 	TargetList targets;
-	if(!target->media.empty()) {
-		targets.push_back(std::move(target));
+	if(!target8bit->media.empty()) {
+		targets.push_back(std::move(target8bit));
+	}
+	if(!targetArchimedes->media.empty()) {
+		targets.push_back(std::move(targetArchimedes));
 	}
 	return targets;
 }

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Acorn_StaticAnalyser_hpp
-#define StaticAnalyser_Acorn_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Acorn {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* AcornAnalyser_hpp */

Analyser/Static/Acorn/Tape.cpp

@@ -19,8 +19,10 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 	auto new_chunk = std::make_unique<File::Chunk>();
 	int shift_register = 0;
 
-// TODO: move this into the parser
-#define shift()	shift_register = (shift_register >> 1) | (parser.get_next_bit(tape) << 9)
+	// TODO: move this into the parser
+	const auto shift = [&] {
+		shift_register = (shift_register >> 1) | (parser.get_next_bit(tape) << 9);
+	};
 
 	// find next area of high tone
 	while(!tape->is_at_end() && (shift_register != 0x3ff)) {
@@ -32,8 +34,6 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 		shift();
 	}
 
-#undef shift
-
 	parser.reset_crc();
 	parser.reset_error_flag();
 

Analyser/Static/Acorn/Tape.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Acorn_Tape_hpp
-#define StaticAnalyser_Acorn_Tape_hpp
+#pragma once
 
 #include <memory>
 
@@ -19,5 +18,3 @@ namespace Analyser::Static::Acorn {
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
 }
-
-#endif /* Tape_hpp */

Analyser/Static/Acorn/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Acorn_Target_h
-#define Analyser_Static_Acorn_Target_h
+#pragma once
 
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
@@ -15,7 +14,7 @@
 
 namespace Analyser::Static::Acorn {
 
-struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
+struct ElectronTarget: public ::Analyser::Static::Target, public Reflection::StructImpl<ElectronTarget> {
 	bool has_acorn_adfs = false;
 	bool has_pres_adfs = false;
 	bool has_dfs = false;
@@ -24,7 +23,7 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	bool should_shift_restart = false;
 	std::string loading_command;
 
-	Target() : Analyser::Static::Target(Machine::Electron) {
+	ElectronTarget() : Analyser::Static::Target(Machine::Electron) {
 		if(needs_declare()) {
 			DeclareField(has_pres_adfs);
 			DeclareField(has_acorn_adfs);
@@ -35,6 +34,10 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	}
 };
 
-}
+struct ArchimedesTarget: public ::Analyser::Static::Target, public Reflection::StructImpl<ArchimedesTarget> {
+	std::string main_program;
 
-#endif /* Analyser_Static_Acorn_Target_h */
+	ArchimedesTarget() : Analyser::Static::Target(Machine::Archimedes) {}
+};
+
+}

Analyser/Static/Amiga/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Amiga_StaticAnalyser_hpp
-#define Analyser_Static_Amiga_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Amiga {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_Amiga_StaticAnalyser_hpp */

Analyser/Static/Amiga/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Amiga_Target_h
-#define Analyser_Static_Amiga_Target_h
+#pragma once
 
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
@@ -40,5 +39,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_Amiga_Target_h */

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -159,8 +159,8 @@ void InspectCatalogue(
 }
 
 bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
-	Storage::Encodings::MFM::Parser parser(true, disk);
-	Storage::Encodings::MFM::Sector *boot_sector = parser.get_sector(0, 0, 0x41);
+	Storage::Encodings::MFM::Parser parser(Storage::Encodings::MFM::Density::Double, disk);
+	const Storage::Encodings::MFM::Sector *boot_sector = parser.sector(0, 0, 0x41);
 	if(boot_sector != nullptr && !boot_sector->samples.empty() && boot_sector->samples[0].size() == 512) {
 		// Check that the first 64 bytes of the sector aren't identical; if they are then probably
 		// this disk was formatted and the filler byte never replaced.

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AmstradCPC_StaticAnalyser_hpp
-#define Analyser_Static_AmstradCPC_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::AmstradCPC {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_AmstradCPC_StaticAnalyser_hpp */

Analyser/Static/AmstradCPC/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AmstradCPC_Target_h
-#define Analyser_Static_AmstradCPC_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -30,5 +29,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/AppleII/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AppleII_StaticAnalyser_hpp
-#define Analyser_Static_AppleII_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::AppleII {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_AppleII_StaticAnalyser_hpp */

Analyser/Static/AppleII/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AppleII_Target_h
-#define Analyser_Static_AppleII_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -35,12 +34,14 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	Model model = Model::IIe;
 	DiskController disk_controller = DiskController::None;
 	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);
 
 			AnnounceEnum(Model);
 			AnnounceEnum(DiskController);
@@ -49,6 +50,8 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
+constexpr bool is_iie(Target::Model model) {
+	return model == Target::Model::IIe || model == Target::Model::EnhancedIIe;
 }
 
-#endif /* Analyser_Static_AppleII_Target_h */
+}

Analyser/Static/AppleIIgs/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AppleIIgs_StaticAnalyser_hpp
-#define Analyser_Static_AppleIIgs_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::AppleIIgs {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_AppleIIgs_StaticAnalyser_hpp */

Analyser/Static/AppleIIgs/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AppleIIgs_Target_h
-#define Analyser_Static_AppleIIgs_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -41,5 +40,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_AppleIIgs_Target_h */

Analyser/Static/Atari2600/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Atari_StaticAnalyser_hpp
-#define StaticAnalyser_Atari_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Atari2600 {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/Atari2600/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Atari2600_Target_h
-#define Analyser_Static_Atari2600_Target_h
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 
@@ -37,5 +36,3 @@ struct Target: public ::Analyser::Static::Target {
 };
 
 }
-
-#endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/AtariST/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AtariST_StaticAnalyser_hpp
-#define Analyser_Static_AtariST_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::AtariST {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_AtariST_StaticAnalyser_hpp */

Analyser/Static/AtariST/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_AtariST_Target_h
-#define Analyser_Static_AtariST_Target_h
+#pragma once
 
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
@@ -30,5 +29,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_AtariST_Target_h */

Analyser/Static/Coleco/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Coleco_StaticAnalyser_hpp
-#define StaticAnalyser_Coleco_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Coleco {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/Commodore/Disk.cpp

@@ -37,7 +37,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 			@returns a sector if one was found; @c nullptr otherwise.
 		*/
-		std::shared_ptr<Sector> get_sector(uint8_t track, uint8_t sector) {
+		std::shared_ptr<Sector> sector(uint8_t track, uint8_t sector) {
 			int difference = int(track) - int(track_);
 			track_ = track;
 
@@ -182,7 +182,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 	uint8_t next_track = 18;
 	uint8_t next_sector = 1;
 	while(1) {
-		sector = parser.get_sector(next_track, next_sector);
+		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];
@@ -221,7 +221,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 
 		bool is_first_sector = true;
 		while(next_track) {
-			sector = parser.get_sector(next_track, next_sector);
+			sector = parser.sector(next_track, next_sector);
 			if(!sector) break;
 
 			next_track = sector->data[0];

Analyser/Static/Commodore/Disk.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Commodore_Disk_hpp
-#define StaticAnalyser_Commodore_Disk_hpp
+#pragma once
 
 #include "../../../Storage/Disk/Disk.hpp"
 #include "File.hpp"
@@ -19,5 +18,3 @@ namespace Analyser::Static::Commodore {
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
 }
-
-#endif /* Disk_hpp */

Analyser/Static/Commodore/File.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef File_hpp
-#define File_hpp
+#pragma once
 
 #include <cstdint>
 #include <string>
@@ -35,5 +34,3 @@ struct File {
 };
 
 }
-
-#endif /* File_hpp */

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -93,7 +93,7 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 		// make a first guess based on loading address
 		switch(files.front().starting_address) {
 			default:
-				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) << files.front().starting_address);
+				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;

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Commodore_StaticAnalyser_hpp
-#define StaticAnalyser_Commodore_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Commodore {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* CommodoreAnalyser_hpp */

Analyser/Static/Commodore/Tape.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Commodore_Tape_hpp
-#define StaticAnalyser_Commodore_Tape_hpp
+#pragma once
 
 #include "../../../Storage/Tape/Tape.hpp"
 #include "File.hpp"
@@ -17,5 +16,3 @@ namespace Analyser::Static::Commodore {
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
 }
-
-#endif /* Tape_hpp */

Analyser/Static/Commodore/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Commodore_Target_h
-#define Analyser_Static_Commodore_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -70,5 +69,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Disassembler_6502_hpp
-#define StaticAnalyser_Disassembler_6502_hpp
+#pragma once
 
 #include <cstdint>
 #include <functional>
@@ -93,5 +92,3 @@ Disassembly Disassemble(
 	std::vector<uint16_t> entry_points);
 
 }
-
-#endif /* Disassembler6502_hpp */

Analyser/Static/Disassembler/AddressMapper.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef AddressMapper_hpp
-#define AddressMapper_hpp
+#pragma once
 
 #include <functional>
 
@@ -24,5 +23,3 @@ template <typename T> std::function<std::size_t(T)> OffsetMapper(T start_address
 }
 
 }
-
-#endif /* AddressMapper_hpp */

Analyser/Static/Disassembler/Kernel.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef Kernel_hpp
-#define Kernel_hpp
+#pragma once
 
 namespace Analyser::Static::Disassembly {
 
@@ -65,5 +64,3 @@ template <typename D, typename S, typename Disassembler> D Disassemble(
 }
 
 }
-
-#endif /* Kernel_hpp */

Analyser/Static/Disassembler/Z80.cpp

@@ -56,11 +56,11 @@ class Accessor {
 		bool overrun_ = false;
 };
 
-#define x(v) (v >> 6)
-#define y(v) ((v >> 3) & 7)
-#define q(v) ((v >> 3) & 1)
-#define p(v) ((v >> 4) & 3)
-#define z(v) (v & 7)
+constexpr uint8_t x(uint8_t v) { return v >> 6; }
+constexpr uint8_t y(uint8_t v) { return (v >> 3) & 7; }
+constexpr uint8_t q(uint8_t v) { return (v >> 3) & 1; }
+constexpr uint8_t p(uint8_t v) { return (v >> 4) & 3; }
+constexpr uint8_t z(uint8_t v) { return v & 7; }
 
 Instruction::Condition condition_table[] = {
 	Instruction::Condition::NZ,		Instruction::Condition::Z,

Analyser/Static/Disassembler/Z80.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Disassembler_Z80_hpp
-#define StaticAnalyser_Disassembler_Z80_hpp
+#pragma once
 
 #include <cstdint>
 #include <functional>
@@ -91,5 +90,3 @@ Disassembly Disassemble(
 	Approach approach);
 
 }
-
-#endif /* StaticAnalyser_Disassembler_Z80_hpp */

Analyser/Static/DiskII/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_DiskII_StaticAnalyser_hpp
-#define Analyser_Static_DiskII_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::DiskII {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_DiskII_StaticAnalyser_hpp */

Analyser/Static/Enterprise/StaticAnalyser.cpp

@@ -40,6 +40,8 @@ Analyser::Static::TargetList Analyser::Static::Enterprise::GetTargets(const Medi
 	target->basic_version = Target::BASICVersion::Any;
 
 	// Inspect any supplied disks.
+	//
+	// TODO: how best can these be discerned from MS-DOS and MSX disks?
 	if(!media.disks.empty()) {
 		// DOS will be needed.
 		target->dos = Target::DOS::EXDOS;

Analyser/Static/Enterprise/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Enterprise_StaticAnalyser_hpp
-#define Analyser_Static_Enterprise_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Enterprise {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_Enterprise_StaticAnalyser_hpp */

Analyser/Static/Enterprise/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Enterprise_Target_h
-#define Analyser_Static_Enterprise_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -49,5 +48,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_Enterprise_Target_h */

Analyser/Static/FAT12/StaticAnalyser.cpp

@@ -0,0 +1,100 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 05/12/2023.
+//  Copyright 2023 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "../Enterprise/StaticAnalyser.hpp"
+#include "../PCCompatible/StaticAnalyser.hpp"
+
+#include "../../../Storage/Disk/Track/TrackSerialiser.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/Constants.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/SegmentParser.hpp"
+
+
+Analyser::Static::TargetList Analyser::Static::FAT12::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType platforms) {
+	// This analyser can comprehend disks only.
+	if(media.disks.empty()) return {};
+
+	auto &disk = media.disks.front();
+	TargetList targets;
+
+	// Total list of potential platforms is:
+	//
+	//	* the Enterprise (and, by extension, CP/M-targetted software);
+	//	* the Atari ST;
+	//	* the MSX (ditto on CP/M); and
+	//	* the PC.
+	//
+	// (though the MSX and Atari ST don't currently call in here for now)
+
+	// If the disk image is very small or large, map it to the PC. That's the only option old enough
+	// to have used 5.25" media.
+	if(disk->get_maximum_head_position() <= Storage::Disk::HeadPosition(40)) {
+		return Analyser::Static::PCCompatible::GetTargets(media, file_name, platforms);
+	}
+
+	// Attempt to grab MFM track 0, sector 1: the boot sector.
+	const auto track_zero = disk->get_track_at_position(Storage::Disk::Track::Address(0, Storage::Disk::HeadPosition(0)));
+	const auto sector_map = Storage::Encodings::MFM::sectors_from_segment(
+			Storage::Disk::track_serialisation(
+				*track_zero,
+				Storage::Encodings::MFM::MFMBitLength
+			), Storage::Encodings::MFM::Density::Double);
+
+	// If no sectors were found, assume this disk was either single density or high density, which both imply the PC.
+	if(sector_map.empty() || sector_map.size() > 10) {
+		return Analyser::Static::PCCompatible::GetTargets(media, file_name, platforms);
+	}
+
+	const Storage::Encodings::MFM::Sector *boot_sector = nullptr;
+	for(const auto &pair: sector_map) {
+		if(pair.second.address.sector == 1) {
+			boot_sector = &pair.second;
+			break;
+		}
+	}
+
+	// This shouldn't technically be possible since the disk has been identified as FAT12, but be safe.
+	if(!boot_sector) {
+		return {};
+	}
+
+	// Check for key phrases that imply a PC disk.
+	const auto &sample = boot_sector->samples[0];
+	const std::vector<std::string> pc_strings = {
+		// MS-DOS strings.
+		"MSDOS",
+		"Non-System disk or disk error",
+		// DOS Plus strings.
+		"Insert a SYSTEM disk",
+	};
+	for(const auto &string: pc_strings) {
+		if(
+			std::search(sample.begin(), sample.end(), string.begin(), string.end()) != sample.end()
+		) {
+			return Analyser::Static::PCCompatible::GetTargets(media, file_name, platforms);
+		}
+	}
+
+	// TODO: look for a COM, EXE or BAT, inspect. AUTOEXEC.BAT and/or CONFIG.SYS could be either PC or MSX.
+	// Disassembling the boot sector doesn't necessarily work, as several Enterprise titles out there in the wild seem
+	// to have been created by WINIMAGE which adds an x86 PC-style boot sector.
+
+	// Enterprise notes: EXOS files all start with a 16-byte header which should begin with a 0 and then have a type
+	// byte that will be 0xa or lower; cf http://epbas.lgb.hu/readme.html
+	//
+	// Some disks commonly passed around as Enterprise software are actually CP/M software, expecting IS-DOS (the CP/M
+	// clone) to be present. It's certainly possible the same could be true of MSX disks and MSX-DOS. So analysing COM
+	// files probably means searching for CALL 5s and/or INT 21hs, if not a more rigorous disassembly.
+	//
+	// I have not been able to locate a copy of IS-DOS so there's probably not much that can be done here; perhaps I
+	// could redirect to an MSX2 with MSX-DOS2? Though it'd be nicer if I had a machine that was pure CP/M.
+
+	// Being unable to prove that this is a PC disk, throw it to the Enterprise.
+	return Analyser::Static::Enterprise::GetTargets(media, file_name, platforms);
+}

Analyser/Static/FAT12/StaticAnalyser.hpp

@@ -0,0 +1,19 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 05/12/2023.
+//  Copyright 2023 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser::Static::FAT12 {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}

Analyser/Static/MSX/Cartridge.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Cartridge_hpp
-#define Cartridge_hpp
+#pragma once
 
 #include "../../../Storage/Cartridge/Cartridge.hpp"
 
@@ -32,5 +31,3 @@ struct Cartridge: public ::Storage::Cartridge::Cartridge {
 };
 
 }
-
-#endif /* Cartridge_hpp */

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_MSX_StaticAnalyser_hpp
-#define StaticAnalyser_MSX_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::MSX {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_MSX_StaticAnalyser_hpp */

Analyser/Static/MSX/Tape.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_MSX_Tape_hpp
-#define StaticAnalyser_MSX_Tape_hpp
+#pragma once
 
 #include "../../../Storage/Tape/Tape.hpp"
 
@@ -36,5 +35,3 @@ struct File {
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
 }
-
-#endif /* StaticAnalyser_MSX_Tape_hpp */

Analyser/Static/MSX/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_MSX_Target_h
-#define Analyser_Static_MSX_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -47,5 +46,3 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 };
 
 }
-
-#endif /* Analyser_Static_MSX_Target_h */

Analyser/Static/Macintosh/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Macintosh_StaticAnalyser_hpp
-#define Analyser_Static_Macintosh_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Macintosh {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* Analyser_Static_Macintosh_StaticAnalyser_hpp */

Analyser/Static/Macintosh/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Macintosh_Target_h
-#define Analyser_Static_Macintosh_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -29,5 +28,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_Macintosh_Target_h */

Analyser/Static/Oric/StaticAnalyser.cpp

@@ -85,7 +85,7 @@ bool is_microdisc(Storage::Encodings::MFM::Parser &parser) {
 	/*
 		The Microdisc boot sector is sector 2 of track 0 and contains a 23-byte signature.
 	*/
-	Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 2);
+	const Storage::Encodings::MFM::Sector *sector = parser.sector(0, 0, 2);
 	if(!sector) return false;
 	if(sector->samples.empty()) return false;
 
@@ -108,7 +108,7 @@ bool is_400_loader(Storage::Encodings::MFM::Parser &parser, uint16_t range_start
 		use disassembly to test for likely matches.
 	*/
 
-	Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 1);
+	const Storage::Encodings::MFM::Sector *sector = parser.sector(0, 0, 1);
 	if(!sector) return false;
 	if(sector->samples.empty()) return false;
 
@@ -175,7 +175,7 @@ Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &med
 		// 8-DOS is recognised by a dedicated Disk II analyser, so check only for Microdisc,
 		// Jasmin and BD-DOS formats here.
 		for(auto &disk: media.disks) {
-			Storage::Encodings::MFM::Parser parser(true, disk);
+			Storage::Encodings::MFM::Parser parser(Storage::Encodings::MFM::Density::Double, disk);
 
 			if(is_microdisc(parser)) {
 				target->disk_interface = Target::DiskInterface::Microdisc;

Analyser/Static/Oric/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Oric_StaticAnalyser_hpp
-#define StaticAnalyser_Oric_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Oric {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/Oric/Tape.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Oric_Tape_hpp
-#define StaticAnalyser_Oric_Tape_hpp
+#pragma once
 
 #include "../../../Storage/Tape/Tape.hpp"
 
@@ -32,5 +31,3 @@ struct File {
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
 }
-
-#endif /* Tape_hpp */

Analyser/Static/Oric/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Oric_Target_h
-#define Analyser_Static_Oric_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -55,5 +54,3 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-
-#endif /* Analyser_Static_Oric_Target_h */

Analyser/Static/PCCompatible/StaticAnalyser.cpp

@@ -0,0 +1,25 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/10/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::PCCompatible::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	// This analyser can comprehend disks only.
+	if(media.disks.empty()) return {};
+
+	// No analysis is applied yet.
+	Analyser::Static::TargetList targets;
+
+	using Target = Analyser::Static::PCCompatible::Target;
+	auto *const target = new Target();
+	target->media = media;
+	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
+
+	return targets;
+}

Analyser/Static/PCCompatible/StaticAnalyser.hpp

@@ -0,0 +1,19 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/11/2019.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser::Static::PCCompatible {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}

Analyser/Static/PCCompatible/Target.hpp

@@ -0,0 +1,37 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/11/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::PCCompatible {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(VideoAdaptor,
+		MDA,
+		CGA);
+	VideoAdaptor adaptor = VideoAdaptor::CGA;
+
+	ReflectableEnum(Speed,
+		ApproximatelyOriginal,
+		Fast);
+	Speed speed = Speed::Fast;
+
+	Target() : Analyser::Static::Target(Machine::PCCompatible) {
+		if(needs_declare()) {
+			AnnounceEnum(VideoAdaptor);
+			AnnounceEnum(Speed);
+			DeclareField(adaptor);
+			DeclareField(speed);
+		}
+	}
+};
+
+}

Analyser/Static/Sega/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_Sega_StaticAnalyser_hpp
-#define StaticAnalyser_Sega_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::Sega {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/Sega/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Sega_Target_h
-#define Analyser_Static_Sega_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -51,5 +50,3 @@ constexpr bool is_master_system(Analyser::Static::Sega::Target::Model model) {
 }
 
 }
-
-#endif /* Analyser_Static_Sega_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -9,6 +9,7 @@
 #include "StaticAnalyser.hpp"
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
@@ -25,9 +26,11 @@
 #include "Commodore/StaticAnalyser.hpp"
 #include "DiskII/StaticAnalyser.hpp"
 #include "Enterprise/StaticAnalyser.hpp"
+#include "FAT12/StaticAnalyser.hpp"
 #include "Macintosh/StaticAnalyser.hpp"
 #include "MSX/StaticAnalyser.hpp"
 #include "Oric/StaticAnalyser.hpp"
+#include "PCCompatible/StaticAnalyser.hpp"
 #include "Sega/StaticAnalyser.hpp"
 #include "ZX8081/StaticAnalyser.hpp"
 #include "ZXSpectrum/StaticAnalyser.hpp"
@@ -48,10 +51,12 @@
 #include "../../Storage/Disk/DiskImage/Formats/FAT12.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/IPF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/IMD.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/MacintoshIMG.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/MSA.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/NIB.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/PCBooter.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/STX.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/WOZ.hpp"
@@ -84,6 +89,7 @@
 template<class> inline constexpr bool always_false_v = false;
 
 using namespace Analyser::Static;
+using namespace Storage;
 
 namespace {
 
@@ -97,46 +103,90 @@ std::string get_extension(const std::string &name) {
 	return extension;
 }
 
+class MediaAccumulator {
+	public:
+	MediaAccumulator(const std::string &file_name, TargetPlatform::IntType &potential_platforms) :
+		file_name_(file_name), potential_platforms_(potential_platforms), extension_(get_extension(file_name)) {}
+
+	/// Adds @c instance to the media collection and adds @c platforms to the set of potentials.
+	/// If @c instance is an @c TargetPlatform::TypeDistinguisher then it is given an opportunity to restrict the set of potentials.
+	template <typename InstanceT>
+	void insert(TargetPlatform::IntType platforms, std::shared_ptr<InstanceT> instance) {
+		if constexpr (std::is_base_of_v<Storage::Disk::Disk, InstanceT>) {
+			media.disks.push_back(instance);
+		} else if constexpr (std::is_base_of_v<Storage::Tape::Tape, InstanceT>) {
+			media.tapes.push_back(instance);
+		} else if constexpr (std::is_base_of_v<Storage::Cartridge::Cartridge, InstanceT>) {
+			media.cartridges.push_back(instance);
+		} else if constexpr (std::is_base_of_v<Storage::MassStorage::MassStorageDevice, InstanceT>) {
+			media.mass_storage_devices.push_back(instance);
+		} else {
+			static_assert(always_false_v<InstanceT>, "Unexpected type encountered.");
+		}
+
+		potential_platforms_ |= platforms;
+
+		// Check whether the instance itself has any input on target platforms.
+		TargetPlatform::TypeDistinguisher *const distinguisher =
+			dynamic_cast<TargetPlatform::TypeDistinguisher *>(instance.get());
+		if(distinguisher) potential_platforms_ &= distinguisher->target_platform_type();
+	}
+
+	/// Concstructs a new instance of @c InstanceT supplying @c args and adds it to the back of @c list using @c insert_instance.
+	template <typename InstanceT, typename... Args>
+	void insert(TargetPlatform::IntType platforms, Args &&... args) {
+		insert(platforms, std::make_shared<InstanceT>(std::forward<Args>(args)...));
+	}
+
+	/// Calls @c insert with the specified parameters, ignoring any exceptions thrown.
+	template <typename InstanceT, typename... Args>
+	void try_insert(TargetPlatform::IntType platforms, Args &&... args) {
+		try {
+			insert<InstanceT>(platforms, std::forward<Args>(args)...);
+		} catch(...) {}
+	}
+
+	/// Performs a @c try_insert for an object of @c InstanceT if @c extension matches that of the file name,
+	/// providing the file name as the only construction argument.
+	template <typename InstanceT>
+	void try_standard(TargetPlatform::IntType platforms, const char *extension) {
+		if(name_matches(extension))	{
+			try_insert<InstanceT>(platforms, file_name_);
+		}
+	}
+
+	bool name_matches(const char *extension) {
+		return extension_ == extension;
+	}
+
+	Media media;
+
+	private:
+		const std::string &file_name_;
+		TargetPlatform::IntType &potential_platforms_;
+		const std::string extension_;
+};
+
 }
 
 static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::IntType &potential_platforms) {
-	Media result;
-	const std::string extension = get_extension(file_name);
-
-#define InsertInstance(list, instance, platforms) \
-	list.emplace_back(instance);\
-	potential_platforms |= platforms;\
-	TargetPlatform::TypeDistinguisher *const distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
-	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
-
-#define Insert(list, class, platforms, ...) \
-	InsertInstance(list, new Storage::class(__VA_ARGS__), platforms);
-
-#define TryInsert(list, class, platforms, ...) \
-	try {\
-		Insert(list, class, platforms, __VA_ARGS__) \
-	} catch(...) {}
-
-#define Format(ext, list, class, platforms) \
-	if(extension == ext)	{		\
-		TryInsert(list, class, platforms, file_name)	\
-	}
+	MediaAccumulator accumulator(file_name, potential_platforms);
 
 	// 2MG
-	if(extension == "2mg") {
+	if(accumulator.name_matches("2mg")) {
 		// 2MG uses a factory method; defer to it.
 		try {
-			const auto media = Storage::Disk::Disk2MG::open(file_name);
-			std::visit([&result, &potential_platforms](auto &&arg) {
+			const auto media = Disk::Disk2MG::open(file_name);
+			std::visit([&](auto &&arg) {
 				using Type = typename std::decay<decltype(arg)>::type;
 
-				if constexpr (std::is_same<Type, nullptr_t>::value) {
+				if constexpr (std::is_same<Type, std::nullptr_t>::value) {
 					// It's valid for no media to be returned.
-				} else if constexpr (std::is_same<Type, Storage::Disk::DiskImageHolderBase *>::value) {
-					InsertInstance(result.disks, arg, TargetPlatform::DiskII);
-				} else if constexpr (std::is_same<Type, Storage::MassStorage::MassStorageDevice *>::value) {
+				} else if constexpr (std::is_same<Type, Disk::DiskImageHolderBase *>::value) {
+					accumulator.insert(TargetPlatform::DiskII, std::shared_ptr<Disk::DiskImageHolderBase>(arg));
+				} else if constexpr (std::is_same<Type, MassStorage::MassStorageDevice *>::value) {
 					// TODO: or is it Apple IIgs?
-					InsertInstance(result.mass_storage_devices, arg, TargetPlatform::AppleII);
+					accumulator.insert(TargetPlatform::AppleII, std::shared_ptr<MassStorage::MassStorageDevice>(arg));
 				} else {
 					static_assert(always_false_v<Type>, "Unexpected type encountered.");
 				}
@@ -144,95 +194,108 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 		} catch(...) {}
 	}
 
-	Format("80", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 80
-	Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 81
-	Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600)							// A26
-	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADF (Acorn)
-	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AmigaADF>, TargetPlatform::Amiga)			// ADF (Amiga)
-	Format("adl", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADL
-	Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge)						// BIN (cartridge dump)
-	Format("cas", result.tapes, Tape::CAS, TargetPlatform::MSX)													// CAS
-	Format("cdt", result.tapes, Tape::TZX, TargetPlatform::AmstradCPC)											// CDT
-	Format("col", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Coleco)								// COL
-	Format("csw", result.tapes, Tape::CSW, TargetPlatform::AllTape)												// CSW
-	Format("d64", result.disks, Disk::DiskImageHolder<Storage::Disk::D64>, TargetPlatform::Commodore)			// D64
-	Format("dat", result.mass_storage_devices, MassStorage::DAT, TargetPlatform::Acorn)							// DAT
-	Format("dmk", result.disks, Disk::DiskImageHolder<Storage::Disk::DMK>, TargetPlatform::MSX)					// DMK
-	Format("do", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)			// DO
-	Format("dsd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)				// DSD
-	Format(	"dsk",
-			result.disks,
-			Disk::DiskImageHolder<Storage::Disk::CPCDSK>,
-			TargetPlatform::AmstradCPC | TargetPlatform::Oric | TargetPlatform::ZXSpectrum)						// DSK (Amstrad CPC, etc)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)			// DSK (Apple II)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)	// DSK (Macintosh, floppy disk)
-	Format("dsk", result.mass_storage_devices, MassStorage::HFV, TargetPlatform::Macintosh)						// DSK (Macintosh, hard disk, single volume image)
-	Format("dsk", result.mass_storage_devices, MassStorage::DSK, TargetPlatform::Macintosh)						// DSK (Macintosh, hard disk, full device image)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::MSX)				// DSK (MSX)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::OricMFMDSK>, TargetPlatform::Oric)			// DSK (Oric)
-	Format("g64", result.disks, Disk::DiskImageHolder<Storage::Disk::G64>, TargetPlatform::Commodore)			// G64
-	Format("hdv", result.mass_storage_devices, MassStorage::HDV, TargetPlatform::AppleII)						// HDV (Apple II, hard disk, single volume image)
-	Format(	"hfe",
-			result.disks,
-			Disk::DiskImageHolder<Storage::Disk::HFE>,
-			TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric | TargetPlatform::ZXSpectrum)
-			// HFE (TODO: switch to AllDisk once the MSX stops being so greedy)
-	Format("img", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)		// IMG (DiskCopy 4.2)
-	Format("image", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)	// IMG (DiskCopy 4.2)
-	Format("img", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::Enterprise)			// IMG (Enterprise/MS-DOS style)
-	Format(	"ipf",
-			result.disks,
-			Disk::DiskImageHolder<Storage::Disk::IPF>,
-			TargetPlatform::Amiga | TargetPlatform::AtariST | TargetPlatform::AmstradCPC | TargetPlatform::ZXSpectrum)		// IPF
-	Format("msa", result.disks, Disk::DiskImageHolder<Storage::Disk::MSA>, TargetPlatform::AtariST)				// MSA
-	Format("mx2", result.cartridges, Cartridge::BinaryDump, TargetPlatform::MSX)								// MX2
-	Format("nib", result.disks, Disk::DiskImageHolder<Storage::Disk::NIB>, TargetPlatform::DiskII)				// NIB
-	Format("o", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// O
-	Format("p", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// P
-	Format("po", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)			// PO (original Apple II kind)
+	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "80");
+	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "81");
 
-	// PO (Apple IIgs kind)
-	if(extension == "po")	{
-		TryInsert(result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::AppleIIgs, file_name, Storage::Disk::MacintoshIMG::FixedType::GCR)
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::Atari2600, "a26");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AcornADF>>(TargetPlatform::Acorn, "adf");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AmigaADF>>(TargetPlatform::Amiga, "adf");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AcornADF>>(TargetPlatform::Acorn, "adl");
+
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::AllCartridge, "bin");
+
+	accumulator.try_standard<Tape::CAS>(TargetPlatform::MSX, "cas");
+	accumulator.try_standard<Tape::TZX>(TargetPlatform::AmstradCPC, "cdt");
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::Coleco, "col");
+	accumulator.try_standard<Tape::CSW>(TargetPlatform::AllTape, "csw");
+
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::D64>>(TargetPlatform::Commodore, "d64");
+	accumulator.try_standard<MassStorage::DAT>(TargetPlatform::Acorn, "dat");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::DMK>>(TargetPlatform::MSX, "dmk");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AppleDSK>>(TargetPlatform::DiskII, "do");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::SSD>>(TargetPlatform::Acorn, "dsd");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::CPCDSK>>(
+		TargetPlatform::AmstradCPC | TargetPlatform::Oric | TargetPlatform::ZXSpectrum, "dsk");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AppleDSK>>(TargetPlatform::DiskII, "dsk");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::MacintoshIMG>>(TargetPlatform::Macintosh, "dsk");
+	accumulator.try_standard<MassStorage::HFV>(TargetPlatform::Macintosh, "dsk");
+	accumulator.try_standard<MassStorage::DSK>(TargetPlatform::Macintosh, "dsk");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::FAT12>>(TargetPlatform::MSX, "dsk");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::OricMFMDSK>>(TargetPlatform::Oric, "dsk");
+
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::G64>>(TargetPlatform::Commodore, "g64");
+
+	accumulator.try_standard<MassStorage::HDV>(TargetPlatform::AppleII, "hdv");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::HFE>>(
+		TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric | TargetPlatform::ZXSpectrum,
+		"hfe");	// TODO: switch to AllDisk once the MSX stops being so greedy.
+
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::FAT12>>(TargetPlatform::PCCompatible, "ima");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::MacintoshIMG>>(TargetPlatform::Macintosh, "image");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::IMD>>(TargetPlatform::PCCompatible, "imd");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::MacintoshIMG>>(TargetPlatform::Macintosh, "img");
+
+	// Treat PC booter as a potential backup only if this doesn't parse as a FAT12.
+	if(accumulator.name_matches("img")) {
+		try {
+			accumulator.insert<Disk::DiskImageHolder<Disk::FAT12>>(TargetPlatform::FAT12, file_name);
+		} catch(...) {
+			accumulator.try_standard<Disk::DiskImageHolder<Disk::PCBooter>>(TargetPlatform::PCCompatible, "img");
+		}
 	}
 
-	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// P81
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::IPF>>(
+		TargetPlatform::Amiga | TargetPlatform::AtariST | TargetPlatform::AmstradCPC | TargetPlatform::ZXSpectrum,
+		"ipf");
 
-	// PRG
-	if(extension == "prg") {
-		// try instantiating as a ROM; failing that accept as a tape
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::MSA>>(TargetPlatform::AtariST, "msa");
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::MSX, "mx2");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::NIB>>(TargetPlatform::DiskII, "nib");
+
+	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "o");
+	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "p");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::AppleDSK>>(TargetPlatform::DiskII, "po");
+
+	if(accumulator.name_matches("po"))	{
+		accumulator.try_insert<Disk::DiskImageHolder<Disk::MacintoshIMG>>(
+			TargetPlatform::AppleIIgs,
+			file_name, Disk::MacintoshIMG::FixedType::GCR);
+	}
+
+	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "p81");
+
+	if(accumulator.name_matches("prg")) {
+		// Try instantiating as a ROM; failing that accept as a tape.
 		try {
-			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore, file_name)
+			accumulator.insert<Cartridge::PRG>(TargetPlatform::Commodore, file_name);
 		} catch(...) {
 			try {
-				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore, file_name)
+				accumulator.insert<Tape::PRG>(TargetPlatform::Commodore, file_name);
 			} catch(...) {}
 		}
 	}
 
-	Format(	"rom",
-			result.cartridges,
-			Cartridge::BinaryDump,
-			TargetPlatform::AcornElectron | TargetPlatform::Coleco | TargetPlatform::MSX)						// ROM
-	Format("sg", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Sega)								// SG
-	Format("sms", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Sega)								// SMS
-	Format("ssd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)				// SSD
-	Format("st", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::AtariST)			// ST
-	Format("stx", result.disks, Disk::DiskImageHolder<Storage::Disk::STX>, TargetPlatform::AtariST)				// STX
-	Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore)									// TAP (Commodore)
-	Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric)											// TAP (Oric)
-	Format("tap", result.tapes, Tape::ZXSpectrumTAP, TargetPlatform::ZXSpectrum)								// TAP (ZX Spectrum)
-	Format("tsx", result.tapes, Tape::TZX, TargetPlatform::MSX)													// TSX
-	Format("tzx", result.tapes, Tape::TZX, TargetPlatform::ZX8081 | TargetPlatform::ZXSpectrum)					// TZX
-	Format("uef", result.tapes, Tape::UEF, TargetPlatform::Acorn)												// UEF (tape)
-	Format("woz", result.disks, Disk::DiskImageHolder<Storage::Disk::WOZ>, TargetPlatform::DiskII)				// WOZ
+	accumulator.try_standard<Cartridge::BinaryDump>(
+		TargetPlatform::AcornElectron | TargetPlatform::Coleco | TargetPlatform::MSX,
+		"rom");
 
-#undef Format
-#undef Insert
-#undef TryInsert
-#undef InsertInstance
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::Sega, "sg");
+	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::Sega, "sms");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::SSD>>(TargetPlatform::Acorn, "ssd");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::FAT12>>(TargetPlatform::AtariST, "st");
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::STX>>(TargetPlatform::AtariST, "stx");
 
-	return result;
+	accumulator.try_standard<Tape::CommodoreTAP>(TargetPlatform::Commodore, "tap");
+	accumulator.try_standard<Tape::OricTAP>(TargetPlatform::Oric, "tap");
+	accumulator.try_standard<Tape::ZXSpectrumTAP>(TargetPlatform::ZXSpectrum, "tap");
+	accumulator.try_standard<Tape::TZX>(TargetPlatform::MSX, "tsx");
+	accumulator.try_standard<Tape::TZX>(TargetPlatform::ZX8081 | TargetPlatform::ZXSpectrum, "tzx");
+
+	accumulator.try_standard<Tape::UEF>(TargetPlatform::Acorn, "uef");
+
+	accumulator.try_standard<Disk::DiskImageHolder<Disk::WOZ>>(TargetPlatform::DiskII, "woz");
+
+	return accumulator.media;
 }
 
 Media Analyser::Static::GetMedia(const std::string &file_name) {
@@ -241,26 +304,28 @@ Media Analyser::Static::GetMedia(const std::string &file_name) {
 }
 
 TargetList Analyser::Static::GetTargets(const std::string &file_name) {
-	TargetList targets;
 	const std::string extension = get_extension(file_name);
+	TargetList targets;
 
 	// Check whether the file directly identifies a target; if so then just return that.
-#define Format(ext, class)											\
-	if(extension == ext)	{										\
-		try {														\
-			auto target = Storage::State::class::load(file_name);	\
-			if(target) {											\
-				targets.push_back(std::move(target));				\
-				return targets;										\
-			}														\
-		} catch(...) {}												\
-	}
+	const auto try_snapshot = [&](const char *ext, auto loader) -> bool {
+		if(extension != ext) {
+			return false;
+		}
+		try {
+			auto target = loader(file_name);
+			if(target) {
+				targets.push_back(std::move(target));
+				return true;
+			}
+		} catch(...) {}
 
-	Format("sna", SNA);
-	Format("szx", SZX);
-	Format("z80", Z80);
+		return false;
+	};
 
-#undef TryInsert
+	if(try_snapshot("sna", Storage::State::SNA::load)) return targets;
+	if(try_snapshot("szx", Storage::State::SZX::load)) return targets;
+	if(try_snapshot("z80", Storage::State::Z80::load)) return targets;
 
 	// Otherwise:
 	//
@@ -271,28 +336,33 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 
 	// Hand off to platform-specific determination of whether these
 	// things are actually compatible and, if so, how to load them.
-#define Append(x) if(potential_platforms & TargetPlatform::x) {\
-	auto new_targets = x::GetTargets(media, file_name, potential_platforms);\
-	std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));\
-}
-	Append(Acorn);
-	Append(AmstradCPC);
-	Append(AppleII);
-	Append(AppleIIgs);
-	Append(Amiga);
-	Append(Atari2600);
-	Append(AtariST);
-	Append(Coleco);
-	Append(Commodore);
-	Append(DiskII);
-	Append(Enterprise);
-	Append(Macintosh);
-	Append(MSX);
-	Append(Oric);
-	Append(Sega);
-	Append(ZX8081);
-	Append(ZXSpectrum);
-#undef Append
+	const auto append = [&](TargetPlatform::IntType platform, auto evaluator) {
+		if(!(potential_platforms & platform)) {
+			return;
+		}
+		auto new_targets = evaluator(media, file_name, potential_platforms);
+		std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));
+	};
+
+	append(TargetPlatform::Acorn, Acorn::GetTargets);
+	append(TargetPlatform::AmstradCPC, AmstradCPC::GetTargets);
+	append(TargetPlatform::AppleII, AppleII::GetTargets);
+	append(TargetPlatform::AppleIIgs, AppleIIgs::GetTargets);
+	append(TargetPlatform::Amiga, Amiga::GetTargets);
+	append(TargetPlatform::Atari2600, Atari2600::GetTargets);
+	append(TargetPlatform::AtariST, AtariST::GetTargets);
+	append(TargetPlatform::Coleco, Coleco::GetTargets);
+	append(TargetPlatform::Commodore, Commodore::GetTargets);
+	append(TargetPlatform::DiskII, DiskII::GetTargets);
+	append(TargetPlatform::Enterprise, Enterprise::GetTargets);
+	append(TargetPlatform::FAT12, FAT12::GetTargets);
+	append(TargetPlatform::Macintosh, Macintosh::GetTargets);
+	append(TargetPlatform::MSX, MSX::GetTargets);
+	append(TargetPlatform::Oric, Oric::GetTargets);
+	append(TargetPlatform::PCCompatible, PCCompatible::GetTargets);
+	append(TargetPlatform::Sega, Sega::GetTargets);
+	append(TargetPlatform::ZX8081, ZX8081::GetTargets);
+	append(TargetPlatform::ZXSpectrum, ZXSpectrum::GetTargets);
 
 	// Reset any tapes to their initial position.
 	for(const auto &target : targets) {

Analyser/Static/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef StaticAnalyser_hpp
-#define StaticAnalyser_hpp
+#pragma once
 
 #include "../Machines.hpp"
 
@@ -39,12 +38,15 @@ struct Media {
 	}
 
 	Media &operator +=(const Media &rhs) {
-#define append(name)	name.insert(name.end(), rhs.name.begin(), rhs.name.end());
-		append(disks);
-		append(tapes);
-		append(cartridges);
-		append(mass_storage_devices);
-#undef append
+		const auto append = [&](auto &destination, auto &source) {
+			destination.insert(destination.end(), source.begin(), source.end());
+		};
+
+		append(disks, rhs.disks);
+		append(tapes, rhs.tapes);
+		append(cartridges, rhs.cartridges);
+		append(mass_storage_devices, rhs.mass_storage_devices);
+
 		return *this;
 	}
 };
@@ -55,7 +57,7 @@ struct Media {
 */
 struct Target {
 	Target(Machine machine) : machine(machine) {}
-	virtual ~Target() {}
+	virtual ~Target() = default;
 
 	// This field is entirely optional.
 	std::unique_ptr<Reflection::Struct> state;
@@ -79,5 +81,3 @@ TargetList GetTargets(const std::string &file_name);
 Media GetMedia(const std::string &file_name);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_ZX8081_StaticAnalyser_hpp
-#define Analyser_Static_ZX8081_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::ZX8081 {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_ZX8081_Target_h
-#define Analyser_Static_ZX8081_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -39,5 +38,3 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 };
 
 }
-
-#endif /* Analyser_Static_ZX8081_Target_h */

Analyser/Static/ZXSpectrum/StaticAnalyser.cpp

@@ -33,14 +33,14 @@ bool IsSpectrumTape(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 }
 
 bool IsSpectrumDisk(const std::shared_ptr<Storage::Disk::Disk> &disk) {
-	Storage::Encodings::MFM::Parser parser(true, disk);
+	Storage::Encodings::MFM::Parser parser(Storage::Encodings::MFM::Density::Double, disk);
 
 	// Get logical sector 1; the Spectrum appears to support various physical
 	// sectors as sector 1.
-	Storage::Encodings::MFM::Sector *boot_sector = nullptr;
+	const Storage::Encodings::MFM::Sector *boot_sector = nullptr;
 	uint8_t sector_mask = 0;
 	while(!boot_sector) {
-		boot_sector = parser.get_sector(0, 0, sector_mask + 1);
+		boot_sector = parser.sector(0, 0, sector_mask + 1);
 		sector_mask += 0x40;
 		if(!sector_mask) break;
 	}

Analyser/Static/ZXSpectrum/StaticAnalyser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_ZXSpectrum_StaticAnalyser_hpp
-#define Analyser_Static_ZXSpectrum_StaticAnalyser_hpp
+#pragma once
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -18,5 +17,3 @@ namespace Analyser::Static::ZXSpectrum {
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
 }
-
-#endif /* StaticAnalyser_hpp */

Analyser/Static/ZXSpectrum/Target.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_ZXSpectrum_Target_h
-#define Analyser_Static_ZXSpectrum_Target_h
+#pragma once
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -37,5 +36,3 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 };
 
 }
-
-#endif /* Target_h */

BUILD.md

@@ -0,0 +1,99 @@
+![Clock Signal Application Icon](READMEImages/Icon.png)
+# Building Clock Signal
+
+Clock Signal is available as [a macOS native application using
+Metal](#macos-app) or as [a cross-platform command-line-driven SDL executable
+using OpenGL](#sdl-app).
+
+## macOS app
+
+The macOS native application requires a Metal-capable Mac running macOS 10.13 or
+later and has no prerequisites beyond the normal system libraries. It can be
+built [using Xcode](#building-the-macos-app-using-xcode) or on the command line
+[using `xcodebuild`](#building-the-macos-app-using-xcodebuild).
+
+Machine ROMs are intended to be built into the application bundle; populate the
+dummy folders below ROMImages before building.
+
+The Xcode project is configured to sign the application using the developer's
+certificate, but if you are not the developer then you will get a "No signing
+certificate" error. To avoid this, you'll specify that you want to sign the
+application to run locally.
+
+### Building the macOS app using Xcode
+
+Open the Clock Signal Xcode project in OSBindings/Mac.
+
+To avoid signing errors, edit the project, select the Signing & Capabilities
+tab, and change the Signing Certificate drop-down menu from "Development" to
+"Sign to Run Locally".
+
+To avoid crashes when running Clock Signal via Xcode on older Macs due to
+"unrecognized selector sent to instance" errors, edit the scheme, and in the Run
+section, scroll down to the Metal heading and uncheck the "API Validation"
+checkbox.
+
+To build, choose "Build" from Xcode's Product menu or press
+<kbd>Command</kbd> + <kbd>B</kbd>.
+
+To build and run, choose "Run" from the Product menu or press
+<kbd>Command</kbd> + <kbd>R</kbd>.
+
+To see the folder where the Clock Signal application was built, choose "Show
+Build Folder in Finder" from the Product menu. Look in the "Products" folder for
+a folder named after the configuration (e.g. "Debug" or "Release").
+
+### Building the macOS app using `xcodebuild`
+
+To build, change to the OSBindings/Mac directory in the Terminal, then run
+`xcodebuild`, specifying `-` as the code sign identity to sign the application
+to run locally to avoid signing errors:
+
+	cd OSBindings/Mac
+	xcodebuild CODE_SIGN_IDENTITY=-
+
+`xcodebuild` will create a "build" folder in this directory which is where you
+can find the Clock Signal application after it's compiled, in a directory named
+after the configuration (e.g. "Debug" or "Release").
+
+## SDL app
+
+The SDL app can be built on Linux, BSD, macOS, and other Unix-like operating
+systems. Prerequisites are SDL 2, ZLib and OpenGL (or Mesa). OpenGL 3.2 or
+better is required at runtime. It can be built [using
+SCons](#building-the-sdl-app-using-scons).
+
+### Building the SDL app using SCons
+
+To build, change to the OSBindings/SDL directory and run `scons`. You can add a
+`-j` flag to build in parallel. For example, if you have 8 processor cores:
+
+	cd OSBindings/SDL
+	scons -j8
+
+The `clksignal` executable will be created in this directory. You can run it
+from here or install it by copying it where you want it, for example:
+
+	cp clksignal /usr/local/bin
+
+To start an emulator with a particular disk image `file`, if you've installed
+`clksignal` to a directory in your `PATH`, run:
+
+	clksignal file
+
+Or if you're running it from the current directory:
+
+	./clksignal file
+
+Other options are availble. Run `clksignal` or `./clksignal` with no arguments
+to learn more.
+
+Setting up `clksignal` as the associated program for supported file types in
+your favoured filesystem browser is recommended; it has no file navigation
+abilities of its own.
+
+Some emulated systems require the provision of original machine ROMs. These are
+not included and may be located in either /usr/local/share/CLK/ or
+/usr/share/CLK/. You will be prompted for them if they are found to be missing.
+The structure should mirror that under OSBindings in the source archive; see the
+readme.txt in each folder to determine the proper files and names ahead of time.

BUILD.txt

@@ -1,30 +0,0 @@
-Linux, BSD
-==========
-
-Prerequisites are SDL 2, ZLib and OpenGL (or Mesa), and SCons for the provided build script. OpenGL 3.2 or better is required at runtime.
-
-Build:
-
-	cd OSBindings/SDL
-	scons
-
-Optionally:
-
-	cp clksignal /usr/bin
-
-To launch:
-
-	clksignal file
-
-Setting up clksignal as the associated program for supported file types in your favoured filesystem browser is recommended; it has no file navigation abilities of its own.
-
-Some emulated systems require the provision of original machine ROMs. These are not included and may be located in either /usr/local/share/CLK/ or /usr/share/CLK/. You will be prompted for them if they are found to be missing. The structure should mirror that under OSBindings in the source archive; see the readme.txt in each folder to determine the proper files and names ahead of time.
-
-macOS
-=====
-
-There are no prerequisites beyond the normal system libraries; the macOS build is a native Cocoa application.
-
-Build: open the Xcode project in OSBindings/Mac and press command+b.
-
-Machine ROMs are intended to be built into the application bundle; populate the dummy folders below ROMImages before building.

CMakeLists.txt

@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 3.19 FATAL_ERROR)
+
+project(CLK
+	LANGUAGES CXX
+	VERSION 24.01.22
+)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(CLK_UIS "SDL")
+#list(PREPEND CLK_UIS "QT")
+#if(APPLE)
+#	list(PREPEND CLK_UIS "MAC")
+#	set(CLK_DEFAULT_UI "MAC")
+#else()
+	set(CLK_DEFAULT_UI "SDL")
+#endif()
+
+set(CLK_UI ${CLK_DEFAULT_UI} CACHE STRING "User interface")
+set_property(CACHE CLK_UI PROPERTY STRINGS ${CLK_UIS})
+
+if(NOT CLK_UI IN_LIST CLK_UIS)
+	list(JOIN CLK_UIS ", " CLK_UIS_PRETTY)
+	message(FATAL_ERROR "Invalid value for 'CLK_UI'; must be one of ${CLK_UIS_PRETTY}")
+endif()
+
+message(STATUS "Configuring for ${CLK_UI} UI")
+
+list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include("CLK_SOURCES")
+
+add_executable(clksignal ${CLK_SOURCES})
+
+if(MSVC)
+	target_compile_options(clksignal PRIVATE /W4)
+else()
+	# TODO: Add -Wpedandic.
+	target_compile_options(clksignal PRIVATE -Wall -Wextra)
+endif()
+
+find_package(ZLIB REQUIRED)
+target_link_libraries(clksignal PRIVATE ZLIB::ZLIB)
+
+if(CLK_UI STREQUAL "MAC")
+	enable_language(OBJC OBJCXX SWIFT)
+	# TODO: Build the Mac version.
+else()
+	find_package(OpenGL REQUIRED)
+	target_link_libraries(clksignal PRIVATE OpenGL::GL)
+	if(APPLE)
+		target_compile_definitions(clksignal PRIVATE "GL_SILENCE_DEPRECATION" "IGNORE_APPLE")
+	endif()
+endif()
+
+if(CLK_UI STREQUAL "QT")
+	# TODO: Build the Qt version.
+elseif(APPLE)
+	set(BLA_VENDOR Apple)
+	find_package(BLAS REQUIRED)
+	target_link_libraries(clksignal PRIVATE BLAS::BLAS)
+endif()
+
+if(CLK_UI STREQUAL "SDL")
+	find_package(SDL2 REQUIRED CONFIG REQUIRED COMPONENTS SDL2)
+	target_link_libraries(clksignal PRIVATE SDL2::SDL2)
+endif()
+
+# TODO: Investigate building on Windows.

ClockReceiver/ClockReceiver.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef ClockReceiver_hpp
-#define ClockReceiver_hpp
+#pragma once
 
 #include "ForceInline.hpp"
 
@@ -277,5 +276,3 @@ template <class T> class HalfClockReceiver: public T {
 	private:
 		HalfCycles half_cycles_;
 };
-
-#endif /* ClockReceiver_hpp */

ClockReceiver/ClockingHintSource.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef ClockingHintSource_hpp
-#define ClockingHintSource_hpp
+#pragma once
 
 namespace ClockingHint {
 
@@ -84,5 +83,3 @@ class Source {
 };
 
 }
-
-#endif /* ClockingHintSource_h */

ClockReceiver/DeferredQueue.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef DeferredQueue_h
-#define DeferredQueue_h
+#pragma once
 
 #include <functional>
 #include <vector>
@@ -74,6 +73,11 @@ template <typename TimeUnit> class DeferredQueue {
 			}
 		}
 
+		/// @returns @c true if no actions are enqueued; @c false otherwise.
+		bool empty() const {
+			return pending_actions_.empty();
+		}
+
 	private:
 		// The list of deferred actions.
 		struct DeferredAction {
@@ -120,5 +124,3 @@ template <typename TimeUnit> class DeferredQueuePerformer: public DeferredQueue<
 	private:
 		std::function<void(TimeUnit)> target_;
 };
-
-#endif /* DeferredQueue_h */

ClockReceiver/DeferredValue.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef DeferredValue_h
-#define DeferredValue_h
+#pragma once
 
 /*!
 	Provides storage for a single deferred value: one with a current value and a certain number
@@ -44,5 +43,3 @@ template <int DeferredDepth, typename ValueT> class DeferredValue {
 				(backlog[DeferredDepth / elements_per_uint32] & insert_mask) | (value << insert_shift);
 		}
 };
-
-#endif /* DeferredValue_h */

ClockReceiver/ForceInline.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef ForceInline_hpp
-#define ForceInline_hpp
+#pragma once
 
 #ifndef NDEBUG
 
@@ -22,5 +21,3 @@
 #endif
 
 #endif
-
-#endif /* ForceInline_h */

ClockReceiver/JustInTime.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef JustInTime_h
-#define JustInTime_h
+#pragma once
 
 #include "ClockReceiver.hpp"
 #include "../Concurrency/AsyncTaskQueue.hpp"
@@ -335,5 +334,3 @@ template <class T, class LocalTimeScale = HalfCycles, class TargetTimeScale = Lo
 		bool is_flushed_ = true;
 		Concurrency::AsyncTaskQueue<true> task_queue_;
 };
-
-#endif /* JustInTime_h */

ClockReceiver/ScanSynchroniser.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2020 Thomas Harte. All rights reserved.
 //
 
-#ifndef ScanSynchroniser_h
-#define ScanSynchroniser_h
+#pragma once
 
 #include "../Outputs/ScanTarget.hpp"
 
@@ -84,5 +83,3 @@ class ScanSynchroniser {
 };
 
 }
-
-#endif /* ScanSynchroniser_h */

ClockReceiver/TimeTypes.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef TimeTypes_h
-#define TimeTypes_h
+#pragma once
 
 #include <chrono>
 
@@ -25,6 +24,3 @@ inline Seconds seconds(Nanos nanos) {
 }
 
 }
-
-#endif /* TimeTypes_h */
-

ClockReceiver/VSyncPredictor.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2020 Thomas Harte. All rights reserved.
 //
 
-#ifndef VSyncPredictor_hpp
-#define VSyncPredictor_hpp
+#pragma once
 
 #include "TimeTypes.hpp"
 #include <cassert>
@@ -151,5 +150,3 @@ class VSyncPredictor {
 };
 
 }
-
-#endif /* VSyncPredictor_hpp */

Components/1770/1770.cpp

@@ -9,10 +9,12 @@
 #include "1770.hpp"
 
 #include "../../Storage/Disk/Encodings/MFM/Constants.hpp"
-
-#define LOG_PREFIX "[WD FDC] "
 #include "../../Outputs/Log.hpp"
 
+namespace {
+Log::Logger<Log::Source::WDFDC> logger;
+}
+
 using namespace WD;
 
 WD1770::WD1770(Personality p) :
@@ -29,10 +31,10 @@ void WD1770::write(int address, uint8_t value) {
 			if((value&0xf0) == 0xd0) {
 				if(value == 0xd0) {
 					// Force interrupt **immediately**.
-					LOG("Force interrupt immediately");
+					logger.info().append("Force interrupt immediately");
 					posit_event(int(Event1770::ForceInterrupt));
 				} else {
-					ERROR("!!!TODO: force interrupt!!!");
+					logger.error().append("TODO: force interrupt");
 					update_status([] (Status &status) {
 						status.type = Status::One;
 					});
@@ -99,14 +101,14 @@ uint8_t WD1770::read(int address) {
 				if(status_.type == Status::One)
 					status |= (status_.spin_up ? Flag::SpinUp : 0);
 			}
-//			LOG("Returned status " << PADHEX(2) << int(status) << " of type " << 1+int(status_.type));
+//			logger.info().append("Returned status %02x of type %d", status, 1+int(status_.type));
 			return status;
 		}
 		case 1:
-			LOG("Returned track " << int(track_));
+			logger.info().append("Returned track %d", track_);
 			return track_;
 		case 2:
-			LOG("Returned sector " << int(sector_));
+			logger.info().append("Returned sector %d", sector_);
 			return sector_;
 		case 3:
 			update_status([] (Status &status) {
@@ -212,7 +214,7 @@ void WD1770::posit_event(int new_event_type) {
 	// Wait for a new command, branch to the appropriate handler.
 	case 0:
 	wait_for_command:
-		LOG("Idle...");
+		logger.info().append("Idle...");
 		set_data_mode(DataMode::Scanning);
 		index_hole_count_ = 0;
 
@@ -229,7 +231,7 @@ void WD1770::posit_event(int new_event_type) {
 			status.track_zero = false;	// Always reset by a non-type 1; so reset regardless and set properly later.
 		});
 
-		LOG("Starting " << PADHEX(2) << int(command_));
+		logger.info().append("Starting %02x", command_);
 
 		if(!(command_ & 0x80)) goto begin_type_1;
 		if(!(command_ & 0x40)) goto begin_type_2;
@@ -259,7 +261,7 @@ void WD1770::posit_event(int new_event_type) {
 			status.data_request = false;
 		});
 
-		LOG("Step/Seek/Restore with track " << int(track_) << " data " << int(data_));
+		logger.info().append("Step/Seek/Restore with track %d data %d", track_, data_);
 		if(!has_motor_on_line() && !has_head_load_line()) goto test_type1_type;
 
 		if(has_motor_on_line()) goto begin_type1_spin_up;
@@ -339,7 +341,7 @@ void WD1770::posit_event(int new_event_type) {
 		READ_ID();
 
 		if(index_hole_count_ == 6) {
-			LOG("Nothing found to verify");
+			logger.info().append("Nothing found to verify");
 			update_status([] (Status &status) {
 				status.seek_error = true;
 			});
@@ -357,7 +359,7 @@ void WD1770::posit_event(int new_event_type) {
 			}
 
 			if(header_[0] == track_) {
-				LOG("Reached track " << std::dec << int(track_));
+				logger.info().append("Reached track %d", track_);
 				update_status([] (Status &status) {
 					status.crc_error = false;
 				});
@@ -430,7 +432,7 @@ void WD1770::posit_event(int new_event_type) {
 		READ_ID();
 
 		if(index_hole_count_ == 5) {
-			LOG("Failed to find sector " << std::dec << int(sector_));
+			logger.info().append("Failed to find sector %d", sector_);
 			update_status([] (Status &status) {
 				status.record_not_found = true;
 			});
@@ -440,12 +442,12 @@ void WD1770::posit_event(int new_event_type) {
 			distance_into_section_ = 0;
 			set_data_mode(DataMode::Scanning);
 
-			LOG("Considering " << std::dec << int(header_[0]) << "/" << int(header_[2]));
+			logger.info().append("Considering %d/%d", header_[0], header_[2]);
 			if(		header_[0] == track_ && header_[2] == sector_ &&
 					(has_motor_on_line() || !(command_&0x02) || ((command_&0x08) >> 3) == header_[1])) {
-				LOG("Found " << std::dec << int(header_[0]) << "/" << int(header_[2]));
+				logger.info().append("Found %d/%d", header_[0], header_[2]);
 				if(get_crc_generator().get_value()) {
-					LOG("CRC error; back to searching");
+					logger.info().append("CRC error; back to searching");
 					update_status([] (Status &status) {
 						status.crc_error = true;
 					});
@@ -503,18 +505,18 @@ void WD1770::posit_event(int new_event_type) {
 			set_data_mode(DataMode::Scanning);
 
 			if(get_crc_generator().get_value()) {
-				LOG("CRC error; terminating");
+				logger.info().append("CRC error; terminating");
 				update_status([] (Status &status) {
 					status.crc_error = true;
 				});
 				goto wait_for_command;
 			}
 
-			LOG("Finished reading sector " << std::dec << int(sector_));
+			logger.info().append("Finished reading sector %d", sector_);
 
 			if(command_ & 0x10) {
 				sector_++;
-				LOG("Advancing to search for sector " << std::dec << int(sector_));
+				logger.info().append("Advancing to search for sector %d", sector_);
 				goto test_type2_write_protection;
 			}
 			goto wait_for_command;
@@ -598,7 +600,7 @@ void WD1770::posit_event(int new_event_type) {
 			sector_++;
 			goto test_type2_write_protection;
 		}
-		LOG("Wrote sector " << std::dec << int(sector_));
+		logger.info().append("Wrote sector %d", sector_);
 		goto wait_for_command;
 
 

Components/1770/1770.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef _770_hpp
-#define _770_hpp
+#pragma once
 
 #include "../../Storage/Disk/Controller/MFMDiskController.hpp"
 
@@ -31,7 +30,7 @@ class WD1770: public Storage::Disk::MFMController {
 			@param p The type of controller to emulate.
 		*/
 		WD1770(Personality p);
-		virtual ~WD1770() {}
+		virtual ~WD1770() = default;
 
 		/// Sets the value of the double-density input; when @c is_double_density is @c true, reads and writes double-density format data.
 		using Storage::Disk::MFMController::set_is_double_density;
@@ -141,5 +140,3 @@ class WD1770: public Storage::Disk::MFMController {
 };
 
 }
-
-#endif /* _770_hpp */

Components/5380/ncr5380.cpp

@@ -8,13 +8,11 @@
 
 #include "ncr5380.hpp"
 
-#ifndef NDEBUG
-#define NDEBUG
-#endif
-#define LOG_PREFIX "[5380] "
-
 #include "../../Outputs/Log.hpp"
 
+namespace {
+Log::Logger<Log::Source::NCR5380> logger;
+}
 // TODO:
 //
 //	end_of_dma_ should be set if: /EOP && /DACK && (/RD || /WR); for at least 100ns.
@@ -38,7 +36,7 @@ NCR5380::NCR5380(SCSI::Bus &bus, int clock_rate) :
 void NCR5380::write(int address, uint8_t value, bool) {
 	switch(address & 7) {
 		case 0:
-			LOG("[0] Set current SCSI bus state to " << PADHEX(2) << int(value));
+			logger.info().append("[0] Set current SCSI bus state to %02x", value);
 
 			data_bus_ = value;
 			if(dma_request_ && dma_operation_ == DMAOperation::Send) {
@@ -47,7 +45,7 @@ void NCR5380::write(int address, uint8_t value, bool) {
 		break;
 
 		case 1: {
-			LOG("[1] Initiator command register set: " << PADHEX(2) << int(value));
+			logger.info().append("[1] Initiator command register set: %02x", value);
 			initiator_command_ = value;
 
 			bus_output_ &= ~(Line::Reset | Line::Acknowledge | Line::Busy | Line::SelectTarget | Line::Attention);
@@ -63,7 +61,7 @@ void NCR5380::write(int address, uint8_t value, bool) {
 		} break;
 
 		case 2:
-			LOG("[2] Set mode: " << PADHEX(2) << int(value));
+			logger.info().append("[2] Set mode: %02x", value);
 			mode_ = value;
 
 			// bit 7: 1 = use block mode DMA mode (if DMA mode is also enabled)
@@ -104,27 +102,27 @@ void NCR5380::write(int address, uint8_t value, bool) {
 		break;
 
 		case 3: {
-			LOG("[3] Set target command: " << PADHEX(2) << int(value));
+			logger.info().append("[3] Set target command: %02x", value);
 			target_command_ = value;
 			update_control_output();
 		} break;
 
 		case 4:
-			LOG("[4] Set select enabled: " << PADHEX(2) << int(value));
+			logger.info().append("[4] Set select enabled: %02x", value);
 		break;
 
 		case 5:
-			LOG("[5] Start DMA send: " << PADHEX(2) << int(value));
+			logger.info().append("[5] Start DMA send: %02x", value);
 			dma_operation_ = DMAOperation::Send;
 		break;
 
 		case 6:
-			LOG("[6] Start DMA target receive: " << PADHEX(2) << int(value));
+			logger.info().append("[6] Start DMA target receive: %02x", value);
 			dma_operation_ = DMAOperation::TargetReceive;
 		break;
 
 		case 7:
-			LOG("[7] Start DMA initiator receive: " << PADHEX(2) << int(value));
+			logger.info().append("[7] Start DMA initiator receive: %02x", value);
 			dma_operation_ = DMAOperation::InitiatorReceive;
 		break;
 	}
@@ -148,7 +146,7 @@ void NCR5380::write(int address, uint8_t value, bool) {
 uint8_t NCR5380::read(int address, bool) {
 	switch(address & 7) {
 		case 0:
-			LOG("[0] Get current SCSI bus state: " << PADHEX(2) << (bus_.get_state() & 0xff));
+			logger.info().append("[0] Get current SCSI bus state: %02x", (bus_.get_state() & 0xff));
 
 			if(dma_request_ && dma_operation_ == DMAOperation::InitiatorReceive) {
 				return dma_acknowledge();
@@ -156,7 +154,7 @@ uint8_t NCR5380::read(int address, bool) {
 		return uint8_t(bus_.get_state());
 
 		case 1:
-			LOG("[1] Initiator command register get: " << (arbitration_in_progress_ ? 'p' : '-') << (lost_arbitration_ ? 'l' : '-'));
+			logger.info().append("[1] Initiator command register get: %c%c", arbitration_in_progress_ ? 'p' : '-', lost_arbitration_ ? 'l' : '-');
 		return
 			// Bits repeated as they were set.
 			(initiator_command_ & ~0x60) |
@@ -168,11 +166,11 @@ uint8_t NCR5380::read(int address, bool) {
 			(lost_arbitration_ ? 0x20 : 0x00);
 
 		case 2:
-			LOG("[2] Get mode");
+			logger.info().append("[2] Get mode");
 		return mode_;
 
 		case 3:
-			LOG("[3] Get target command");
+			logger.info().append("[3] Get target command");
 		return target_command_;
 
 		case 4: {
@@ -186,7 +184,7 @@ uint8_t NCR5380::read(int address, bool) {
 				((bus_state & Line::Input)			? 0x04 : 0x00) |
 				((bus_state & Line::SelectTarget)	? 0x02 : 0x00) |
 				((bus_state & Line::Parity)			? 0x01 : 0x00);
-			LOG("[4] Get current bus state: " << PADHEX(2) << int(result));
+			logger.info().append("[4] Get current bus state: %02x", result);
 			return result;
 		}
 
@@ -201,16 +199,16 @@ uint8_t NCR5380::read(int address, bool) {
 				/* b2 = busy error */
 				((bus_state & Line::Attention) ? 0x02 : 0x00) |
 				((bus_state & Line::Acknowledge) ? 0x01 : 0x00);
-			LOG("[5] Get bus and status: " << PADHEX(2) << int(result));
+			logger.info().append("[5] Get bus and status: %02x", result);
 			return result;
 		}
 
 		case 6:
-			LOG("[6] Get input data");
+			logger.info().append("[6] Get input data");
 		return 0xff;
 
 		case 7:
-			LOG("[7] Reset parity/interrupt");
+			logger.info().append("[7] Reset parity/interrupt");
 			irq_ = false;
 		return 0xff;
 	}

Components/5380/ncr5380.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#ifndef ncr5380_hpp
-#define ncr5380_hpp
+#pragma once
 
 #include <cstdint>
 
@@ -86,5 +85,3 @@ class NCR5380 final: public SCSI::Bus::Observer {
 };
 
 }
-
-#endif /* ncr5380_hpp */

Components/6522/6522.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef _522_hpp
-#define _522_hpp
+#pragma once
 
 #include <cstdint>
 
@@ -69,7 +68,7 @@ class IRQDelegatePortHandler: public PortHandler {
 		/// Sets the delegate that will receive notification of changes in the interrupt line.
 		void set_interrupt_delegate(Delegate *delegate);
 
-		/// Overrides PortHandler::set_interrupt_status, notifying the delegate if one is set.
+		/// Overrides @c PortHandler::set_interrupt_status, notifying the delegate if one is set.
 		void set_interrupt_status(bool new_status);
 
 	private:
@@ -140,5 +139,3 @@ template <class BusHandlerT> class MOS6522: public MOS6522Storage {
 }
 
 #include "Implementation/6522Implementation.hpp"
-
-#endif /* _522_hpp */

Components/6522/Implementation/6522Storage.hpp

@@ -6,8 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef _522Storage_hpp
-#define _522Storage_hpp
+#pragma once
 
 #include <cstdint>
 
@@ -107,5 +106,3 @@ class MOS6522Storage {
 };
 
 }
-
-#endif /* _522Storage_hpp */

Components/6526/6526.hpp

@@ -6,8 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef _526_h
-#define _526_h
+#pragma once
 
 #include <cstdint>
 
@@ -83,10 +82,10 @@ template <typename PortHandlerT, Personality personality> class MOS6526:
 		void advance_counters(int);
 
 		bool serial_line_did_produce_bit(Serial::Line<true> *line, int bit) final;
+
+		Log::Logger<Log::Source::MOS6526> log;
 };
 
 }
 
 #include "Implementation/6526Implementation.hpp"
-
-#endif /* _526_h */

Components/6526/Implementation/6526Implementation.hpp

@@ -6,11 +6,7 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#ifndef _526Implementation_h
-#define _526Implementation_h
-
-#include <cassert>
-#include <cstdio>
+#pragma once
 
 namespace MOS::MOS6526 {
 
@@ -133,13 +129,11 @@ void MOS6526<BusHandlerT, personality>::write(int address, uint8_t value) {
 
 		// Shift control.
 		case 12:
-			printf("TODO: write to shift register\n");
+			log.error().append("TODO: write to shift register");
 		break;
 
-		default:
-			printf("Unhandled 6526 write: %02x to %d\n", value, address);
-			assert(false);
-		break;
+		// Logically unreachable.
+		default: break;
 	}
 }
 
@@ -180,10 +174,8 @@ uint8_t MOS6526<BusHandlerT, personality>::read(int address) {
 		// Shift register.
 		case 12:	return shift_data_;
 
-		default:
-			printf("Unhandled 6526 read from %d\n", address);
-			assert(false);
-		break;
+		// Logically unreachable.
+		default: break;
 	}
 	return 0xff;
 }
@@ -238,5 +230,3 @@ bool MOS6526<BusHandlerT, personality>::serial_line_did_produce_bit(Serial::Line
 }
 
 }
-
-#endif /* _526Implementation_h */