Remove logging.

Now tracking: issue seems to be reaching TEST4.ASM:D11 with an interrupt that it believes to be software-originating.

.github/workflows/build.yml

@@ -1,18 +1,24 @@
 name: Build
 on: [pull_request]
 jobs:
-#  build-mac-xcodebuild:
+
-#    name: Mac UI / xcodebuild / ${{ matrix.os }}
+  build-mac-xcodebuild:
-#    strategy:
+    name: Mac UI / xcodebuild / ${{ matrix.os }}
-#      matrix:
+    strategy:
-#        os: [macos-13, macos-14, macos-15]
+      matrix:
-#    runs-on: ${{ matrix.os }}
+        os: [macos-latest] #[macos-13, macos-14, macos-15]
-#    steps:
+    runs-on: ${{ matrix.os }}
-#    - name: Checkout
+    steps:
-#      uses: actions/checkout@v4
+    - name: Checkout
-#    - name: Make
+      uses: actions/checkout@v4
-#      working-directory: OSBindings/Mac
+    - name: Install Xcode
-#      run: xcodebuild CODE_SIGN_IDENTITY=-
+      uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: latest-stable
+    - name: Make
+      working-directory: OSBindings/Mac
+      run: xcodebuild CODE_SIGN_IDENTITY=-
+
   build-sdl-cmake:
     name: SDL UI / cmake / ${{ matrix.os }}
     strategy:
@@ -31,6 +37,7 @@ jobs:
             sudo apt-get --fix-missing install cmake gcc-10 libsdl2-dev
             ;;
           macOS)
+            brew uninstall cmake
             brew install cmake sdl2
             ;;
         esac
@@ -49,6 +56,7 @@ jobs:
         esac
         cmake -S. -Bbuild -DCLK_UI=SDL -DCMAKE_BUILD_TYPE=Release
         cmake --build build -v -j"$jobs"
+
   build-sdl-scons:
     name: SDL UI / scons / ${{ matrix.os }}
     strategy:
@@ -85,8 +93,9 @@ jobs:
             jobs=1
         esac
         scons -j"$jobs"
-  build-qt:
+
-    name: Qt / ${{ matrix.os }}
+  build-qt5:
+    name: Qt 5 / ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest]
@@ -105,3 +114,24 @@ jobs:
       run: |
         qmake -o Makefile clksignal.pro
         make
+
+#  build-qt6:
+#    name: Qt 6 / ${{ matrix.os }}
+#    strategy:
+#      matrix:
+#        os: [ubuntu-latest]
+#    runs-on: ${{ matrix.os }}
+#    steps:
+#    - name: Checkout
+#      uses: actions/checkout@v4
+#    - name: Install dependencies
+#      uses: jurplel/install-qt-action@v4
+#      with:
+#        version: '6.8'
+#        archives: qtbase
+#    - name: Make
+#      working-directory: OSBindings/Qt
+#      shell: bash
+#      run: |
+#        qmake -o Makefile clksignal.pro
+#        make

Activity/Source.hpp

@@ -14,7 +14,7 @@ namespace Activity {
 
 class Source {
 public:
-	virtual void set_activity_observer(Observer *observer) = 0;
+	virtual void set_activity_observer(Observer *) = 0;
 };
 
 }

Analyser/Dynamic/ConfidenceCounter.cpp

@@ -10,7 +10,7 @@
 
 using namespace Analyser::Dynamic;
 
-float ConfidenceCounter::get_confidence() {
+float ConfidenceCounter::confidence() const {
 	return float(hits_) / float(hits_ + misses_);
 }
 

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -20,7 +20,7 @@ namespace Analyser::Dynamic {
 class ConfidenceCounter: public ConfidenceSource {
 public:
 	/*! @returns The computed probability, based on the history of events. */
-	float get_confidence() final;
+	float confidence() const final;
 
 	/*! Records an event that implies this is the appropriate class: pushes probability up towards 1.0. */
 	void add_hit();

Analyser/Dynamic/ConfidenceSource.hpp

@@ -17,7 +17,7 @@ namespace Analyser::Dynamic {
 	program is handed to an Atari 2600 then its confidence should grow towards 1.0.
 */
 struct ConfidenceSource {
-	virtual float get_confidence() = 0;
+	virtual float confidence() const = 0;
 };
 
 }

Analyser/Dynamic/ConfidenceSummary.cpp

@@ -22,10 +22,10 @@ ConfidenceSummary::ConfidenceSummary(
 	weight_sum_ = std::accumulate(weights.begin(), weights.end(), 0.0f);
 }
 
-float ConfidenceSummary::get_confidence() {
+float ConfidenceSummary::confidence() const {
 	float result = 0.0f;
 	for(std::size_t index = 0; index < sources_.size(); ++index) {
-		result += sources_[index]->get_confidence() * weights_[index];
+		result += sources_[index]->confidence() * weights_[index];
 	}
 	return result / weight_sum_;
 }

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -30,7 +30,7 @@ public:
 		const std::vector<float> &weights);
 
 	/*! @returns The weighted sum of all sources. */
-	float get_confidence() final;
+	float confidence() const final;
 
 private:
 	const std::vector<ConfidenceSource *> sources_;

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
-#include "../../../../Configurable/Configurable.hpp"
+#include "Configurable/Configurable.hpp"
 
 #include <memory>
 #include <vector>

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
 
 #include <memory>
 #include <vector>

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
-#include "../../../../Machines/KeyboardMachine.hpp"
+#include "Machines/KeyboardMachine.hpp"
 
 #include <memory>
 #include <vector>

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.cpp

@@ -7,6 +7,7 @@
 //
 
 #include "MultiMediaTarget.hpp"
+#include <unordered_set>
 
 using namespace Analyser::Dynamic;
 
@@ -27,3 +28,29 @@ bool MultiMediaTarget::insert_media(const Analyser::Static::Media &media) {
 	}
 	return inserted;
 }
+
+MultiMediaChangeObserver::MultiMediaChangeObserver(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		auto media_change_observer = machine->media_change_observer();
+		if(media_change_observer) targets_.push_back(media_change_observer);
+	}
+}
+
+using ChangeEffect = MachineTypes::MediaChangeObserver::ChangeEffect;
+
+ChangeEffect MultiMediaChangeObserver::effect_for_file_did_change(const std::string &name) const {
+	if(targets_.empty()) {
+		return ChangeEffect::None;
+	}
+
+	std::unordered_set<ChangeEffect> effects;
+	for(const auto &target: targets_) {
+		effects.insert(target->effect_for_file_did_change(name));
+	}
+
+	// No agreement => restart.
+	if(effects.size() > 1) {
+		return ChangeEffect::RestartMachine;
+	}
+	return *effects.begin();
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../../Machines/MediaTarget.hpp"
+#include "Machines/MediaTarget.hpp"
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
 
 #include <memory>
 #include <vector>
@@ -33,4 +33,15 @@ private:
 	std::vector<MachineTypes::MediaTarget *> targets_;
 };
 
+struct MultiMediaChangeObserver: public MachineTypes::MediaChangeObserver {
+public:
+	MultiMediaChangeObserver(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &);
+
+	// Below is the standard MediaTarget::Machine interface; see there for documentation.
+	ChangeEffect effect_for_file_did_change(const std::string &) const final;
+
+private:
+	std::vector<MachineTypes::MediaChangeObserver *> targets_;
+};
+
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.cpp

@@ -19,7 +19,7 @@ template <typename MachineType>
 void MultiInterface<MachineType>::perform_parallel(const std::function<void(MachineType *)> &function) {
 	// Apply a blunt force parallelisation of the machines; each run_for is dispatched
 	// to a separate queue and this queue will block until all are done.
-	volatile std::size_t outstanding_machines;
+	std::size_t outstanding_machines;
 	std::condition_variable condition;
 	std::mutex mutex;
 	{
@@ -33,7 +33,7 @@ void MultiInterface<MachineType>::perform_parallel(const std::function<void(Mach
 				if(machine) function(machine);
 
 				std::lock_guard lock(mutex);
-				outstanding_machines--;
+				--outstanding_machines;
 				condition.notify_all();
 			});
 		}
@@ -106,5 +106,5 @@ void MultiTimedMachine::run_for(const Time::Seconds duration) {
 		if(machine->get_confidence() >= 0.01f) machine->run_for(duration);
 	});
 
-	if(delegate_) delegate_->did_run_machines(this);
+	if(delegate_) delegate_->did_run_machines(*this);
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../../Concurrency/AsyncTaskQueue.hpp"
+#include "Concurrency/AsyncTaskQueue.hpp"
-#include "../../../../Machines/MachineTypes.hpp"
+#include "Machines/MachineTypes.hpp"
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
 
 #include "MultiSpeaker.hpp"
 
@@ -60,7 +60,7 @@ public:
 		been received.
 	*/
 	struct Delegate {
-		virtual void did_run_machines(MultiTimedMachine *) = 0;
+		virtual void did_run_machines(MultiTimedMachine &) = 0;
 	};
 	/// Sets @c delegate as the receiver of delegate messages.
 	void set_delegate(Delegate *const delegate) {

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -60,24 +60,24 @@ void MultiSpeaker::set_output_volume(const float volume) {
 	}
 }
 
-void MultiSpeaker::speaker_did_complete_samples(Speaker *const speaker, const std::vector<int16_t> &buffer) {
+void MultiSpeaker::speaker_did_complete_samples(Speaker &speaker, const std::vector<int16_t> &buffer) {
 	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
 		std::lock_guard lock_guard(front_speaker_mutex_);
-		if(speaker != front_speaker_) return;
+		if(&speaker != front_speaker_) return;
 	}
 	did_complete_samples(this, buffer, stereo_output_);
 }
 
-void MultiSpeaker::speaker_did_change_input_clock(Speaker *const speaker) {
+void MultiSpeaker::speaker_did_change_input_clock(Speaker &speaker) {
 	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
 		std::lock_guard lock_guard(front_speaker_mutex_);
-		if(speaker != front_speaker_) return;
+		if(&speaker != front_speaker_) return;
 	}
-	delegate->speaker_did_change_input_clock(this);
+	delegate->speaker_did_change_input_clock(*this);
 }
 
 void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *const machine) {
@@ -87,6 +87,6 @@ void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *const machin
 	}
 	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(delegate) {
-		delegate->speaker_did_change_input_clock(this);
+		delegate->speaker_did_change_input_clock(*this);
 	}
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
-#include "../../../../Outputs/Speaker/Speaker.hpp"
+#include "Outputs/Speaker/Speaker.hpp"
 
 #include <memory>
 #include <mutex>
@@ -42,8 +42,8 @@ public:
 	void set_output_volume(float) override;
 
 private:
-	void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) final;
+	void speaker_did_complete_samples(Speaker &, const std::vector<int16_t> &buffer) final;
-	void speaker_did_change_input_clock(Speaker *speaker) final;
+	void speaker_did_change_input_clock(Speaker &) final;
 	MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers);
 
 	std::vector<Outputs::Speaker::Speaker *> speakers_;

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -7,7 +7,7 @@
 //
 
 #include "MultiMachine.hpp"
-#include "../../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
 #include <algorithm>
 
@@ -27,7 +27,8 @@ MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machin
 	audio_producer_(machines_, machines_mutex_),
 	joystick_machine_(machines_),
 	keyboard_machine_(machines_),
-	media_target_(machines_)
+	media_target_(machines_),
+	media_change_observer_(machines_)
 {
 	timed_machine_.set_delegate(this);
 }
@@ -52,6 +53,7 @@ Provider(MachineTypes::AudioProducer, audio_producer, audio_producer_)
 Provider(MachineTypes::JoystickMachine, joystick_machine, joystick_machine_)
 Provider(MachineTypes::KeyboardMachine, keyboard_machine, keyboard_machine_)
 Provider(MachineTypes::MediaTarget, media_target, media_target_)
+Provider(MachineTypes::MediaChangeObserver, media_change_observer, media_change_observer_)
 
 MachineTypes::MouseMachine *MultiMachine::mouse_machine() {
 	// TODO.
@@ -66,10 +68,10 @@ bool MultiMachine::would_collapse(const std::vector<std::unique_ptr<DynamicMachi
 		(machines.front()->timed_machine()->get_confidence() >= 2.0f * machines[1]->timed_machine()->get_confidence());
 }
 
-void MultiMachine::did_run_machines(MultiTimedMachine *) {
+void MultiMachine::did_run_machines(MultiTimedMachine &) {
 	std::lock_guard machines_lock(machines_mutex_);
 
-	if constexpr (logger.enabled) {
+	if constexpr (logger.InfoEnabled) {
 		auto line = logger.info();
 		for(const auto &machine: machines_) {
 			auto timed_machine = machine->timed_machine();

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -8,14 +8,14 @@
 
 #pragma once
 
-#include "../../../Machines/DynamicMachine.hpp"
+#include "Machines/DynamicMachine.hpp"
 
-#include "Implementation/MultiProducer.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp"
-#include "Implementation/MultiConfigurable.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp"
-#include "Implementation/MultiProducer.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp"
-#include "Implementation/MultiJoystickMachine.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp"
-#include "Implementation/MultiKeyboardMachine.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp"
-#include "Implementation/MultiMediaTarget.hpp"
+#include "Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp"
 
 #include <memory>
 #include <mutex>
@@ -58,10 +58,11 @@ public:
 	MachineTypes::KeyboardMachine *keyboard_machine() final;
 	MachineTypes::MouseMachine *mouse_machine() final;
 	MachineTypes::MediaTarget *media_target() final;
+	MachineTypes::MediaChangeObserver *media_change_observer() final;
 	void *raw_pointer() final;
 
 private:
-	void did_run_machines(MultiTimedMachine *) final;
+	void did_run_machines(MultiTimedMachine &) final;
 
 	std::vector<std::unique_ptr<DynamicMachine>> machines_;
 	std::recursive_mutex machines_mutex_;
@@ -73,6 +74,7 @@ private:
 	MultiJoystickMachine joystick_machine_;
 	MultiKeyboardMachine keyboard_machine_;
 	MultiMediaTarget media_target_;
+	MultiMediaChangeObserver media_change_observer_;
 
 	void pick_first();
 	bool has_picked_ = false;

Analyser/Static/Acorn/Disk.cpp

@@ -8,9 +8,9 @@
 
 #include "Disk.hpp"
 
-#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "Storage/Disk/Controller/DiskController.hpp"
-#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "Storage/Disk/Encodings/MFM/Parser.hpp"
-#include "../../../Numeric/CRC.hpp"
+#include "Numeric/CRC.hpp"
 
 #include <algorithm>
 #include <cstring>

Analyser/Static/Acorn/Disk.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "File.hpp"
-#include "../../../Storage/Disk/Disk.hpp"
+#include "Storage/Disk/Disk.hpp"
 
 namespace Analyser::Static::Acorn {
 

Analyser/Static/Acorn/File.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>

Analyser/Static/Acorn/StaticAnalyser.cpp

@@ -12,7 +12,7 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 
-#include "../../../Numeric/StringSimilarity.hpp"
+#include "Numeric/StringSimilarity.hpp"
 
 #include <algorithm>
 #include <map>
@@ -167,8 +167,8 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(
 				// Take whatever else comes with a preference for things that don't
 				// have 'boot' or 'read' in them (the latter of which will tend to be
 				// read_me or read_this or similar).
-				constexpr char read[] = "read";
+				static constexpr char read[] = "read";
-				constexpr char boot[] = "boot";
+				static constexpr char boot[] = "boot";
 				const auto has = [&](const char *begin, const char *end) {
 					return  std::search(
 						file.name.begin(), file.name.end(),

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Acorn {

Analyser/Static/Acorn/Tape.cpp

@@ -10,8 +10,8 @@
 
 #include <deque>
 
-#include "../../../Numeric/CRC.hpp"
+#include "Numeric/CRC.hpp"
-#include "../../../Storage/Tape/Parsers/Acorn.hpp"
+#include "Storage/Tape/Parsers/Acorn.hpp"
 
 using namespace Analyser::Static::Acorn;
 

Analyser/Static/Acorn/Tape.hpp

@@ -8,10 +8,10 @@
 
 #pragma once
 
-#include <memory>
-
 #include "File.hpp"
-#include "../../../Storage/Tape/Tape.hpp"
+#include "Storage/Tape/Tape.hpp"
+
+#include <vector>
 
 namespace Analyser::Static::Acorn {
 

Analyser/Static/Acorn/Target.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../Reflection/Struct.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 #include <string>
 
 namespace Analyser::Static::Acorn {

Analyser/Static/Amiga/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Amiga {

Analyser/Static/Amiga/Target.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../Reflection/Struct.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::Amiga {
 

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -8,15 +8,15 @@
 
 #include "StaticAnalyser.hpp"
 
-#include <algorithm>
+#include "Storage/Disk/Parsers/CPM.hpp"
-#include <cstring>
+#include "Storage/Disk/Encodings/MFM/Parser.hpp"
-
+#include "Storage/Tape/Parsers/Spectrum.hpp"
-#include "../../../Storage/Disk/Parsers/CPM.hpp"
-#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
-#include "../../../Storage/Tape/Parsers/Spectrum.hpp"
 
 #include "Target.hpp"
 
+#include <algorithm>
+#include <cstring>
+
 namespace {
 
 bool strcmp_insensitive(const char *a, const char *b) {

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::AmstradCPC {

Analyser/Static/AmstradCPC/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Reflection/Enum.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Struct.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
 #include <string>
 
 namespace Analyser::Static::AmstradCPC {

Analyser/Static/AppleII/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::AppleII {

Analyser/Static/AppleII/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::AppleII {
 

Analyser/Static/AppleIIgs/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::AppleIIgs {

Analyser/Static/AppleIIgs/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::AppleIIgs {
 

Analyser/Static/Atari2600/StaticAnalyser.cpp

@@ -10,7 +10,7 @@
 
 #include "Target.hpp"
 
-#include "../Disassembler/6502.hpp"
+#include "Analyser/Static/Disassembler/6502.hpp"
 
 using namespace Analyser::Static::Atari2600;
 using Target = Analyser::Static::Atari2600::Target;

Analyser/Static/Atari2600/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Atari2600 {

Analyser/Static/Atari2600/Target.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
 
 namespace Analyser::Static::Atari2600 {
 

Analyser/Static/AtariST/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::AtariST {

Analyser/Static/AtariST/Target.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../Reflection/Struct.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::AtariST {
 

Analyser/Static/Coleco/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Coleco {

Analyser/Static/Commodore/Disk.cpp

@@ -7,14 +7,14 @@
 //
 
 #include "Disk.hpp"
-#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "Storage/Disk/Controller/DiskController.hpp"
-#include "../../../Storage/Disk/Encodings/CommodoreGCR.hpp"
+#include "Storage/Disk/Encodings/CommodoreGCR.hpp"
-#include "../../../Storage/Data/Commodore.hpp"
+#include "Storage/Data/Commodore.hpp"
 
-#include <limits>
-#include <vector>
 #include <array>
+#include <limits>
 #include <unordered_map>
+#include <vector>
 
 using namespace Analyser::Static::Commodore;
 

Analyser/Static/Commodore/Disk.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../../Storage/Disk/Disk.hpp"
+#include "Storage/Disk/Disk.hpp"
 #include "File.hpp"
 
 #include <vector>

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -12,11 +12,11 @@
 #include "File.hpp"
 #include "Tape.hpp"
 #include "Target.hpp"
-#include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
+#include "Storage/Cartridge/Encodings/CommodoreROM.hpp"
-#include "../../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
-#include "../Disassembler/6502.hpp"
+#include "Analyser/Static/Disassembler/6502.hpp"
-#include "../Disassembler/AddressMapper.hpp"
+#include "Analyser/Static/Disassembler/AddressMapper.hpp"
 
 #include <algorithm>
 #include <cstring>
@@ -180,9 +180,8 @@ bool obviously_uses_ted(const File &file) {
 		analysis->machine_code_addresses
 	);
 
-	// If FF3E or FF3F is touched, this is for the +4.
+	// Check for interrupt status and paging touches.
-	// TODO: probably require a very early touch.
+	for(const auto address: {0xff3e, 0xff3f, 0xff09}) {
-	for(const auto address: {0xff3e, 0xff3f}) {
 		for(const auto &collection: {
 			disassembly.external_loads,
 			disassembly.external_stores,
@@ -299,7 +298,7 @@ std::unique_ptr<Analyser::Static::Target> get_target<TargetPlatform::Plus4>(
 
 	// Attach a 1541 if there are any disks here.
 	target->has_c1541 = !target->media.disks.empty();
-	return std::move(target);
+	return target;
 }
 
 template<>
@@ -392,7 +391,7 @@ std::unique_ptr<Analyser::Static::Target> get_target<TargetPlatform::Vic20>(
 
 	// Attach a 1540 if there are any disks here.
 	target->has_c1540 = !target->media.disks.empty();
-	return std::move(target);
+	return target;
 }
 
 }

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Commodore {

Analyser/Static/Commodore/Tape.cpp

@@ -7,8 +7,9 @@
 //
 
 #include "Tape.hpp"
+#include "Storage/Tape/Parsers/Commodore.hpp"
 
-#include "../../../Storage/Tape/Parsers/Commodore.hpp"
+#include <algorithm>
 
 using namespace Analyser::Static::Commodore;
 
@@ -38,7 +39,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(Storage::Tape::TapeSeria
 					header = parser.get_next_header(serialiser);
 					if(!header) continue;
 					if(header->type != Storage::Tape::Commodore::Header::DataBlock) break;
-					std::copy(header->data.begin(), header->data.end(), std::back_inserter(new_file.data));
+					std::ranges::copy(header->data, std::back_inserter(new_file.data));
 				}
 			}
 			break;

Analyser/Static/Commodore/Tape.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../../../Storage/Tape/Tape.hpp"
+#include "Storage/Tape/Tape.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include "File.hpp"
 
 namespace Analyser::Static::Commodore {

Analyser/Static/Commodore/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 #include <string>
 
 namespace Analyser::Static::Commodore {

Analyser/Static/Disassembler/Z80.cpp

@@ -60,11 +60,11 @@ private:
 	bool overrun_ = false;
 };
 
-constexpr uint8_t x(uint8_t v) { return v >> 6; }
+constexpr uint8_t x(const uint8_t v) { return v >> 6; }
-constexpr uint8_t y(uint8_t v) { return (v >> 3) & 7; }
+constexpr uint8_t y(const uint8_t v) { return (v >> 3) & 7; }
-constexpr uint8_t q(uint8_t v) { return (v >> 3) & 1; }
+constexpr uint8_t q(const uint8_t v) { return (v >> 3) & 1; }
-constexpr uint8_t p(uint8_t v) { return (v >> 4) & 3; }
+constexpr uint8_t p(const uint8_t v) { return (v >> 4) & 3; }
-constexpr uint8_t z(uint8_t v) { return v & 7; }
+constexpr uint8_t z(const uint8_t v) { return v & 7; }
 
 Instruction::Condition condition_table[] = {
 	Instruction::Condition::NZ,		Instruction::Condition::Z,
@@ -92,7 +92,7 @@ Instruction::Location RegisterTableEntry(
 	Instruction &instruction,
 	const bool needs_indirect_offset
 ) {
-	constexpr Instruction::Location register_table[] = {
+	static constexpr Instruction::Location register_table[] = {
 		Instruction::Location::B,	Instruction::Location::C,
 		Instruction::Location::D,	Instruction::Location::E,
 		Instruction::Location::H,	Instruction::Location::L,

Analyser/Static/DiskII/StaticAnalyser.cpp

@@ -8,14 +8,14 @@
 
 #include "StaticAnalyser.hpp"
 
-#include "../AppleII/Target.hpp"
+#include "Analyser/Static/AppleII/Target.hpp"
-#include "../AppleIIgs/Target.hpp"
+#include "Analyser/Static//AppleIIgs/Target.hpp"
-#include "../Oric/Target.hpp"
+#include "Analyser/Static//Oric/Target.hpp"
-#include "../Disassembler/6502.hpp"
+#include "Analyser/Static//Disassembler/6502.hpp"
-#include "../Disassembler/AddressMapper.hpp"
+#include "Analyser/Static//Disassembler/AddressMapper.hpp"
 
-#include "../../../Storage/Disk/Track/TrackSerialiser.hpp"
+#include "Storage/Disk/Track/TrackSerialiser.hpp"
-#include "../../../Storage/Disk/Encodings/AppleGCR/SegmentParser.hpp"
+#include "Storage/Disk/Encodings/AppleGCR/SegmentParser.hpp"
 
 namespace {
 
@@ -60,7 +60,7 @@ Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(
 	TargetList targets;
 
 	// If the disk image is too large for a 5.25" disk, map this to the IIgs.
-	if(disk->get_maximum_head_position() > Storage::Disk::HeadPosition(40)) {
+	if(disk->maximum_head_position() > Storage::Disk::HeadPosition(40)) {
 		targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleIIgsTarget()));
 		targets.back()->media = media;
 		return targets;

Analyser/Static/DiskII/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::DiskII {

Analyser/Static/Enterprise/StaticAnalyser.cpp

@@ -9,7 +9,7 @@
 #include "StaticAnalyser.hpp"
 #include "Target.hpp"
 
-#include "../../../Storage/Disk/Parsers/FAT.hpp"
+#include "Storage/Disk/Parsers/FAT.hpp"
 
 #include <algorithm>
 

Analyser/Static/Enterprise/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Enterprise {

Analyser/Static/Enterprise/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 #include <string>
 

Analyser/Static/FAT12/StaticAnalyser.cpp

@@ -8,12 +8,12 @@
 
 #include "StaticAnalyser.hpp"
 
-#include "../Enterprise/StaticAnalyser.hpp"
+#include "Analyser/Static/Enterprise/StaticAnalyser.hpp"
-#include "../PCCompatible/StaticAnalyser.hpp"
+#include "Analyser/Static/PCCompatible/StaticAnalyser.hpp"
 
-#include "../../../Storage/Disk/Track/TrackSerialiser.hpp"
+#include "Storage/Disk/Track/TrackSerialiser.hpp"
-#include "../../../Storage/Disk/Encodings/MFM/Constants.hpp"
+#include "Storage/Disk/Encodings/MFM/Constants.hpp"
-#include "../../../Storage/Disk/Encodings/MFM/SegmentParser.hpp"
+#include "Storage/Disk/Encodings/MFM/SegmentParser.hpp"
 
 
 Analyser::Static::TargetList Analyser::Static::FAT12::GetTargets(
@@ -39,7 +39,7 @@ Analyser::Static::TargetList Analyser::Static::FAT12::GetTargets(
 
 	// 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)) {
+	if(disk->maximum_head_position() <= Storage::Disk::HeadPosition(40)) {
 		return Analyser::Static::PCCompatible::GetTargets(media, file_name, platforms, true);
 	}
 

Analyser/Static/FAT12/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::FAT12 {

Analyser/Static/MSX/Cartridge.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../../Storage/Cartridge/Cartridge.hpp"
+#include "Storage/Cartridge/Cartridge.hpp"
 
 namespace Analyser::Static::MSX {
 

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -12,8 +12,8 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 
-#include "../Disassembler/Z80.hpp"
+#include "Analyser/Static/Disassembler/Z80.hpp"
-#include "../Disassembler/AddressMapper.hpp"
+#include "Analyser/Static//Disassembler/AddressMapper.hpp"
 
 #include <algorithm>
 

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::MSX {

Analyser/Static/MSX/Tape.cpp

@@ -8,7 +8,7 @@
 
 #include "Tape.hpp"
 
-#include "../../../Storage/Tape/Parsers/MSX.hpp"
+#include "Storage/Tape/Parsers/MSX.hpp"
 
 using namespace Analyser::Static::MSX;
 

Analyser/Static/MSX/Tape.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../../Storage/Tape/Tape.hpp"
+#include "Storage/Tape/Tape.hpp"
 
 #include <string>
 #include <vector>

Analyser/Static/MSX/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 #include <string>
 
 namespace Analyser::Static::MSX {

Analyser/Static/Macintosh/StaticAnalyser.cpp

@@ -29,7 +29,7 @@ Analyser::Static::TargetList Analyser::Static::Macintosh::GetTargets(
 	if(media.mass_storage_devices.empty()) {
 		bool has_800kb_disks = false;
 		for(const auto &disk: media.disks) {
-			has_800kb_disks |= disk->get_head_count() > 1;
+			has_800kb_disks |= disk->head_count() > 1;
 		}
 
 		if(!has_800kb_disks) {

Analyser/Static/Macintosh/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Macintosh {

Analyser/Static/Macintosh/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::Macintosh {
 

Analyser/Static/Oric/StaticAnalyser.cpp

@@ -11,10 +11,10 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 
-#include "../Disassembler/6502.hpp"
+#include "Analyser/Static/Disassembler/6502.hpp"
-#include "../Disassembler/AddressMapper.hpp"
+#include "Analyser/Static/Disassembler/AddressMapper.hpp"
 
-#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "Storage/Disk/Encodings/MFM/Parser.hpp"
 
 #include <cstring>
 

Analyser/Static/Oric/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Oric {

Analyser/Static/Oric/Tape.cpp

@@ -7,7 +7,7 @@
 //
 
 #include "Tape.hpp"
-#include "../../../Storage/Tape/Parsers/Oric.hpp"
+#include "Storage/Tape/Parsers/Oric.hpp"
 
 using namespace Analyser::Static::Oric;
 

Analyser/Static/Oric/Tape.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../../Storage/Tape/Tape.hpp"
+#include "Storage/Tape/Tape.hpp"
 
 #include <string>
 #include <vector>

Analyser/Static/Oric/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 #include <string>
 
 namespace Analyser::Static::Oric {

Analyser/Static/PCCompatible/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::PCCompatible {

Analyser/Static/PCCompatible/Target.hpp

@@ -8,21 +8,36 @@
 
 #pragma once
 
-#include "../../../Reflection/Struct.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::PCCompatible {
 
+ReflectableEnum(Model,
+	XT,
+	TurboXT,
+	AT
+);
+
+constexpr bool is_xt(const Model model) {
+	return model <= Model::TurboXT;
+}
+
+constexpr bool is_at(const Model model) {
+	return model >= Model::AT;
+}
+
+constexpr bool has_ide(const Model model) {
+	return model >= Model::AT;
+}
+
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(VideoAdaptor,
 		MDA,
-		CGA);
+		CGA,
+	);
 	VideoAdaptor adaptor = VideoAdaptor::CGA;
-
+	Model model = Model::TurboXT;
-	ReflectableEnum(Speed,
-		ApproximatelyOriginal,
-		Fast);
-	Speed speed = Speed::Fast;
 
 	Target() : Analyser::Static::Target(Machine::PCCompatible) {}
 
@@ -30,9 +45,9 @@ private:
 	friend Reflection::StructImpl<Target>;
 	void declare_fields() {
 		AnnounceEnum(VideoAdaptor);
-		AnnounceEnum(Speed);
+		AnnounceEnum(Model);
 		DeclareField(adaptor);
-		DeclareField(speed);
+		DeclareField(model);
 	}
 };
 

Analyser/Static/Sega/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::Sega {

Analyser/Static/Sega/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::Sega {
 

Analyser/Static/StaticAnalyser.cpp

@@ -9,82 +9,85 @@
 #include "StaticAnalyser.hpp"
 
 #include <algorithm>
+#include <bit>
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <iterator>
 
 // Analysers
-#include "Acorn/StaticAnalyser.hpp"
+#include "Analyser/Static/Acorn/StaticAnalyser.hpp"
-#include "Amiga/StaticAnalyser.hpp"
+#include "Analyser/Static/Amiga/StaticAnalyser.hpp"
-#include "AmstradCPC/StaticAnalyser.hpp"
+#include "Analyser/Static/AmstradCPC/StaticAnalyser.hpp"
-#include "AppleII/StaticAnalyser.hpp"
+#include "Analyser/Static/AppleII/StaticAnalyser.hpp"
-#include "AppleIIgs/StaticAnalyser.hpp"
+#include "Analyser/Static/AppleIIgs/StaticAnalyser.hpp"
-#include "Atari2600/StaticAnalyser.hpp"
+#include "Analyser/Static/Atari2600/StaticAnalyser.hpp"
-#include "AtariST/StaticAnalyser.hpp"
+#include "Analyser/Static/AtariST/StaticAnalyser.hpp"
-#include "Coleco/StaticAnalyser.hpp"
+#include "Analyser/Static/Coleco/StaticAnalyser.hpp"
-#include "Commodore/StaticAnalyser.hpp"
+#include "Analyser/Static/Commodore/StaticAnalyser.hpp"
-#include "DiskII/StaticAnalyser.hpp"
+#include "Analyser/Static/DiskII/StaticAnalyser.hpp"
-#include "Enterprise/StaticAnalyser.hpp"
+#include "Analyser/Static/Enterprise/StaticAnalyser.hpp"
-#include "FAT12/StaticAnalyser.hpp"
+#include "Analyser/Static/FAT12/StaticAnalyser.hpp"
-#include "Macintosh/StaticAnalyser.hpp"
+#include "Analyser/Static/Macintosh/StaticAnalyser.hpp"
-#include "MSX/StaticAnalyser.hpp"
+#include "Analyser/Static/MSX/StaticAnalyser.hpp"
-#include "Oric/StaticAnalyser.hpp"
+#include "Analyser/Static/Oric/StaticAnalyser.hpp"
-#include "PCCompatible/StaticAnalyser.hpp"
+#include "Analyser/Static/PCCompatible/StaticAnalyser.hpp"
-#include "Sega/StaticAnalyser.hpp"
+#include "Analyser/Static/Sega/StaticAnalyser.hpp"
-#include "ZX8081/StaticAnalyser.hpp"
+#include "Analyser/Static/ZX8081/StaticAnalyser.hpp"
-#include "ZXSpectrum/StaticAnalyser.hpp"
+#include "Analyser/Static/ZXSpectrum/StaticAnalyser.hpp"
 
 // Cartridges
-#include "../../Storage/Cartridge/Formats/BinaryDump.hpp"
+#include "Storage/Cartridge/Formats/BinaryDump.hpp"
-#include "../../Storage/Cartridge/Formats/PRG.hpp"
+#include "Storage/Cartridge/Formats/PRG.hpp"
 
 // Disks
-#include "../../Storage/Disk/DiskImage/Formats/2MG.hpp"
+#include "Storage/Disk/DiskImage/Formats/2MG.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp"
+#include "Storage/Disk/DiskImage/Formats/AcornADF.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/AmigaADF.hpp"
+#include "Storage/Disk/DiskImage/Formats/AmigaADF.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/AppleDSK.hpp"
+#include "Storage/Disk/DiskImage/Formats/AppleDSK.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
+#include "Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/D64.hpp"
+#include "Storage/Disk/DiskImage/Formats/D64.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/G64.hpp"
+#include "Storage/Disk/DiskImage/Formats/G64.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/DMK.hpp"
+#include "Storage/Disk/DiskImage/Formats/DMK.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/FAT12.hpp"
+#include "Storage/Disk/DiskImage/Formats/FAT12.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
+#include "Storage/Disk/DiskImage/Formats/HFE.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/IPF.hpp"
+#include "Storage/Disk/DiskImage/Formats/IPF.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/IMD.hpp"
+#include "Storage/Disk/DiskImage/Formats/IMD.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/MacintoshIMG.hpp"
+#include "Storage/Disk/DiskImage/Formats/JFD.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/MSA.hpp"
+#include "Storage/Disk/DiskImage/Formats/MacintoshIMG.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/NIB.hpp"
+#include "Storage/Disk/DiskImage/Formats/MSA.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
+#include "Storage/Disk/DiskImage/Formats/NIB.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/PCBooter.hpp"
+#include "Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
+#include "Storage/Disk/DiskImage/Formats/PCBooter.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/STX.hpp"
+#include "Storage/Disk/DiskImage/Formats/SSD.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/WOZ.hpp"
+#include "Storage/Disk/DiskImage/Formats/STX.hpp"
+#include "Storage/Disk/DiskImage/Formats/WOZ.hpp"
 
 // Mass Storage Devices (i.e. usually, hard disks)
-#include "../../Storage/MassStorage/Formats/DAT.hpp"
+#include "Storage/MassStorage/Formats/DAT.hpp"
-#include "../../Storage/MassStorage/Formats/DSK.hpp"
+#include "Storage/MassStorage/Formats/DSK.hpp"
-#include "../../Storage/MassStorage/Formats/HDV.hpp"
+#include "Storage/MassStorage/Formats/HDV.hpp"
-#include "../../Storage/MassStorage/Formats/HFV.hpp"
+#include "Storage/MassStorage/Formats/HFV.hpp"
+#include "Storage/MassStorage/Formats/VHD.hpp"
 
 // State Snapshots
-#include "../../Storage/State/SNA.hpp"
+#include "Storage/State/SNA.hpp"
-#include "../../Storage/State/SZX.hpp"
+#include "Storage/State/SZX.hpp"
-#include "../../Storage/State/Z80.hpp"
+#include "Storage/State/Z80.hpp"
 
 // Tapes
-#include "../../Storage/Tape/Formats/CAS.hpp"
+#include "Storage/Tape/Formats/CAS.hpp"
-#include "../../Storage/Tape/Formats/CommodoreTAP.hpp"
+#include "Storage/Tape/Formats/CommodoreTAP.hpp"
-#include "../../Storage/Tape/Formats/CSW.hpp"
+#include "Storage/Tape/Formats/CSW.hpp"
-#include "../../Storage/Tape/Formats/OricTAP.hpp"
+#include "Storage/Tape/Formats/OricTAP.hpp"
-#include "../../Storage/Tape/Formats/TapePRG.hpp"
+#include "Storage/Tape/Formats/TapePRG.hpp"
-#include "../../Storage/Tape/Formats/TapeUEF.hpp"
+#include "Storage/Tape/Formats/TapeUEF.hpp"
-#include "../../Storage/Tape/Formats/TZX.hpp"
+#include "Storage/Tape/Formats/TZX.hpp"
-#include "../../Storage/Tape/Formats/ZX80O81P.hpp"
+#include "Storage/Tape/Formats/ZX80O81P.hpp"
-#include "../../Storage/Tape/Formats/ZXSpectrumTAP.hpp"
+#include "Storage/Tape/Formats/ZXSpectrumTAP.hpp"
 
 // Target Platform Types
-#include "../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 
 template<class> inline constexpr bool always_false_v = false;
 
@@ -205,6 +208,7 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	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<Disk::DiskImageHolder<Disk::JFD>>(TargetPlatform::Archimedes, "jfd");
 
 	accumulator.try_standard<Cartridge::BinaryDump>(TargetPlatform::AllCartridge, "bin");
 
@@ -269,13 +273,14 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 
 	accumulator.try_standard<Tape::ZX80O81P>(TargetPlatform::ZX8081, "p81");
 
+	static constexpr auto PRGTargets = TargetPlatform::Vic20; //Commodore8bit;	// Disabled until analysis improves.
 	if(accumulator.name_matches("prg")) {
 		// Try instantiating as a ROM; failing that accept as a tape.
 		try {
-			accumulator.insert<Cartridge::PRG>(TargetPlatform::Commodore8bit, file_name);
+			accumulator.insert<Cartridge::PRG>(PRGTargets, file_name);
 		} catch(...) {
 			try {
-				accumulator.insert<Tape::PRG>(TargetPlatform::Commodore8bit, file_name);
+				accumulator.insert<Tape::PRG>(PRGTargets, file_name);
 			} catch(...) {}
 		}
 	}
@@ -298,6 +303,8 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 
 	accumulator.try_standard<Tape::UEF>(TargetPlatform::Acorn, "uef");
 
+	accumulator.try_standard<MassStorage::VHD>(TargetPlatform::PCCompatible, "vhd");
+
 	accumulator.try_standard<Disk::DiskImageHolder<Disk::WOZ>>(TargetPlatform::DiskII, "woz");
 
 	return accumulator.media;
@@ -339,13 +346,7 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 	TargetPlatform::IntType potential_platforms = 0;
 	Media media = GetMediaAndPlatforms(file_name, potential_platforms);
 
-	// TODO: std::popcount here.
+	int total_options = std::popcount(potential_platforms);
-	int total_options = 0;
-	TargetPlatform::IntType mask = 1;
-	while(mask) {
-		total_options += bool(potential_platforms & mask);
-		mask <<= 1;
-	}
 	const bool is_confident = total_options == 1;
 	// i.e. This analyser `is_confident` if file analysis suggested only one potential target platform.
 	// The machine-specific static analyser will still run in case it can provide meaningful annotations on

Analyser/Static/StaticAnalyser.hpp

@@ -8,14 +8,14 @@
 
 #pragma once
 
-#include "../Machines.hpp"
+#include "Analyser/Machines.hpp"
 
-#include "../../Storage/Cartridge/Cartridge.hpp"
+#include "Storage/Cartridge/Cartridge.hpp"
-#include "../../Storage/Disk/Disk.hpp"
+#include "Storage/Disk/Disk.hpp"
-#include "../../Storage/MassStorage/MassStorageDevice.hpp"
+#include "Storage/MassStorage/MassStorageDevice.hpp"
-#include "../../Storage/Tape/Tape.hpp"
+#include "Storage/Tape/Tape.hpp"
-#include "../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
-#include "../../Reflection/Struct.hpp"
+#include "Reflection/Struct.hpp"
 
 #include <memory>
 #include <string>

Analyser/Static/ZX8081/StaticAnalyser.cpp

@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "Target.hpp"
-#include "../../../Storage/Tape/Parsers/ZX8081.hpp"
+#include "Storage/Tape/Parsers/ZX8081.hpp"
 
 static std::vector<Storage::Data::ZX8081::File> GetFiles(Storage::Tape::TapeSerialiser &serialiser) {
 	std::vector<Storage::Data::ZX8081::File> files;

Analyser/Static/ZX8081/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::ZX8081 {

Analyser/Static/ZX8081/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 #include <string>
 
 namespace Analyser::Static::ZX8081 {

Analyser/Static/ZXSpectrum/StaticAnalyser.cpp

@@ -8,9 +8,9 @@
 
 #include "StaticAnalyser.hpp"
 
-#include "../../../Storage/Disk/Parsers/CPM.hpp"
+#include "Storage/Disk/Parsers/CPM.hpp"
-#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "Storage/Disk/Encodings/MFM/Parser.hpp"
-#include "../../../Storage/Tape/Parsers/Spectrum.hpp"
+#include "Storage/Tape/Parsers/Spectrum.hpp"
 
 #include "Target.hpp"
 

Analyser/Static/ZXSpectrum/StaticAnalyser.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "../StaticAnalyser.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Storage/TargetPlatforms.hpp"
+#include "Storage/TargetPlatforms.hpp"
 #include <string>
 
 namespace Analyser::Static::ZXSpectrum {

Analyser/Static/ZXSpectrum/Target.hpp

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "../../../Reflection/Enum.hpp"
+#include "Analyser/Static/StaticAnalyser.hpp"
-#include "../../../Reflection/Struct.hpp"
+#include "Reflection/Enum.hpp"
-#include "../StaticAnalyser.hpp"
+#include "Reflection/Struct.hpp"
 
 namespace Analyser::Static::ZXSpectrum {
 

CMakeLists.txt

@@ -5,7 +5,7 @@ project(CLK
 	VERSION 24.01.22
 )
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
@@ -29,6 +29,7 @@ endif()
 message(STATUS "Configuring for ${CLK_UI} UI")
 
 list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include_directories(".")
 include("CLK_SOURCES")
 
 add_executable(clksignal ${CLK_SOURCES})

ClockReceiver/ClockReceiver.hpp

@@ -128,12 +128,7 @@ public:
 
 	forceinline constexpr T operator -() const						{	return T(- length_);				}
 
-	forceinline constexpr bool operator <(const T &rhs) const		{	return length_ < rhs.length_;		}
+	auto operator <=>(const WrappedInt &) const = default;
-	forceinline constexpr bool operator >(const T &rhs) const		{	return length_ > rhs.length_;		}
-	forceinline constexpr bool operator <=(const T &rhs) const		{	return length_ <= rhs.length_;		}
-	forceinline constexpr bool operator >=(const T &rhs) const		{	return length_ >= rhs.length_;		}
-	forceinline constexpr bool operator ==(const T &rhs) const		{	return length_ == rhs.length_;		}
-	forceinline constexpr bool operator !=(const T &rhs) const		{	return length_ != rhs.length_;		}
 
 	forceinline constexpr bool operator !() const					{	return !length_;					}
 	// bool operator () is not supported because it offers an implicit cast to int,

ClockReceiver/DeferredValue.hpp

@@ -16,10 +16,10 @@ template <int DeferredDepth, typename ValueT> class DeferredValue {
 private:
 	static_assert(sizeof(ValueT) <= 4);
 
-	constexpr int elements_per_uint32 = sizeof(uint32_t) / sizeof(ValueT);
+	static constexpr int elements_per_uint32 = sizeof(uint32_t) / sizeof(ValueT);
-	constexpr int unit_shift = sizeof(ValueT) * 8;
+	static constexpr int unit_shift = sizeof(ValueT) * 8;
-	constexpr int insert_shift = (DeferredDepth & (elements_per_uint32 - 1)) * unit_shift;
+	static constexpr int insert_shift = (DeferredDepth & (elements_per_uint32 - 1)) * unit_shift;
-	constexpr uint32_t insert_mask = ~(0xffff'ffff << insert_shift);
+	static constexpr uint32_t insert_mask = ~(0xffff'ffff << insert_shift);
 
 	std::array<uint32_t, (DeferredDepth + elements_per_uint32 - 1) / elements_per_uint32> backlog;
 

ClockReceiver/JustInTime.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "ClockReceiver.hpp"
-#include "../Concurrency/AsyncTaskQueue.hpp"
+#include "Concurrency/AsyncTaskQueue.hpp"
 #include "ClockingHintSource.hpp"
 #include "ForceInline.hpp"
 

ClockReceiver/ScanSynchroniser.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../Outputs/ScanTarget.hpp"
+#include "Outputs/ScanTarget.hpp"
 
 #include <cmath>
 

Components/1770/1770.cpp

@@ -8,8 +8,8 @@
 
 #include "1770.hpp"
 
-#include "../../Storage/Disk/Encodings/MFM/Constants.hpp"
+#include "Storage/Disk/Encodings/MFM/Constants.hpp"
-#include "../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
 namespace {
 Log::Logger<Log::Source::WDFDC> logger;
@@ -77,7 +77,7 @@ uint8_t WD1770::read(const int address) {
 					status |=
 						(status_.track_zero ? Flag::TrackZero : 0) |
 						(status_.seek_error ? Flag::SeekError : 0) |
-						(get_drive().get_is_read_only() ? Flag::WriteProtect : 0) |
+						(get_drive().is_read_only() ? Flag::WriteProtect : 0) |
 						(get_drive().get_index_pulse() ? Flag::Index : 0);
 				break;
 
@@ -132,26 +132,29 @@ void WD1770::run_for(const Cycles cycles) {
 	}
 }
 
+void WD1770::posit_event(const int new_event_type) {
 #define WAIT_FOR_EVENT(mask)	resume_point_ = __LINE__; interesting_event_mask_ = int(mask); return; case __LINE__:
 #define WAIT_FOR_TIME(ms)		resume_point_ = __LINE__; delay_time_ = ms * 8000; WAIT_FOR_EVENT(Event1770::Timer);
-#define WAIT_FOR_BYTES(count)	resume_point_ = __LINE__; distance_into_section_ = 0; WAIT_FOR_EVENT(Event::Token); if(get_latest_token().type == Token::Byte) distance_into_section_++; if(distance_into_section_ < count) { interesting_event_mask_ = int(Event::Token); return; }
+#define WAIT_FOR_BYTES(count)	distance_into_section_ = 0; \
+								WAIT_FOR_EVENT(Event::Token); \
+								if(get_latest_token().type == Token::Byte) ++distance_into_section_; \
+								if(distance_into_section_ < count) { \
+									return;	\
+								}
 #define BEGIN_SECTION()	switch(resume_point_) { default:
 #define END_SECTION()	(void)0; }
 
-#define READ_ID()	\
+	const auto READ_ID = [&] {
-		if(new_event_type == int(Event::Token)) {	\
+		if(new_event_type == int(Event::Token)) {
-			if(!distance_into_section_ && get_latest_token().type == Token::ID) {\
+			if(!distance_into_section_ && get_latest_token().type == Token::ID) {
-				set_data_mode(DataMode::Reading);	\
+				set_data_mode(DataMode::Reading);
-				++distance_into_section_;	\
+				++distance_into_section_;
-			} else if(distance_into_section_ && distance_into_section_ < 7 && get_latest_token().type == Token::Byte) {	\
+			} else if(distance_into_section_ && distance_into_section_ < 7 && get_latest_token().type == Token::Byte) {
-				header_[distance_into_section_ - 1] = get_latest_token().byte_value;	\
+				header_[distance_into_section_ - 1] = get_latest_token().byte_value;
-				++distance_into_section_;	\
+				++distance_into_section_;
-			}	\
 			}
-
+		}
-#define CONCATENATE(x, y) x ## y
+	};
-#define INDIRECT_CONCATENATE(x, y) TOKENPASTE(x, y)
-#define LINE_LABEL INDIRECT_CONCATENATE(label, __LINE__)
 
 #define SPIN_UP()	\
 		set_motor_on(true);	\
@@ -160,24 +163,6 @@ void WD1770::run_for(const Cycles cycles) {
 		WAIT_FOR_EVENT(Event1770::IndexHoleTarget);	\
 		status_.spin_up = true;
 
-// +--------+----------+-------------------------+
-// !	    !	       !          BITS           !
-// ! TYPE   ! COMMAND  !  7  6	5  4  3  2  1  0 !
-// +--------+----------+-------------------------+
-// !	 1  ! Restore  !  0  0	0  0  h  v r1 r0 !
-// !	 1  ! Seek     !  0  0	0  1  h  v r1 r0 !
-// !	 1  ! Step     !  0  0	1  u  h  v r1 r0 !
-// !	 1  ! Step-in  !  0  1	0  u  h  v r1 r0 !
-// !	 1  ! Step-out !  0  1	1  u  h  v r1 r0 !
-// !	 2  ! Rd sectr !  1  0	0  m  h  E  0  0 !
-// !	 2  ! Wt sectr !  1  0	1  m  h  E  P a0 !
-// !	 3  ! Rd addr  !  1  1	0  0  h  E  0  0 !
-// !	 3  ! Rd track !  1  1	1  0  h  E  0  0 !
-// !	 3  ! Wt track !  1  1	1  1  h  E  P  0 !
-// !	 4  ! Forc int !  1  1	0  1 i3 i2 i1 i0 !
-// +--------+----------+-------------------------+
-
-void WD1770::posit_event(const int new_event_type) {
 	if(new_event_type == int(Event::IndexHole)) {
 		index_hole_count_++;
 		if(index_hole_count_target_ == index_hole_count_) {
@@ -209,6 +194,23 @@ void WD1770::posit_event(const int new_event_type) {
 		interesting_event_mask_ &= ~new_event_type;
 	}
 
+// +--------+----------+-------------------------+
+// !	    !	       !          BITS           !
+// ! TYPE   ! COMMAND  !  7  6	5  4  3  2  1  0 !
+// +--------+----------+-------------------------+
+// !	 1  ! Restore  !  0  0	0  0  h  v r1 r0 !
+// !	 1  ! Seek     !  0  0	0  1  h  v r1 r0 !
+// !	 1  ! Step     !  0  0	1  u  h  v r1 r0 !
+// !	 1  ! Step-in  !  0  1	0  u  h  v r1 r0 !
+// !	 1  ! Step-out !  0  1	1  u  h  v r1 r0 !
+// !	 2  ! Rd sectr !  1  0	0  m  h  E  0  0 !
+// !	 2  ! Wt sectr !  1  0	1  m  h  E  P a0 !
+// !	 3  ! Rd addr  !  1  1	0  0  h  E  0  0 !
+// !	 3  ! Rd track !  1  1	1  0  h  E  0  0 !
+// !	 3  ! Wt track !  1  1	1  1  h  E  P  0 !
+// !	 4  ! Forc int !  1  1	0  1 i3 i2 i1 i0 !
+// +--------+----------+-------------------------+
+
 	BEGIN_SECTION()
 
 	// Wait for a new command, branch to the appropriate handler.
@@ -417,7 +419,7 @@ void WD1770::posit_event(const int new_event_type) {
 		WAIT_FOR_TIME(30);
 
 	test_type2_write_protection:
-		if(command_&0x20 && get_drive().get_is_read_only()) {
+		if(command_&0x20 && get_drive().is_read_only()) {
 			update_status([] (Status &status) {
 				status.write_protect = true;
 			});
@@ -716,7 +718,7 @@ void WD1770::posit_event(const int new_event_type) {
 			status.lost_data = false;
 		});
 
-		if(get_drive().get_is_read_only()) {
+		if(get_drive().is_read_only()) {
 			update_status([] (Status &status) {
 				status.write_protect = true;
 			});
@@ -818,7 +820,7 @@ void WD1770::update_status(const std::function<void(Status &)> updater) {
 			(status_.busy != old_status.busy) ||
 			(status_.data_request != old_status.data_request) ||
 			(status_.interrupt_request != old_status.interrupt_request);
-		if(did_change) delegate_->wd1770_did_change_output(this);
+		if(did_change) delegate_->wd1770_did_change_output(*this);
 	} else updater(status_);
 
 	if(status_.busy != old_status.busy) update_clocking_observer();

Components/1770/1770.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../Storage/Disk/Controller/MFMDiskController.hpp"
+#include "Storage/Disk/Controller/MFMDiskController.hpp"
 
 namespace WD {
 
@@ -66,9 +66,8 @@ public:
 	/// @returns The current value of the DRQ line output.
 	inline bool get_data_request_line() const		{	return status_.data_request;		}
 
-	class Delegate {
+	struct Delegate {
-		public:
+		virtual void wd1770_did_change_output(WD1770 &) = 0;
-			virtual void wd1770_did_change_output(WD1770 *wd1770) = 0;
 	};
 	inline void set_delegate(Delegate *delegate)	{	delegate_ = delegate;				}
 

Components/5380/ncr5380.cpp

@@ -8,7 +8,7 @@
 
 #include "ncr5380.hpp"
 
-#include "../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
 namespace {
 Log::Logger<Log::Source::NCR5380> logger;
@@ -25,7 +25,7 @@ NCR5380::NCR5380(SCSI::Bus &bus, const int clock_rate) :
 	bus_(bus),
 	clock_rate_(clock_rate) {
 	device_id_ = bus_.add_device();
-	bus_.add_observer(this);
+	bus_.add_observer(*this);
 
 	// TODO: use clock rate and expected phase. This implementation currently
 	// provides only CPU-driven polling behaviour.
@@ -146,12 +146,12 @@ void NCR5380::write(const int address, const uint8_t value, bool) {
 uint8_t NCR5380::read(const int address, bool) {
 	switch(address & 7) {
 		case 0:
-			logger.info().append("[0] Get current SCSI bus state: %02x", (bus_.get_state() & 0xff));
+			logger.info().append("[0] Get current SCSI bus state: %02x", (bus_.state() & 0xff));
 
 			if(dma_request_ && dma_operation_ == DMAOperation::InitiatorReceive) {
 				return dma_acknowledge();
 			}
-		return uint8_t(bus_.get_state());
+		return uint8_t(bus_.state());
 
 		case 1:
 			logger.info().append(
@@ -177,7 +177,7 @@ uint8_t NCR5380::read(const int address, bool) {
 		return target_command_;
 
 		case 4: {
-			const auto bus_state = bus_.get_state();
+			const auto bus_state = bus_.state();
 			const uint8_t result =
 				((bus_state & Line::Reset)			? 0x80 : 0x00) |
 				((bus_state & Line::Busy)			? 0x40 : 0x00) |
@@ -192,7 +192,7 @@ uint8_t NCR5380::read(const int address, bool) {
 		}
 
 		case 5: {
-			const auto bus_state = bus_.get_state();
+			const auto bus_state = bus_.state();
 			const uint8_t result =
 				(end_of_dma_ ? 0x80 : 0x00) |
 				((dma_request_ && state_ == ExecutionState::PerformingDMA) ? 0x40 : 0x00)	|
@@ -242,7 +242,7 @@ void NCR5380::update_control_output() {
 	}
 }
 
-void NCR5380::scsi_bus_did_change(SCSI::Bus *, const SCSI::BusState new_state, const double time_since_change) {
+void NCR5380::scsi_bus_did_change(SCSI::Bus &, const SCSI::BusState new_state, const double time_since_change) {
 	/*
 		When connected as an Initiator with DMA Mode True,
 		if the phase lines I//O, C//D, and /MSG do not match the
@@ -350,7 +350,7 @@ bool NCR5380::dma_request() {
 }
 
 uint8_t NCR5380::dma_acknowledge() {
-	const uint8_t bus_state = uint8_t(bus_.get_state());
+	const uint8_t bus_state = uint8_t(bus_.state());
 
 	dma_acknowledge_ = true;
 	dma_request_ = false;
@@ -370,7 +370,7 @@ void NCR5380::dma_acknowledge(const uint8_t value) {
 }
 
 bool NCR5380::phase_matches() const {
-	const auto bus_state = bus_.get_state();
+	const auto bus_state = bus_.state();
 	return
 		(target_output() & (Line::Message | Line::Control | Line::Input)) ==
 		(bus_state & (Line::Message | Line::Control | Line::Input));

Components/5380/ncr5380.hpp

@@ -8,11 +8,9 @@
 
 #pragma once
 
+#include "Storage/MassStorage/SCSI/SCSI.hpp"
 #include <cstdint>
 
-#include "../../Storage/MassStorage/SCSI/SCSI.hpp"
-
-
 namespace NCR::NCR5380 {
 
 /*!
@@ -80,7 +78,7 @@ private:
 	SCSI::BusState target_output() const;
 	void update_control_output();
 
-	void scsi_bus_did_change(SCSI::Bus *, SCSI::BusState new_state, double time_since_change) final;
+	void scsi_bus_did_change(SCSI::Bus &, SCSI::BusState, double) final;
 	bool phase_matches() const;
 };
 

Components/6522/6522.hpp

@@ -8,12 +8,10 @@
 
 #pragma once
 
+#include "Components/6522/Implementation/6522Storage.hpp"
+#include "ClockReceiver/ClockReceiver.hpp"
 #include <cstdint>
 
-#include "Implementation/6522Storage.hpp"
-
-#include "../../ClockReceiver/ClockReceiver.hpp"
-
 namespace MOS::MOS6522 {
 
 enum Port {
@@ -62,8 +60,7 @@ public:
 */
 class IRQDelegatePortHandler: public PortHandler {
 public:
-	class Delegate {
+	struct Delegate {
-		public:
 		/// Indicates that the interrupt status has changed for the IRQDelegatePortHandler provided.
 		virtual void mos6522_did_change_interrupt_status(void *irq_delegate) = 0;
 	};

Components/6522/Implementation/6522Implementation.hpp

@@ -6,7 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#include "../../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
 // As-yet unimplemented (incomplete list):
 //

Components/6522/Implementation/IRQDelegatePortHandler.cpp

@@ -6,7 +6,7 @@
 //  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
-#include "../6522.hpp"
+#include "Components/6522/6522.hpp"
 
 using namespace MOS::MOS6522;
 

Components/6526/6526.hpp

@@ -11,7 +11,7 @@
 #include <cstdint>
 
 #include "Implementation/6526Storage.hpp"
-#include "../Serial/Line.hpp"
+#include "Components/Serial/Line.hpp"
 
 namespace MOS::MOS6526 {
 

Components/6526/Implementation/6526Storage.hpp

@@ -10,8 +10,8 @@
 
 #include <array>
 
-#include "../../../ClockReceiver/ClockReceiver.hpp"
+#include "ClockReceiver/ClockReceiver.hpp"
-#include "../../../Outputs/Log.hpp"
+#include "Outputs/Log.hpp"
 
 namespace MOS::MOS6526 {
 
@@ -125,11 +125,11 @@ private:
 	uint32_t alarm_ = 0xff'ffff;
 
 public:
-	template <int byte> void write(uint8_t v) {
+	template <int byte> void write(const uint8_t v) {
 		if constexpr (byte == 3) {
 			return;
 		}
-		constexpr int shift = byte << 3;
+		static constexpr int shift = byte << 3;
 
 		// Write to either the alarm or the current value as directed;
 		// writing to any part of the current value other than the LSB
@@ -147,7 +147,7 @@ public:
 		if constexpr (byte == 3) {
 			return 0xff;	// Assumed. Just a guess.
 		}
-		constexpr int shift = byte << 3;
+		static constexpr int shift = byte << 3;
 
 		if constexpr (byte == 2) {
 			latch_ = value_ | 0xff00'0000;
@@ -163,7 +163,7 @@ public:
 		return result;
 	}
 
-	bool advance(int count) {
+	bool advance(const int count) {
 		// The 8250 uses a simple binary counter to replace the
 		// 6526's time-of-day clock. So this is easy.
 		const uint32_t distance_to_alarm = (alarm_ - value_) & 0xff'ffff;

Components/6532/6532.hpp

@@ -8,11 +8,11 @@
 
 #pragma once
 
+#include "ClockReceiver/ClockReceiver.hpp"
+
 #include <cstdint>
 #include <cstdio>
 
-#include "../../ClockReceiver/ClockReceiver.hpp"
-
 namespace MOS {
 
 /*!

Components/6560/6560.cpp

@@ -97,19 +97,29 @@ constexpr uint8_t noise_pattern[] = {
 	0xf0, 0xe1, 0xe0, 0x78, 0x70, 0x38, 0x3c, 0x3e, 0x1e, 0x3c, 0x1e, 0x1c, 0x70, 0x3c, 0x38, 0x3f,
 };
 
-#define shift(r) shift_registers_[r] = \
-	(shift_registers_[r] << 1) | (((shift_registers_[r]^0x80)&control_registers_[r]) >> 7)
-#define increment(r) shift_registers_[r] = (shift_registers_[r]+1)%8191
-#define update(r, m, up) \
-	counters_[r]++; if((counters_[r] >> m) == 0x80) { up(r); counters_[r] = unsigned(control_registers_[r]&0x7f) << m; }
-// Note on slightly askew test: as far as I can make out, if the value in the register is 0x7f then what's supposed to
-// happen is that the 0x7f is loaded, on the next clocked cycle the Vic spots a 0x7f, pumps the output, reloads, etc. No
-// increment ever occurs. It's conditional. I don't really want two conditionals if I can avoid it so I'm incrementing
-// regardless and testing against 0x80. The effect should be the same: loading with 0x7f means an output update every
-// cycle, loading with 0x7e means every second cycle, etc.
-
 template <Outputs::Speaker::Action action>
 void AudioGenerator::apply_samples(const std::size_t number_of_samples, Outputs::Speaker::MonoSample *const target) {
+	const auto shift = [&](const int r) {
+		shift_registers_[r] =
+			(shift_registers_[r] << 1) | (((shift_registers_[r] ^ 0x80) & control_registers_[r]) >> 7);
+	};
+	const auto increment = [&](const int r) {
+		shift_registers_[r] = (shift_registers_[r] + 1) % 8191;
+	};
+	const auto update = [&](const int r, const int m, auto &&up) {
+		++counters_[r];
+
+		if((counters_[r] >> m) == 0x80) {
+			up(r);
+			counters_[r] = unsigned(control_registers_[r]&0x7f) << m;
+		}
+		// Note on slightly askew test: as far as I can make out, if the value in the register is 0x7f then what's
+		// supposed to happen is that the 0x7f is loaded, on the next clocked cycle the Vic spots a 0x7f, pumps the
+		// output, reloads, etc. No increment ever occurs. It's conditional. I don't really want two conditionals if I
+		// can avoid it so I'm incrementing regardless and testing against 0x80. The effect should be the same: loading
+		// with 0x7f means an output update every cycle, loading with 0x7e means every second cycle, etc.
+	};
+
 	for(unsigned int c = 0; c < number_of_samples; ++c) {
 		update(0, 2, shift);
 		update(1, 1, shift);

Components/6560/6560.hpp

@@ -8,11 +8,11 @@
 
 #pragma once
 
-#include "../../ClockReceiver/ClockReceiver.hpp"
+#include "ClockReceiver/ClockReceiver.hpp"
-#include "../../Concurrency/AsyncTaskQueue.hpp"
+#include "Concurrency/AsyncTaskQueue.hpp"
-#include "../../Outputs/CRT/CRT.hpp"
+#include "Outputs/CRT/CRT.hpp"
-#include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
+#include "Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
-#include "../../Outputs/Speaker/Implementation/BufferSource.hpp"
+#include "Outputs/Speaker/Implementation/BufferSource.hpp"
 
 namespace MOS::MOS6560 {
 

Components/6845/CRTC6845.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "../../ClockReceiver/ClockReceiver.hpp"
+#include "ClockReceiver/ClockReceiver.hpp"
 
 #include <cstdint>
 #include <cstdio>
@@ -29,7 +29,7 @@ struct BusState {
 };
 
 class BusHandler {
-	public:
+public:
 	void perform_bus_cycle(const BusState &) {}
 };
 
@@ -96,7 +96,7 @@ public:
 			target = (target & 0xff00) | value;
 		};
 		const auto load_high = [value](uint16_t &target) {
-			constexpr uint8_t mask = RefreshMask >> 8;
+			static constexpr uint8_t mask = RefreshMask >> 8;
 			target = uint16_t((target & 0x00ff) | ((value & mask) << 8));
 		};