Merge branch 'master' into SeparateFetchClock

.github/workflows/build.yml

@@ -1,51 +0,0 @@
-name: Build
-on: [pull_request]
-jobs:
-  build-mac:
-    name: Mac UI on ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-    - name: Make
-      working-directory: OSBindings/Mac
-      run: xcodebuild CODE_SIGN_IDENTITY=-
-  build-sdl:
-    name: SDL UI on ${{ 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 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

@@ -0,0 +1,16 @@
+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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef ActivityObserver_h
+#define ActivityObserver_h
 
 #include <cstdint>
 #include <string>
@@ -23,8 +24,6 @@ namespace Activity {
 */
 class Observer {
 	public:
-		virtual ~Observer() {}
-
 		/// 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.
@@ -57,3 +56,5 @@ class Observer {
 };
 
 }
+
+#endif /* ActivityObserver_h */

Activity/Source.hpp

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

Analyser/Dynamic/ConfidenceCounter.hpp

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

Analyser/Dynamic/ConfidenceSource.hpp

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

Analyser/Dynamic/ConfidenceSummary.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef MultiJoystickMachine_hpp
+#define MultiJoystickMachine_hpp
 
 #include "../../../../Machines/DynamicMachine.hpp"
 
@@ -33,3 +34,5 @@ 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 is_repeat) {
+bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed) {
 	bool was_consumed = false;
 	for(const auto &machine: machines_) {
-		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed, is_repeat);
+		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed);
 	}
 	return was_consumed;
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

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

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

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

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

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

Analyser/Machines.hpp

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

Analyser/Static/Acorn/Disk.cpp

@@ -19,10 +19,10 @@ 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(Storage::Encodings::MFM::Density::Single, disk);
+	Storage::Encodings::MFM::Parser parser(false, disk);
 
-	const Storage::Encodings::MFM::Sector *const names = parser.sector(0, 0, 0);
-	const Storage::Encodings::MFM::Sector *const details = parser.sector(0, 0, 1);
+	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);
 
 	if(!names || !details) return nullptr;
 	if(names->samples.empty() || details->samples.empty()) return nullptr;
@@ -65,7 +65,7 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 			uint8_t track = uint8_t(start_sector / 10);
 			start_sector++;
 
-			const Storage::Encodings::MFM::Sector *next_sector = parser.sector(0, track, sector);
+			Storage::Encodings::MFM::Sector *next_sector = parser.get_sector(0, track, sector);
 			if(!next_sector) break;
 
 			long length_from_sector = std::min(data_length, 256l);
@@ -84,15 +84,15 @@ 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(Storage::Encodings::MFM::Density::Double, disk);
+	Storage::Encodings::MFM::Parser parser(true, disk);
 
-	const Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.sector(0, 0, 1);
+	Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.get_sector(0, 0, 1);
 	if(!free_space_map_second_half) return nullptr;
 
 	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.sector(0, 0, c);
+		const Storage::Encodings::MFM::Sector *const sector = parser.get_sector(0, 0, c);
 		if(!sector) return nullptr;
 		root_directory.insert(root_directory.end(), sector->samples[0].begin(), sector->samples[0].end());
 	}
@@ -166,7 +166,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.sector(start_sector / (80 * 16), (start_sector / 16) % 80, start_sector % 16);
+			const Storage::Encodings::MFM::Sector *const sector = parser.get_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());

Analyser/Static/Acorn/Disk.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Acorn_Disk_hpp
+#define StaticAnalyser_Acorn_Disk_hpp
 
 #include "File.hpp"
 #include "../../../Storage/Disk/Disk.hpp"
@@ -29,3 +30,5 @@ 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,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Acorn_File_hpp
+#define StaticAnalyser_Acorn_File_hpp
 
 #include <memory>
 #include <string>
@@ -58,3 +59,5 @@ struct File {
 };
 
 }
+
+#endif /* File_hpp */

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Acorn_StaticAnalyser_hpp
+#define StaticAnalyser_Acorn_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Acorn_Tape_hpp
+#define StaticAnalyser_Acorn_Tape_hpp
 
 #include <memory>
 
@@ -18,3 +19,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Acorn_Target_h
+#define Analyser_Static_Acorn_Target_h
 
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
@@ -35,3 +36,5 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 };
 
 }
+
+#endif /* Analyser_Static_Acorn_Target_h */

Analyser/Static/Amiga/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Amiga_StaticAnalyser_hpp
+#define Analyser_Static_Amiga_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Amiga_Target_h
+#define Analyser_Static_Amiga_Target_h
 
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
@@ -39,3 +40,5 @@ 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(Storage::Encodings::MFM::Density::Double, disk);
-	const Storage::Encodings::MFM::Sector *boot_sector = parser.sector(0, 0, 0x41);
+	Storage::Encodings::MFM::Parser parser(true, disk);
+	Storage::Encodings::MFM::Sector *boot_sector = parser.get_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,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_AmstradCPC_StaticAnalyser_hpp
+#define Analyser_Static_AmstradCPC_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_AmstradCPC_Target_h
+#define Analyser_Static_AmstradCPC_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -29,3 +30,5 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
+
+#endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/AppleII/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_AppleII_StaticAnalyser_hpp
+#define Analyser_Static_AppleII_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_AppleII_Target_h
+#define Analyser_Static_AppleII_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -49,3 +50,5 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
+
+#endif /* Analyser_Static_AppleII_Target_h */

Analyser/Static/AppleIIgs/StaticAnalyser.hpp

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

Analyser/Static/Atari2600/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Atari_StaticAnalyser_hpp
+#define StaticAnalyser_Atari_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Atari2600_Target_h
+#define Analyser_Static_Atari2600_Target_h
 
 #include "../StaticAnalyser.hpp"
 
@@ -36,3 +37,5 @@ struct Target: public ::Analyser::Static::Target {
 };
 
 }
+
+#endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/AtariST/StaticAnalyser.hpp

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

Analyser/Static/Coleco/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Coleco_StaticAnalyser_hpp
+#define StaticAnalyser_Coleco_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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> sector(uint8_t track, uint8_t sector) {
+		std::shared_ptr<Sector> get_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.sector(next_track, next_sector);
+		sector = parser.get_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.sector(next_track, next_sector);
+			sector = parser.get_sector(next_track, next_sector);
 			if(!sector) break;
 
 			next_track = sector->data[0];

Analyser/Static/Commodore/Disk.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Commodore_Disk_hpp
+#define StaticAnalyser_Commodore_Disk_hpp
 
 #include "../../../Storage/Disk/Disk.hpp"
 #include "File.hpp"
@@ -18,3 +19,5 @@ 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,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef File_hpp
+#define File_hpp
 
 #include <cstdint>
 #include <string>
@@ -34,3 +35,5 @@ 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::Logger<Log::Source::CommodoreStaticAnalyser>().error().append("Unrecognised loading address for Commodore program: %04x", files.front().starting_address);
+				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) << files.front().starting_address);
 				[[fallthrough]];
 			case 0x1001:
 				memory_model = Target::MemoryModel::Unexpanded;

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Commodore_StaticAnalyser_hpp
+#define StaticAnalyser_Commodore_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Commodore_Tape_hpp
+#define StaticAnalyser_Commodore_Tape_hpp
 
 #include "../../../Storage/Tape/Tape.hpp"
 #include "File.hpp"
@@ -16,3 +17,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Commodore_Target_h
+#define Analyser_Static_Commodore_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -69,3 +70,5 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
+
+#endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.cpp

@@ -236,7 +236,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			case Instruction::Relative: {
 				std::size_t operand_address = address_mapper(address);
 				if(operand_address >= memory.size()) return;
-				++address;
+				address++;
 
 				instruction.operand = memory[operand_address];
 			}
@@ -291,34 +291,20 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 		}
 
 		// Decide on overall flow control.
-
-		// All relative instructions are flow control.
+		if(instruction.operation == Instruction::RTS || instruction.operation == Instruction::RTI) return;
+		if(instruction.operation == Instruction::BRK) return;	// TODO: check whether IRQ vector is within memory range
+		if(instruction.operation == Instruction::JSR) {
+			disassembly.remaining_entry_points.push_back(instruction.operand);
+		}
+		if(instruction.operation == Instruction::JMP) {
+			if(instruction.addressing_mode == Instruction::Absolute)
+				disassembly.remaining_entry_points.push_back(instruction.operand);
+			return;
+		}
 		if(instruction.addressing_mode == Instruction::Relative) {
 			uint16_t destination = uint16_t(address + int8_t(instruction.operand));
 			disassembly.remaining_entry_points.push_back(destination);
 		}
-
-		switch(instruction.operation) {
-			default: break;
-
-			case Instruction::KIL:
-			case Instruction::RTS:
-			case Instruction::RTI:
-			case Instruction::BRK: // TODO: check whether IRQ vector is within memory range.
-				disassembly.implicit_entry_points.push_back(address);
-			return;
-
-			case Instruction::JMP:
-				// Adding a new entry point for relative jumps was handled above.
-				if(instruction.addressing_mode == Instruction::Absolute) {
-					disassembly.remaining_entry_points.push_back(instruction.operand);
-				}
-			return;
-
-			case Instruction::JSR:
-				disassembly.remaining_entry_points.push_back(instruction.operand);
-			break;
-		}
 	}
 }
 
@@ -330,5 +316,5 @@ Disassembly Analyser::Static::MOS6502::Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(uint16_t)> &address_mapper,
 	std::vector<uint16_t> entry_points) {
-	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, MOS6502Disassembler>(memory, address_mapper, entry_points, false);
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, MOS6502Disassembler>(memory, address_mapper, entry_points);
 }

Analyser/Static/Disassembler/6502.hpp

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

Analyser/Static/Disassembler/AddressMapper.hpp

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

Analyser/Static/Disassembler/Kernel.hpp

@@ -6,61 +6,43 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Kernel_hpp
+#define Kernel_hpp
 
 namespace Analyser::Static::Disassembly {
 
 template <typename D, typename S> struct PartialDisassembly {
 	D disassembly;
 	std::vector<S> remaining_entry_points;
-	std::vector<S> implicit_entry_points;
 };
 
 template <typename D, typename S, typename Disassembler> D Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(S)> &address_mapper,
-	std::vector<S> entry_points,
-	bool exhaustive)
-{
+	std::vector<S> entry_points) {
 	PartialDisassembly<D, S> partial_disassembly;
 	partial_disassembly.remaining_entry_points = entry_points;
 
 	while(!partial_disassembly.remaining_entry_points.empty()) {
-		// Do a recursive-style disassembly for all current entry points.
-		while(!partial_disassembly.remaining_entry_points.empty()) {
-			// Pull the next entry point from the back of the vector.
-			const S next_entry_point = partial_disassembly.remaining_entry_points.back();
-			partial_disassembly.remaining_entry_points.pop_back();
+		// pull the next entry point from the back of the vector
+		S next_entry_point = partial_disassembly.remaining_entry_points.back();
+		partial_disassembly.remaining_entry_points.pop_back();
 
-			// If that address has already been visited, forget about it.
-			if(	partial_disassembly.disassembly.instructions_by_address.find(next_entry_point)
-				!= partial_disassembly.disassembly.instructions_by_address.end()) continue;
+		// if that address has already been visited, forget about it
+		if(	partial_disassembly.disassembly.instructions_by_address.find(next_entry_point)
+			!= partial_disassembly.disassembly.instructions_by_address.end()) continue;
 
-			// If it's outgoing, log it as such and forget about it; otherwise disassemble.
-			std::size_t mapped_entry_point = address_mapper(next_entry_point);
-			if(mapped_entry_point >= memory.size())
-				partial_disassembly.disassembly.outward_calls.insert(next_entry_point);
-			else
-				Disassembler::AddToDisassembly(partial_disassembly, memory, address_mapper, next_entry_point);
-		}
-
-		// If this is not an exhaustive disassembly, that's your lot.
-		if(!exhaustive) {
-			break;
-		}
-
-		// Otherwise, copy in the new 'implicit entry points' (i.e. all locations that are one after
-		// a disassembled region). There's a test above that'll ignore any which have already been
-		// disassembled from.
-		std::move(
-			partial_disassembly.implicit_entry_points.begin(),
-			partial_disassembly.implicit_entry_points.end(),
-			std::back_inserter(partial_disassembly.remaining_entry_points)
-		);
-		partial_disassembly.implicit_entry_points.clear();
+		// if it's outgoing, log it as such and forget about it; otherwise disassemble
+		std::size_t mapped_entry_point = address_mapper(next_entry_point);
+		if(mapped_entry_point >= memory.size())
+			partial_disassembly.disassembly.outward_calls.insert(next_entry_point);
+		else
+			Disassembler::AddToDisassembly(partial_disassembly, memory, address_mapper, next_entry_point);
 	}
 
 	return partial_disassembly.disassembly;
 }
 
 }
+
+#endif /* Kernel_hpp */

Analyser/Static/Disassembler/Z80.cpp

@@ -56,11 +56,11 @@ class Accessor {
 		bool overrun_ = false;
 };
 
-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; }
+#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)
 
 Instruction::Condition condition_table[] = {
 	Instruction::Condition::NZ,		Instruction::Condition::Z,
@@ -589,7 +589,7 @@ struct Z80Disassembler {
 				break;
 			}
 
-			// Add any (potentially) newly-discovered entry point.
+			// Add any (potentially) newly discovered entry point.
 			if(	instruction.operation == Instruction::Operation::JP ||
 				instruction.operation == Instruction::Operation::JR ||
 				instruction.operation == Instruction::Operation::CALL ||
@@ -598,37 +598,22 @@ struct Z80Disassembler {
 			}
 
 			// This is it if: an unconditional RET, RETI, RETN, JP or JR is found.
-			switch(instruction.operation) {
-				default: break;
+			if(instruction.condition != Instruction::Condition::None)	continue;
 
-				case Instruction::Operation::RET:
-				case Instruction::Operation::RETI:
-				case Instruction::Operation::RETN:
-				case Instruction::Operation::JP:
-				case Instruction::Operation::JR:
-					if(instruction.condition == Instruction::Condition::None) {
-						disassembly.implicit_entry_points.push_back(accessor.address());
-						return;
-					}
-			}
+			if(instruction.operation == Instruction::Operation::RET)	return;
+			if(instruction.operation == Instruction::Operation::RETI)	return;
+			if(instruction.operation == Instruction::Operation::RETN)	return;
+			if(instruction.operation == Instruction::Operation::JP)		return;
+			if(instruction.operation == Instruction::Operation::JR)		return;
 		}
 	}
 };
 
 }	// end of anonymous namespace
 
-
-
 Disassembly Analyser::Static::Z80::Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(uint16_t)> &address_mapper,
-	std::vector<uint16_t> entry_points,
-	Approach approach)
-{
-	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, Z80Disassembler>(
-		memory,
-		address_mapper,
-		entry_points,
-		approach == Approach::Exhaustive
-	);
+	std::vector<uint16_t> entry_points) {
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, Z80Disassembler>(memory, address_mapper, entry_points);
 }

Analyser/Static/Disassembler/Z80.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Disassembler_Z80_hpp
+#define StaticAnalyser_Disassembler_Z80_hpp
 
 #include <cstdint>
 #include <functional>
@@ -75,18 +76,11 @@ struct Disassembly {
 	std::set<uint16_t> internal_stores, internal_loads, internal_modifies;
 };
 
-enum class Approach {
-	/// Disassemble from the supplied entry points until an indeterminate branch or return only, adding other fully-static
-	/// entry points as they are observed.
-	Recursive,
-	/// Disassemble all supplied bytes, regardless of what nonsense may be encountered by accidental parsing of data areas.
-	Exhaustive,
-};
-
 Disassembly Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(uint16_t)> &address_mapper,
-	std::vector<uint16_t> entry_points,
-	Approach approach);
+	std::vector<uint16_t> entry_points);
 
 }
+
+#endif /* StaticAnalyser_Disassembler_Z80_hpp */

Analyser/Static/DiskII/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_DiskII_StaticAnalyser_hpp
+#define Analyser_Static_DiskII_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,8 +40,6 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Enterprise_StaticAnalyser_hpp
+#define Analyser_Static_Enterprise_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Enterprise_Target_h
+#define Analyser_Static_Enterprise_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -48,3 +49,5 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
+
+#endif /* Analyser_Static_Enterprise_Target_h */

Analyser/Static/FAT12/StaticAnalyser.cpp

@@ -1,100 +0,0 @@
-//
-//  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

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

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -115,16 +115,97 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 		// be at play; disassemble to try to figure it out.
 		std::vector<uint8_t> first_8k;
 		first_8k.insert(first_8k.begin(), segment.data.begin(), segment.data.begin() + 8192);
-		const Analyser::Static::Z80::Disassembly disassembly =
+		Analyser::Static::Z80::Disassembly disassembly =
 			Analyser::Static::Z80::Disassemble(
 				first_8k,
 				Analyser::Static::Disassembler::OffsetMapper(start_address),
-				{ init_address },
-				Analyser::Static::Z80::Approach::Exhaustive
+				{ init_address }
 			);
 
+//		// Look for a indirect store followed by an unconditional JP or CALL into another
+//		// segment, that's a fairly explicit sign where found.
 		using Instruction = Analyser::Static::Z80::Instruction;
-		const std::map<uint16_t, Instruction> &instructions = disassembly.instructions_by_address;
+		std::map<uint16_t, Instruction> &instructions = disassembly.instructions_by_address;
+		bool is_ascii = false;
+//		auto iterator = instructions.begin();
+//		while(iterator != instructions.end()) {
+//			auto next_iterator = iterator;
+//			next_iterator++;
+//			if(next_iterator == instructions.end()) break;
+//
+//			if(	iterator->second.operation == Instruction::Operation::LD &&
+//				iterator->second.destination == Instruction::Location::Operand_Indirect &&
+//				(
+//					iterator->second.operand == 0x5000 ||
+//					iterator->second.operand == 0x6000 ||
+//					iterator->second.operand == 0x6800 ||
+//					iterator->second.operand == 0x7000 ||
+//					iterator->second.operand == 0x77ff ||
+//					iterator->second.operand == 0x7800 ||
+//					iterator->second.operand == 0x8000 ||
+//					iterator->second.operand == 0x9000 ||
+//					iterator->second.operand == 0xa000
+//				) &&
+//				(
+//					next_iterator->second.operation == Instruction::Operation::CALL ||
+//					next_iterator->second.operation == Instruction::Operation::JP
+//				) &&
+//				((next_iterator->second.operand >> 13) != (0x4000 >> 13))
+//			) {
+//				const uint16_t address = uint16_t(next_iterator->second.operand);
+//				switch(iterator->second.operand) {
+//					case 0x6000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x6800:
+//						if(address >= 0x6000 && address < 0x6800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x7000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//						if(address >= 0x7000 && address < 0x7800) {
+//							is_ascii = true;
+//						}
+//					break;
+//					case 0x77ff:
+//						if(address >= 0x7000 && address < 0x7800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII16kb;
+//						}
+//					break;
+//					case 0x7800:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x8000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x9000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0xa000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::Konami;
+//						}
+//					break;
+//					case 0xb000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//				}
+//			}
+//
+//			iterator = next_iterator;
 
 		// Look for LD (nnnn), A instructions, and collate those addresses.
 		std::map<uint16_t, int> address_counts;
@@ -136,46 +217,49 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 			}
 		}
 
-		// Weight confidences by number of observed hits; if any is above 60% confidence, just use it.
-		const auto ascii_8kb_total = address_counts[0x6000] + address_counts[0x6800] + address_counts[0x7000] + address_counts[0x7800];
-		const auto ascii_16kb_total = address_counts[0x6000] + address_counts[0x7000] + address_counts[0x77ff];
-		const auto konami_total = address_counts[0x6000] + address_counts[0x8000] + address_counts[0xa000];
-		const auto konami_with_scc_total = address_counts[0x5000] + address_counts[0x7000] + address_counts[0x9000] + address_counts[0xb000];
+		// Weight confidences by number of observed hits.
+		float total_hits =
+			float(
+				address_counts[0x6000] + address_counts[0x6800] +
+				address_counts[0x7000] + address_counts[0x7800] +
+				address_counts[0x77ff] + address_counts[0x8000] +
+				address_counts[0xa000] + address_counts[0x5000] +
+				address_counts[0x9000] + address_counts[0xb000]
+			);
 
-		const auto total_hits = ascii_8kb_total + ascii_16kb_total + konami_total + konami_with_scc_total;
-
-		const bool is_ascii_8kb = (ascii_8kb_total * 5) / (total_hits * 3);
-		const bool is_ascii_16kb = (ascii_16kb_total * 5) / (total_hits * 3);
-		const bool is_konami = (konami_total * 5) / (total_hits * 3);
-		const bool is_konami_with_scc = (konami_with_scc_total * 5) / (total_hits * 3);
-
-		if(!is_ascii_16kb && !is_konami && !is_konami_with_scc) {
-			targets.push_back(CartridgeTarget(
-				segment,
-				start_address,
-				Analyser::Static::MSX::Cartridge::ASCII8kb,
-				float(ascii_8kb_total) / float(total_hits)));
-		}
-		if(!is_ascii_8kb && !is_konami && !is_konami_with_scc) {
-			targets.push_back(CartridgeTarget(
-				segment,
-				start_address,
-				Analyser::Static::MSX::Cartridge::ASCII16kb,
-				float(ascii_16kb_total) / float(total_hits)));
-		}
-		if(!is_ascii_8kb && !is_ascii_16kb && !is_konami_with_scc) {
+		targets.push_back(CartridgeTarget(
+			segment,
+			start_address,
+			Analyser::Static::MSX::Cartridge::ASCII8kb,
+			float(	address_counts[0x6000] +
+					address_counts[0x6800] +
+					address_counts[0x7000] +
+					address_counts[0x7800]) / total_hits));
+		targets.push_back(CartridgeTarget(
+			segment,
+			start_address,
+			Analyser::Static::MSX::Cartridge::ASCII16kb,
+			float(	address_counts[0x6000] +
+					address_counts[0x7000] +
+					address_counts[0x77ff]) / total_hits));
+		if(!is_ascii) {
 			targets.push_back(CartridgeTarget(
 				segment,
 				start_address,
 				Analyser::Static::MSX::Cartridge::Konami,
-				float(konami_total) / float(total_hits)));
+				float(	address_counts[0x6000] +
+						address_counts[0x8000] +
+						address_counts[0xa000]) / total_hits));
 		}
-		if(!is_ascii_8kb && !is_ascii_16kb && !is_konami) {
+		if(!is_ascii) {
 			targets.push_back(CartridgeTarget(
 				segment,
 				start_address,
 				Analyser::Static::MSX::Cartridge::KonamiWithSCC,
-				float(konami_with_scc_total) / float(total_hits)));
+				float(	address_counts[0x5000] +
+						address_counts[0x7000] +
+						address_counts[0x9000] +
+						address_counts[0xb000]) / total_hits));
 		}
 	}
 

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_MSX_StaticAnalyser_hpp
+#define StaticAnalyser_MSX_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_MSX_Tape_hpp
+#define StaticAnalyser_MSX_Tape_hpp
 
 #include "../../../Storage/Tape/Tape.hpp"
 
@@ -35,3 +36,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_MSX_Target_h
+#define Analyser_Static_MSX_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -46,3 +47,5 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 };
 
 }
+
+#endif /* Analyser_Static_MSX_Target_h */

Analyser/Static/Macintosh/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Macintosh_StaticAnalyser_hpp
+#define Analyser_Static_Macintosh_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Macintosh_Target_h
+#define Analyser_Static_Macintosh_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -28,3 +29,5 @@ 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.
 	*/
-	const Storage::Encodings::MFM::Sector *sector = parser.sector(0, 0, 2);
+	Storage::Encodings::MFM::Sector *sector = parser.get_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.
 	*/
 
-	const Storage::Encodings::MFM::Sector *sector = parser.sector(0, 0, 1);
+	Storage::Encodings::MFM::Sector *sector = parser.get_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(Storage::Encodings::MFM::Density::Double, disk);
+			Storage::Encodings::MFM::Parser parser(true, disk);
 
 			if(is_microdisc(parser)) {
 				target->disk_interface = Target::DiskInterface::Microdisc;

Analyser/Static/Oric/StaticAnalyser.hpp

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

Analyser/Static/Oric/Target.hpp

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

Analyser/Static/PCCompatible/StaticAnalyser.cpp

@@ -1,25 +0,0 @@
-//
-//  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

@@ -1,19 +0,0 @@
-//
-//  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

@@ -1,37 +0,0 @@
-//
-//  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,7 +6,8 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_Sega_StaticAnalyser_hpp
+#define StaticAnalyser_Sega_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_Sega_Target_h
+#define Analyser_Static_Sega_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -50,3 +51,5 @@ constexpr bool is_master_system(Analyser::Static::Sega::Target::Model model) {
 }
 
 }
+
+#endif /* Analyser_Static_Sega_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -9,7 +9,6 @@
 #include "StaticAnalyser.hpp"
 
 #include <algorithm>
-#include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
@@ -26,11 +25,9 @@
 #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"
@@ -51,12 +48,10 @@
 #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"
@@ -89,7 +84,6 @@
 template<class> inline constexpr bool always_false_v = false;
 
 using namespace Analyser::Static;
-using namespace Storage;
 
 namespace {
 
@@ -103,90 +97,46 @@ 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) {
-	MediaAccumulator accumulator(file_name, 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)	\
+	}
 
 	// 2MG
-	if(accumulator.name_matches("2mg")) {
+	if(extension == "2mg") {
 		// 2MG uses a factory method; defer to it.
 		try {
-			const auto media = Disk::Disk2MG::open(file_name);
-			std::visit([&](auto &&arg) {
+			const auto media = Storage::Disk::Disk2MG::open(file_name);
+			std::visit([&result, &potential_platforms](auto &&arg) {
 				using Type = typename std::decay<decltype(arg)>::type;
 
-				if constexpr (std::is_same<Type, std::nullptr_t>::value) {
+				if constexpr (std::is_same<Type, nullptr_t>::value) {
 					// It's valid for no media to be returned.
-				} 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) {
+				} 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) {
 					// TODO: or is it Apple IIgs?
-					accumulator.insert(TargetPlatform::AppleII, std::shared_ptr<MassStorage::MassStorageDevice>(arg));
+					InsertInstance(result.mass_storage_devices, arg, TargetPlatform::AppleII);
 				} else {
 					static_assert(always_false_v<Type>, "Unexpected type encountered.");
 				}
@@ -194,108 +144,95 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 		} catch(...) {}
 	}
 
-	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "80");
-	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "81");
+	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<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");
-		}
+	// 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<Disk::DiskImageHolder<Disk::IPF>>(
-		TargetPlatform::Amiga | TargetPlatform::AtariST | TargetPlatform::AmstradCPC | TargetPlatform::ZXSpectrum,
-		"ipf");
+	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// P81
 
-	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.
+	// PRG
+	if(extension == "prg") {
+		// try instantiating as a ROM; failing that accept as a tape
 		try {
-			accumulator.insert<Cartridge::PRG>(TargetPlatform::Commodore, file_name);
+			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore, file_name)
 		} catch(...) {
 			try {
-				accumulator.insert<Tape::PRG>(TargetPlatform::Commodore, file_name);
+				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore, file_name)
 			} catch(...) {}
 		}
 	}
 
-	accumulator.try_standard<Cartridge::BinaryDump>(
-		TargetPlatform::AcornElectron | TargetPlatform::Coleco | TargetPlatform::MSX,
-		"rom");
+	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::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");
+#undef Format
+#undef Insert
+#undef TryInsert
+#undef InsertInstance
 
-	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;
+	return result;
 }
 
 Media Analyser::Static::GetMedia(const std::string &file_name) {
@@ -304,28 +241,26 @@ Media Analyser::Static::GetMedia(const std::string &file_name) {
 }
 
 TargetList Analyser::Static::GetTargets(const std::string &file_name) {
-	const std::string extension = get_extension(file_name);
 	TargetList targets;
+	const std::string extension = get_extension(file_name);
 
 	// Check whether the file directly identifies a target; if so then just return that.
-	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(...) {}
+#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(...) {}												\
+	}
 
-		return false;
-	};
+	Format("sna", SNA);
+	Format("szx", SZX);
+	Format("z80", Z80);
 
-	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;
+#undef TryInsert
 
 	// Otherwise:
 	//
@@ -336,33 +271,28 @@ 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.
-	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);
+#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
 
 	// Reset any tapes to their initial position.
 	for(const auto &target : targets) {

Analyser/Static/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef StaticAnalyser_hpp
+#define StaticAnalyser_hpp
 
 #include "../Machines.hpp"
 
@@ -78,3 +79,5 @@ TargetList GetTargets(const std::string &file_name);
 Media GetMedia(const std::string &file_name);
 
 }
+
+#endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_ZX8081_StaticAnalyser_hpp
+#define Analyser_Static_ZX8081_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
 #include "../../../Storage/TargetPlatforms.hpp"
@@ -17,3 +18,5 @@ 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,7 +6,8 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef Analyser_Static_ZX8081_Target_h
+#define Analyser_Static_ZX8081_Target_h
 
 #include "../../../Reflection/Enum.hpp"
 #include "../../../Reflection/Struct.hpp"
@@ -38,3 +39,5 @@ 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(Storage::Encodings::MFM::Density::Double, disk);
+	Storage::Encodings::MFM::Parser parser(true, disk);
 
 	// Get logical sector 1; the Spectrum appears to support various physical
 	// sectors as sector 1.
-	const Storage::Encodings::MFM::Sector *boot_sector = nullptr;
+	Storage::Encodings::MFM::Sector *boot_sector = nullptr;
 	uint8_t sector_mask = 0;
 	while(!boot_sector) {
-		boot_sector = parser.sector(0, 0, sector_mask + 1);
+		boot_sector = parser.get_sector(0, 0, sector_mask + 1);
 		sector_mask += 0x40;
 		if(!sector_mask) break;
 	}

Analyser/Static/ZXSpectrum/StaticAnalyser.hpp

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

ClockReceiver/ClockReceiver.hpp

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

ClockReceiver/ClockingHintSource.hpp

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

ClockReceiver/DeferredQueue.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2018 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef DeferredQueue_h
+#define DeferredQueue_h
 
 #include <functional>
 #include <vector>
@@ -119,3 +120,5 @@ template <typename TimeUnit> class DeferredQueuePerformer: public DeferredQueue<
 	private:
 		std::function<void(TimeUnit)> target_;
 };
+
+#endif /* DeferredQueue_h */

ClockReceiver/DeferredValue.hpp

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

ClockReceiver/ForceInline.hpp

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

ClockReceiver/JustInTime.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2019 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef JustInTime_h
+#define JustInTime_h
 
 #include "ClockReceiver.hpp"
 #include "../Concurrency/AsyncTaskQueue.hpp"
@@ -25,7 +26,7 @@
 	Machines that accumulate HalfCycle time but supply to a Cycle-counted device may supply a
 	separate @c TargetTimeScale at template declaration.
 
-	If the held object implements @c next_sequence_point() then it'll be used to flush implicitly
+	If the held object implements get_next_sequence_point() then it'll be used to flush implicitly
 	as and when sequence points are hit. Callers can use will_flush() to predict these.
 
 	If the held object is a subclass of ClockingHint::Source, this template will register as an
@@ -39,7 +40,7 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 	private:
 		/*!
 			A std::unique_ptr deleter which causes an update_sequence_point to occur on the actor supplied
-			to it at construction if it implements @c next_sequence_point(). Otherwise destruction is a no-op.
+			to it at construction if it implements get_next_sequence_point(). Otherwise destruction is a no-op.
 
 			**Does not delete the object.**
 
@@ -246,9 +247,9 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 				// going to be applied then do a direct max -> max translation rather than
 				// allowing the arithmetic to overflow.
 				if constexpr (divider == 1 && std::is_same_v<LocalTimeScale, TargetTimeScale>) {
-					time_until_event_ = object_.next_sequence_point();
+					time_until_event_ = object_.get_next_sequence_point();
 				} else {
-					const auto time = object_.next_sequence_point();
+					const auto time = object_.get_next_sequence_point();
 					if(time == TargetTimeScale::max()) {
 						time_until_event_ = LocalTimeScale::max();
 					} else {
@@ -271,7 +272,7 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 		bool did_flush_ = false;
 
 		template <typename S, typename = void> struct has_sequence_points : std::false_type {};
-		template <typename S> struct has_sequence_points<S, decltype(void(std::declval<S &>().next_sequence_point()))> : std::true_type {};
+		template <typename S> struct has_sequence_points<S, decltype(void(std::declval<S &>().get_next_sequence_point()))> : std::true_type {};
 
 		ClockingHint::Preference clocking_preference_ = ClockingHint::Preference::JustInTime;
 		void set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference clocking) {
@@ -334,3 +335,5 @@ 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,7 +6,8 @@
 //  Copyright © 2020 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef ScanSynchroniser_h
+#define ScanSynchroniser_h
 
 #include "../Outputs/ScanTarget.hpp"
 
@@ -83,3 +84,5 @@ class ScanSynchroniser {
 };
 
 }
+
+#endif /* ScanSynchroniser_h */

ClockReceiver/TimeTypes.hpp

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

ClockReceiver/VSyncPredictor.hpp

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

Components/1770/1770.cpp

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

Components/1770/1770.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _770_hpp
+#define _770_hpp
 
 #include "../../Storage/Disk/Controller/MFMDiskController.hpp"
 
@@ -140,3 +141,5 @@ class WD1770: public Storage::Disk::MFMController {
 };
 
 }
+
+#endif /* _770_hpp */

Components/5380/ncr5380.cpp

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

Components/5380/ncr5380.hpp

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

Components/6522/6522.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _522_hpp
+#define _522_hpp
 
 #include <cstdint>
 
@@ -139,3 +140,5 @@ template <class BusHandlerT> class MOS6522: public MOS6522Storage {
 }
 
 #include "Implementation/6522Implementation.hpp"
+
+#endif /* _522_hpp */

Components/6522/Implementation/6522Storage.hpp

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

Components/6526/6526.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _526_h
+#define _526_h
 
 #include <cstdint>
 
@@ -87,3 +88,5 @@ template <typename PortHandlerT, Personality personality> class MOS6526:
 }
 
 #include "Implementation/6526Implementation.hpp"
+
+#endif /* _526_h */

Components/6526/Implementation/6526Implementation.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _526Implementation_h
+#define _526Implementation_h
 
 #include <cassert>
 #include <cstdio>
@@ -237,3 +238,5 @@ bool MOS6526<BusHandlerT, personality>::serial_line_did_produce_bit(Serial::Line
 }
 
 }
+
+#endif /* _526Implementation_h */

Components/6526/Implementation/6526Storage.hpp

@@ -6,7 +6,8 @@
 //  Copyright © 2021 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _526Storage_h
+#define _526Storage_h
 
 #include <array>
 
@@ -321,6 +322,8 @@ struct MOS6526Storage {
 			static constexpr int TestInputNow = 1 << 8;
 
 			static constexpr int PendingClearMask = ~(ReloadNow | OneShotNow | ApplyClockNow);
+
+			bool active_ = false;
 	} counter_[2];
 
 	static constexpr int InterruptInOne = 1 << 0;
@@ -330,3 +333,5 @@ struct MOS6526Storage {
 };
 
 }
+
+#endif /* _526Storage_h */

Components/6532/6532.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _532_hpp
+#define _532_hpp
 
 #include <cstdint>
 #include <cstdio>
@@ -187,3 +188,5 @@ template <class T> class MOS6532 {
 };
 
 }
+
+#endif /* _532_hpp */

Components/6560/6560.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef _560_hpp
+#define _560_hpp
 
 #include "../../ClockReceiver/ClockReceiver.hpp"
 #include "../../Concurrency/AsyncTaskQueue.hpp"
@@ -277,7 +278,7 @@ template <class BusHandler> class MOS6560 {
 					switch(output_state_) {
 						case State::Sync:			crt_.output_sync(cycles_in_state_ * 4);														break;
 						case State::ColourBurst:	crt_.output_colour_burst(cycles_in_state_ * 4, (is_odd_frame_ || is_odd_line_) ? 128 : 0);	break;
-						case State::Border:			crt_.output_level<uint16_t>(cycles_in_state_ * 4, registers_.borderColour);					break;
+						case State::Border:			output_border(cycles_in_state_ * 4);														break;
 						case State::Pixels:			crt_.output_data(cycles_in_state_ * 4);														break;
 					}
 					output_state_ = this_state_;
@@ -399,7 +400,7 @@ template <class BusHandler> class MOS6560 {
 				case 0xf: {
 					uint16_t new_border_colour = colours_[value & 0x07];
 					if(this_state_ == State::Border && new_border_colour != registers_.borderColour) {
-						crt_.output_level<uint16_t>(cycles_in_state_ * 4, registers_.borderColour);
+						output_border(cycles_in_state_ * 4);
 						cycles_in_state_ = 0;
 					}
 					registers_.invertedCells = !((value >> 3)&1);
@@ -502,6 +503,11 @@ template <class BusHandler> class MOS6560 {
 		uint16_t colours_[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 		uint16_t *pixel_pointer = nullptr;
+		void output_border(int number_of_cycles) {
+			uint16_t *colour_pointer = reinterpret_cast<uint16_t *>(crt_.begin_data(1));
+			if(colour_pointer) *colour_pointer = registers_.borderColour;
+			crt_.output_level(number_of_cycles);
+		}
 
 		struct {
 			int cycles_per_line = 0;
@@ -514,3 +520,5 @@ template <class BusHandler> class MOS6560 {
 };
 
 }
+
+#endif /* _560_hpp */

Components/6845/CRTC6845.hpp

@@ -6,7 +6,8 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#pragma once
+#ifndef CRTC6845_hpp
+#define CRTC6845_hpp
 
 #include "../../ClockReceiver/ClockReceiver.hpp"
 
@@ -22,10 +23,6 @@ struct BusState {
 	bool cursor = false;
 	uint16_t refresh_address = 0;
 	uint16_t row_address = 0;
-
-	// Not strictly part of the bus state; provided because the partition between 6845 and bus handler
-	// doesn't quite hold up in some emulated systems where the two are integrated and share more state.
-	int field_count = 0;
 };
 
 class BusHandler {
@@ -45,49 +42,31 @@ class BusHandler {
 		void perform_bus_cycle_phase2(const BusState &) {}
 };
 
-enum class Personality {
+enum Personality {
 	HD6845S,	// Type 0 in CPC parlance. Zero-width HSYNC available, no status, programmable VSYNC length.
 				// Considered exactly identical to the UM6845, so this enum covers both.
 	UM6845R,	// Type 1 in CPC parlance. Status register, fixed-length VSYNC.
 	MC6845,		// Type 2. No status register, fixed-length VSYNC, no zero-length HSYNC.
-	AMS40226,	// Type 3. Status is get register, fixed-length VSYNC, no zero-length HSYNC.
-
-	EGA,		// Extended EGA-style CRTC; uses 16-bit addressing throughout.
-};
-
-constexpr bool is_egavga(Personality p) {
-	return p >= Personality::EGA;
-}
-
-// https://www.pcjs.org/blog/2018/03/20/ advises that "the behavior of bits 5 and 6 [of register 10, the cursor start
-// register is really card specific".
-//
-// This enum captures those specifics.
-enum class CursorType {
-	/// No cursor signal is generated.
-	None,
-	/// MDA style: 00 => symmetric blinking; 01 or 10 => no blinking; 11 => short on, long off.
-	MDA,
-	/// EGA style: ignore the bits completely.
-	EGA,
+	AMS40226	// Type 3. Status is get register, fixed-length VSYNC, no zero-length HSYNC.
 };
 
 // TODO UM6845R and R12/R13; see http://www.cpcwiki.eu/index.php/CRTC#CRTC_Differences
 
-template <class BusHandlerT, Personality personality, CursorType cursor_type> class CRTC6845 {
+template <class T> class CRTC6845 {
 	public:
-		CRTC6845(BusHandlerT &bus_handler) noexcept :
-			bus_handler_(bus_handler), status_(0) {}
+
+		CRTC6845(Personality p, T &bus_handler) noexcept :
+			personality_(p), bus_handler_(bus_handler), status_(0) {}
 
 		void select_register(uint8_t r) {
 			selected_register_ = r;
 		}
 
 		uint8_t get_status() {
-			switch(personality) {
-				case Personality::UM6845R:	return status_ | (bus_state_.vsync ? 0x20 : 0x00);
-				case Personality::AMS40226:	return get_register();
-				default:					return 0xff;
+			switch(personality_) {
+				case UM6845R:	return status_ | (bus_state_.vsync ? 0x20 : 0x00);
+				case AMS40226:	return get_register();
+				default:		return 0xff;
 			}
 			return 0xff;
 		}
@@ -96,85 +75,30 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 			if(selected_register_ == 31) status_ &= ~0x80;
 			if(selected_register_ == 16 || selected_register_ == 17) status_ &= ~0x40;
 
-			if(personality == Personality::UM6845R && selected_register_ == 31) return dummy_register_;
+			if(personality_ == UM6845R && selected_register_ == 31) return dummy_register_;
 			if(selected_register_ < 12 || selected_register_ > 17) return 0xff;
 			return registers_[selected_register_];
 		}
 
 		void set_register(uint8_t value) {
-			static constexpr bool is_ega = is_egavga(personality);
-
-			auto load_low = [value](uint16_t &target) {
-				target = (target & 0xff00) | value;
-			};
-			auto load_high = [value](uint16_t &target) {
-				constexpr uint8_t mask = RefreshMask >> 8;
-				target = uint16_t((target & 0x00ff) | ((value & mask) << 8));
+			static uint8_t masks[] = {
+				0xff, 0xff, 0xff, 0xff, 0x7f, 0x1f, 0x7f, 0x7f,
+				0xff, 0x1f, 0x7f, 0x1f, 0x3f, 0xff, 0x3f, 0xff
 			};
 
-			switch(selected_register_) {
-				case 0:	layout_.horizontal.total = value;		break;
-				case 1: layout_.horizontal.displayed = value;	break;
-				case 2:	layout_.horizontal.start_sync = value;	break;
-				case 3:
-					layout_.horizontal.sync_width = value & 0xf;
-					layout_.vertical.sync_lines = value >> 4;
-					// TODO: vertical sync lines:
-					// "(0 means 16 on some CRTC. Not present on all CRTCs, fixed to 16 lines on these)"
-				break;
-				case 4:	layout_.vertical.total = value & 0x7f;		break;
-				case 5:	layout_.vertical.adjust = value & 0x1f;		break;
-				case 6:	layout_.vertical.displayed = value & 0x7f;	break;
-				case 7:	layout_.vertical.start_sync = value & 0x7f;	break;
-				case 8:
-					switch(value & 3) {
-						default:	layout_.interlace_mode_ = InterlaceMode::Off;					break;
-						case 0b01:	layout_.interlace_mode_ = InterlaceMode::InterlaceSync;			break;
-						case 0b11:	layout_.interlace_mode_ = InterlaceMode::InterlaceSyncAndVideo;	break;
-					}
-
-					// Per CPC documentation, skew doesn't work on a "type 1 or 2", i.e. an MC6845 or a UM6845R.
-					if(personality != Personality::UM6845R && personality != Personality::MC6845) {
-						switch((value >> 4)&3) {
-							default:	display_skew_mask_ = 1;		break;
-							case 1:		display_skew_mask_ = 2;		break;
-							case 2:		display_skew_mask_ = 4;		break;
-						}
-					}
-				break;
-				case 9:	layout_.vertical.end_row = value & 0x1f;	break;
-				case 10:
-					layout_.vertical.start_cursor = value & 0x1f;
-					layout_.cursor_flags = (value >> 5) & 3;
-				break;
-				case 11:
-					layout_.vertical.end_cursor = value & 0x1f;
-				break;
-				case 12:	load_high(layout_.start_address);	break;
-				case 13:	load_low(layout_.start_address);	break;
-				case 14:	load_high(layout_.cursor_address);	break;
-				case 15:	load_low(layout_.cursor_address);	break;
+			// Per CPC documentation, skew doesn't work on a "type 1 or 2", i.e. an MC6845 or a UM6845R.
+			if(selected_register_ == 8 && personality_ != UM6845R && personality_ != MC6845) {
+				switch((value >> 4)&3) {
+					default:	display_skew_mask_ = 1;		break;
+					case 1:		display_skew_mask_ = 2;		break;
+					case 2:		display_skew_mask_ = 4;		break;
+				}
 			}
 
-			static constexpr uint8_t masks[] = {
-				0xff,	// Horizontal total.
-				0xff,	// Horizontal display end.
-				0xff,	// Start horizontal blank.
-				0xff,	//
-						// EGA: b0–b4: end of horizontal blank;
-						// b5–b6: "Number of character clocks to delay start of display after Horizontal Total has been reached."
-
-				is_ega ? 0xff : 0x7f,	// Start horizontal retrace.
-				0x1f, 0x7f, 0x7f,
-				0xff, 0x1f, 0x7f, 0x1f,
-				uint8_t(RefreshMask >> 8), uint8_t(RefreshMask),
-				uint8_t(RefreshMask >> 8), uint8_t(RefreshMask),
-			};
-
 			if(selected_register_ < 16) {
 				registers_[selected_register_] = value & masks[selected_register_];
 			}
-			if(selected_register_ == 31 && personality == Personality::UM6845R) {
+			if(selected_register_ == 31 && personality_ == UM6845R) {
 				dummy_register_ = value;
 			}
 		}
@@ -188,48 +112,45 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 		void run_for(Cycles cycles) {
 			auto cyles_remaining = cycles.as_integral();
 			while(cyles_remaining--) {
-				// Check for end of visible characters.
-				if(character_counter_ == layout_.horizontal.displayed) {
+				// check for end of visible characters
+				if(character_counter_ == registers_[1]) {
 					// TODO: consider skew in character_is_visible_. Or maybe defer until perform_bus_cycle?
 					character_is_visible_ = false;
 					end_of_line_address_ = bus_state_.refresh_address;
 				}
 
 				perform_bus_cycle_phase1();
-				bus_state_.refresh_address = (bus_state_.refresh_address + 1) & RefreshMask;
+				bus_state_.refresh_address = (bus_state_.refresh_address + 1) & 0x3fff;
 
-				bus_state_.cursor = is_cursor_line_ &&
-					bus_state_.refresh_address == layout_.cursor_address;
-
-				// Check for end-of-line.
-				if(character_counter_ == layout_.horizontal.total) {
+				// check for end-of-line
+				if(character_counter_ == registers_[0]) {
 					character_counter_ = 0;
 					do_end_of_line();
 					character_is_visible_ = true;
 				} else {
-					// Increment counter.
+					// increment counter
 					character_counter_++;
 				}
 
-				// Check for start of horizontal sync.
-				if(character_counter_ == layout_.horizontal.start_sync) {
+				// check for start of horizontal sync
+				if(character_counter_ == registers_[2]) {
 					hsync_counter_ = 0;
 					bus_state_.hsync = true;
 				}
 
-				// Check for end of horizontal sync; note that a sync time of zero will result in an immediate
+				// check for end of horizontal sync; note that a sync time of zero will result in an immediate
 				// cancellation of the plan to perform sync if this is an HD6845S or UM6845R; otherwise zero
 				// will end up counting as 16 as it won't be checked until after overflow.
 				if(bus_state_.hsync) {
-					switch(personality) {
-						case Personality::HD6845S:
-						case Personality::UM6845R:
-							bus_state_.hsync = hsync_counter_ != layout_.horizontal.sync_width;
+					switch(personality_) {
+						case HD6845S:
+						case UM6845R:
+							bus_state_.hsync = hsync_counter_ != (registers_[3] & 15);
 							hsync_counter_ = (hsync_counter_ + 1) & 15;
 						break;
 						default:
 							hsync_counter_ = (hsync_counter_ + 1) & 15;
-							bus_state_.hsync = hsync_counter_ != layout_.horizontal.sync_width;
+							bus_state_.hsync = hsync_counter_ != (registers_[3] & 15);
 						break;
 					}
 				}
@@ -243,8 +164,6 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 		}
 
 	private:
-		static constexpr uint16_t RefreshMask = (personality >= Personality::EGA) ? 0xffff : 0x3fff;
-
 		inline void perform_bus_cycle_phase1() {
 			// Skew theory of operation: keep a history of the last three states, and apply whichever is selected.
 			character_is_visible_shifter_ = (character_is_visible_shifter_ << 1) | unsigned(character_is_visible_);
@@ -257,21 +176,15 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 		}
 
 		inline void do_end_of_line() {
-			if constexpr (cursor_type != CursorType::None) {
-				// Check for cursor disable.
-				// TODO: this is handled differently on the EGA, should I ever implement that.
-				is_cursor_line_ &= bus_state_.row_address != layout_.vertical.end_cursor;
-			}
-
-			// Check for end of vertical sync.
+			// check for end of vertical sync
 			if(bus_state_.vsync) {
 				vsync_counter_ = (vsync_counter_ + 1) & 15;
-				// On the UM6845R and AMS40226, honour the programmed vertical sync time; on the other CRTCs
+				// on the UM6845R and AMS40226, honour the programmed vertical sync time; on the other CRTCs
 				// always use a vertical sync count of 16.
-				switch(personality) {
-					case Personality::HD6845S:
-					case Personality::AMS40226:
-						bus_state_.vsync = vsync_counter_ != layout_.vertical.sync_lines;
+				switch(personality_) {
+					case HD6845S:
+					case AMS40226:
+						bus_state_.vsync = vsync_counter_ != (registers_[3] >> 4);
 					break;
 					default:
 						bus_state_.vsync = vsync_counter_ != 0;
@@ -281,19 +194,19 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 
 			if(is_in_adjustment_period_) {
 				line_counter_++;
-				if(line_counter_ == layout_.vertical.adjust) {
+				if(line_counter_ == registers_[5]) {
 					is_in_adjustment_period_ = false;
 					do_end_of_frame();
 				}
 			} else {
-				// Advance vertical counter.
-				if(bus_state_.row_address == layout_.vertical.end_row) {
+				// advance vertical counter
+				if(bus_state_.row_address == registers_[9]) {
 					bus_state_.row_address = 0;
 					line_address_ = end_of_line_address_;
 
-					// Check for entry into the overflow area.
-					if(line_counter_ == layout_.vertical.total) {
-						if(layout_.vertical.adjust) {
+					// check for entry into the overflow area
+					if(line_counter_ == registers_[4]) {
+						if(registers_[5]) {
 							line_counter_ = 0;
 							is_in_adjustment_period_ = true;
 						} else {
@@ -302,14 +215,14 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 					} else {
 						line_counter_ = (line_counter_ + 1) & 0x7f;
 
-						// Check for start of vertical sync.
-						if(line_counter_ == layout_.vertical.start_sync) {
+						// check for start of vertical sync
+						if(line_counter_ == registers_[7]) {
 							bus_state_.vsync = true;
 							vsync_counter_ = 0;
 						}
 
-						// Check for end of visible lines.
-						if(line_counter_ == layout_.vertical.displayed) {
+						// check for end of visible lines
+						if(line_counter_ == registers_[6]) {
 							line_is_visible_ = false;
 						}
 					}
@@ -320,76 +233,21 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 
 			bus_state_.refresh_address = line_address_;
 			character_counter_ = 0;
-			character_is_visible_ = (layout_.horizontal.displayed != 0);
-
-			if constexpr (cursor_type != CursorType::None) {
-				// Check for cursor enable.
-				is_cursor_line_ |= bus_state_.row_address == layout_.vertical.start_cursor;
-
-				switch(cursor_type) {
-					// MDA-style blinking.
-					// https://retrocomputing.stackexchange.com/questions/27803/what-are-the-blinking-rates-of-the-caret-and-of-blinking-text-on-pc-graphics-car
-					// gives an 8/8 pattern for regular blinking though mode 11 is then just a guess.
-					case CursorType::MDA:
-						switch(layout_.cursor_flags) {
-							case 0b11: is_cursor_line_ &= (bus_state_.field_count & 8) < 3;	break;
-							case 0b00: is_cursor_line_ &= bool(bus_state_.field_count & 8);	break;
-							case 0b01: is_cursor_line_ = false;								break;
-							case 0b10: is_cursor_line_ = true;								break;
-							default: break;
-						}
-					break;
-				}
-			}
+			character_is_visible_ = (registers_[1] != 0);
 		}
 
 		inline void do_end_of_frame() {
 			line_counter_ = 0;
 			line_is_visible_ = true;
-			line_address_ = layout_.start_address;
+			line_address_ = uint16_t((registers_[12] << 8) | registers_[13]);
 			bus_state_.refresh_address = line_address_;
-			++bus_state_.field_count;
 		}
 
-		BusHandlerT &bus_handler_;
+		Personality personality_;
+		T &bus_handler_;
 		BusState bus_state_;
 
-		enum class InterlaceMode {
-			Off,
-			InterlaceSync,
-			InterlaceSyncAndVideo,
-		};
-		enum class BlinkMode {
-			// TODO.
-		};
-		struct {
-			struct {
-				uint8_t total;
-				uint8_t displayed;
-				uint8_t start_sync;
-				uint8_t sync_width;
-			} horizontal;
-
-			struct {
-				uint8_t total;
-				uint8_t displayed;
-				uint8_t start_sync;
-				uint8_t sync_lines;
-				uint8_t adjust;
-
-				uint8_t end_row;
-				uint8_t start_cursor;
-				uint8_t end_cursor;
-			} vertical;
-
-			InterlaceMode interlace_mode_ = InterlaceMode::Off;
-			uint16_t start_address;
-			uint16_t cursor_address;
-			uint16_t light_pen_address;
-			uint8_t cursor_flags;
-		} layout_;
-
-		uint8_t registers_[18]{};
+		uint8_t registers_[18] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 		uint8_t dummy_register_ = 0;
 		int selected_register_ = 0;
 
@@ -408,8 +266,8 @@ template <class BusHandlerT, Personality personality, CursorType cursor_type> cl
 
 		int display_skew_mask_ = 1;
 		unsigned int character_is_visible_shifter_ = 0;
-
-		bool is_cursor_line_ = false;
 };
 
 }
+
+#endif /* CRTC6845_hpp */