Merge branch 'master' into SeparateFetchClock

Use full 16-bit stack pointer for all 'new' instructions.

.editorconfig

@@ -0,0 +1,6 @@
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 4
+trim_trailing_whitespace = true
+

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: ['https://www.amazon.com/hz/wishlist/ls/8WPVFLQQDPTA']
+# Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.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)

.travis.yml

@@ -1,13 +0,0 @@
-# language: objective-c
-# osx_image: xcode8.2
-# xcode_project: OSBindings/Mac/Clock Signal.xcodeproj
-# xcode_scheme: Clock Signal
-# xcode_sdk: macosx10.12
-
-language: cpp
-before_install:
-	- sudo apt-get install libsdl2-dev
-script: cd OSBindings/SDL && scons
-compiler:
-	- clang
-	- gcc

Activity/Observer.hpp

@@ -9,6 +9,7 @@
 #ifndef ActivityObserver_h
 #define ActivityObserver_h
 
+#include <cstdint>
 #include <string>
 
 namespace Activity {
@@ -23,14 +24,23 @@ namespace Activity {
 */
 class Observer {
 	public:
+		/// 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.
+			/// If this flag is absent then the LED describes an ephemeral state, such as media access.
+			Persistent = (1 << 0),
+		};
+
 		/// Announces to the receiver that there is an LED of name @c name.
-		virtual void register_led(const std::string &name) = 0;
+		virtual void register_led([[maybe_unused]] const std::string &name, [[maybe_unused]] uint8_t presentation = 0) {}
 
 		/// Announces to the receiver that there is a drive of name @c name.
-		virtual void register_drive(const std::string &name) = 0;
+		///
+		/// If a drive has the same name as an LED, that LED goes with this drive.
+		virtual void register_drive([[maybe_unused]] const std::string &name) {}
 
 		/// Informs the receiver of the new state of the LED with name @c name.
-		virtual void set_led_status(const std::string &name, bool lit) = 0;
+		virtual void set_led_status([[maybe_unused]] const std::string &name, [[maybe_unused]] bool lit) {}
 
 		enum class DriveEvent {
 			StepNormal,
@@ -39,11 +49,10 @@ class Observer {
 		};
 
 		/// Informs the receiver that the named event just occurred for the drive with name @c name.
-		virtual void announce_drive_event(const std::string &name, DriveEvent event) = 0;
+		virtual void announce_drive_event([[maybe_unused]] const std::string &name, [[maybe_unused]] DriveEvent event) {}
 
 		/// Informs the receiver of the motor-on status of the drive with name @c name.
-		virtual void set_drive_motor_status(const std::string &name, bool is_on) = 0;
-
+		virtual void set_drive_motor_status([[maybe_unused]] const std::string &name, [[maybe_unused]] bool is_on) {}
 };
 
 }

Analyser/Dynamic/ConfidenceCounter.cpp

@@ -11,20 +11,20 @@
 using namespace Analyser::Dynamic;
 
 float ConfidenceCounter::get_confidence() {
-	return static_cast<float>(hits_) / static_cast<float>(hits_ + misses_);
+	return float(hits_) / float(hits_ + misses_);
 }
 
 void ConfidenceCounter::add_hit() {
-	hits_++;
+	++hits_;
 }
 
 void ConfidenceCounter::add_miss() {
-	misses_++;
+	++misses_;
 }
 
 void ConfidenceCounter::add_equivocal() {
 	if(hits_ > misses_) {
-		hits_++;
-		misses_++;
+		++hits_;
+		++misses_;
 	}
 }

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -11,8 +11,7 @@
 
 #include "ConfidenceSource.hpp"
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a confidence source that calculates its probability by virtual of a history of events.
@@ -22,7 +21,7 @@ namespace Dynamic {
 class ConfidenceCounter: public ConfidenceSource {
 	public:
 		/*! @returns The computed probability, based on the history of events. */
-		float get_confidence() override;
+		float get_confidence() final;
 
 		/*! Records an event that implies this is the appropriate class: pushes probability up towards 1.0. */
 		void add_hit();
@@ -41,7 +40,6 @@ class ConfidenceCounter: public ConfidenceSource {
 		int misses_ = 1;
 };
 
-}
 }
 
 #endif /* ConfidenceCounter_hpp */

Analyser/Dynamic/ConfidenceSource.hpp

@@ -9,8 +9,7 @@
 #ifndef ConfidenceSource_hpp
 #define ConfidenceSource_hpp
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides an abstract interface through which objects can declare the probability
@@ -22,7 +21,6 @@ struct ConfidenceSource {
 	virtual float get_confidence() = 0;
 };
 
-}
 }
 
 #endif /* ConfidenceSource_hpp */

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -13,8 +13,7 @@
 
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Summaries a collection of confidence sources by calculating their weighted sum.
@@ -32,15 +31,14 @@ class ConfidenceSummary: public ConfidenceSource {
 			const std::vector<float> &weights);
 
 		/*! @returns The weighted sum of all sources. */
-		float get_confidence() override;
+		float get_confidence() final;
 
 	private:
-		std::vector<ConfidenceSource *> sources_;
-		std::vector<float> weights_;
+		const std::vector<ConfidenceSource *> sources_;
+		const std::vector<float> weights_;
 		float weight_sum_;
 };
 
-}
 }
 
 #endif /* ConfidenceSummary_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.cpp

@@ -1,90 +0,0 @@
-//
-//  MultiCRTMachine.cpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 29/01/2018.
-//  Copyright 2018 Thomas Harte. All rights reserved.
-//
-
-#include "MultiCRTMachine.hpp"
-
-#include <condition_variable>
-#include <mutex>
-
-using namespace Analyser::Dynamic;
-
-MultiCRTMachine::MultiCRTMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::mutex &machines_mutex) :
-	machines_(machines), machines_mutex_(machines_mutex), queues_(machines.size()) {
-	speaker_ = MultiSpeaker::create(machines);
-}
-
-void MultiCRTMachine::perform_parallel(const std::function<void(::CRTMachine::Machine *)> &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::condition_variable condition;
-	std::mutex mutex;
-	{
-		std::lock_guard<std::mutex> machines_lock(machines_mutex_);
-		std::lock_guard<std::mutex> lock(mutex);
-		outstanding_machines = machines_.size();
-
-		for(std::size_t index = 0; index < machines_.size(); ++index) {
-			CRTMachine::Machine *crt_machine = machines_[index]->crt_machine();
-			queues_[index].enqueue([&mutex, &condition, crt_machine, function, &outstanding_machines]() {
-				if(crt_machine) function(crt_machine);
-
-				std::lock_guard<std::mutex> lock(mutex);
-				outstanding_machines--;
-				condition.notify_all();
-			});
-		}
-	}
-
-	std::unique_lock<std::mutex> lock(mutex);
-	condition.wait(lock, [&outstanding_machines] { return !outstanding_machines; });
-}
-
-void MultiCRTMachine::perform_serial(const std::function<void (::CRTMachine::Machine *)> &function) {
-	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
-	for(const auto &machine: machines_) {
-		CRTMachine::Machine *crt_machine = machine->crt_machine();
-		if(crt_machine) function(crt_machine);
-	}
-}
-
-void MultiCRTMachine::setup_output(float aspect_ratio) {
-	perform_serial([=](::CRTMachine::Machine *machine) {
-		machine->setup_output(aspect_ratio);
-	});
-}
-
-void MultiCRTMachine::close_output() {
-	perform_serial([=](::CRTMachine::Machine *machine) {
-		machine->close_output();
-	});
-}
-
-Outputs::CRT::CRT *MultiCRTMachine::get_crt() {
-	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
-	CRTMachine::Machine *crt_machine = machines_.front()->crt_machine();
-	return crt_machine ? crt_machine->get_crt() : nullptr;
-}
-
-Outputs::Speaker::Speaker *MultiCRTMachine::get_speaker() {
-	return speaker_;
-}
-
-void MultiCRTMachine::run_for(Time::Seconds duration) {
-	perform_parallel([=](::CRTMachine::Machine *machine) {
-		if(machine->get_confidence() >= 0.01f) machine->run_for(duration);
-	});
-
-	if(delegate_) delegate_->multi_crt_did_run_machines();
-}
-
-void MultiCRTMachine::did_change_machine_order() {
-	if(speaker_) {
-		speaker_->set_new_front_machine(machines_.front().get());
-	}
-}

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.hpp

@@ -1,89 +0,0 @@
-//
-//  MultiCRTMachine.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 29/01/2018.
-//  Copyright 2018 Thomas Harte. All rights reserved.
-//
-
-#ifndef MultiCRTMachine_hpp
-#define MultiCRTMachine_hpp
-
-#include "../../../../Concurrency/AsyncTaskQueue.hpp"
-#include "../../../../Machines/CRTMachine.hpp"
-#include "../../../../Machines/DynamicMachine.hpp"
-
-#include "MultiSpeaker.hpp"
-
-#include <memory>
-#include <mutex>
-#include <vector>
-
-namespace Analyser {
-namespace Dynamic {
-
-/*!
-	Provides a class that multiplexes the CRT machine interface to multiple machines.
-
-	Keeps a reference to the original vector of machines; will access it only after
-	acquiring a supplied mutex. The owner should also call did_change_machine_order()
-	if the order of machines changes.
-*/
-class MultiCRTMachine: public CRTMachine::Machine {
-	public:
-		MultiCRTMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::mutex &machines_mutex);
-
-		/*!
-			Informs the MultiCRTMachine that the order of machines has changed; the MultiCRTMachine
-			uses this as an opportunity to synthesis any CRTMachine::Machine::Delegate messages that
-			are necessary to bridge the gap between one machine and the next.
-		*/
-		void did_change_machine_order();
-
-		/*!
-			Provides a mechanism by which a delegate can be informed each time a call to run_for has
-			been received.
-		*/
-		struct Delegate {
-			virtual void multi_crt_did_run_machines() = 0;
-		};
-		/// Sets @c delegate as the receiver of delegate messages.
-		void set_delegate(Delegate *delegate) {
-			delegate_ = delegate;
-		}
-
-		// Below is the standard CRTMachine::Machine interface; see there for documentation.
-		void setup_output(float aspect_ratio) override;
-		void close_output() override;
-		Outputs::CRT::CRT *get_crt() override;
-		Outputs::Speaker::Speaker *get_speaker() override;
-		void run_for(Time::Seconds duration) override;
-
-	private:
-		void run_for(const Cycles cycles) override {}
-		const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines_;
-		std::mutex &machines_mutex_;
-		std::vector<Concurrency::AsyncTaskQueue> queues_;
-		MultiSpeaker *speaker_ = nullptr;
-		Delegate *delegate_ = nullptr;
-
-		/*!
-			Performs a parallel for operation across all machines, performing the supplied
-			function on each and returning only once all applications have completed.
-
-			No guarantees are extended as to which thread operations will occur on.
-		*/
-		void perform_parallel(const std::function<void(::CRTMachine::Machine *)> &);
-
-		/*!
-			Performs a serial for operation across all machines, performing the supplied
-			function on each on the calling thread.
-		*/
-		void perform_serial(const std::function<void(::CRTMachine::Machine *)> &);
-};
-
-}
-}
-
-
-#endif /* MultiCRTMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.cpp

@@ -12,6 +12,97 @@
 
 using namespace Analyser::Dynamic;
 
+namespace {
+
+class MultiStruct: public Reflection::Struct {
+	public:
+		MultiStruct(const std::vector<Configurable::Device *> &devices) : devices_(devices) {
+			for(auto device: devices) {
+				options_.emplace_back(device->get_options());
+			}
+		}
+
+		void apply() {
+			auto options = options_.begin();
+			for(auto device: devices_) {
+				device->set_options(*options);
+				++options;
+			}
+		}
+
+		std::vector<std::string> all_keys() const final {
+			std::set<std::string> keys;
+			for(auto &options: options_) {
+				const auto new_keys = options->all_keys();
+				keys.insert(new_keys.begin(), new_keys.end());
+			}
+			return std::vector<std::string>(keys.begin(), keys.end());
+		}
+
+		std::vector<std::string> values_for(const std::string &name) const final {
+			std::set<std::string> values;
+			for(auto &options: options_) {
+				const auto new_values = options->values_for(name);
+				values.insert(new_values.begin(), new_values.end());
+			}
+			return std::vector<std::string>(values.begin(), values.end());
+		}
+
+		const std::type_info *type_of(const std::string &name) const final {
+			for(auto &options: options_) {
+				auto info = options->type_of(name);
+				if(info) return info;
+			}
+			return nullptr;
+		}
+
+		size_t count_of(const std::string &name) const final {
+			for(auto &options: options_) {
+				auto info = options->type_of(name);
+				if(info) return options->count_of(name);
+			}
+			return 0;
+		}
+
+		const void *get(const std::string &name) const final {
+			for(auto &options: options_) {
+				auto value = options->get(name);
+				if(value) return value;
+			}
+			return nullptr;
+		}
+
+		void *get(const std::string &name) final {
+			for(auto &options: options_) {
+				auto value = options->get(name);
+				if(value) return value;
+			}
+			return nullptr;
+		}
+
+		void set(const std::string &name, const void *value, size_t offset) final {
+			const auto safe_type = type_of(name);
+			if(!safe_type) return;
+
+			// Set this property only where the child's type is the same as that
+			// which was returned from here for type_of.
+			for(auto &options: options_) {
+				const auto type = options->type_of(name);
+				if(!type) continue;
+
+				if(*type == *safe_type) {
+					options->set(name, value, offset);
+				}
+			}
+		}
+
+	private:
+		const std::vector<Configurable::Device *> &devices_;
+		std::vector<std::unique_ptr<Reflection::Struct>> options_;
+};
+
+}
+
 MultiConfigurable::MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
 	for(const auto &machine: machines) {
 		Configurable::Device *device = machine->configurable_device();
@@ -19,46 +110,11 @@ MultiConfigurable::MultiConfigurable(const std::vector<std::unique_ptr<::Machine
 	}
 }
 
-std::vector<std::unique_ptr<Configurable::Option>> MultiConfigurable::get_options() {
-	std::vector<std::unique_ptr<Configurable::Option>> options;
-
-	// Produce the list of unique options.
-	for(const auto &device : devices_) {
-		std::vector<std::unique_ptr<Configurable::Option>> device_options = device->get_options();
-		for(auto &option : device_options) {
-			if(std::find(options.begin(), options.end(), option) == options.end()) {
-				options.push_back(std::move(option));
-			}
-		}
-	}
-
-	return options;
+void MultiConfigurable::set_options(const std::unique_ptr<Reflection::Struct> &str) {
+	const auto options = dynamic_cast<MultiStruct *>(str.get());
+	options->apply();
 }
 
-void MultiConfigurable::set_selections(const Configurable::SelectionSet &selection_by_option) {
-	for(const auto &device : devices_) {
-		device->set_selections(selection_by_option);
-	}
-}
-
-Configurable::SelectionSet MultiConfigurable::get_accurate_selections() {
-	Configurable::SelectionSet set;
-	for(const auto &device : devices_) {
-		Configurable::SelectionSet device_set = device->get_accurate_selections();
-		for(auto &selection : device_set) {
-			set.insert(std::move(selection));
-		}
-	}
-	return set;
-}
-
-Configurable::SelectionSet MultiConfigurable::get_user_friendly_selections() {
-	Configurable::SelectionSet set;
-	for(const auto &device : devices_) {
-		Configurable::SelectionSet device_set = device->get_user_friendly_selections();
-		for(auto &selection : device_set) {
-			set.insert(std::move(selection));
-		}
-	}
-	return set;
+std::unique_ptr<Reflection::Struct> MultiConfigurable::get_options() {
+	return std::make_unique<MultiStruct>(devices_);
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -10,12 +10,12 @@
 #define MultiConfigurable_hpp
 
 #include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Configurable/Configurable.hpp"
 
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the configurable interface to multiple machines.
@@ -28,16 +28,13 @@ class MultiConfigurable: public Configurable::Device {
 		MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
 
 		// Below is the standard Configurable::Device interface; see there for documentation.
-		std::vector<std::unique_ptr<Configurable::Option>> get_options() override;
-		void set_selections(const Configurable::SelectionSet &selection_by_option) override;
-		Configurable::SelectionSet get_accurate_selections() override;
-		Configurable::SelectionSet get_user_friendly_selections() override;
+		void set_options(const std::unique_ptr<Reflection::Struct> &options) final;
+		std::unique_ptr<Reflection::Struct> get_options() final;
 
 	private:
 		std::vector<Configurable::Device *> devices_;
 };
 
-}
 }
 
 #endif /* MultiConfigurable_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurationTarget.cpp

@@ -1,29 +0,0 @@
-//
-//  MultiConfigurationTarget.cpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 29/01/2018.
-//  Copyright 2018 Thomas Harte. All rights reserved.
-//
-
-#include "MultiConfigurationTarget.hpp"
-
-using namespace Analyser::Dynamic;
-
-MultiConfigurationTarget::MultiConfigurationTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
-	for(const auto &machine: machines) {
-		ConfigurationTarget::Machine *configuration_target = machine->configuration_target();
-		if(configuration_target) targets_.push_back(configuration_target);
-	}
-}
-
-void MultiConfigurationTarget::configure_as_target(const Analyser::Static::Target *target) {
-}
-
-bool MultiConfigurationTarget::insert_media(const Analyser::Static::Media &media) {
-	bool inserted = false;
-	for(const auto &target : targets_) {
-		inserted |= target->insert_media(media);
-	}
-	return inserted;
-}

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurationTarget.hpp

@@ -1,42 +0,0 @@
-//
-//  MultiConfigurationTarget.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 29/01/2018.
-//  Copyright 2018 Thomas Harte. All rights reserved.
-//
-
-#ifndef MultiConfigurationTarget_hpp
-#define MultiConfigurationTarget_hpp
-
-#include "../../../../Machines/ConfigurationTarget.hpp"
-#include "../../../../Machines/DynamicMachine.hpp"
-
-#include <memory>
-#include <vector>
-
-namespace Analyser {
-namespace Dynamic {
-
-/*!
-	Provides a class that multiplexes the configuration target interface to multiple machines.
-
-	Makes a static internal copy of the list of machines; makes no guarantees about the
-	order of delivered messages.
-*/
-struct MultiConfigurationTarget: public ConfigurationTarget::Machine {
-	public:
-		MultiConfigurationTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
-
-		// Below is the standard ConfigurationTarget::Machine interface; see there for documentation.
-		void configure_as_target(const Analyser::Static::Target *target) override;
-		bool insert_media(const Analyser::Static::Media &media) override;
-
-	private:
-		std::vector<ConfigurationTarget::Machine *> targets_;
-};
-
-}
-}
-
-#endif /* MultiConfigurationTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.cpp

@@ -16,7 +16,7 @@ namespace {
 
 class MultiJoystick: public Inputs::Joystick {
 	public:
-		MultiJoystick(std::vector<JoystickMachine::Machine *> &machines, std::size_t index) {
+		MultiJoystick(std::vector<MachineTypes::JoystickMachine *> &machines, std::size_t index) {
 			for(const auto &machine: machines) {
 				const auto &joysticks = machine->get_joysticks();
 				if(joysticks.size() >= index) {
@@ -25,14 +25,14 @@ class MultiJoystick: public Inputs::Joystick {
 			}
 		}
 
-		std::vector<DigitalInput> get_inputs() override {
-			std::vector<DigitalInput> inputs;
-
-			for(const auto &joystick: joysticks_) {
-				std::vector<DigitalInput> joystick_inputs = joystick->get_inputs();
-				for(const auto &input: joystick_inputs) {
-					if(std::find(inputs.begin(), inputs.end(), input) != inputs.end()) {
-						inputs.push_back(input);
+		const std::vector<Input> &get_inputs() final {
+			if(inputs.empty()) {
+				for(const auto &joystick: joysticks_) {
+					std::vector<Input> joystick_inputs = joystick->get_inputs();
+					for(const auto &input: joystick_inputs) {
+						if(std::find(inputs.begin(), inputs.end(), input) != inputs.end()) {
+							inputs.push_back(input);
+						}
 					}
 				}
 			}
@@ -40,18 +40,26 @@ class MultiJoystick: public Inputs::Joystick {
 			return inputs;
 		}
 
-		void set_digital_input(const DigitalInput &digital_input, bool is_active) override {
+		void set_input(const Input &digital_input, bool is_active) final {
 			for(const auto &joystick: joysticks_) {
-				joystick->set_digital_input(digital_input, is_active);
+				joystick->set_input(digital_input, is_active);
 			}
 		}
-		void reset_all_inputs() override {
+
+		void set_input(const Input &digital_input, float value) final {
+			for(const auto &joystick: joysticks_) {
+				joystick->set_input(digital_input, value);
+			}
+		}
+
+		void reset_all_inputs() final {
 			for(const auto &joystick: joysticks_) {
 				joystick->reset_all_inputs();
 			}
 		}
 
 	private:
+		std::vector<Input> inputs;
 		std::vector<Inputs::Joystick *> joysticks_;
 };
 
@@ -59,9 +67,9 @@ class MultiJoystick: public Inputs::Joystick {
 
 MultiJoystickMachine::MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
 	std::size_t total_joysticks = 0;
-	std::vector<JoystickMachine::Machine *> joystick_machines;
+	std::vector<MachineTypes::JoystickMachine *> joystick_machines;
 	for(const auto &machine: machines) {
-		JoystickMachine::Machine *joystick_machine = machine->joystick_machine();
+		auto joystick_machine = machine->joystick_machine();
 		if(joystick_machine) {
 			joystick_machines.push_back(joystick_machine);
 			total_joysticks = std::max(total_joysticks, joystick_machine->get_joysticks().size());
@@ -73,6 +81,6 @@ MultiJoystickMachine::MultiJoystickMachine(const std::vector<std::unique_ptr<::M
 	}
 }
 
-std::vector<std::unique_ptr<Inputs::Joystick>> &MultiJoystickMachine::get_joysticks() {
+const std::vector<std::unique_ptr<Inputs::Joystick>> &MultiJoystickMachine::get_joysticks() {
 	return joysticks_;
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -14,8 +14,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the joystick machine interface to multiple machines.
@@ -23,18 +22,17 @@ namespace Dynamic {
 	Makes a static internal copy of the list of machines; makes no guarantees about the
 	order of delivered messages.
 */
-class MultiJoystickMachine: public JoystickMachine::Machine {
+class MultiJoystickMachine: public MachineTypes::JoystickMachine {
 	public:
 		MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
 
 		// Below is the standard JoystickMachine::Machine interface; see there for documentation.
-		std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override;
+		const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() final;
 
 	private:
 		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
 };
 
-}
 }
 
 #endif /* MultiJoystickMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -12,9 +12,10 @@ using namespace Analyser::Dynamic;
 
 MultiKeyboardMachine::MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
 	for(const auto &machine: machines) {
-		KeyboardMachine::Machine *keyboard_machine = machine->keyboard_machine();
+		auto keyboard_machine = machine->keyboard_machine();
 		if(keyboard_machine) machines_.push_back(keyboard_machine);
 	}
+	keyboard_ = std::make_unique<MultiKeyboard>(machines_);
 }
 
 void MultiKeyboardMachine::clear_all_keys() {
@@ -35,9 +36,44 @@ void MultiKeyboardMachine::type_string(const std::string &string) {
 	}
 }
 
-void MultiKeyboardMachine::keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) {
+bool MultiKeyboardMachine::can_type(char c) const {
+	bool can_type = true;
 	for(const auto &machine: machines_) {
-		uint16_t mapped_key = machine->get_keyboard_mapper()->mapped_key_for_key(key);
-		if(mapped_key != KeyNotMapped) machine->set_key_state(mapped_key, is_pressed);
+		can_type &= machine->can_type(c);
+	}
+	return can_type;
+}
+
+Inputs::Keyboard &MultiKeyboardMachine::get_keyboard() {
+	return *keyboard_;
+}
+
+MultiKeyboardMachine::MultiKeyboard::MultiKeyboard(const std::vector<::MachineTypes::KeyboardMachine *> &machines)
+	: machines_(machines) {
+	for(const auto &machine: machines_) {
+		observed_keys_.insert(machine->get_keyboard().observed_keys().begin(), machine->get_keyboard().observed_keys().end());
+		is_exclusive_ |= machine->get_keyboard().is_exclusive();
 	}
 }
+
+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);
+	}
+	return was_consumed;
+}
+
+void MultiKeyboardMachine::MultiKeyboard::reset_all_keys() {
+	for(const auto &machine: machines_) {
+		machine->get_keyboard().reset_all_keys();
+	}
+}
+
+const std::set<Inputs::Keyboard::Key> &MultiKeyboardMachine::MultiKeyboard::observed_keys() const {
+	return observed_keys_;
+}
+
+bool MultiKeyboardMachine::MultiKeyboard::is_exclusive() const {
+	return is_exclusive_;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -15,8 +15,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the keyboard machine interface to multiple machines.
@@ -24,21 +23,37 @@ namespace Dynamic {
 	Makes a static internal copy of the list of machines; makes no guarantees about the
 	order of delivered messages.
 */
-class MultiKeyboardMachine: public KeyboardMachine::Machine {
+class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
+	private:
+		std::vector<MachineTypes::KeyboardMachine *> machines_;
+
+		class MultiKeyboard: public Inputs::Keyboard {
+			public:
+				MultiKeyboard(const std::vector<MachineTypes::KeyboardMachine *> &machines);
+
+				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;
+
+			private:
+				const std::vector<MachineTypes::KeyboardMachine *> &machines_;
+				std::set<Key> observed_keys_;
+				bool is_exclusive_ = false;
+		};
+		std::unique_ptr<MultiKeyboard> keyboard_;
+
 	public:
 		MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
 
 		// Below is the standard KeyboardMachine::Machine interface; see there for documentation.
-		void clear_all_keys() override;
-		void set_key_state(uint16_t key, bool is_pressed) override;
-		void type_string(const std::string &) override;
-		void keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) override;
-
-	private:
-		std::vector<::KeyboardMachine::Machine *> machines_;
+		void clear_all_keys() final;
+		void set_key_state(uint16_t key, bool is_pressed) final;
+		void type_string(const std::string &) final;
+		bool can_type(char c) const final;
+		Inputs::Keyboard &get_keyboard() final;
 };
 
-}
 }
 
 #endif /* MultiKeyboardMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.cpp

@@ -0,0 +1,26 @@
+//
+//  MultiMediaTarget.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiMediaTarget.hpp"
+
+using namespace Analyser::Dynamic;
+
+MultiMediaTarget::MultiMediaTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		auto media_target = machine->media_target();
+		if(media_target) targets_.push_back(media_target);
+	}
+}
+
+bool MultiMediaTarget::insert_media(const Analyser::Static::Media &media) {
+	bool inserted = false;
+	for(const auto &target : targets_) {
+		inserted |= target->insert_media(media);
+	}
+	return inserted;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -0,0 +1,39 @@
+//
+//  MultiMediaTarget.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiMediaTarget_hpp
+#define MultiMediaTarget_hpp
+
+#include "../../../../Machines/MediaTarget.hpp"
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser::Dynamic {
+
+/*!
+	Provides a class that multiplexes the media target interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+struct MultiMediaTarget: public MachineTypes::MediaTarget {
+	public:
+		MultiMediaTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard MediaTarget::Machine interface; see there for documentation.
+		bool insert_media(const Analyser::Static::Media &media) final;
+
+	private:
+		std::vector<MachineTypes::MediaTarget *> targets_;
+};
+
+}
+
+#endif /* MultiMediaTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.cpp

@@ -0,0 +1,105 @@
+//
+//  MultiProducer.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiProducer.hpp"
+
+#include <condition_variable>
+#include <mutex>
+
+using namespace Analyser::Dynamic;
+
+// MARK: - MultiInterface
+
+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::condition_variable condition;
+	std::mutex mutex;
+	{
+		std::lock_guard machines_lock(machines_mutex_);
+		std::lock_guard lock(mutex);
+		outstanding_machines = machines_.size();
+
+		for(std::size_t index = 0; index < machines_.size(); ++index) {
+			const auto machine = ::Machine::get<MachineType>(*machines_[index].get());
+			queues_[index].enqueue([&mutex, &condition, machine, function, &outstanding_machines]() {
+				if(machine) function(machine);
+
+				std::lock_guard lock(mutex);
+				outstanding_machines--;
+				condition.notify_all();
+			});
+		}
+	}
+
+	std::unique_lock lock(mutex);
+	condition.wait(lock, [&outstanding_machines] { return !outstanding_machines; });
+}
+
+template <typename MachineType>
+void MultiInterface<MachineType>::perform_serial(const std::function<void(MachineType *)> &function) {
+	std::lock_guard machines_lock(machines_mutex_);
+	for(const auto &machine: machines_) {
+		const auto typed_machine = ::Machine::get<MachineType>(*machine.get());
+		if(typed_machine) function(typed_machine);
+	}
+}
+
+// MARK: - MultiScanProducer
+void MultiScanProducer::set_scan_target(Outputs::Display::ScanTarget *scan_target) {
+	scan_target_ = scan_target;
+
+	std::lock_guard machines_lock(machines_mutex_);
+	const auto machine = machines_.front()->scan_producer();
+	if(machine) machine->set_scan_target(scan_target);
+}
+
+Outputs::Display::ScanStatus MultiScanProducer::get_scan_status() const {
+	std::lock_guard machines_lock(machines_mutex_);
+	const auto machine = machines_.front()->scan_producer();
+	if(machine) return machine->get_scan_status();
+	return Outputs::Display::ScanStatus();
+}
+
+void MultiScanProducer::did_change_machine_order() {
+	if(scan_target_) scan_target_->will_change_owner();
+
+	perform_serial([](MachineTypes::ScanProducer *machine) {
+		machine->set_scan_target(nullptr);
+	});
+	std::lock_guard machines_lock(machines_mutex_);
+	const auto machine = machines_.front()->scan_producer();
+	if(machine) machine->set_scan_target(scan_target_);
+}
+
+// MARK: - MultiAudioProducer
+MultiAudioProducer::MultiAudioProducer(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex) : MultiInterface(machines, machines_mutex) {
+	speaker_ = MultiSpeaker::create(machines);
+}
+
+Outputs::Speaker::Speaker *MultiAudioProducer::get_speaker() {
+	return speaker_;
+}
+
+void MultiAudioProducer::did_change_machine_order() {
+	if(speaker_) {
+		speaker_->set_new_front_machine(machines_.front().get());
+	}
+}
+
+// MARK: - MultiTimedMachine
+
+void MultiTimedMachine::run_for(Time::Seconds duration) {
+	perform_parallel([duration](::MachineTypes::TimedMachine *machine) {
+		if(machine->get_confidence() >= 0.01f) machine->run_for(duration);
+	});
+
+	if(delegate_) delegate_->did_run_machines(this);
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

@@ -0,0 +1,119 @@
+//
+//  MultiProducer.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiProducer_hpp
+#define MultiProducer_hpp
+
+#include "../../../../Concurrency/AsyncTaskQueue.hpp"
+#include "../../../../Machines/MachineTypes.hpp"
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include "MultiSpeaker.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser::Dynamic {
+
+template <typename MachineType> class MultiInterface {
+	public:
+		MultiInterface(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex) :
+			machines_(machines), machines_mutex_(machines_mutex), queues_(machines.size()) {}
+
+	protected:
+		/*!
+			Performs a parallel for operation across all machines, performing the supplied
+			function on each and returning only once all applications have completed.
+
+			No guarantees are extended as to which thread operations will occur on.
+		*/
+		void perform_parallel(const std::function<void(MachineType *)> &);
+
+		/*!
+			Performs a serial for operation across all machines, performing the supplied
+			function on each on the calling thread.
+		*/
+		void perform_serial(const std::function<void(MachineType *)> &);
+
+	protected:
+		const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines_;
+		std::recursive_mutex &machines_mutex_;
+
+	private:
+		std::vector<Concurrency::AsyncTaskQueue<true>> queues_;
+};
+
+class MultiTimedMachine: public MultiInterface<MachineTypes::TimedMachine>, public MachineTypes::TimedMachine {
+	public:
+		using MultiInterface::MultiInterface;
+
+		/*!
+			Provides a mechanism by which a delegate can be informed each time a call to run_for has
+			been received.
+		*/
+		struct Delegate {
+			virtual void did_run_machines(MultiTimedMachine *) = 0;
+		};
+		/// Sets @c delegate as the receiver of delegate messages.
+		void set_delegate(Delegate *delegate) {
+			delegate_ = delegate;
+		}
+
+		void run_for(Time::Seconds duration) final;
+
+	private:
+		void run_for(const Cycles) final {}
+		Delegate *delegate_ = nullptr;
+};
+
+class MultiScanProducer: public MultiInterface<MachineTypes::ScanProducer>, public MachineTypes::ScanProducer {
+	public:
+		using MultiInterface::MultiInterface;
+
+		/*!
+			Informs the MultiScanProducer that the order of machines has changed; it
+			uses this as an opportunity to synthesis any CRTMachine::Machine::Delegate messages that
+			are necessary to bridge the gap between one machine and the next.
+		*/
+		void did_change_machine_order();
+
+		void set_scan_target(Outputs::Display::ScanTarget *scan_target) final;
+		Outputs::Display::ScanStatus get_scan_status() const final;
+
+	private:
+		Outputs::Display::ScanTarget *scan_target_ = nullptr;
+};
+
+class MultiAudioProducer: public MultiInterface<MachineTypes::AudioProducer>, public MachineTypes::AudioProducer {
+	public:
+		MultiAudioProducer(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex);
+
+		/*!
+			Informs the MultiAudio that the order of machines has changed; it
+			uses this as an opportunity to switch speaker delegates as appropriate.
+		*/
+		void did_change_machine_order();
+
+		Outputs::Speaker::Speaker *get_speaker() final;
+
+	private:
+		MultiSpeaker *speaker_ = nullptr;
+};
+
+/*!
+	Provides a class that multiplexes the CRT machine interface to multiple machines.
+
+	Keeps a reference to the original vector of machines; will access it only after
+	acquiring a supplied mutex. The owner should also call did_change_machine_order()
+	if the order of machines changes.
+*/
+
+}
+
+#endif /* MultiProducer_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -13,7 +13,7 @@ using namespace Analyser::Dynamic;
 MultiSpeaker *MultiSpeaker::create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
 	std::vector<Outputs::Speaker::Speaker *> speakers;
 	for(const auto &machine: machines) {
-		Outputs::Speaker::Speaker *speaker = machine->crt_machine()->get_speaker();
+		Outputs::Speaker::Speaker *speaker = machine->audio_producer()->get_speaker();
 		if(speaker) speakers.push_back(speaker);
 	}
 	if(speakers.empty()) return nullptr;
@@ -34,43 +34,59 @@ float MultiSpeaker::get_ideal_clock_rate_in_range(float minimum, float maximum)
 		ideal += speaker->get_ideal_clock_rate_in_range(minimum, maximum);
 	}
 
-	return ideal / static_cast<float>(speakers_.size());
+	return ideal / float(speakers_.size());
 }
 
-void MultiSpeaker::set_output_rate(float cycles_per_second, int buffer_size) {
+void MultiSpeaker::set_computed_output_rate(float cycles_per_second, int buffer_size, bool stereo) {
+	stereo_output_ = stereo;
 	for(const auto &speaker: speakers_) {
-		speaker->set_output_rate(cycles_per_second, buffer_size);
+		speaker->set_computed_output_rate(cycles_per_second, buffer_size, stereo);
 	}
 }
 
-void MultiSpeaker::set_delegate(Outputs::Speaker::Speaker::Delegate *delegate) {
-	delegate_ = delegate;
+bool MultiSpeaker::get_is_stereo() {
+	// Return as stereo if any subspeaker is stereo.
+	for(const auto &speaker: speakers_) {
+		if(speaker->get_is_stereo()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void MultiSpeaker::set_output_volume(float volume) {
+	for(const auto &speaker: speakers_) {
+		speaker->set_output_volume(volume);
+	}
 }
 
 void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) {
-	if(!delegate_) return;
+	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	if(!delegate) return;
 	{
-		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		std::lock_guard lock_guard(front_speaker_mutex_);
 		if(speaker != front_speaker_) return;
 	}
-	delegate_->speaker_did_complete_samples(this, buffer);
+	did_complete_samples(this, buffer, stereo_output_);
 }
 
 void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
-	if(!delegate_) return;
+	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	if(!delegate) return;
 	{
-		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		std::lock_guard lock_guard(front_speaker_mutex_);
 		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 *machine) {
 	{
-		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
-		front_speaker_ = machine->crt_machine()->get_speaker();
+		std::lock_guard lock_guard(front_speaker_mutex_);
+		front_speaker_ = machine->audio_producer()->get_speaker();
 	}
-	if(delegate_) {
-		delegate_->speaker_did_change_input_clock(this);
+	auto delegate = delegate_.load(std::memory_order::memory_order_relaxed);
+	if(delegate) {
+		delegate->speaker_did_change_input_clock(this);
 	}
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -16,8 +16,7 @@
 #include <mutex>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes calls to and from Outputs::Speaker::Speaker in order
@@ -39,21 +38,22 @@ class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker:
 
 		// Below is the standard Outputs::Speaker::Speaker interface; see there for documentation.
 		float get_ideal_clock_rate_in_range(float minimum, float maximum) override;
-		void set_output_rate(float cycles_per_second, int buffer_size) override;
-		void set_delegate(Outputs::Speaker::Speaker::Delegate *delegate) override;
+		void set_computed_output_rate(float cycles_per_second, int buffer_size, bool stereo) override;
+		bool get_is_stereo() override;
+		void set_output_volume(float) override;
 
 	private:
-		void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) override;
-		void speaker_did_change_input_clock(Speaker *speaker) override;
+		void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) final;
+		void speaker_did_change_input_clock(Speaker *speaker) final;
 		MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers);
 
 		std::vector<Outputs::Speaker::Speaker *> speakers_;
 		Outputs::Speaker::Speaker *front_speaker_ = nullptr;
-		Outputs::Speaker::Speaker::Delegate *delegate_ = nullptr;
 		std::mutex front_speaker_mutex_;
+
+		bool stereo_output_ = false;
 };
 
-}
 }
 
 #endif /* MultiSpeaker_hpp */

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -7,6 +7,7 @@
 //
 
 #include "MultiMachine.hpp"
+#include "../../../Outputs/Log.hpp"
 
 #include <algorithm>
 
@@ -15,85 +16,70 @@ using namespace Analyser::Dynamic;
 MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines) :
 	machines_(std::move(machines)),
 	configurable_(machines_),
-	configuration_target_(machines_),
-	crt_machine_(machines_, machines_mutex_),
-	joystick_machine_(machines),
-	keyboard_machine_(machines_) {
-	crt_machine_.set_delegate(this);
+	timed_machine_(machines_, machines_mutex_),
+	scan_producer_(machines_, machines_mutex_),
+	audio_producer_(machines_, machines_mutex_),
+	joystick_machine_(machines_),
+	keyboard_machine_(machines_),
+	media_target_(machines_) {
+	timed_machine_.set_delegate(this);
 }
 
 Activity::Source *MultiMachine::activity_source() {
 	return nullptr; // TODO
 }
 
-ConfigurationTarget::Machine *MultiMachine::configuration_target() {
-	if(has_picked_) {
-		return machines_.front()->configuration_target();
-	} else {
-		return &configuration_target_;
+#define Provider(type, name, member)	\
+	type *MultiMachine::name() {	\
+		if(has_picked_) {	\
+			return machines_.front()->name();	\
+		} else {	\
+			return &member;	\
+		}	\
 	}
+
+Provider(Configurable::Device, configurable_device, configurable_)
+Provider(MachineTypes::TimedMachine, timed_machine, timed_machine_)
+Provider(MachineTypes::ScanProducer, scan_producer, scan_producer_)
+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_)
+
+MachineTypes::MouseMachine *MultiMachine::mouse_machine() {
+	// TODO.
+	return nullptr;
 }
 
-CRTMachine::Machine *MultiMachine::crt_machine() {
-	if(has_picked_) {
-		return machines_.front()->crt_machine();
-	} else {
-		return &crt_machine_;
-	}
-}
-
-JoystickMachine::Machine *MultiMachine::joystick_machine() {
-	if(has_picked_) {
-		return machines_.front()->joystick_machine();
-	} else {
-		return &joystick_machine_;
-	}
-}
-
-KeyboardMachine::Machine *MultiMachine::keyboard_machine() {
-	if(has_picked_) {
-		return machines_.front()->keyboard_machine();
-	} else {
-		return &keyboard_machine_;
-	}
-}
-
-Configurable::Device *MultiMachine::configurable_device() {
-	if(has_picked_) {
-		return machines_.front()->configurable_device();
-	} else {
-		return &configurable_;
-	}
-}
+#undef Provider
 
 bool MultiMachine::would_collapse(const std::vector<std::unique_ptr<DynamicMachine>> &machines) {
 	return
-		(machines.front()->crt_machine()->get_confidence() > 0.9f) ||
-		(machines.front()->crt_machine()->get_confidence() >= 2.0f * machines[1]->crt_machine()->get_confidence());
+		(machines.front()->timed_machine()->get_confidence() > 0.9f) ||
+		(machines.front()->timed_machine()->get_confidence() >= 2.0f * machines[1]->timed_machine()->get_confidence());
 }
 
-void MultiMachine::multi_crt_did_run_machines() {
-	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
-#ifdef DEBUG
+void MultiMachine::did_run_machines(MultiTimedMachine *) {
+	std::lock_guard machines_lock(machines_mutex_);
+#ifndef NDEBUG
 	for(const auto &machine: machines_) {
-		CRTMachine::Machine *crt = machine->crt_machine();
-		printf("%0.2f ", crt->get_confidence());
-		crt->print_type();
-		printf("; ");
+		auto timed_machine = machine->timed_machine();
+		LOGNBR(PADHEX(2) << timed_machine->get_confidence() << " " << timed_machine->debug_type() << "; ");
 	}
-	printf("\n");
+	LOGNBR(std::endl);
 #endif
 
 	DynamicMachine *front = machines_.front().get();
 	std::stable_sort(machines_.begin(), machines_.end(),
 		[] (const std::unique_ptr<DynamicMachine> &lhs, const std::unique_ptr<DynamicMachine> &rhs){
-			CRTMachine::Machine *lhs_crt = lhs->crt_machine();
-			CRTMachine::Machine *rhs_crt = rhs->crt_machine();
-			return lhs_crt->get_confidence() > rhs_crt->get_confidence();
+			auto lhs_timed = lhs->timed_machine();
+			auto rhs_timed = rhs->timed_machine();
+			return lhs_timed->get_confidence() > rhs_timed->get_confidence();
 		});
 
 	if(machines_.front().get() != front) {
-		crt_machine_.did_change_machine_order();
+		scan_producer_.did_change_machine_order();
+		audio_producer_.did_change_machine_order();
 	}
 
 	if(would_collapse(machines_)) {
@@ -103,9 +89,28 @@ void MultiMachine::multi_crt_did_run_machines() {
 
 void MultiMachine::pick_first() {
 	has_picked_ = true;
+
+	// Ensure output rate specifics are properly copied; these may be set only once by the owner,
+	// but rather than being propagated directly by the MultiSpeaker only the derived computed
+	// output rate is propagated. So this ensures that if a new derivation is made, it's made correctly.
+	if(machines_[0]->audio_producer()) {
+		auto multi_speaker = audio_producer_.get_speaker();
+		auto specific_speaker = machines_[0]->audio_producer()->get_speaker();
+
+		if(specific_speaker && multi_speaker) {
+			specific_speaker->copy_output_rate(*multi_speaker);
+		}
+	}
+
+	// TODO: because it is not invalid for a caller to keep a reference to anything previously returned,
+	// this erase can be added only once the Multi machines that take static copies of the machines list
+	// are updated.
+	//
+	// Example failing use case otherwise: a caller still has reference to the MultiJoystickMachine, and
+	// it has dangling references to the various JoystickMachines.
+	//
+	// This gets into particularly long grass with the MultiConfigurable and its MultiStruct.
 //	machines_.erase(machines_.begin() + 1, machines_.end());
-	// TODO: this isn't quite correct, because it may leak OpenGL/etc resources through failure to
-	// request a close_output while the context is active.
 }
 
 void *MultiMachine::raw_pointer() {

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -11,18 +11,18 @@
 
 #include "../../../Machines/DynamicMachine.hpp"
 
+#include "Implementation/MultiProducer.hpp"
 #include "Implementation/MultiConfigurable.hpp"
-#include "Implementation/MultiConfigurationTarget.hpp"
-#include "Implementation/MultiCRTMachine.hpp"
+#include "Implementation/MultiProducer.hpp"
 #include "Implementation/MultiJoystickMachine.hpp"
 #include "Implementation/MultiKeyboardMachine.hpp"
+#include "Implementation/MultiMediaTarget.hpp"
 
 #include <memory>
 #include <mutex>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides the same interface as to a single machine, while multiplexing all
@@ -38,7 +38,7 @@ namespace Dynamic {
 	If confidence for any machine becomes disproportionately low compared to
 	the others in the set, that machine stops running.
 */
-class MultiMachine: public ::Machine::DynamicMachine, public MultiCRTMachine::Delegate {
+class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::Delegate {
 	public:
 		/*!
 			Allows a potential MultiMachine creator to enquire as to whether there's any benefit in
@@ -50,31 +50,35 @@ class MultiMachine: public ::Machine::DynamicMachine, public MultiCRTMachine::De
 		static bool would_collapse(const std::vector<std::unique_ptr<DynamicMachine>> &machines);
 		MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines);
 
-		Activity::Source *activity_source() override;
-		ConfigurationTarget::Machine *configuration_target() override;
-		CRTMachine::Machine *crt_machine() override;
-		JoystickMachine::Machine *joystick_machine() override;
-		KeyboardMachine::Machine *keyboard_machine() override;
-		Configurable::Device *configurable_device() override;
-		void *raw_pointer() override;
+		Activity::Source *activity_source() final;
+		Configurable::Device *configurable_device() final;
+		MachineTypes::TimedMachine *timed_machine() final;
+		MachineTypes::ScanProducer *scan_producer() final;
+		MachineTypes::AudioProducer *audio_producer() final;
+		MachineTypes::JoystickMachine *joystick_machine() final;
+		MachineTypes::KeyboardMachine *keyboard_machine() final;
+		MachineTypes::MouseMachine *mouse_machine() final;
+		MachineTypes::MediaTarget *media_target() final;
+		void *raw_pointer() final;
 
 	private:
-		void multi_crt_did_run_machines() override;
+		void did_run_machines(MultiTimedMachine *) final;
 
 		std::vector<std::unique_ptr<DynamicMachine>> machines_;
-		std::mutex machines_mutex_;
+		std::recursive_mutex machines_mutex_;
 
 		MultiConfigurable configurable_;
-		MultiConfigurationTarget configuration_target_;
-		MultiCRTMachine crt_machine_;
+		MultiTimedMachine timed_machine_;
+		MultiScanProducer scan_producer_;
+		MultiAudioProducer audio_producer_;
 		MultiJoystickMachine joystick_machine_;
 		MultiKeyboardMachine keyboard_machine_;
+		MultiMediaTarget media_target_;
 
 		void pick_first();
 		bool has_picked_ = false;
 };
 
-}
 }
 
 #endif /* MultiMachine_hpp */

Analyser/Machines.hpp

@@ -14,13 +14,20 @@ namespace Analyser {
 enum class Machine {
 	AmstradCPC,
 	AppleII,
+	AppleIIgs,
 	Atari2600,
+	AtariST,
+	Amiga,
 	ColecoVision,
 	Electron,
+	Enterprise,
+	Macintosh,
+	MasterSystem,
 	MSX,
 	Oric,
 	Vic20,
-	ZX8081
+	ZX8081,
+	ZXSpectrum,
 };
 
 }

Analyser/Static/Acorn/Disk.cpp

@@ -10,7 +10,7 @@
 
 #include "../../../Storage/Disk/Controller/DiskController.hpp"
 #include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
-#include "../../../NumberTheory/CRC.hpp"
+#include "../../../Numeric/CRC.hpp"
 
 #include <algorithm>
 
@@ -18,11 +18,11 @@ 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
-	std::unique_ptr<Catalogue> catalogue(new Catalogue);
+	auto catalogue = std::make_unique<Catalogue>();
 	Storage::Encodings::MFM::Parser parser(false, disk);
 
-	Storage::Encodings::MFM::Sector *names = parser.get_sector(0, 0, 0);
-	Storage::Encodings::MFM::Sector *details = parser.get_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;
@@ -48,18 +48,21 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 		char name[10];
 		snprintf(name, 10, "%c.%.7s", names->samples[0][file_offset + 7] & 0x7f, &names->samples[0][file_offset]);
 		new_file.name = name;
-		new_file.load_address = (uint32_t)(details->samples[0][file_offset] | (details->samples[0][file_offset+1] << 8) | ((details->samples[0][file_offset+6]&0x0c) << 14));
-		new_file.execution_address = (uint32_t)(details->samples[0][file_offset+2] | (details->samples[0][file_offset+3] << 8) | ((details->samples[0][file_offset+6]&0xc0) << 10));
-		new_file.is_protected = !!(names->samples[0][file_offset + 7] & 0x80);
+		new_file.load_address = uint32_t(details->samples[0][file_offset] | (details->samples[0][file_offset+1] << 8) | ((details->samples[0][file_offset+6]&0x0c) << 14));
+		new_file.execution_address = uint32_t(details->samples[0][file_offset+2] | (details->samples[0][file_offset+3] << 8) | ((details->samples[0][file_offset+6]&0xc0) << 10));
+		if(names->samples[0][file_offset + 7] & 0x80) {
+			// File is locked; it may not be altered or deleted.
+			new_file.flags |= File::Flags::Locked;
+		}
 
-		long data_length = static_cast<long>(details->samples[0][file_offset+4] | (details->samples[0][file_offset+5] << 8) | ((details->samples[0][file_offset+6]&0x30) << 12));
+		long data_length = long(details->samples[0][file_offset+4] | (details->samples[0][file_offset+5] << 8) | ((details->samples[0][file_offset+6]&0x30) << 12));
 		int start_sector = details->samples[0][file_offset+7] | ((details->samples[0][file_offset+6]&0x03) << 8);
-		new_file.data.reserve(static_cast<std::size_t>(data_length));
+		new_file.data.reserve(size_t(data_length));
 
 		if(start_sector < 2) continue;
 		while(data_length > 0) {
-			uint8_t sector = static_cast<uint8_t>(start_sector % 10);
-			uint8_t track = static_cast<uint8_t>(start_sector / 10);
+			uint8_t sector = uint8_t(start_sector % 10);
+			uint8_t track = uint8_t(start_sector / 10);
 			start_sector++;
 
 			Storage::Encodings::MFM::Sector *next_sector = parser.get_sector(0, track, sector);
@@ -69,13 +72,18 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 			new_file.data.insert(new_file.data.end(), next_sector->samples[0].begin(), next_sector->samples[0].begin() + length_from_sector);
 			data_length -= length_from_sector;
 		}
-		if(!data_length) catalogue->files.push_back(new_file);
+		if(!data_length) catalogue->files.push_back(std::move(new_file));
 	}
 
 	return catalogue;
 }
+
+/*
+	Primary resource used: "Acorn 8-Bit ADFS Filesystem Structure";
+	http://mdfs.net/Docs/Comp/Disk/Format/ADFS
+*/
 std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
-	std::unique_ptr<Catalogue> catalogue(new Catalogue);
+	auto catalogue = std::make_unique<Catalogue>();
 	Storage::Encodings::MFM::Parser parser(true, disk);
 
 	Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.get_sector(0, 0, 1);
@@ -84,7 +92,7 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::
 	std::vector<uint8_t> root_directory;
 	root_directory.reserve(5 * 256);
 	for(uint8_t c = 2; c < 7; c++) {
-		Storage::Encodings::MFM::Sector *sector = parser.get_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());
 	}
@@ -101,5 +109,73 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::
 		case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
 	}
 
+	// Parse the root directory, at least.
+	for(std::size_t file_offset = 0x005; file_offset < 0x4cb; file_offset += 0x1a) {
+		// Obtain the name, which will be at most ten characters long, and will
+		// be terminated by either a NULL character or a \r.
+		char name[11];
+		std::size_t c = 0;
+		for(; c < 10; c++) {
+			const char next = root_directory[file_offset + c] & 0x7f;
+			name[c] = next;
+			if(next == '\0' || next == '\r') break;
+		}
+		name[c] = '\0';
+
+		// Skip if the name is empty.
+		if(name[0] == '\0') continue;
+
+		// Populate a file then.
+		File new_file;
+		new_file.name = name;
+		new_file.flags =
+			(root_directory[file_offset + 0] & 0x80 ? File::Flags::Readable : 0) |
+			(root_directory[file_offset + 1] & 0x80 ? File::Flags::Writable : 0) |
+			(root_directory[file_offset + 2] & 0x80 ? File::Flags::Locked : 0) |
+			(root_directory[file_offset + 3] & 0x80 ? File::Flags::IsDirectory : 0) |
+			(root_directory[file_offset + 4] & 0x80 ? File::Flags::ExecuteOnly : 0) |
+			(root_directory[file_offset + 5] & 0x80 ? File::Flags::PubliclyReadable : 0) |
+			(root_directory[file_offset + 6] & 0x80 ? File::Flags::PubliclyWritable : 0) |
+			(root_directory[file_offset + 7] & 0x80 ? File::Flags::PubliclyExecuteOnly : 0) |
+			(root_directory[file_offset + 8] & 0x80 ? File::Flags::IsPrivate : 0);
+
+		new_file.load_address =
+			(uint32_t(root_directory[file_offset + 0x0a]) << 0) |
+			(uint32_t(root_directory[file_offset + 0x0b]) << 8) |
+			(uint32_t(root_directory[file_offset + 0x0c]) << 16) |
+			(uint32_t(root_directory[file_offset + 0x0d]) << 24);
+
+		new_file.execution_address =
+			(uint32_t(root_directory[file_offset + 0x0e]) << 0) |
+			(uint32_t(root_directory[file_offset + 0x0f]) << 8) |
+			(uint32_t(root_directory[file_offset + 0x10]) << 16) |
+			(uint32_t(root_directory[file_offset + 0x11]) << 24);
+
+		new_file.sequence_number = root_directory[file_offset + 0x19];
+
+		const uint32_t size =
+			(uint32_t(root_directory[file_offset + 0x12]) << 0) |
+			(uint32_t(root_directory[file_offset + 0x13]) << 8) |
+			(uint32_t(root_directory[file_offset + 0x14]) << 16) |
+			(uint32_t(root_directory[file_offset + 0x15]) << 24);
+
+		uint32_t start_sector =
+			(uint32_t(root_directory[file_offset + 0x16]) << 0) |
+			(uint32_t(root_directory[file_offset + 0x17]) << 8) |
+			(uint32_t(root_directory[file_offset + 0x18]) << 16);
+
+		new_file.data.reserve(size);
+		while(new_file.data.size() < size) {
+			const Storage::Encodings::MFM::Sector *const sector = parser.get_sector(start_sector / (80 * 16), (start_sector / 16) % 80, start_sector % 16);
+			if(!sector) break;
+
+			const auto length_from_sector = std::min(size - new_file.data.size(), sector->samples[0].size());
+			new_file.data.insert(new_file.data.end(), sector->samples[0].begin(), sector->samples[0].begin() + ssize_t(length_from_sector));
+			++start_sector;
+		}
+
+		catalogue->files.push_back(std::move(new_file));
+	}
+
 	return catalogue;
 }

Analyser/Static/Acorn/Disk.hpp

@@ -12,9 +12,7 @@
 #include "File.hpp"
 #include "../../../Storage/Disk/Disk.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 /// Describes a DFS- or ADFS-format catalogue(/directory): the list of files available and the catalogue's boot option.
 struct Catalogue {
@@ -31,8 +29,6 @@ struct Catalogue {
 std::unique_ptr<Catalogue> GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 std::unique_ptr<Catalogue> GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
-}
-}
 }
 
 #endif /* Disk_hpp */

Analyser/Static/Acorn/File.hpp

@@ -13,25 +13,42 @@
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 struct File {
 	std::string name;
-	uint32_t load_address;
-	uint32_t execution_address;
-	bool is_protected;
+	uint32_t load_address = 0;
+	uint32_t execution_address = 0;
+
+	enum Flags: uint16_t {
+		Readable = 1 << 0,
+		Writable = 1 << 1,
+		Locked = 1 << 2,
+		IsDirectory = 1 << 3,
+		ExecuteOnly = 1 << 4,
+		PubliclyReadable = 1 << 5,
+		PubliclyWritable = 1 << 6,
+		PubliclyExecuteOnly = 1 << 7,
+		IsPrivate = 1 << 8,
+	};
+	uint16_t flags = Flags::Readable | Flags::Readable | Flags::PubliclyReadable | Flags::PubliclyWritable;
+	uint8_t sequence_number = 0;
+
 	std::vector<uint8_t> data;
 
+	/// Describes a single chunk of file data; these relate to the tape and ROM filing system.
+	/// The File-level fields contain a 'definitive' version of the load and execution addresses,
+	/// but both of those filing systems also store them per chunk.
+	///
+	/// Similarly, the file-level data will contain the aggregate data of all chunks.
 	struct Chunk {
 		std::string name;
-		uint32_t load_address;
-		uint32_t execution_address;
-		uint16_t block_number;
-		uint16_t block_length;
-		uint8_t block_flag;
-		uint32_t next_address;
+		uint32_t load_address = 0;
+		uint32_t execution_address = 0;
+		uint16_t block_number = 0;
+		uint16_t block_length = 0;
+		uint32_t next_address = 0;
+		uint8_t block_flag = 0;
 
 		bool header_crc_matched;
 		bool data_crc_matched;
@@ -41,8 +58,6 @@ struct File {
 	std::vector<Chunk> chunks;
 };
 
-}
-}
 }
 
 #endif /* File_hpp */

Analyser/Static/Acorn/StaticAnalyser.cpp

@@ -12,6 +12,8 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 
+#include <algorithm>
+
 using namespace Analyser::Static::Acorn;
 
 static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
@@ -29,7 +31,7 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 		if(segment.data.size() != 0x4000 && segment.data.size() != 0x2000) continue;
 
 		// is a copyright string present?
-		uint8_t copyright_offset = segment.data[7];
+		const uint8_t copyright_offset = segment.data[7];
 		if(
 			segment.data[copyright_offset] != 0x00 ||
 			segment.data[copyright_offset+1] != 0x28 ||
@@ -57,35 +59,30 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	return acorn_cartridges;
 }
 
-Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
-	std::unique_ptr<Target> target(new Target);
-	target->machine = Machine::Electron;
-	target->confidence = 0.5; // TODO: a proper estimation
-	target->has_dfs = false;
-	target->has_adfs = false;
-	target->should_shift_restart = false;
+Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	auto target = std::make_unique<Target>();
 
 	// strip out inappropriate cartridges
 	target->media.cartridges = AcornCartridgesFrom(media.cartridges);
 
 	// if there are any tapes, attempt to get data from the first
-	if(media.tapes.size() > 0) {
+	if(!media.tapes.empty()) {
 		std::shared_ptr<Storage::Tape::Tape> tape = media.tapes.front();
 		std::vector<File> files = GetFiles(tape);
 		tape->reset();
 
 		// continue if there are any files
-		if(files.size()) {
+		if(!files.empty()) {
 			bool is_basic = true;
 
-			// protected files are always for *RUNning only
-			if(files.front().is_protected) is_basic = false;
+			// If a file is execute-only, that means *RUN.
+			if(files.front().flags & File::Flags::ExecuteOnly) is_basic = false;
 
 			// check also for a continuous threading of BASIC lines; if none then this probably isn't BASIC code,
 			// so that's also justification to *RUN
 			std::size_t pointer = 0;
-			uint8_t *data = &files.front().data[0];
-			std::size_t data_size = files.front().data.size();
+			uint8_t *const data = &files.front().data[0];
+			const std::size_t data_size = files.front().data.size();
 			while(1) {
 				if(pointer >= data_size-1 || data[pointer] != 13) {
 					is_basic = false;
@@ -103,21 +100,66 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &me
 		}
 	}
 
-	if(media.disks.size() > 0) {
+	if(!media.disks.empty()) {
 		std::shared_ptr<Storage::Disk::Disk> disk = media.disks.front();
 		std::unique_ptr<Catalogue> dfs_catalogue, adfs_catalogue;
 		dfs_catalogue = GetDFSCatalogue(disk);
 		if(dfs_catalogue == nullptr) adfs_catalogue = GetADFSCatalogue(disk);
 		if(dfs_catalogue || adfs_catalogue) {
+			// Accept the disk and determine whether DFS or ADFS ROMs are implied.
+			// Use the Pres ADFS if using an ADFS, as it leaves Page at &EOO.
 			target->media.disks = media.disks;
-			target->has_dfs = !!dfs_catalogue;
-			target->has_adfs = !!adfs_catalogue;
+			target->has_dfs = bool(dfs_catalogue);
+			target->has_pres_adfs = bool(adfs_catalogue);
 
+			// Check whether a simple shift+break will do for loading this disk.
 			Catalogue::BootOption bootOption = (dfs_catalogue ?: adfs_catalogue)->bootOption;
-			if(bootOption != Catalogue::BootOption::None)
+			if(bootOption != Catalogue::BootOption::None) {
 				target->should_shift_restart = true;
-			else
+			} else {
 				target->loading_command = "*CAT\n";
+			}
+
+			// Check whether adding the AP6 ROM is justified.
+			// For now this is an incredibly dense text search;
+			// if any of the commands that aren't usually present
+			// on a stock Electron are here, add the AP6 ROM and
+			// some sideways RAM such that the SR commands are useful.
+			for(const auto &file: dfs_catalogue ? dfs_catalogue->files : adfs_catalogue->files) {
+				for(const auto &command: {
+					"AQRPAGE", "BUILD", "DUMP", "FORMAT", "INSERT", "LANG", "LIST", "LOADROM",
+					"LOCK", "LROMS", "RLOAD", "ROMS", "RSAVE", "SAVEROM", "SRLOAD", "SRPAGE",
+					"SRUNLOCK", "SRWIPE", "TUBE", "TYPE", "UNLOCK", "UNPLUG", "UROMS",
+					"VERIFY", "ZERO"
+				}) {
+					if(std::search(file.data.begin(), file.data.end(), command, command+strlen(command)) != file.data.end()) {
+						target->has_ap6_rom = true;
+						target->has_sideways_ram = true;
+					}
+				}
+			}
+		}
+	}
+
+	// Enable the Acorn ADFS if a mass-storage device is attached;
+	// unlike the Pres ADFS it retains SCSI logic.
+	if(!media.mass_storage_devices.empty()) {
+		target->has_pres_adfs = false;	// To override a floppy selection, if one was made.
+		target->has_acorn_adfs = true;
+
+		// Assume some sort of later-era Acorn work is likely to happen;
+		// so ensure *TYPE, etc are present.
+		target->has_ap6_rom = true;
+		target->has_sideways_ram = true;
+
+		target->media.mass_storage_devices = media.mass_storage_devices;
+
+		// Check for a boot option.
+		const auto sector = target->media.mass_storage_devices.front()->get_block(1);
+		if(sector[0xfd]) {
+			target->should_shift_restart = true;
+		} else {
+			target->loading_command = "*CAT\n";
 		}
 	}
 

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
 
-}
-}
 }
 
 #endif /* AcornAnalyser_hpp */

Analyser/Static/Acorn/Tape.cpp

@@ -10,17 +10,17 @@
 
 #include <deque>
 
-#include "../../../NumberTheory/CRC.hpp"
+#include "../../../Numeric/CRC.hpp"
 #include "../../../Storage/Tape/Parsers/Acorn.hpp"
 
 using namespace Analyser::Static::Acorn;
 
 static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::Tape::Tape> &tape, Storage::Tape::Acorn::Parser &parser) {
-	std::unique_ptr<File::Chunk> new_chunk(new File::Chunk);
+	auto new_chunk = std::make_unique<File::Chunk>();
 	int shift_register = 0;
 
 // TODO: move this into the parser
-#define shift()	shift_register = (shift_register >> 1) |  (parser.get_next_bit(tape) << 9)
+#define shift()	shift_register = (shift_register >> 1) | (parser.get_next_bit(tape) << 9)
 
 	// find next area of high tone
 	while(!tape->is_at_end() && (shift_register != 0x3ff)) {
@@ -41,24 +41,24 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 	char name[11];
 	std::size_t name_ptr = 0;
 	while(!tape->is_at_end() && name_ptr < sizeof(name)) {
-		name[name_ptr] = (char)parser.get_next_byte(tape);
+		name[name_ptr] = char(parser.get_next_byte(tape));
 		if(!name[name_ptr]) break;
-		name_ptr++;
+		++name_ptr;
 	}
 	name[sizeof(name)-1] = '\0';
 	new_chunk->name = name;
 
 	// addresses
-	new_chunk->load_address = (uint32_t)parser.get_next_word(tape);
-	new_chunk->execution_address = (uint32_t)parser.get_next_word(tape);
-	new_chunk->block_number = static_cast<uint16_t>(parser.get_next_short(tape));
-	new_chunk->block_length = static_cast<uint16_t>(parser.get_next_short(tape));
-	new_chunk->block_flag = static_cast<uint8_t>(parser.get_next_byte(tape));
-	new_chunk->next_address = (uint32_t)parser.get_next_word(tape);
+	new_chunk->load_address = uint32_t(parser.get_next_word(tape));
+	new_chunk->execution_address = uint32_t(parser.get_next_word(tape));
+	new_chunk->block_number = uint16_t(parser.get_next_short(tape));
+	new_chunk->block_length = uint16_t(parser.get_next_short(tape));
+	new_chunk->block_flag = uint8_t(parser.get_next_byte(tape));
+	new_chunk->next_address = uint32_t(parser.get_next_word(tape));
 
 	uint16_t calculated_header_crc = parser.get_crc();
-	uint16_t stored_header_crc = static_cast<uint16_t>(parser.get_next_short(tape));
-	stored_header_crc = static_cast<uint16_t>((stored_header_crc >> 8) | (stored_header_crc << 8));
+	uint16_t stored_header_crc = uint16_t(parser.get_next_short(tape));
+	stored_header_crc = uint16_t((stored_header_crc >> 8) | (stored_header_crc << 8));
 	new_chunk->header_crc_matched = stored_header_crc == calculated_header_crc;
 
 	if(!new_chunk->header_crc_matched) return nullptr;
@@ -66,13 +66,13 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 	parser.reset_crc();
 	new_chunk->data.reserve(new_chunk->block_length);
 	for(int c = 0; c < new_chunk->block_length; c++) {
-		new_chunk->data.push_back(static_cast<uint8_t>(parser.get_next_byte(tape)));
+		new_chunk->data.push_back(uint8_t(parser.get_next_byte(tape)));
 	}
 
 	if(new_chunk->block_length && !(new_chunk->block_flag&0x40)) {
 		uint16_t calculated_data_crc = parser.get_crc();
-		uint16_t stored_data_crc = static_cast<uint16_t>(parser.get_next_short(tape));
-		stored_data_crc = static_cast<uint16_t>((stored_data_crc >> 8) | (stored_data_crc << 8));
+		uint16_t stored_data_crc = uint16_t(parser.get_next_short(tape));
+		stored_data_crc = uint16_t((stored_data_crc >> 8) | (stored_data_crc << 8));
 		new_chunk->data_crc_matched = stored_data_crc == calculated_data_crc;
 	} else {
 		new_chunk->data_crc_matched = true;
@@ -90,7 +90,7 @@ static std::unique_ptr<File> GetNextFile(std::deque<File::Chunk> &chunks) {
 	if(!chunks.size()) return nullptr;
 
 	// accumulate chunks for as long as block number is sequential and the end-of-file bit isn't set
-	std::unique_ptr<File> file(new File);
+	auto file = std::make_unique<File>();
 
 	uint16_t block_number = 0;
 
@@ -109,7 +109,12 @@ static std::unique_ptr<File> GetNextFile(std::deque<File::Chunk> &chunks) {
 	file->name = file->chunks.front().name;
 	file->load_address = file->chunks.front().load_address;
 	file->execution_address = file->chunks.front().execution_address;
-	file->is_protected = !!(file->chunks.back().block_flag & 0x01);	// I think the last flags are the ones that count; TODO: check.
+	// I think the final chunk's flags are the ones that count; TODO: check.
+	if(file->chunks.back().block_flag & 0x01) {
+		// File is locked, which in more generalised terms means it is
+		// for execution only.
+		file->flags |= File::Flags::ExecuteOnly;
+	}
 
 	// copy all data into a single big block
 	for(File::Chunk chunk : file->chunks) {

Analyser/Static/Acorn/Tape.hpp

@@ -14,14 +14,10 @@
 #include "File.hpp"
 #include "../../../Storage/Tape/Tape.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
-}
-}
 }
 
 #endif /* Tape_hpp */

Analyser/Static/Acorn/Target.hpp

@@ -9,22 +9,32 @@
 #ifndef Analyser_Static_Acorn_Target_h
 #define Analyser_Static_Acorn_Target_h
 
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
-struct Target: public ::Analyser::Static::Target {
-	bool has_adfs = false;
+struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	bool has_acorn_adfs = false;
+	bool has_pres_adfs = false;
 	bool has_dfs = false;
+	bool has_ap6_rom = false;
+	bool has_sideways_ram = false;
 	bool should_shift_restart = false;
 	std::string loading_command;
+
+	Target() : Analyser::Static::Target(Machine::Electron) {
+		if(needs_declare()) {
+			DeclareField(has_pres_adfs);
+			DeclareField(has_acorn_adfs);
+			DeclareField(has_dfs);
+			DeclareField(has_ap6_rom);
+			DeclareField(has_sideways_ram);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Acorn_Target_h */

Analyser/Static/Amiga/StaticAnalyser.cpp

@@ -0,0 +1,25 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 16/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::Amiga::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	// This analyser can comprehend disks and mass-storage devices only.
+	if(media.disks.empty()) return {};
+
+	// As there is at least one usable media image, wave it through.
+	Analyser::Static::TargetList targets;
+
+	using Target = Analyser::Static::Amiga::Target;
+	auto *const target = new Target();
+	target->media = media;
+	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
+
+	return targets;
+}

Analyser/Static/Amiga/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 16/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Amiga_StaticAnalyser_hpp
+#define Analyser_Static_Amiga_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,44 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 16/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Amiga_Target_h
+#define Analyser_Static_Amiga_Target_h
+
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::Amiga {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(ChipRAM,
+		FiveHundredAndTwelveKilobytes,
+		OneMegabyte,
+		TwoMegabytes);
+	ReflectableEnum(FastRAM,
+		None,
+		OneMegabyte,
+		TwoMegabytes,
+		FourMegabytes,
+		EightMegabytes);
+
+	ChipRAM chip_ram = ChipRAM::FiveHundredAndTwelveKilobytes;
+	FastRAM fast_ram = FastRAM::EightMegabytes;
+
+	Target() : Analyser::Static::Target(Machine::Amiga) {
+		if(needs_declare()) {
+			DeclareField(fast_ram);
+			DeclareField(chip_ram);
+			AnnounceEnum(FastRAM);
+			AnnounceEnum(ChipRAM);
+		}
+	}
+};
+
+}
+
+#endif /* Analyser_Static_Amiga_Target_h */

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -11,12 +11,15 @@
 #include <algorithm>
 #include <cstring>
 
-#include "Target.hpp"
-
 #include "../../../Storage/Disk/Parsers/CPM.hpp"
 #include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "../../../Storage/Tape/Parsers/Spectrum.hpp"
 
-static bool strcmp_insensitive(const char *a, const char *b) {
+#include "Target.hpp"
+
+namespace {
+
+bool strcmp_insensitive(const char *a, const char *b) {
 	if(std::strlen(a) != std::strlen(b)) return false;
 	while(*a) {
 		if(std::tolower(*a) != std::tolower(*b)) return false;
@@ -26,20 +29,20 @@ static bool strcmp_insensitive(const char *a, const char *b) {
 	return true;
 }
 
-static bool is_implied_extension(const std::string &extension) {
+bool is_implied_extension(const std::string &extension) {
 	return
 		extension == "   " ||
 		strcmp_insensitive(extension.c_str(), "BAS") ||
 		strcmp_insensitive(extension.c_str(), "BIN");
 }
 
-static void right_trim(std::string &string) {
+void right_trim(std::string &string) {
 	string.erase(std::find_if(string.rbegin(), string.rend(), [](int ch) {
 		return !std::isspace(ch);
 	}).base(), string.end());
 }
 
-static std::string RunCommandFor(const Storage::Disk::CPM::File &file) {
+std::string RunCommandFor(const Storage::Disk::CPM::File &file) {
 	// Trim spaces from the name.
 	std::string name = file.name;
 	right_trim(name);
@@ -58,7 +61,7 @@ static std::string RunCommandFor(const Storage::Disk::CPM::File &file) {
 	return command + "\n";
 }
 
-static void InspectCatalogue(
+void InspectCatalogue(
 	const Storage::Disk::CPM::Catalogue &catalogue,
 	const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
 
@@ -155,7 +158,7 @@ static void InspectCatalogue(
 	target->loading_command = "cat\n";
 }
 
-static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
+bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
 	Storage::Encodings::MFM::Parser parser(true, disk);
 	Storage::Encodings::MFM::Sector *boot_sector = parser.get_sector(0, 0, 0x41);
 	if(boot_sector != nullptr && !boot_sector->samples.empty() && boot_sector->samples[0].size() == 512) {
@@ -179,22 +182,49 @@ static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, co
 	return false;
 }
 
-Analyser::Static::TargetList Analyser::Static::AmstradCPC::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+bool IsAmstradTape(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	// Limited sophistication here; look for a CPC-style file header, that is
+	// any Spectrum-esque block with a synchronisation character of 0x2c.
+	//
+	// More could be done here: parse the header, look for 0x16 data records.
+	using Parser = Storage::Tape::ZXSpectrum::Parser;
+	Parser parser(Parser::MachineType::AmstradCPC);
+
+	while(true) {
+		const auto block = parser.find_block(tape);
+		if(!block) break;
+
+		if(block->type == 0x2c) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+} // namespace
+
+Analyser::Static::TargetList Analyser::Static::AmstradCPC::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	TargetList destination;
-	std::unique_ptr<Target> target(new Target);
-	target->machine = Machine::AmstradCPC;
+	auto target = std::make_unique<Target>();
 	target->confidence = 0.5;
 
 	target->model = Target::Model::CPC6128;
 
 	if(!media.tapes.empty()) {
-		// TODO: which of these are actually potentially CPC tapes?
-		target->media.tapes = media.tapes;
+		bool has_cpc_tape = false;
+		for(auto &tape: media.tapes) {
+			has_cpc_tape |= IsAmstradTape(tape);
+		}
 
-		// Ugliness flows here: assume the CPC isn't smart enough to pause between pressing
-		// enter and responding to the follow-on prompt to press a key, so just type for
-		// a while. Yuck!
-		target->loading_command = "|tape\nrun\"\n1234567890";
+		if(has_cpc_tape) {
+			target->media.tapes = media.tapes;
+
+			// Ugliness flows here: assume the CPC isn't smart enough to pause between pressing
+			// enter and responding to the follow-on prompt to press a key, so just type for
+			// a while. Yuck!
+			target->loading_command = "|tape\nrun\"\n123";
+		}
 	}
 
 	if(!media.disks.empty()) {

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace AmstradCPC {
+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

@@ -9,27 +9,26 @@
 #ifndef Analyser_Static_AmstradCPC_Target_h
 #define Analyser_Static_AmstradCPC_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace AmstradCPC {
-
-struct Target: public ::Analyser::Static::Target {
-	enum class Model {
-		CPC464,
-		CPC664,
-		CPC6128
-	};
+namespace Analyser::Static::AmstradCPC {
 
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model, CPC464, CPC664, CPC6128);
 	Model model = Model::CPC464;
 	std::string loading_command;
+
+	Target() : Analyser::Static::Target(Machine::AmstradCPC) {
+		if(needs_declare()) {
+			DeclareField(model);
+			AnnounceEnum(Model);
+		}
+	}
 };
 
 }
-}
-}
-
 
 #endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/AppleII/StaticAnalyser.cpp

@@ -9,13 +9,21 @@
 #include "StaticAnalyser.hpp"
 #include "Target.hpp"
 
-Analyser::Static::TargetList Analyser::Static::AppleII::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
-	auto target = std::unique_ptr<Target>(new Target);
-	target->machine = Machine::AppleII;
+Analyser::Static::TargetList Analyser::Static::AppleII::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	auto target = std::make_unique<Target>();
 	target->media = media;
 
-	if(!target->media.disks.empty())
+	// If any disks are present, attach a Disk II.
+	if(!target->media.disks.empty()) {
 		target->disk_controller = Target::DiskController::SixteenSector;
+	}
+
+	// The emulated SCSI card requires a IIe, so upgrade to that if
+	// any mass storage is present.
+	if(!target->media.mass_storage_devices.empty()) {
+		target->model = Target::Model::EnhancedIIe;
+		target->scsi_controller = Target::SCSIController::AppleSCSI;
+	}
 
 	TargetList targets;
 	targets.push_back(std::move(target));

Analyser/Static/AppleII/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace AppleII {
+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,32 +6,49 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Target_h
-#define Target_h
+#ifndef Analyser_Static_AppleII_Target_h
+#define Analyser_Static_AppleII_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace AppleII {
+namespace Analyser::Static::AppleII {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class Model {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model,
 		II,
-		IIplus
-	};
-	enum class DiskController {
+		IIplus,
+		IIe,
+		EnhancedIIe
+	);
+	ReflectableEnum(DiskController,
 		None,
 		SixteenSector,
 		ThirteenSector
-	};
+	);
+	ReflectableEnum(SCSIController,
+		None,
+		AppleSCSI
+	);
 
-	Model model = Model::IIplus;
+	Model model = Model::IIe;
 	DiskController disk_controller = DiskController::None;
+	SCSIController scsi_controller = SCSIController::None;
+
+	Target() : Analyser::Static::Target(Machine::AppleII) {
+		if(needs_declare()) {
+			DeclareField(model);
+			DeclareField(disk_controller);
+			DeclareField(scsi_controller);
+
+			AnnounceEnum(Model);
+			AnnounceEnum(DiskController);
+			AnnounceEnum(SCSIController);
+		}
+	}
 };
 
-}
-}
 }
 
-#endif /* Target_h */
+#endif /* Analyser_Static_AppleII_Target_h */

Analyser/Static/AppleIIgs/StaticAnalyser.cpp

@@ -0,0 +1,19 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/10/2020.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::AppleIIgs::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	auto target = std::make_unique<Target>();
+	target->media = media;
+
+	TargetList targets;
+	targets.push_back(std::move(target));
+	return targets;
+}

Analyser/Static/AppleIIgs/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/10/2020.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AppleIIgs_StaticAnalyser_hpp
+#define Analyser_Static_AppleIIgs_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,45 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/10/2020.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AppleIIgs_Target_h
+#define Analyser_Static_AppleIIgs_Target_h
+
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::AppleIIgs {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model,
+		ROM00,
+		ROM01,
+		ROM03
+	);
+	ReflectableEnum(MemoryModel,
+		TwoHundredAndFiftySixKB,
+		OneMB,
+		EightMB
+	);
+
+	Model model = Model::ROM01;
+	MemoryModel memory_model = MemoryModel::EightMB;
+
+	Target() : Analyser::Static::Target(Machine::AppleIIgs) {
+		if(needs_declare()) {
+			DeclareField(model);
+			DeclareField(memory_model);
+			AnnounceEnum(Model);
+			AnnounceEnum(MemoryModel);
+		}
+	}
+};
+
+}
+
+#endif /* Analyser_Static_AppleIIgs_Target_h */

Analyser/Static/Atari2600/StaticAnalyser.cpp

@@ -12,27 +12,26 @@
 
 #include "../Disassembler/6502.hpp"
 
-using namespace Analyser::Static::Atari;
+using namespace Analyser::Static::Atari2600;
+using Target = Analyser::Static::Atari2600::Target;
 
-static void DeterminePagingFor2kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
-	// if this is a 2kb cartridge then it's definitely either unpaged or a CommaVid
-	uint16_t entry_address, break_address;
+static void DeterminePagingFor2kCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+	// If this is a 2kb cartridge then it's definitely either unpaged or a CommaVid.
+	const uint16_t entry_address = uint16_t(segment.data[0x7fc] | (segment.data[0x7fd] << 8)) & 0x1fff;
+	const uint16_t break_address = uint16_t(segment.data[0x7fe] | (segment.data[0x7ff] << 8)) & 0x1fff;
 
-	entry_address = (static_cast<uint16_t>(segment.data[0x7fc] | (segment.data[0x7fd] << 8))) & 0x1fff;
-	break_address = (static_cast<uint16_t>(segment.data[0x7fe] | (segment.data[0x7ff] << 8))) & 0x1fff;
-
-	// a CommaVid start address needs to be outside of its RAM
+	// A CommaVid start address needs to be outside of its RAM.
 	if(entry_address < 0x1800 || break_address < 0x1800) return;
 
 	std::function<std::size_t(uint16_t address)> high_location_mapper = [](uint16_t address) {
 		address &= 0x1fff;
-		return static_cast<std::size_t>(address - 0x1800);
+		return size_t(address - 0x1800);
 	};
 	Analyser::Static::MOS6502::Disassembly high_location_disassembly =
 		Analyser::Static::MOS6502::Disassemble(segment.data, high_location_mapper, {entry_address, break_address});
 
-	// assume that any kind of store that looks likely to be intended for large amounts of memory implies
-	// large amounts of memory
+	// Assume that any kind of store that looks likely to be intended for large amounts of memory implies
+	// large amounts of memory.
 	bool has_wide_area_store = false;
 	for(std::map<uint16_t, Analyser::Static::MOS6502::Instruction>::value_type &entry : high_location_disassembly.instructions_by_address) {
 		if(entry.second.operation == Analyser::Static::MOS6502::Instruction::STA) {
@@ -44,28 +43,28 @@ static void DeterminePagingFor2kCartridge(Analyser::Static::Atari::Target &targe
 		}
 	}
 
-	// conclude that this is a CommaVid if it attempted to write something to the CommaVid RAM locations;
+	// Conclude that this is a CommaVid if it attempted to write something to the CommaVid RAM locations;
 	// caveat: false positives aren't likely to be problematic; a false positive is a 2KB ROM that always addresses
 	// itself so as to land in ROM even if mapped as a CommaVid and this code is on the fence as to whether it
-	// attempts to modify itself but it probably doesn't
-	if(has_wide_area_store) target.paging_model = Analyser::Static::Atari::Target::PagingModel::CommaVid;
+	// attempts to modify itself but it probably doesn't.
+	if(has_wide_area_store) target.paging_model = Target::PagingModel::CommaVid;
 }
 
-static void DeterminePagingFor8kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
+static void DeterminePagingFor8kCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	// Activision stack titles have their vectors at the top of the low 4k, not the top, and
 	// always list 0xf000 as both vectors; they do not repeat them, and, inexplicably, they all
-	// issue an SEI as their first instruction (maybe some sort of relic of the development environment?)
+	// issue an SEI as their first instruction (maybe some sort of relic of the development environment?).
 	if(
 		segment.data[4095] == 0xf0 && segment.data[4093] == 0xf0 && segment.data[4094] == 0x00 && segment.data[4092] == 0x00 &&
 		(segment.data[8191] != 0xf0 || segment.data[8189] != 0xf0 || segment.data[8190] != 0x00 || segment.data[8188] != 0x00) &&
 		segment.data[0] == 0x78
 	) {
-		target.paging_model = Analyser::Static::Atari::Target::PagingModel::ActivisionStack;
+		target.paging_model = Target::PagingModel::ActivisionStack;
 		return;
 	}
 
-	// make an assumption that this is the Atari paging model
-	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari8k;
+	// Make an assumption that this is the Atari paging model.
+	target.paging_model = Target::PagingModel::Atari8k;
 
 	std::set<uint16_t> internal_accesses;
 	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
@@ -85,13 +84,13 @@ static void DeterminePagingFor8kCartridge(Analyser::Static::Atari::Target &targe
 		tigervision_access_count += masked_address == 0x3f;
 	}
 
-	if(parker_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::ParkerBros;
-	else if(tigervision_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
+	if(parker_access_count > atari_access_count) target.paging_model = Target::PagingModel::ParkerBros;
+	else if(tigervision_access_count > atari_access_count) target.paging_model = Target::PagingModel::Tigervision;
 }
 
-static void DeterminePagingFor16kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
-	// make an assumption that this is the Atari paging model
-	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari16k;
+static void DeterminePagingFor16kCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &, const Analyser::Static::MOS6502::Disassembly &disassembly) {
+	// Make an assumption that this is the Atari paging model.
+	target.paging_model = Target::PagingModel::Atari16k;
 
 	std::set<uint16_t> internal_accesses;
 	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
@@ -106,33 +105,31 @@ static void DeterminePagingFor16kCartridge(Analyser::Static::Atari::Target &targ
 		mnetwork_access_count += masked_address >= 0x1fe0 && masked_address < 0x1ffb;
 	}
 
-	if(mnetwork_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::MNetwork;
+	if(mnetwork_access_count > atari_access_count) target.paging_model = Target::PagingModel::MNetwork;
 }
 
-static void DeterminePagingFor64kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
-	// make an assumption that this is a Tigervision if there is a write to 3F
+static void DeterminePagingFor64kCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &, const Analyser::Static::MOS6502::Disassembly &disassembly) {
+	// Make an assumption that this is a Tigervision if there is a write to 3F.
 	target.paging_model =
 		(disassembly.external_stores.find(0x3f) != disassembly.external_stores.end()) ?
-			Analyser::Static::Atari::Target::PagingModel::Tigervision : Analyser::Static::Atari::Target::PagingModel::MegaBoy;
+			Target::PagingModel::Tigervision : Target::PagingModel::MegaBoy;
 }
 
-static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+static void DeterminePagingForCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
 	if(segment.data.size() == 2048) {
 		DeterminePagingFor2kCartridge(target, segment);
 		return;
 	}
 
-	uint16_t entry_address, break_address;
-
-	entry_address = static_cast<uint16_t>(segment.data[segment.data.size() - 4] | (segment.data[segment.data.size() - 3] << 8));
-	break_address = static_cast<uint16_t>(segment.data[segment.data.size() - 2] | (segment.data[segment.data.size() - 1] << 8));
+	const uint16_t entry_address = uint16_t(segment.data[segment.data.size() - 4] | (segment.data[segment.data.size() - 3] << 8));
+	const uint16_t break_address = uint16_t(segment.data[segment.data.size() - 2] | (segment.data[segment.data.size() - 1] << 8));
 
 	std::function<std::size_t(uint16_t address)> address_mapper = [](uint16_t address) {
-		if(!(address & 0x1000)) return static_cast<std::size_t>(-1);
-		return static_cast<std::size_t>(address & 0xfff);
+		if(!(address & 0x1000)) return size_t(-1);
+		return size_t(address & 0xfff);
 	};
 
-	std::vector<uint8_t> final_4k(segment.data.end() - 4096, segment.data.end());
+	const std::vector<uint8_t> final_4k(segment.data.end() - 4096, segment.data.end());
 	Analyser::Static::MOS6502::Disassembly disassembly = Analyser::Static::MOS6502::Disassemble(final_4k, address_mapper, {entry_address, break_address});
 
 	switch(segment.data.size()) {
@@ -140,16 +137,16 @@ static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target,
 			DeterminePagingFor8kCartridge(target, segment, disassembly);
 		break;
 		case 10495:
-			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Pitfall2;
+			target.paging_model = Target::PagingModel::Pitfall2;
 		break;
 		case 12288:
-			target.paging_model = Analyser::Static::Atari::Target::PagingModel::CBSRamPlus;
+			target.paging_model = Target::PagingModel::CBSRamPlus;
 		break;
 		case 16384:
 			DeterminePagingFor16kCartridge(target, segment, disassembly);
 		break;
 		case 32768:
-			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari32k;
+			target.paging_model = Target::PagingModel::Atari32k;
 		break;
 		case 65536:
 			DeterminePagingFor64kCartridge(target, segment, disassembly);
@@ -158,11 +155,11 @@ static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target,
 		break;
 	}
 
-	// check for a Super Chip. Atari ROM images [almost] always have the same value stored over RAM
+	// Check for a Super Chip. Atari ROM images [almost] always have the same value stored over RAM
 	// regions; when they don't they at least seem to have the first 128 bytes be the same as the
 	// next 128 bytes. So check for that.
-	if(	target.paging_model != Analyser::Static::Atari::Target::PagingModel::CBSRamPlus &&
-		target.paging_model != Analyser::Static::Atari::Target::PagingModel::MNetwork) {
+	if(	target.paging_model != Target::PagingModel::CBSRamPlus &&
+		target.paging_model != Target::PagingModel::MNetwork) {
 		bool has_superchip = true;
 		for(std::size_t address = 0; address < 128; address++) {
 			if(segment.data[address] != segment.data[address+128]) {
@@ -173,20 +170,19 @@ static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target,
 		target.uses_superchip = has_superchip;
 	}
 
-	// check for a Tigervision or Tigervision-esque scheme
-	if(target.paging_model == Analyser::Static::Atari::Target::PagingModel::None && segment.data.size() > 4096) {
+	// Check for a Tigervision or Tigervision-esque scheme
+	if(target.paging_model == Target::PagingModel::None && segment.data.size() > 4096) {
 		bool looks_like_tigervision = disassembly.external_stores.find(0x3f) != disassembly.external_stores.end();
-		if(looks_like_tigervision) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
+		if(looks_like_tigervision) target.paging_model = Target::PagingModel::Tigervision;
 	}
 }
 
-Analyser::Static::TargetList Analyser::Static::Atari::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::Atari2600::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	// TODO: sanity checking; is this image really for an Atari 2600?
-	std::unique_ptr<Analyser::Static::Atari::Target> target(new Analyser::Static::Atari::Target);
-	target->machine = Machine::Atari2600;
+	auto target = std::make_unique<Target>();
 	target->confidence = 0.5;
 	target->media.cartridges = media.cartridges;
-	target->paging_model = Analyser::Static::Atari::Target::PagingModel::None;
+	target->paging_model = Target::PagingModel::None;
 	target->uses_superchip = false;
 
 	// try to figure out the paging scheme

Analyser/Static/Atari2600/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Atari {
+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,14 +6,12 @@
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef Analyser_Static_Atari_Target_h
-#define Analyser_Static_Atari_Target_h
+#ifndef Analyser_Static_Atari2600_Target_h
+#define Analyser_Static_Atari2600_Target_h
 
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Atari {
+namespace Analyser::Static::Atari2600 {
 
 struct Target: public ::Analyser::Static::Target {
 	enum class PagingModel {
@@ -34,10 +32,10 @@ struct Target: public ::Analyser::Static::Target {
 	// TODO: shouldn't these be properties of the cartridge?
 	PagingModel paging_model = PagingModel::None;
 	bool uses_superchip = false;
+
+	Target() : Analyser::Static::Target(Machine::Atari2600) {}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/AtariST/StaticAnalyser.cpp

@@ -0,0 +1,25 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/10/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::AtariST::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	// This analyser can comprehend disks and mass-storage devices only.
+	if(media.disks.empty()) return {};
+
+	// As there is at least one usable media image, wave it through.
+	Analyser::Static::TargetList targets;
+
+	using Target = Analyser::Static::AtariST::Target;
+	auto *const target = new Target();
+	target->media = media;
+	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
+
+	return targets;
+}

Analyser/Static/AtariST/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/10/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AtariST_StaticAnalyser_hpp
+#define Analyser_Static_AtariST_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,34 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/06/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AtariST_Target_h
+#define Analyser_Static_AtariST_Target_h
+
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::AtariST {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(MemorySize,
+		FiveHundredAndTwelveKilobytes,
+		OneMegabyte,
+		FourMegabytes);
+	MemorySize memory_size = MemorySize::OneMegabyte;
+
+	Target() : Analyser::Static::Target(Machine::AtariST) {
+		if(needs_declare()) {
+			DeclareField(memory_size);
+			AnnounceEnum(MemorySize);
+		}
+	}
+};
+
+}
+
+#endif /* Analyser_Static_AtariST_Target_h */

Analyser/Static/Coleco/StaticAnalyser.cpp

@@ -17,45 +17,44 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 
 		// only one mapped item is allowed
 		if(segments.size() != 1) continue;
-
-		// which must be 8, 12, 16, 24 or 32 kb in size
 		const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
 		const std::size_t data_size = segment.data.size();
-		const std::size_t overflow = data_size&8191;
-		if(overflow > 8 && overflow != 512 && (data_size != 12*1024)) continue;
-		if(data_size < 8192) continue;
 
 		// the two bytes that will be first must be 0xaa and 0x55, either way around
 		auto *start = &segment.data[0];
-		if((data_size & static_cast<std::size_t>(~8191)) > 32768) {
+		if((data_size & size_t(~8191)) > 32768) {
 			start = &segment.data[segment.data.size() - 16384];
 		}
 		if(start[0] != 0xaa && start[0] != 0x55 && start[1] != 0xaa && start[1] != 0x55) continue;
 		if(start[0] == start[1]) continue;
 
 		// probability of a random binary blob that isn't a Coleco ROM proceeding to here is 1 - 1/32768.
-		if(!overflow) {
-			coleco_cartridges.push_back(cartridge);
+
+		// Round up to the next multiple of 8kb if this image is less than 32kb. Otherwise round down if
+		// this image is within a short distance of 32kb.
+		std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
+
+		size_t target_size;
+		if(data_size >= 32*1024 && data_size < 32*1024 + 512) {
+			target_size = 32 * 1024;
 		} else {
-			// Size down to a multiple of 8kb and apply the start address.
-			std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
-
-			std::vector<uint8_t> truncated_data;
-			std::vector<uint8_t>::difference_type truncated_size = static_cast<std::vector<uint8_t>::difference_type>(segment.data.size()) & ~8191;
-			truncated_data.insert(truncated_data.begin(), segment.data.begin(), segment.data.begin() + truncated_size);
-			output_segments.emplace_back(0x8000, truncated_data);
-
-			coleco_cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
+			target_size = data_size + ((8192 - (data_size & 8191)) & 8191);
 		}
+
+		std::vector<uint8_t> truncated_data;
+		truncated_data = segment.data;
+		truncated_data.resize(target_size);
+		output_segments.emplace_back(0x8000, truncated_data);
+
+		coleco_cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
 	}
 
 	return coleco_cartridges;
 }
 
-Analyser::Static::TargetList Analyser::Static::Coleco::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::Coleco::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	TargetList targets;
-	std::unique_ptr<Target> target(new Target);
-	target->machine = Machine::ColecoVision;
+	auto target = std::make_unique<Target>(Machine::ColecoVision);
 	target->confidence = 1.0f - 1.0f / 32768.0f;
 	target->media.cartridges = ColecoCartridgesFrom(media.cartridges);
 	if(!target->media.empty())

Analyser/Static/Coleco/StaticAnalyser.hpp

@@ -13,15 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Coleco {
+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

@@ -19,12 +19,10 @@ using namespace Analyser::Static::Commodore;
 
 class CommodoreGCRParser: public Storage::Disk::Controller {
 	public:
-		std::shared_ptr<Storage::Disk::Drive> drive;
-
 		CommodoreGCRParser() : Storage::Disk::Controller(4000000), shift_register_(0), track_(1) {
-			drive.reset(new Storage::Disk::Drive(4000000, 300, 2));
-			set_drive(drive);
-			drive->set_motor_on(true);
+			emplace_drive(4000000, 300, 2);
+			set_drive(1);
+			get_drive().set_motor_on(true);
 		}
 
 		struct Sector {
@@ -40,7 +38,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 			@returns a sector if one was found; @c nullptr otherwise.
 		*/
 		std::shared_ptr<Sector> get_sector(uint8_t track, uint8_t sector) {
-			int difference = static_cast<int>(track) - static_cast<int>(track_);
+			int difference = int(track) - int(track_);
 			track_ = track;
 
 			if(difference) {
@@ -61,6 +59,10 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 			return get_sector(sector);
 		}
 
+		void set_disk(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+			get_drive().set_disk(disk);
+		}
+
 	private:
 		unsigned int shift_register_;
 		int index_count_;
@@ -69,7 +71,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		std::shared_ptr<Sector> sector_cache_[65536];
 
 		void process_input_bit(int value) {
-			shift_register_ = ((shift_register_ << 1) | static_cast<unsigned int>(value)) & 0x3ff;
+			shift_register_ = ((shift_register_ << 1) | unsigned(value)) & 0x3ff;
 			bit_count_++;
 		}
 
@@ -110,22 +112,22 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 
 		std::shared_ptr<Sector> get_sector(uint8_t sector) {
-			uint16_t sector_address = static_cast<uint16_t>((track_ << 8) | sector);
+			const uint16_t sector_address = uint16_t((track_ << 8) | sector);
 			if(sector_cache_[sector_address]) return sector_cache_[sector_address];
 
-			std::shared_ptr<Sector> first_sector = get_next_sector();
+			const std::shared_ptr<Sector> first_sector = get_next_sector();
 			if(!first_sector) return first_sector;
 			if(first_sector->sector == sector) return first_sector;
 
 			while(1) {
-				std::shared_ptr<Sector> next_sector = get_next_sector();
+				const std::shared_ptr<Sector> next_sector = get_next_sector();
 				if(next_sector->sector == first_sector->sector) return nullptr;
 				if(next_sector->sector == sector) return next_sector;
 			}
 		}
 
 		std::shared_ptr<Sector> get_next_sector() {
-			std::shared_ptr<Sector> sector(new Sector);
+			auto sector = std::make_shared<Sector>();
 			const int max_index_count = index_count_ + 2;
 
 			while(index_count_ < max_index_count) {
@@ -136,12 +138,12 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 				}
 
 				// get sector details, skip if this looks malformed
-				uint8_t checksum = static_cast<uint8_t>(get_next_byte());
-				sector->sector = static_cast<uint8_t>(get_next_byte());
-				sector->track = static_cast<uint8_t>(get_next_byte());
+				uint8_t checksum = uint8_t(get_next_byte());
+				sector->sector = uint8_t(get_next_byte());
+				sector->track = uint8_t(get_next_byte());
 				uint8_t disk_id[2];
-				disk_id[0] = static_cast<uint8_t>(get_next_byte());
-				disk_id[1] = static_cast<uint8_t>(get_next_byte());
+				disk_id[0] = uint8_t(get_next_byte());
+				disk_id[1] = uint8_t(get_next_byte());
 				if(checksum != (sector->sector ^ sector->track ^ disk_id[0] ^ disk_id[1])) continue;
 
 				// look for the following data
@@ -152,12 +154,12 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 				checksum = 0;
 				for(std::size_t c = 0; c < 256; c++) {
-					sector->data[c] = static_cast<uint8_t>(get_next_byte());
+					sector->data[c] = uint8_t(get_next_byte());
 					checksum ^= sector->data[c];
 				}
 
 				if(checksum == get_next_byte()) {
-					uint16_t sector_address = static_cast<uint16_t>((sector->track << 8) | sector->sector);
+					uint16_t sector_address = uint16_t((sector->track << 8) | sector->sector);
 					sector_cache_[sector_address] = sector;
 					return sector;
 				}
@@ -170,7 +172,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	std::vector<File> files;
 	CommodoreGCRParser parser;
-	parser.drive->set_disk(disk);
+	parser.set_disk(disk);
 
 	// find any sector whatsoever to establish the current track
 	std::shared_ptr<CommodoreGCRParser::Sector> sector;
@@ -190,7 +192,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 	}
 
 	// parse directory
-	std::size_t header_pointer = static_cast<std::size_t>(-32);
+	std::size_t header_pointer = size_t(-32);
 	while(header_pointer+32+31 < directory.size()) {
 		header_pointer += 32;
 
@@ -214,7 +216,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 		}
 		new_file.name = Storage::Data::Commodore::petscii_from_bytes(&new_file.raw_name[0], 16, false);
 
-		std::size_t number_of_sectors = static_cast<std::size_t>(directory[header_pointer + 0x1e]) + (static_cast<std::size_t>(directory[header_pointer + 0x1f]) << 8);
+		std::size_t number_of_sectors = size_t(directory[header_pointer + 0x1e]) + (size_t(directory[header_pointer + 0x1f]) << 8);
 		new_file.data.reserve((number_of_sectors - 1) * 254 + 252);
 
 		bool is_first_sector = true;
@@ -225,7 +227,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 			next_track = sector->data[0];
 			next_sector = sector->data[1];
 
-			if(is_first_sector) new_file.starting_address = static_cast<uint16_t>(sector->data[2]) | static_cast<uint16_t>(sector->data[3] << 8);
+			if(is_first_sector) new_file.starting_address = uint16_t(sector->data[2]) | uint16_t(sector->data[3] << 8);
 			if(next_track)
 				new_file.data.insert(new_file.data.end(), sector->data.begin() + (is_first_sector ? 4 : 2), sector->data.end());
 			else

Analyser/Static/Commodore/Disk.hpp

@@ -14,14 +14,10 @@
 
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+namespace Analyser::Static::Commodore {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
-}
-}
 }
 
 #endif /* Disk_hpp */

Analyser/Static/Commodore/File.cpp

@@ -23,7 +23,7 @@ bool Analyser::Static::Commodore::File::is_basic() {
 	//		... null-terminated code ...
 	//	(with a next line address of 0000 indicating end of program)
 	while(1) {
-		if(static_cast<size_t>(line_address - starting_address) >= data.size() + 2) break;
+		if(size_t(line_address - starting_address) >= data.size() + 2) break;
 
 		uint16_t next_line_address = data[line_address - starting_address];
 		next_line_address |= data[line_address - starting_address + 1] << 8;
@@ -33,13 +33,13 @@ bool Analyser::Static::Commodore::File::is_basic() {
 		}
 		if(next_line_address < line_address + 5) break;
 
-		if(static_cast<size_t>(line_address - starting_address) >= data.size() + 5) break;
+		if(size_t(line_address - starting_address) >= data.size() + 5) break;
 		uint16_t next_line_number = data[line_address - starting_address + 2];
 		next_line_number |= data[line_address - starting_address + 3] << 8;
 
 		if(next_line_number <= line_number) break;
 
-		line_number = static_cast<uint16_t>(next_line_number);
+		line_number = uint16_t(next_line_number);
 		line_address = next_line_address;
 	}
 

Analyser/Static/Commodore/File.hpp

@@ -9,12 +9,11 @@
 #ifndef File_hpp
 #define File_hpp
 
+#include <cstdint>
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+namespace Analyser::Static::Commodore {
 
 struct File {
 	std::wstring name;
@@ -35,8 +34,6 @@ struct File {
 	bool is_basic();
 };
 
-}
-}
 }
 
 #endif /* File_hpp */

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -13,8 +13,10 @@
 #include "Tape.hpp"
 #include "Target.hpp"
 #include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
+#include "../../../Outputs/Log.hpp"
 
 #include <algorithm>
+#include <cstring>
 #include <sstream>
 
 using namespace Analyser::Static::Commodore;
@@ -40,10 +42,10 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	return vic20_cartridges;
 }
 
-Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType) {
 	TargetList destination;
 
-	std::unique_ptr<Target> target(new Target);
+	auto target = std::make_unique<Target>();
 	target->machine = Machine::Vic20;	// TODO: machine estimation
 	target->confidence = 0.5; // TODO: a proper estimation
 
@@ -77,10 +79,10 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 	}
 
 	if(!files.empty()) {
-		target->memory_model = Target::MemoryModel::Unexpanded;
+		auto memory_model = Target::MemoryModel::Unexpanded;
 		std::ostringstream string_stream;
 		string_stream << "LOAD\"" << (is_disk ? "*" : "") << "\"," << device << ",";
-  		if(files.front().is_basic()) {
+		if(files.front().is_basic()) {
 			string_stream << "0";
 		} else {
 			string_stream << "1";
@@ -91,18 +93,21 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 		// make a first guess based on loading address
 		switch(files.front().starting_address) {
 			default:
-				printf("Starting address %04x?\n", files.front().starting_address);
+				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) << files.front().starting_address);
+				[[fallthrough]];
 			case 0x1001:
-				target->memory_model = Target::MemoryModel::Unexpanded;
+				memory_model = Target::MemoryModel::Unexpanded;
 			break;
 			case 0x1201:
-				target->memory_model = Target::MemoryModel::ThirtyTwoKB;
+				memory_model = Target::MemoryModel::ThirtyTwoKB;
 			break;
 			case 0x0401:
-				target->memory_model = Target::MemoryModel::EightKB;
+				memory_model = Target::MemoryModel::EightKB;
 			break;
 		}
 
+		target->set_memory_model(memory_model);
+
 		// General approach: increase memory size conservatively such that the largest file found will fit.
 //		for(File &file : files) {
 //			std::size_t file_size = file.data.size();
@@ -144,13 +149,52 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 	}
 
 	if(!target->media.empty()) {
-		// Inspect filename for a region hint.
+		// Inspect filename for configuration hints.
 		std::string lowercase_name = file_name;
 		std::transform(lowercase_name.begin(), lowercase_name.end(), lowercase_name.begin(), ::tolower);
+
+		// Hint 1: 'ntsc' anywhere in the name implies America.
 		if(lowercase_name.find("ntsc") != std::string::npos) {
 			target->region = Analyser::Static::Commodore::Target::Region::American;
 		}
 
+		// Potential additional hints: check for TheC64 tags.
+		auto final_underscore = lowercase_name.find_last_of('_');
+		if(final_underscore != std::string::npos) {
+			auto iterator = lowercase_name.begin() + ssize_t(final_underscore) + 1;
+
+			while(iterator != lowercase_name.end()) {
+				// Grab the next tag.
+				char next_tag[3] = {0, 0, 0};
+				next_tag[0] = *iterator++;
+				if(iterator == lowercase_name.end()) break;
+				next_tag[1] = *iterator++;
+
+				// Exit early if attempting to read another tag has run over the file extension.
+				if(next_tag[0] == '.' || next_tag[1] == '.') break;
+
+				// Check whether it's anything.
+				target->enabled_ram.bank0 |= !strcmp(next_tag, "b0");
+				target->enabled_ram.bank1 |= !strcmp(next_tag, "b1");
+				target->enabled_ram.bank2 |= !strcmp(next_tag, "b2");
+				target->enabled_ram.bank3 |= !strcmp(next_tag, "b3");
+				target->enabled_ram.bank5 |= !strcmp(next_tag, "b5");
+				if(!strcmp(next_tag, "tn")) {	// i.e. NTSC.
+					target->region = Analyser::Static::Commodore::Target::Region::American;
+				}
+				if(!strcmp(next_tag, "tp")) {	// i.e. PAL.
+					target->region = Analyser::Static::Commodore::Target::Region::European;
+				}
+
+				// Unhandled:
+				//
+				//	M6:		this is a C64 file.
+				//	MV:		this is a Vic-20 file.
+				//	J1/J2:	this C64 file should have the primary joystick in slot 1/2.
+				//	RO:		this disk image should be treated as read-only.
+			}
+		}
+
 		// Attach a 1540 if there are any disks here.
 		target->has_c1540 = !target->media.disks.empty();
 

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+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

@@ -12,14 +12,10 @@
 #include "../../../Storage/Tape/Tape.hpp"
 #include "File.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+namespace Analyser::Static::Commodore {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
-}
-}
 }
 
 #endif /* Tape_hpp */

Analyser/Static/Commodore/Target.hpp

@@ -9,36 +9,66 @@
 #ifndef Analyser_Static_Commodore_Target_h
 #define Analyser_Static_Commodore_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+namespace Analyser::Static::Commodore {
 
-struct Target: public ::Analyser::Static::Target {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	enum class MemoryModel {
 		Unexpanded,
 		EightKB,
 		ThirtyTwoKB
 	};
 
-	enum class Region {
+	ReflectableEnum(Region,
 		American,
 		Danish,
 		Japanese,
 		European,
 		Swedish
-	};
+	);
+
+	/// Maps from a named memory model to a bank enabled/disabled set.
+	void set_memory_model(MemoryModel memory_model) {
+		// This is correct for unexpanded and 32kb memory models.
+		enabled_ram.bank0 = enabled_ram.bank1 =
+		enabled_ram.bank2 = enabled_ram.bank3 =
+		enabled_ram.bank5 = memory_model == MemoryModel::ThirtyTwoKB;
+
+		// Bank 0 will need to be enabled if this is an 8kb machine.
+		enabled_ram.bank0 |= memory_model == MemoryModel::EightKB;
+	}
+	struct {
+		bool bank0 = false;
+		bool bank1 = false;
+		bool bank2 = false;
+		bool bank3 = false;
+		bool bank5 = false;
+					// Sic. There is no bank 4; this is because the area that logically would be
+					// bank 4 is occupied by the character ROM, colour RAM, hardware registers, etc.
+	} enabled_ram;
 
-	MemoryModel memory_model = MemoryModel::Unexpanded;
 	Region region = Region::European;
 	bool has_c1540 = false;
 	std::string loading_command;
+
+	Target() : Analyser::Static::Target(Machine::Vic20) {
+		if(needs_declare()) {
+			DeclareField(enabled_ram.bank0);
+			DeclareField(enabled_ram.bank1);
+			DeclareField(enabled_ram.bank2);
+			DeclareField(enabled_ram.bank3);
+			DeclareField(enabled_ram.bank5);
+			DeclareField(region);
+			DeclareField(has_c1540);
+			AnnounceEnum(Region);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.cpp

@@ -11,7 +11,7 @@
 #include "Kernel.hpp"
 
 using namespace Analyser::Static::MOS6502;
-namespace  {
+namespace {
 
 using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 
@@ -26,12 +26,12 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 
 		Instruction instruction;
 		instruction.address = address;
-		address++;
+		++address;
 
-		// get operation
-		uint8_t operation = memory[local_address];
+		// Get operation.
+		const uint8_t operation = memory[local_address];
 
-		// decode addressing mode
+		// Decode addressing mode.
 		switch(operation&0x1f) {
 			case 0x00:
 				if(operation >= 0x80) instruction.addressing_mode = Instruction::Immediate;
@@ -74,7 +74,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			break;
 		}
 
-		// decode operation
+		// Decode operation.
 #define RM_INSTRUCTION(base, op)	\
 	case base+0x09: case base+0x05: case base+0x15: case base+0x01: case base+0x11: case base+0x0d: case base+0x1d: case base+0x19:	\
 		instruction.operation = op;	\
@@ -222,14 +222,14 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 #undef M_INSTRUCTION
 #undef IM_INSTRUCTION
 
-		// get operand
+		// Get operand.
 		switch(instruction.addressing_mode) {
-			// zero-byte operands
+			// Zero-byte operands.
 			case Instruction::Implied:
 				instruction.operand = 0;
 			break;
 
-			// one-byte operands
+			// One-byte operands.
 			case Instruction::Immediate:
 			case Instruction::ZeroPage: case Instruction::ZeroPageX: case Instruction::ZeroPageY:
 			case Instruction::IndexedIndirectX: case Instruction::IndirectIndexedY:
@@ -242,7 +242,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			}
 			break;
 
-			// two-byte operands
+			// Two-byte operands.
 			case Instruction::Absolute: case Instruction::AbsoluteX: case Instruction::AbsoluteY:
 			case Instruction::Indirect: {
 				std::size_t low_operand_address = address_mapper(address);
@@ -250,18 +250,18 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 				if(low_operand_address >= memory.size() || high_operand_address >= memory.size()) return;
 				address += 2;
 
-				instruction.operand = memory[low_operand_address] | static_cast<uint16_t>(memory[high_operand_address] << 8);
+				instruction.operand = memory[low_operand_address] | uint16_t(memory[high_operand_address] << 8);
 			}
 			break;
 		}
 
-		// store the instruction away
+		// Store the instruction.
 		disassembly.disassembly.instructions_by_address[instruction.address] = instruction;
 
 		// TODO: something wider-ranging than this
 		if(instruction.addressing_mode == Instruction::Absolute || instruction.addressing_mode == Instruction::ZeroPage) {
-			std::size_t mapped_address = address_mapper(instruction.operand);
-			bool is_external = mapped_address >= memory.size();
+			const size_t mapped_address = address_mapper(instruction.operand);
+			const bool is_external = mapped_address >= memory.size();
 
 			switch(instruction.operation) {
 				default: break;
@@ -290,7 +290,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			}
 		}
 
-		// decide on overall flow control
+		// Decide on overall 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) {
@@ -302,7 +302,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			return;
 		}
 		if(instruction.addressing_mode == Instruction::Relative) {
-			uint16_t destination = static_cast<uint16_t>(address + (int8_t)instruction.operand);
+			uint16_t destination = uint16_t(address + int8_t(instruction.operand));
 			disassembly.remaining_entry_points.push_back(destination);
 		}
 	}

Analyser/Static/Disassembler/6502.hpp

@@ -16,9 +16,7 @@
 #include <set>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace MOS6502 {
+namespace Analyser::Static::MOS6502 {
 
 /*!
 	Describes a 6502 instruciton: its address, the operation it performs, its addressing mode
@@ -95,7 +93,5 @@ Disassembly Disassemble(
 	std::vector<uint16_t> entry_points);
 
 }
-}
-}
 
 #endif /* Disassembler6502_hpp */

Analyser/Static/Disassembler/AddressMapper.cpp

@@ -1,9 +0,0 @@
-//
-//  AddressMapper.cpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 30/12/2017.
-//  Copyright 2017 Thomas Harte. All rights reserved.
-//
-
-#include "AddressMapper.hpp"

Analyser/Static/Disassembler/AddressMapper.hpp

@@ -11,9 +11,7 @@
 
 #include <functional>
 
-namespace Analyser {
-namespace Static {
-namespace Disassembler {
+namespace Analyser::Static::Disassembler {
 
 /*!
 	Provides an address mapper that relocates a chunk of memory so that it starts at
@@ -21,12 +19,10 @@ namespace Disassembler {
 */
 template <typename T> std::function<std::size_t(T)> OffsetMapper(T start_address) {
 	return [start_address](T argument) {
-		return static_cast<std::size_t>(argument - start_address);
+		return size_t(argument - start_address);
 	};
 }
 
-}
-}
 }
 
 #endif /* AddressMapper_hpp */

Analyser/Static/Disassembler/Kernel.hpp

@@ -9,9 +9,7 @@
 #ifndef Kernel_hpp
 #define Kernel_hpp
 
-namespace Analyser {
-namespace Static {
-namespace Disassembly {
+namespace Analyser::Static::Disassembly {
 
 template <typename D, typename S> struct PartialDisassembly {
 	D disassembly;
@@ -45,8 +43,6 @@ template <typename D, typename S, typename Disassembler> D Disassemble(
 	return partial_disassembly.disassembly;
 }
 
-}
-}
 }
 
 #endif /* Kernel_hpp */

Analyser/Static/Disassembler/Z80.cpp

@@ -11,7 +11,7 @@
 #include "Kernel.hpp"
 
 using namespace Analyser::Static::Z80;
-namespace  {
+namespace {
 
 using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 
@@ -33,7 +33,7 @@ class Accessor {
 		uint16_t word() {
 			uint8_t low = byte();
 			uint8_t high = byte();
-			return static_cast<uint16_t>(low | (high << 8));
+			return uint16_t(low | (high << 8));
 		}
 
 		bool overrun() {
@@ -63,9 +63,9 @@ class Accessor {
 #define z(v) (v & 7)
 
 Instruction::Condition condition_table[] = {
-	Instruction::Condition::NZ, 	Instruction::Condition::Z,
-	Instruction::Condition::NC, 	Instruction::Condition::C,
-	Instruction::Condition::PO, 	Instruction::Condition::PE,
+	Instruction::Condition::NZ,		Instruction::Condition::Z,
+	Instruction::Condition::NC,		Instruction::Condition::C,
+	Instruction::Condition::PO,		Instruction::Condition::PE,
 	Instruction::Condition::P,		Instruction::Condition::M
 };
 
@@ -562,7 +562,7 @@ struct Z80Disassembler {
 			int access_type =
 				((instruction.source == Instruction::Location::Operand_Indirect) ? 1 : 0) |
 				((instruction.destination == Instruction::Location::Operand_Indirect) ? 2 : 0);
-			uint16_t address = static_cast<uint16_t>(instruction.operand);
+			uint16_t address = uint16_t(instruction.operand);
 			bool is_internal = address_mapper(address) < memory.size();
 			switch(access_type) {
 				default: break;
@@ -594,7 +594,7 @@ struct Z80Disassembler {
 				instruction.operation == Instruction::Operation::JR ||
 				instruction.operation == Instruction::Operation::CALL ||
 				instruction.operation == Instruction::Operation::RST) {
-				disassembly.remaining_entry_points.push_back(static_cast<uint16_t>(instruction.operand));
+				disassembly.remaining_entry_points.push_back(uint16_t(instruction.operand));
 			}
 
 			// This is it if: an unconditional RET, RETI, RETN, JP or JR is found.

Analyser/Static/Disassembler/Z80.hpp

@@ -15,9 +15,7 @@
 #include <set>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Z80 {
+namespace Analyser::Static::Z80 {
 
 struct Instruction {
 	/*! The address this instruction starts at. This is a mapped address. */
@@ -84,7 +82,5 @@ Disassembly Disassemble(
 	std::vector<uint16_t> entry_points);
 
 }
-}
-}
 
 #endif /* StaticAnalyser_Disassembler_Z80_hpp */

Analyser/Static/DiskII/StaticAnalyser.cpp

@@ -9,6 +9,7 @@
 #include "StaticAnalyser.hpp"
 
 #include "../AppleII/Target.hpp"
+#include "../AppleIIgs/Target.hpp"
 #include "../Oric/Target.hpp"
 #include "../Disassembler/6502.hpp"
 #include "../Disassembler/AddressMapper.hpp"
@@ -18,10 +19,9 @@
 
 namespace {
 
-Analyser::Static::Target *AppleTarget(const Storage::Encodings::AppleGCR::Sector *sector_zero) {
+Analyser::Static::Target *AppleIITarget(const Storage::Encodings::AppleGCR::Sector *sector_zero) {
 	using Target = Analyser::Static::AppleII::Target;
-	auto *target = new Target;
-	target->machine = Analyser::Machine::AppleII;
+	auto *const target = new Target;
 
 	if(sector_zero && sector_zero->encoding == Storage::Encodings::AppleGCR::Sector::Encoding::FiveAndThree) {
 		target->disk_controller = Target::DiskController::ThirteenSector;
@@ -32,10 +32,13 @@ Analyser::Static::Target *AppleTarget(const Storage::Encodings::AppleGCR::Sector
 	return target;
 }
 
-Analyser::Static::Target *OricTarget(const Storage::Encodings::AppleGCR::Sector *sector_zero) {
+Analyser::Static::Target *AppleIIgsTarget() {
+	return new Analyser::Static::AppleIIgs::Target();
+}
+
+Analyser::Static::Target *OricTarget(const Storage::Encodings::AppleGCR::Sector *) {
 	using Target = Analyser::Static::Oric::Target;
-	auto *target = new Target;
-	target->machine = Analyser::Machine::Oric;
+	auto *const target = new Target;
 	target->rom = Target::ROM::Pravetz;
 	target->disk_interface = Target::DiskInterface::Pravetz;
 	target->loading_command = "CALL 800\n";
@@ -44,13 +47,23 @@ Analyser::Static::Target *OricTarget(const Storage::Encodings::AppleGCR::Sector
 
 }
 
-Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	// This analyser can comprehend disks only.
 	if(media.disks.empty()) return {};
 
+	auto &disk = media.disks.front();
+	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)) {
+		targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleIIgsTarget()));
+		targets.back()->media = media;
+		return targets;
+	}
+
 	// Grab track 0, sector 0: the boot sector.
-	auto track_zero = media.disks.front()->get_track_at_position(Storage::Disk::Track::Address(0, Storage::Disk::HeadPosition(0)));
-	auto sector_map = Storage::Encodings::AppleGCR::sectors_from_segment(
+	const auto track_zero = disk->get_track_at_position(Storage::Disk::Track::Address(0, Storage::Disk::HeadPosition(0)));
+	const auto sector_map = Storage::Encodings::AppleGCR::sectors_from_segment(
 		Storage::Disk::track_serialisation(*track_zero, Storage::Time(1, 50000)));
 
 	const Storage::Encodings::AppleGCR::Sector *sector_zero = nullptr;
@@ -63,12 +76,11 @@ Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &m
 
 	// If there's no boot sector then if there are also no sectors at all,
 	// decline to nominate a machine. Otherwise go with an Apple as the default.
-	TargetList targets;
 	if(!sector_zero) {
 		if(sector_map.empty()) {
 			return targets;
 		} else {
-			targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleTarget(nullptr)));
+			targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleIITarget(nullptr)));
 			targets.back()->media = media;
 			return targets;
 		}
@@ -77,7 +89,7 @@ Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &m
 	// If the boot sector looks like it's intended for the Oric, create an Oric.
 	// Otherwise go with the Apple II.
 
-	auto disassembly = Analyser::Static::MOS6502::Disassemble(sector_zero->data, Analyser::Static::Disassembler::OffsetMapper(0xb800), {0xb800});
+	const auto disassembly = Analyser::Static::MOS6502::Disassemble(sector_zero->data, Analyser::Static::Disassembler::OffsetMapper(0xb800), {0xb800});
 
 	bool did_read_shift_register = false;
 	bool is_oric = false;
@@ -118,7 +130,7 @@ Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &m
 	if(is_oric) {
 		targets.push_back(std::unique_ptr<Analyser::Static::Target>(OricTarget(sector_zero)));
 	} else {
-		targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleTarget(sector_zero)));
+		targets.push_back(std::unique_ptr<Analyser::Static::Target>(AppleIITarget(sector_zero)));
 	}
 	targets.back()->media = media;
 	return targets;

Analyser/Static/DiskII/StaticAnalyser.hpp

@@ -13,15 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace DiskII {
+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

@@ -0,0 +1,84 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 24/06/2021.
+//  Copyright 2021 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+#include "../../../Storage/Disk/Parsers/FAT.hpp"
+
+#include <algorithm>
+
+namespace {
+
+bool insensitive_equal(const std::string &lhs, const std::string &rhs) {
+	return std::equal(
+		lhs.begin(), lhs.end(),
+		rhs.begin(), rhs.end(),
+		[] (char l, char r) {
+			return tolower(l) == tolower(r);
+	});
+}
+
+}
+
+Analyser::Static::TargetList Analyser::Static::Enterprise::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	// This analyser can comprehend disks only.
+	if(media.disks.empty()) return {};
+
+	// Otherwise, assume a return will happen.
+	Analyser::Static::TargetList targets;
+	using Target = Analyser::Static::Enterprise::Target;
+	auto *const target = new Target;
+	target->media = media;
+
+	// Always require a BASIC.
+	target->basic_version = Target::BASICVersion::Any;
+
+	// Inspect any supplied disks.
+	if(!media.disks.empty()) {
+		// DOS will be needed.
+		target->dos = Target::DOS::EXDOS;
+
+		// Grab the volume information, which includes the root directory.
+		auto volume = Storage::Disk::FAT::GetVolume(media.disks.front());
+		if(volume) {
+			// If there's an EXDOS.INI then this disk should be able to boot itself.
+			// If not but if there's only one visible .COM or .BAS, automatically load
+			// that. Otherwise, issue a :DIR.
+			using File = Storage::Disk::FAT::File;
+			const File *selected_file = nullptr;
+			bool has_exdos_ini = false;
+			bool did_pick_file = false;
+			for(const auto &file: (*volume).root_directory) {
+				if(insensitive_equal(file.name, "exdos") && insensitive_equal(file.extension, "ini")) {
+					has_exdos_ini = true;
+					break;
+				}
+
+				if(!(file.attributes & File::Attribute::Hidden) &&
+					(insensitive_equal(file.extension, "com") || insensitive_equal(file.extension, "bas"))
+				) {
+					did_pick_file = !selected_file;
+					selected_file = &file;
+				}
+			}
+
+			if(!has_exdos_ini) {
+				if(did_pick_file) {
+					target->loading_command = std::string("run \"") + selected_file->name + "." + selected_file->extension + "\"\n";
+				} else {
+					target->loading_command = ":dir\n";
+				}
+			}
+		}
+	}
+
+	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
+
+	return targets;
+}

Analyser/Static/Enterprise/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 24/06/2021.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Enterprise_StaticAnalyser_hpp
+#define Analyser_Static_Enterprise_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,53 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/06/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Enterprise_Target_h
+#define Analyser_Static_Enterprise_Target_h
+
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+#include <string>
+
+namespace Analyser::Static::Enterprise {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model, Enterprise64, Enterprise128, Enterprise256);
+	ReflectableEnum(EXOSVersion, v10, v20, v21, v23, Any);
+	ReflectableEnum(BASICVersion, v10, v11, v21, Any, None);
+	ReflectableEnum(DOS, EXDOS, None);
+	ReflectableEnum(Speed, FourMHz, SixMHz);
+
+	Model model = Model::Enterprise128;
+	EXOSVersion exos_version = EXOSVersion::Any;
+	BASICVersion basic_version = BASICVersion::None;
+	DOS dos = DOS::None;
+	Speed speed = Speed::FourMHz;
+	std::string loading_command;
+
+	Target() : Analyser::Static::Target(Machine::Enterprise) {
+		if(needs_declare()) {
+			AnnounceEnum(Model);
+			AnnounceEnum(EXOSVersion);
+			AnnounceEnum(BASICVersion);
+			AnnounceEnum(DOS);
+			AnnounceEnum(Speed);
+
+			DeclareField(model);
+			DeclareField(exos_version);
+			DeclareField(basic_version);
+			DeclareField(dos);
+			DeclareField(speed);
+		}
+	}
+};
+
+}
+
+#endif /* Analyser_Static_Enterprise_Target_h */

Analyser/Static/MSX/Cartridge.hpp

@@ -11,9 +11,7 @@
 
 #include "../../../Storage/Cartridge/Cartridge.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace MSX {
+namespace Analyser::Static::MSX {
 
 /*!
 	Extends the base cartridge class by adding a (guess at) the banking scheme.
@@ -33,8 +31,6 @@ struct Cartridge: public ::Storage::Cartridge::Cartridge {
 		Storage::Cartridge::Cartridge(segments), type(type) {}
 };
 
-}
-}
 }
 
 #endif /* Cartridge_hpp */

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -27,17 +27,21 @@ static std::unique_ptr<Analyser::Static::Target> CartridgeTarget(
 	std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
 	if(segment.data.size() & 0x1fff) {
 		std::vector<uint8_t> truncated_data;
-		std::vector<uint8_t>::difference_type truncated_size = static_cast<std::vector<uint8_t>::difference_type>(segment.data.size()) & ~0x1fff;
+		std::vector<uint8_t>::difference_type truncated_size = std::vector<uint8_t>::difference_type(segment.data.size()) & ~0x1fff;
 		truncated_data.insert(truncated_data.begin(), segment.data.begin(), segment.data.begin() + truncated_size);
 		output_segments.emplace_back(start_address, truncated_data);
 	} else {
 		output_segments.emplace_back(start_address, segment.data);
 	}
 
-	std::unique_ptr<Analyser::Static::MSX::Target> target(new Analyser::Static::MSX::Target);
-	target->machine = Analyser::Machine::MSX;
+	auto target = std::make_unique<Analyser::Static::MSX::Target>();
 	target->confidence = confidence;
 
+	// Observation: all ROMs of 48kb or less are from the MSX 1 era.
+	if(segment.data.size() < 48*1024) {
+		target->model = Analyser::Static::MSX::Target::Model::MSX1;
+	}
+
 	if(type == Analyser::Static::MSX::Cartridge::Type::None) {
 		target->media.cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
 	} else {
@@ -97,10 +101,11 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 		// Reject cartridge if the ROM header wasn't found.
 		if(!found_start) continue;
 
-		uint16_t init_address = static_cast<uint16_t>(segment.data[2] | (segment.data[3] << 8));
+		uint16_t init_address = uint16_t(segment.data[2] | (segment.data[3] << 8));
 		// TODO: check for a rational init address?
 
 		// If this ROM is less than 48kb in size then it's an ordinary ROM. Just emplace it and move on.
+		// Bonus observation: all such ROMs are from the MSX 1 era.
 		if(data_size <= 0xc000) {
 			targets.emplace_back(CartridgeTarget(segment, start_address, Analyser::Static::MSX::Cartridge::Type::None, 1.0));
 			continue;
@@ -147,7 +152,7 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 //				) &&
 //				((next_iterator->second.operand >> 13) != (0x4000 >> 13))
 //			) {
-//				const uint16_t address = static_cast<uint16_t>(next_iterator->second.operand);
+//				const uint16_t address = uint16_t(next_iterator->second.operand);
 //				switch(iterator->second.operand) {
 //					case 0x6000:
 //						if(address >= 0x6000 && address < 0x8000) {
@@ -208,13 +213,13 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 			if(	instruction_pair.second.operation == Instruction::Operation::LD &&
 				instruction_pair.second.destination == Instruction::Location::Operand_Indirect &&
 				instruction_pair.second.source == Instruction::Location::A) {
-				address_counts[static_cast<uint16_t>(instruction_pair.second.operand)]++;
+				address_counts[uint16_t(instruction_pair.second.operand)]++;
 			}
 		}
 
 		// Weight confidences by number of observed hits.
 		float total_hits =
-			static_cast<float>(
+			float(
 				address_counts[0x6000] + address_counts[0x6800] +
 				address_counts[0x7000] + address_counts[0x7800] +
 				address_counts[0x77ff] + address_counts[0x8000] +
@@ -226,42 +231,42 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 			segment,
 			start_address,
 			Analyser::Static::MSX::Cartridge::ASCII8kb,
-			static_cast<float>(	address_counts[0x6000] +
-								address_counts[0x6800] +
-								address_counts[0x7000] +
-								address_counts[0x7800]) / total_hits));
+			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,
-			static_cast<float>(	address_counts[0x6000] +
-								address_counts[0x7000] +
-								address_counts[0x77ff]) / total_hits));
+			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,
-				static_cast<float>(	address_counts[0x6000] +
-									address_counts[0x8000] +
-									address_counts[0xa000]) / total_hits));
+				float(	address_counts[0x6000] +
+						address_counts[0x8000] +
+						address_counts[0xa000]) / total_hits));
 		}
 		if(!is_ascii) {
 			targets.push_back(CartridgeTarget(
 				segment,
 				start_address,
 				Analyser::Static::MSX::Cartridge::KonamiWithSCC,
-				static_cast<float>(	address_counts[0x5000] +
-									address_counts[0x7000] +
-									address_counts[0x9000] +
-									address_counts[0xb000]) / total_hits));
+				float(	address_counts[0x5000] +
+						address_counts[0x7000] +
+						address_counts[0x9000] +
+						address_counts[0xb000]) / total_hits));
 		}
 	}
 
 	return targets;
 }
 
-Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	TargetList destination;
 
 	// Append targets for any cartridges that look correct.
@@ -269,7 +274,7 @@ Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &medi
 	std::move(cartridge_targets.begin(), cartridge_targets.end(), std::back_inserter(destination));
 
 	// Consider building a target for disks and/or tapes.
-	std::unique_ptr<Target> target(new Target);
+	auto target = std::make_unique<Target>();
 
 	// Check tapes for loadable files.
 	for(auto &tape : media.tapes) {
@@ -285,12 +290,16 @@ Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &medi
 		}
 	}
 
+	// Region selection: for now, this as simple as:
+	// "If a tape is involved, be European. Otherwise be American (i.e. English, but 60Hz)".
+	target->region = target->media.tapes.empty() ? Target::Region::USA : Target::Region::Europe;
+
 	// Blindly accept disks for now.
+	// TODO: how to spot an MSX disk?
 	target->media.disks = media.disks;
 	target->has_disk_drive = !media.disks.empty();
 
 	if(!target->media.empty()) {
-		target->machine = Machine::MSX;
 		target->confidence = 0.5;
 		destination.push_back(std::move(target));
 	}

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace MSX {
+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.cpp

@@ -44,7 +44,7 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 		for(std::size_t c = 0; c < sizeof(header); ++c) {
 			int next_byte = Parser::get_byte(*file_speed, tape_player);
 			if(next_byte == -1) break;
-			header[c] = static_cast<uint8_t>(next_byte);
+			header[c] = uint8_t(next_byte);
 		}
 
 		bool bytes_are_same = true;
@@ -67,7 +67,7 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 		// Read file name.
 		char name[7];
 		for(std::size_t c = 1; c < 6; ++c)
-			name[c] = static_cast<char>(Parser::get_byte(*file_speed, tape_player));
+			name[c] = char(Parser::get_byte(*file_speed, tape_player));
 		name[6] = '\0';
 		file.name = name;
 
@@ -82,7 +82,7 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 					int byte = Parser::get_byte(*file_speed, tape_player);
 					if(byte == -1) break;
 					contains_end_of_file |= (byte == 0x1a);
-					file.data.push_back(static_cast<uint8_t>(byte));
+					file.data.push_back(uint8_t(byte));
 				}
 				if(c != -1) break;
 				if(contains_end_of_file) {
@@ -105,13 +105,13 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 			for(c = 0; c < sizeof(locations); ++c) {
 				int byte = Parser::get_byte(*file_speed, tape_player);
 				if(byte == -1) break;
-				locations[c] = static_cast<uint8_t>(byte);
+				locations[c] = uint8_t(byte);
 			}
 			if(c != sizeof(locations)) continue;
 
-			file.starting_address = static_cast<uint16_t>(locations[0] | (locations[1] << 8));
-			end_address = static_cast<uint16_t>(locations[2] | (locations[3] << 8));
-			file.entry_address = static_cast<uint16_t>(locations[4] | (locations[5] << 8));
+			file.starting_address = uint16_t(locations[0] | (locations[1] << 8));
+			end_address = uint16_t(locations[2] | (locations[3] << 8));
+			file.entry_address = uint16_t(locations[4] | (locations[5] << 8));
 
 			if(end_address < file.starting_address) continue;
 
@@ -119,7 +119,7 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 			while(length--) {
 				int byte = Parser::get_byte(*file_speed, tape_player);
 				if(byte == -1) continue;
-				file.data.push_back(static_cast<uint8_t>(byte));
+				file.data.push_back(uint8_t(byte));
 			}
 
 			files.push_back(std::move(file));
@@ -135,10 +135,10 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 			next_address_buffer[1] = Parser::get_byte(*file_speed, tape_player);
 
 			if(next_address_buffer[0] == -1 || next_address_buffer[1] == -1) break;
-			file.data.push_back(static_cast<uint8_t>(next_address_buffer[0]));
-			file.data.push_back(static_cast<uint8_t>(next_address_buffer[1]));
+			file.data.push_back(uint8_t(next_address_buffer[0]));
+			file.data.push_back(uint8_t(next_address_buffer[1]));
 
-			uint16_t next_address = static_cast<uint16_t>(next_address_buffer[0] | (next_address_buffer[1] << 8));
+			uint16_t next_address = uint16_t(next_address_buffer[0] | (next_address_buffer[1] << 8));
 			if(!next_address) {
 				files.push_back(std::move(file));
 				break;
@@ -155,7 +155,7 @@ std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage:
 					found_error = true;
 					break;
 				}
-				file.data.push_back(static_cast<uint8_t>(byte));
+				file.data.push_back(uint8_t(byte));
 			}
 			if(found_error) break;
 		}

Analyser/Static/MSX/Tape.hpp

@@ -14,9 +14,7 @@
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace MSX {
+namespace Analyser::Static::MSX {
 
 struct File {
 	std::string name;
@@ -37,8 +35,6 @@ struct File {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
-}
-}
 }
 
 #endif /* StaticAnalyser_MSX_Tape_hpp */

Analyser/Static/MSX/Target.hpp

@@ -9,20 +9,43 @@
 #ifndef Analyser_Static_MSX_Target_h
 #define Analyser_Static_MSX_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace MSX {
+namespace Analyser::Static::MSX {
 
-struct Target: public ::Analyser::Static::Target {
+struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	bool has_disk_drive = false;
+	bool has_msx_music = true;
 	std::string loading_command;
+
+	ReflectableEnum(Model,
+		MSX1,
+		MSX2
+	);
+	Model model = Model::MSX2;
+
+	ReflectableEnum(Region,
+		Japan,
+		USA,
+		Europe
+	);
+	Region region = Region::USA;
+
+	Target(): Analyser::Static::Target(Machine::MSX) {
+		if(needs_declare()) {
+			DeclareField(has_disk_drive);
+			DeclareField(has_msx_music);
+			DeclareField(region);
+			AnnounceEnum(Region);
+			DeclareField(model);
+			AnnounceEnum(Model);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_MSX_Target_h */

Analyser/Static/Macintosh/StaticAnalyser.cpp

@@ -0,0 +1,38 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/06/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::Macintosh::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	// This analyser can comprehend disks and mass-storage devices only.
+	if(media.disks.empty() && media.mass_storage_devices.empty()) return {};
+
+	// As there is at least one usable media image, wave it through.
+	Analyser::Static::TargetList targets;
+
+	using Target = Analyser::Static::Macintosh::Target;
+	auto *const target = new Target;
+	target->media = media;
+
+	// If this is a single-sided floppy disk, guess the Macintosh 512kb.
+	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;
+		}
+
+		if(!has_800kb_disks) {
+			target->model = Target::Model::Mac512k;
+		}
+	}
+
+	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
+
+	return targets;
+}

Analyser/Static/Macintosh/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/06/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Macintosh_StaticAnalyser_hpp
+#define Analyser_Static_Macintosh_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,33 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/06/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Macintosh_Target_h
+#define Analyser_Static_Macintosh_Target_h
+
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::Macintosh {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model, Mac128k, Mac512k, Mac512ke, MacPlus);
+	Model model = Model::MacPlus;
+
+	Target() : Analyser::Static::Target(Machine::Macintosh) {
+		// Boilerplate for declaring fields and potential values.
+		if(needs_declare()) {
+			DeclareField(model);
+			AnnounceEnum(Model);
+		}
+	}
+};
+
+}
+
+#endif /* Analyser_Static_Macintosh_Target_h */

Analyser/Static/Oric/StaticAnalyser.cpp

@@ -20,7 +20,9 @@
 
 using namespace Analyser::Static::Oric;
 
-static int Score(const Analyser::Static::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
+namespace {
+
+int score(const Analyser::Static::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
 	int score = 0;
 
 	for(const auto address : disassembly.outward_calls)		score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1;
@@ -30,7 +32,7 @@ static int Score(const Analyser::Static::MOS6502::Disassembly &disassembly, cons
 	return score;
 }
 
-static int Basic10Score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
+int basic10_score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	const std::set<uint16_t> rom_functions = {
 		0x0228,	0x022b,
 		0xc3ca,	0xc3f8,	0xc448,	0xc47c,	0xc4b5,	0xc4e3,	0xc4e0,	0xc524,	0xc56f,	0xc5a2,	0xc5f8,	0xc60a,	0xc6a5,	0xc6de,	0xc719,	0xc738,
@@ -51,10 +53,10 @@ static int Basic10Score(const Analyser::Static::MOS6502::Disassembly &disassembl
 		0x0228, 0x0229, 0x022a, 0x022b, 0x022c, 0x022d, 0x0230
 	};
 
-	return Score(disassembly, rom_functions, variable_locations);
+	return score(disassembly, rom_functions, variable_locations);
 }
 
-static int Basic11Score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
+int basic11_score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	const std::set<uint16_t> rom_functions = {
 		0x0238,	0x023b,	0x023e,	0x0241,	0x0244,	0x0247,
 		0xc3c6,	0xc3f4,	0xc444,	0xc47c,	0xc4a8,	0xc4d3,	0xc4e0,	0xc524,	0xc55f,	0xc592,	0xc5e8,	0xc5fa,	0xc692,	0xc6b3,	0xc6ee,	0xc70d,
@@ -76,10 +78,10 @@ static int Basic11Score(const Analyser::Static::MOS6502::Disassembly &disassembl
 		0x0244, 0x0245, 0x0246, 0x0247, 0x0248, 0x0249, 0x024a, 0x024b, 0x024c
 	};
 
-	return Score(disassembly, rom_functions, variable_locations);
+	return score(disassembly, rom_functions, variable_locations);
 }
 
-static bool IsMicrodisc(Storage::Encodings::MFM::Parser &parser) {
+bool is_microdisc(Storage::Encodings::MFM::Parser &parser) {
 	/*
 		The Microdisc boot sector is sector 2 of track 0 and contains a 23-byte signature.
 	*/
@@ -100,9 +102,51 @@ static bool IsMicrodisc(Storage::Encodings::MFM::Parser &parser) {
 	return !std::memcmp(signature, first_sample.data(), sizeof(signature));
 }
 
-Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
-	std::unique_ptr<Target> target(new Target);
-	target->machine = Machine::Oric;
+bool is_400_loader(Storage::Encodings::MFM::Parser &parser, uint16_t range_start, uint16_t range_end) {
+	/*
+		Both the Jasmin and BD-DOS boot sectors are sector 1 of track 0 and are loaded at $400;
+		use disassembly to test for likely matches.
+	*/
+
+	Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 1);
+	if(!sector) return false;
+	if(sector->samples.empty()) return false;
+
+	// Take a copy of the first sampling, and keep only the final 256 bytes (assuming at least that many were found).
+	std::vector<uint8_t> first_sample = sector->samples[0];
+	if(first_sample.size() < 256) return false;
+	if(first_sample.size() > 256) {
+		first_sample.erase(first_sample.end() - 256, first_sample.end());
+	}
+
+	// Grab a disassembly.
+	const auto disassembly =
+		Analyser::Static::MOS6502::Disassemble(first_sample, Analyser::Static::Disassembler::OffsetMapper(0x400), {0x400});
+
+	// Check for references to the Jasmin registers.
+	int register_hits = 0;
+	for(auto list : {disassembly.external_stores, disassembly.external_loads, disassembly.external_modifies}) {
+		for(auto address : list) {
+			register_hits += (address >= range_start && address <= range_end);
+		}
+	}
+
+	// Arbitrary, sure, but as long as at least two accesses to the requested register range are found, accept this.
+	return register_hits >= 2;
+}
+
+bool is_jasmin(Storage::Encodings::MFM::Parser &parser) {
+	return is_400_loader(parser, 0x3f4, 0x3ff);
+}
+
+bool is_bd500(Storage::Encodings::MFM::Parser &parser) {
+	return is_400_loader(parser, 0x310, 0x323);
+}
+
+}
+
+Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	auto target = std::make_unique<Target>();
 	target->confidence = 0.5;
 
 	int basic10_votes = 0;
@@ -111,16 +155,14 @@ Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &med
 	for(auto &tape : media.tapes) {
 		std::vector<File> tape_files = GetFiles(tape);
 		tape->reset();
-		if(tape_files.size()) {
+		if(!tape_files.empty()) {
 			for(const auto &file : tape_files) {
 				if(file.data_type == File::MachineCode) {
 					std::vector<uint16_t> entry_points = {file.starting_address};
-					Analyser::Static::MOS6502::Disassembly disassembly =
+					const Analyser::Static::MOS6502::Disassembly disassembly =
 						Analyser::Static::MOS6502::Disassemble(file.data, Analyser::Static::Disassembler::OffsetMapper(file.starting_address), entry_points);
 
-					int basic10_score = Basic10Score(disassembly);
-					int basic11_score = Basic11Score(disassembly);
-					if(basic10_score > basic11_score) basic10_votes++; else basic11_votes++;
+					if(basic10_score(disassembly) > basic11_score(disassembly)) ++basic10_votes; else ++basic11_votes;
 				}
 			}
 
@@ -130,12 +172,22 @@ Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &med
 	}
 
 	if(!media.disks.empty()) {
-		// Only the Microdisc is emulated right now, so accept only disks that it can boot from.
+		// 8-DOS is recognised by a dedicated Disk II analyser, so check only for Microdisc,
+		// Jasmin and BD-DOS formats here.
 		for(auto &disk: media.disks) {
 			Storage::Encodings::MFM::Parser parser(true, disk);
-			if(IsMicrodisc(parser)) {
+
+			if(is_microdisc(parser)) {
 				target->disk_interface = Target::DiskInterface::Microdisc;
 				target->media.disks.push_back(disk);
+			} else if(is_jasmin(parser)) {
+				target->disk_interface = Target::DiskInterface::Jasmin;
+				target->should_start_jasmin = true;
+				target->media.disks.push_back(disk);
+			} else if(is_bd500(parser)) {
+				target->disk_interface = Target::DiskInterface::BD500;
+				target->media.disks.push_back(disk);
+				target->rom = Target::ROM::BASIC10;
 			}
 		}
 	}

Analyser/Static/Oric/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Oric {
+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.cpp

@@ -49,10 +49,10 @@ std::vector<File> Analyser::Static::Oric::GetFiles(const std::shared_ptr<Storage
 		}
 
 		// read end and start addresses
-		new_file.ending_address = static_cast<uint16_t>(parser.get_next_byte(tape, is_fast) << 8);
-		new_file.ending_address |= static_cast<uint16_t>(parser.get_next_byte(tape, is_fast));
-		new_file.starting_address = static_cast<uint16_t>(parser.get_next_byte(tape, is_fast) << 8);
-		new_file.starting_address |= static_cast<uint16_t>(parser.get_next_byte(tape, is_fast));
+		new_file.ending_address = uint16_t(parser.get_next_byte(tape, is_fast) << 8);
+		new_file.ending_address |= uint16_t(parser.get_next_byte(tape, is_fast));
+		new_file.starting_address = uint16_t(parser.get_next_byte(tape, is_fast) << 8);
+		new_file.starting_address |= uint16_t(parser.get_next_byte(tape, is_fast));
 
 		// skip an empty byte
 		parser.get_next_byte(tape, is_fast);
@@ -61,7 +61,7 @@ std::vector<File> Analyser::Static::Oric::GetFiles(const std::shared_ptr<Storage
 		char file_name[17];
 		int name_pos = 0;
 		while(name_pos < 16) {
-			file_name[name_pos] = (char)parser.get_next_byte(tape, is_fast);
+			file_name[name_pos] = char(parser.get_next_byte(tape, is_fast));
 			if(!file_name[name_pos]) break;
 			name_pos++;
 		}
@@ -72,7 +72,7 @@ std::vector<File> Analyser::Static::Oric::GetFiles(const std::shared_ptr<Storage
 		std::size_t body_length = new_file.ending_address - new_file.starting_address + 1;
 		new_file.data.reserve(body_length);
 		for(std::size_t c = 0; c < body_length; c++) {
-			new_file.data.push_back(static_cast<uint8_t>(parser.get_next_byte(tape, is_fast)));
+			new_file.data.push_back(uint8_t(parser.get_next_byte(tape, is_fast)));
 		}
 
 		// only one validation check: was there enough tape?

Analyser/Static/Oric/Tape.hpp

@@ -14,9 +14,7 @@
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Oric {
+namespace Analyser::Static::Oric {
 
 struct File {
 	std::string name;
@@ -33,8 +31,6 @@ struct File {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
-}
-}
 }
 
 #endif /* Tape_hpp */

Analyser/Static/Oric/Target.hpp

@@ -9,33 +9,51 @@
 #ifndef Analyser_Static_Oric_Target_h
 #define Analyser_Static_Oric_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Oric {
+namespace Analyser::Static::Oric {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class ROM {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(ROM,
 		BASIC10,
 		BASIC11,
 		Pravetz
-	};
+	);
 
-	enum class DiskInterface {
+	ReflectableEnum(DiskInterface,
+		None,
 		Microdisc,
 		Pravetz,
-		None
-	};
+		Jasmin,
+		BD500
+	);
+
+	ReflectableEnum(Processor,
+		MOS6502,
+		WDC65816
+	);
 
 	ROM rom = ROM::BASIC11;
 	DiskInterface disk_interface = DiskInterface::None;
+	Processor processor = Processor::MOS6502;
 	std::string loading_command;
+	bool should_start_jasmin = false;
+
+	Target(): Analyser::Static::Target(Machine::Oric) {
+		if(needs_declare()) {
+			DeclareField(rom);
+			DeclareField(disk_interface);
+			DeclareField(processor);
+			AnnounceEnum(ROM);
+			AnnounceEnum(DiskInterface);
+			AnnounceEnum(Processor);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Oric_Target_h */

Analyser/Static/Sega/StaticAnalyser.cpp

@@ -0,0 +1,80 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/09/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "Target.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+Analyser::Static::TargetList Analyser::Static::Sega::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType) {
+	if(media.cartridges.empty())
+		return {};
+
+	TargetList targets;
+	auto target = std::make_unique<Target>();
+
+	// Files named .sg are treated as for the SG1000; otherwise assume a Master System.
+	if(file_name.size() >= 2 && *(file_name.end() - 2) == 's' && *(file_name.end() - 1) == 'g') {
+		target->model = Target::Model::SG1000;
+	} else {
+		target->model = Target::Model::MasterSystem;
+	}
+
+	// If this is a Master System title, look for a ROM header.
+	if(target->model == Target::Model::MasterSystem) {
+		const auto &data = media.cartridges.front()->get_segments()[0].data;
+
+		// First try to locate a header.
+		size_t header_offset = 0;
+		size_t potential_offsets[] = {0x1ff0, 0x3ff0, 0x7ff0};
+		for(auto potential_offset: potential_offsets) {
+			if(!memcmp(&data[potential_offset], "TMR SEGA", 8)) {
+				header_offset = potential_offset;
+				break;
+			}
+		}
+
+		// If a header was found, use it to crib region.
+		if(header_offset) {
+			// Treat export titles as European by default; decline to
+			// do so only if (US) or (NTSC) is in the file name.
+			const uint8_t region = data[header_offset + 0x0f] >> 4;
+			switch(region) {
+				default: break;
+				case 4: {
+					std::string lowercase_name = file_name;
+					std::transform(lowercase_name.begin(), lowercase_name.end(), lowercase_name.begin(), ::tolower);
+					if(lowercase_name.find("(jp)") == std::string::npos) {
+						target->region =
+							(lowercase_name.find("(us)") == std::string::npos &&
+							lowercase_name.find("(ntsc)") == std::string::npos) ? Target::Region::Europe : Target::Region::USA;
+					}
+				} break;
+			}
+
+			// Also check for a Codemasters header.
+			// If one is found, set the paging scheme appropriately.
+			const uint16_t inverse_checksum = uint16_t(0x10000 - (data[0x7fe6] | (data[0x7fe7] << 8)));
+			if(
+				data[0x7fe3] >= 0x87 && data[0x7fe3] < 0x96 &&									// i.e. game is dated between 1987 and 1996
+				(inverse_checksum&0xff) == data[0x7fe8] &&
+				(inverse_checksum >> 8) == data[0x7fe9] &&										// i.e. the standard checksum appears to be present
+				!data[0x7fea] && !data[0x7feb] && !data[0x7fec] && !data[0x7fed] && !data[0x7fee] && !data[0x7fef]
+			) {
+				target->paging_scheme = Target::PagingScheme::Codemasters;
+				target->model = Target::Model::MasterSystem2;
+			}
+		}
+	}
+
+	target->media.cartridges = media.cartridges;
+	targets.push_back(std::move(target));
+	return targets;
+}

Analyser/Static/Sega/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/09/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Sega_StaticAnalyser_hpp
+#define StaticAnalyser_Sega_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+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

@@ -0,0 +1,55 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/09/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Sega_Target_h
+#define Analyser_Static_Sega_Target_h
+
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser::Static::Sega {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	enum class Model {
+		SG1000,
+		MasterSystem,
+		MasterSystem2,
+	};
+
+	ReflectableEnum(Region,
+		Japan,
+		USA,
+		Europe,
+		Brazil
+	);
+
+	enum class PagingScheme {
+		Sega,
+		Codemasters
+	};
+
+	Model model = Model::MasterSystem;
+	Region region = Region::Japan;
+	PagingScheme paging_scheme = PagingScheme::Sega;
+
+	Target() : Analyser::Static::Target(Machine::MasterSystem) {
+		if(needs_declare()) {
+			DeclareField(region);
+			AnnounceEnum(Region);
+		}
+	}
+};
+
+constexpr bool is_master_system(Analyser::Static::Sega::Target::Model model) {
+	return model >= Analyser::Static::Sega::Target::Model::MasterSystem;
+}
+
+}
+
+#endif /* Analyser_Static_Sega_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -15,34 +15,58 @@
 
 // Analysers
 #include "Acorn/StaticAnalyser.hpp"
+#include "Amiga/StaticAnalyser.hpp"
 #include "AmstradCPC/StaticAnalyser.hpp"
 #include "AppleII/StaticAnalyser.hpp"
-#include "Atari/StaticAnalyser.hpp"
+#include "AppleIIgs/StaticAnalyser.hpp"
+#include "Atari2600/StaticAnalyser.hpp"
+#include "AtariST/StaticAnalyser.hpp"
 #include "Coleco/StaticAnalyser.hpp"
 #include "Commodore/StaticAnalyser.hpp"
 #include "DiskII/StaticAnalyser.hpp"
+#include "Enterprise/StaticAnalyser.hpp"
+#include "Macintosh/StaticAnalyser.hpp"
 #include "MSX/StaticAnalyser.hpp"
 #include "Oric/StaticAnalyser.hpp"
+#include "Sega/StaticAnalyser.hpp"
 #include "ZX8081/StaticAnalyser.hpp"
+#include "ZXSpectrum/StaticAnalyser.hpp"
 
 // Cartridges
 #include "../../Storage/Cartridge/Formats/BinaryDump.hpp"
 #include "../../Storage/Cartridge/Formats/PRG.hpp"
 
 // Disks
+#include "../../Storage/Disk/DiskImage/Formats/2MG.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/AmigaADF.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/AppleDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/D64.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/G64.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/DMK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/FAT12.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/MSXDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/IPF.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/SSD.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/DSK.hpp"
+#include "../../Storage/MassStorage/Formats/HDV.hpp"
+#include "../../Storage/MassStorage/Formats/HFV.hpp"
+
+// State Snapshots
+#include "../../Storage/State/SNA.hpp"
+#include "../../Storage/State/SZX.hpp"
+#include "../../Storage/State/Z80.hpp"
+
 // Tapes
 #include "../../Storage/Tape/Formats/CAS.hpp"
 #include "../../Storage/Tape/Formats/CommodoreTAP.hpp"
@@ -52,75 +76,136 @@
 #include "../../Storage/Tape/Formats/TapeUEF.hpp"
 #include "../../Storage/Tape/Formats/TZX.hpp"
 #include "../../Storage/Tape/Formats/ZX80O81P.hpp"
+#include "../../Storage/Tape/Formats/ZXSpectrumTAP.hpp"
 
 // Target Platform Types
 #include "../../Storage/TargetPlatforms.hpp"
 
+template<class> inline constexpr bool always_false_v = false;
+
 using namespace Analyser::Static;
 
+namespace {
+
+std::string get_extension(const std::string &name) {
+	// Get the extension, if any; it will be assumed that extensions are reliable, so an extension is a broad-phase
+	// test as to file format.
+	std::string::size_type final_dot = name.find_last_of(".");
+	if(final_dot == std::string::npos) return name;
+	std::string extension = name.substr(final_dot + 1);
+	std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
+	return extension;
+}
+
+}
+
 static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::IntType &potential_platforms) {
 	Media result;
+	const std::string extension = get_extension(file_name);
 
-	// Get the extension, if any; it will be assumed that extensions are reliable, so an extension is a broad-phase
-	// test as to file format.
-	std::string::size_type final_dot = file_name.find_last_of(".");
-	if(final_dot == std::string::npos) return result;
-	std::string extension = file_name.substr(final_dot + 1);
-	std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
-
-#define Insert(list, class, platforms) \
-	list.emplace_back(new Storage::class(file_name));\
+#define InsertInstance(list, instance, platforms) \
+	list.emplace_back(instance);\
 	potential_platforms |= platforms;\
-	TargetPlatform::TypeDistinguisher *distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
+	TargetPlatform::TypeDistinguisher *const distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
 	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
 
-#define TryInsert(list, class, platforms) \
+#define Insert(list, class, platforms, ...) \
+	InsertInstance(list, new Storage::class(__VA_ARGS__), platforms);
+
+#define TryInsert(list, class, platforms, ...) \
 	try {\
-		Insert(list, class, platforms) \
+		Insert(list, class, platforms, __VA_ARGS__) \
 	} catch(...) {}
 
 #define Format(ext, list, class, platforms) \
 	if(extension == ext)	{		\
-		TryInsert(list, class, platforms)	\
+		TryInsert(list, class, platforms, file_name)	\
 	}
 
-	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
-	Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge)					// BIN
-	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::ColecoVision)					// COL
-	Format("csw", result.tapes, Tape::CSW, TargetPlatform::AllTape)											// CSW
-	Format("d64", result.disks, Disk::DiskImageHolder<Storage::Disk::D64>, TargetPlatform::Commodore)		// D64
-	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)	// DSK (Amstrad CPC)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)		// DSK (Apple)
-	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::MSXDSK>, 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
+	// 2MG
+	if(extension == "2mg") {
+		// 2MG uses a factory method; defer to it.
+		try {
+			const auto media = Storage::Disk::Disk2MG::open(file_name);
+			std::visit([&result, &potential_platforms](auto &&arg) {
+				using Type = typename std::decay<decltype(arg)>::type;
+
+				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, 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?
+					InsertInstance(result.mass_storage_devices, arg, TargetPlatform::AppleII);
+				} else {
+					static_assert(always_false_v<Type>, "Unexpected type encountered.");
+				}
+			}, media);
+		} catch(...) {}
+	}
+
+	Format("80", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 80
+	Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 81
+	Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600)							// A26
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADF (Acorn)
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AmigaADF>, TargetPlatform::Amiga)			// ADF (Amiga)
+	Format("adl", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADL
+	Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge)						// BIN (cartridge dump)
+	Format("cas", result.tapes, Tape::CAS, TargetPlatform::MSX)													// CAS
+	Format("cdt", result.tapes, Tape::TZX, TargetPlatform::AmstradCPC)											// CDT
+	Format("col", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Coleco)								// COL
+	Format("csw", result.tapes, Tape::CSW, TargetPlatform::AllTape)												// CSW
+	Format("d64", result.disks, Disk::DiskImageHolder<Storage::Disk::D64>, TargetPlatform::Commodore)			// D64
+	Format("dat", result.mass_storage_devices, MassStorage::DAT, TargetPlatform::Acorn)							// DAT
+	Format("dmk", result.disks, Disk::DiskImageHolder<Storage::Disk::DMK>, TargetPlatform::MSX)					// DMK
+	Format("do", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)			// DO
+	Format("dsd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)				// DSD
+	Format(	"dsk",
+			result.disks,
+			Disk::DiskImageHolder<Storage::Disk::CPCDSK>,
+			TargetPlatform::AmstradCPC | TargetPlatform::Oric | TargetPlatform::ZXSpectrum)						// DSK (Amstrad CPC, etc)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)			// DSK (Apple II)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)	// DSK (Macintosh, floppy disk)
+	Format("dsk", result.mass_storage_devices, MassStorage::HFV, TargetPlatform::Macintosh)						// DSK (Macintosh, hard disk, single volume image)
+	Format("dsk", result.mass_storage_devices, MassStorage::DSK, TargetPlatform::Macintosh)						// DSK (Macintosh, hard disk, full device image)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::MSX)				// DSK (MSX)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::OricMFMDSK>, TargetPlatform::Oric)			// DSK (Oric)
+	Format("g64", result.disks, Disk::DiskImageHolder<Storage::Disk::G64>, TargetPlatform::Commodore)			// G64
+	Format("hdv", result.mass_storage_devices, MassStorage::HDV, TargetPlatform::AppleII)						// HDV (Apple II, hard disk, single volume image)
 	Format(	"hfe",
 			result.disks,
 			Disk::DiskImageHolder<Storage::Disk::HFE>,
-			TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric)
+			TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric | TargetPlatform::ZXSpectrum)
 			// HFE (TODO: switch to AllDisk once the MSX stops being so greedy)
-	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
-	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// P81
+	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)
+
+	// PO (Apple IIgs kind)
+	if(extension == "po")	{
+		TryInsert(result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::AppleIIgs, file_name, Storage::Disk::MacintoshIMG::FixedType::GCR)
+	}
+
+	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// P81
 
 	// PRG
 	if(extension == "prg") {
 		// try instantiating as a ROM; failing that accept as a tape
 		try {
-			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore)
+			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore, file_name)
 		} catch(...) {
 			try {
-				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore)
+				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore, file_name)
 			} catch(...) {}
 		}
 	}
@@ -128,18 +213,24 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	Format(	"rom",
 			result.cartridges,
 			Cartridge::BinaryDump,
-			TargetPlatform::AcornElectron | TargetPlatform::ColecoVision | TargetPlatform::MSX)				// ROM
-	Format("ssd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)			// SSD
-	Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore)								// TAP (Commodore)
-	Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric)										// TAP (Oric)
-	Format("tsx", result.tapes, Tape::TZX, TargetPlatform::MSX)												// TSX
-	Format("tzx", result.tapes, Tape::TZX, TargetPlatform::ZX8081)											// TZX
-	Format("uef", result.tapes, Tape::UEF, TargetPlatform::Acorn)											// UEF (tape)
-	Format("woz", result.disks, Disk::DiskImageHolder<Storage::Disk::WOZ>, TargetPlatform::DiskII)			// WOZ
+			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
 
 #undef Format
 #undef Insert
 #undef TryInsert
+#undef InsertInstance
 
 	return result;
 }
@@ -151,31 +242,59 @@ Media Analyser::Static::GetMedia(const std::string &file_name) {
 
 TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 	TargetList targets;
+	const std::string extension = get_extension(file_name);
 
-	// Collect all disks, tapes and ROMs as can be extrapolated from this file, forming the
+	// Check whether the file directly identifies a target; if so then just return that.
+#define Format(ext, class)											\
+	if(extension == ext)	{										\
+		try {														\
+			auto target = Storage::State::class::load(file_name);	\
+			if(target) {											\
+				targets.push_back(std::move(target));				\
+				return targets;										\
+			}														\
+		} catch(...) {}												\
+	}
+
+	Format("sna", SNA);
+	Format("szx", SZX);
+	Format("z80", Z80);
+
+#undef TryInsert
+
+	// Otherwise:
+	//
+	// Collect all disks, tapes ROMs, etc as can be extrapolated from this file, forming the
 	// union of all platforms this file might be a target for.
 	TargetPlatform::IntType potential_platforms = 0;
 	Media media = GetMediaAndPlatforms(file_name, potential_platforms);
 
-	// Hand off to platform-specific determination of whether these things are actually compatible and,
-	// if so, how to load them.
-	#define Append(x) {\
-		auto new_targets = x::GetTargets(media, file_name, potential_platforms);\
-		std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));\
-	}
-	if(potential_platforms & TargetPlatform::Acorn)			Append(Acorn);
-	if(potential_platforms & TargetPlatform::AmstradCPC)	Append(AmstradCPC);
-	if(potential_platforms & TargetPlatform::AppleII)		Append(AppleII);
-	if(potential_platforms & TargetPlatform::Atari2600)		Append(Atari);
-	if(potential_platforms & TargetPlatform::ColecoVision)	Append(Coleco);
-	if(potential_platforms & TargetPlatform::Commodore)		Append(Commodore);
-	if(potential_platforms & TargetPlatform::DiskII)		Append(DiskII);
-	if(potential_platforms & TargetPlatform::MSX)			Append(MSX);
-	if(potential_platforms & TargetPlatform::Oric)			Append(Oric);
-	if(potential_platforms & TargetPlatform::ZX8081)		Append(ZX8081);
-	#undef Append
+	// Hand off to platform-specific determination of whether these
+	// things are actually compatible and, if so, how to load them.
+#define Append(x) if(potential_platforms & TargetPlatform::x) {\
+	auto new_targets = x::GetTargets(media, file_name, potential_platforms);\
+	std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));\
+}
+	Append(Acorn);
+	Append(AmstradCPC);
+	Append(AppleII);
+	Append(AppleIIgs);
+	Append(Amiga);
+	Append(Atari2600);
+	Append(AtariST);
+	Append(Coleco);
+	Append(Commodore);
+	Append(DiskII);
+	Append(Enterprise);
+	Append(Macintosh);
+	Append(MSX);
+	Append(Oric);
+	Append(Sega);
+	Append(ZX8081);
+	Append(ZXSpectrum);
+#undef Append
 
-	// Reset any tapes to their initial position
+	// Reset any tapes to their initial position.
 	for(const auto &target : targets) {
 		for(auto &tape : target->media.tapes) {
 			tape->reset();

Analyser/Static/StaticAnalyser.hpp

@@ -11,40 +11,58 @@
 
 #include "../Machines.hpp"
 
-#include "../../Storage/Tape/Tape.hpp"
-#include "../../Storage/Disk/Disk.hpp"
 #include "../../Storage/Cartridge/Cartridge.hpp"
+#include "../../Storage/Disk/Disk.hpp"
+#include "../../Storage/MassStorage/MassStorageDevice.hpp"
+#include "../../Storage/Tape/Tape.hpp"
+#include "../../Reflection/Struct.hpp"
 
 #include <memory>
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
+namespace Analyser::Static {
+
+struct State;
 
 /*!
-	A list of disks, tapes and cartridges.
+	A list of disks, tapes and cartridges, and possibly a state snapshot.
 */
 struct Media {
 	std::vector<std::shared_ptr<Storage::Disk::Disk>> disks;
 	std::vector<std::shared_ptr<Storage::Tape::Tape>> tapes;
 	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> cartridges;
+	std::vector<std::shared_ptr<Storage::MassStorage::MassStorageDevice>> mass_storage_devices;
 
 	bool empty() const {
-		return disks.empty() && tapes.empty() && cartridges.empty();
+		return disks.empty() && tapes.empty() && cartridges.empty() && mass_storage_devices.empty();
+	}
+
+	Media &operator +=(const Media &rhs) {
+#define append(name)	name.insert(name.end(), rhs.name.begin(), rhs.name.end());
+		append(disks);
+		append(tapes);
+		append(cartridges);
+		append(mass_storage_devices);
+#undef append
+		return *this;
 	}
 };
 
 /*!
-	A list of disks, tapes and cartridges plus information about the machine to which to attach them and its configuration,
-	and instructions on how to launch the software attached, plus a measure of confidence in this target's correctness.
+	Describes a machine and possibly its state; conventionally subclassed to add other machine-specific configuration fields and any
+	necessary instructions on how to launch any software provided, plus a measure of confidence in this target's correctness.
 */
 struct Target {
+	Target(Machine machine) : machine(machine) {}
 	virtual ~Target() {}
 
+	// This field is entirely optional.
+	std::unique_ptr<Reflection::Struct> state;
+
 	Machine machine;
 	Media media;
-	float confidence;
+	float confidence = 0.0f;
 };
 typedef std::vector<std::unique_ptr<Target>> TargetList;
 
@@ -60,7 +78,6 @@ TargetList GetTargets(const std::string &file_name);
 */
 Media GetMedia(const std::string &file_name);
 
-}
 }
 
 #endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.cpp

@@ -28,13 +28,13 @@ static std::vector<Storage::Data::ZX8081::File> GetFiles(const std::shared_ptr<S
 	return files;
 }
 
-Analyser::Static::TargetList Analyser::Static::ZX8081::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+Analyser::Static::TargetList Analyser::Static::ZX8081::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType potential_platforms) {
 	TargetList destination;
 	if(!media.tapes.empty()) {
 		std::vector<Storage::Data::ZX8081::File> files = GetFiles(media.tapes.front());
 		media.tapes.front()->reset();
 		if(!files.empty()) {
-			Target *target = new Target;
+			Target *const target = new Target;
 			destination.push_back(std::unique_ptr<::Analyser::Static::Target>(target));
 			target->machine = Machine::ZX8081;
 

Analyser/Static/ZX8081/StaticAnalyser.hpp

@@ -13,14 +13,10 @@
 #include "../../../Storage/TargetPlatforms.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace ZX8081 {
+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

@@ -9,28 +9,35 @@
 #ifndef Analyser_Static_ZX8081_Target_h
 #define Analyser_Static_ZX8081_Target_h
 
+#include "../../../Reflection/Enum.hpp"
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace ZX8081 {
+namespace Analyser::Static::ZX8081 {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class MemoryModel {
+struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(MemoryModel,
 		Unexpanded,
 		SixteenKB,
 		SixtyFourKB
-	};
+	);
 
 	MemoryModel memory_model = MemoryModel::Unexpanded;
 	bool is_ZX81 = false;
 	bool ZX80_uses_ZX81_ROM = false;
 	std::string loading_command;
+
+	Target(): Analyser::Static::Target(Machine::ZX8081) {
+		if(needs_declare()) {
+			DeclareField(memory_model);
+			DeclareField(is_ZX81);
+			DeclareField(ZX80_uses_ZX81_ROM);
+			AnnounceEnum(MemoryModel);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_ZX8081_Target_h */

Analyser/Static/ZXSpectrum/StaticAnalyser.cpp

@@ -0,0 +1,95 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 17/03/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "../../../Storage/Tape/Parsers/Spectrum.hpp"
+
+#include "Target.hpp"
+
+namespace {
+
+bool IsSpectrumTape(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	using Parser = Storage::Tape::ZXSpectrum::Parser;
+	Parser parser(Parser::MachineType::ZXSpectrum);
+
+	while(true) {
+		const auto block = parser.find_block(tape);
+		if(!block) break;
+
+		// Check for a Spectrum header block.
+		if(block->type == 0x00) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool IsSpectrumDisk(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+	Storage::Encodings::MFM::Parser parser(true, disk);
+
+	// Get logical sector 1; the Spectrum appears to support various physical
+	// sectors as sector 1.
+	Storage::Encodings::MFM::Sector *boot_sector = nullptr;
+	uint8_t sector_mask = 0;
+	while(!boot_sector) {
+		boot_sector = parser.get_sector(0, 0, sector_mask + 1);
+		sector_mask += 0x40;
+		if(!sector_mask) break;
+	}
+	if(!boot_sector) return false;
+
+	// Test that the contents of the boot sector sum to 3, modulo 256.
+	uint8_t byte_sum = 0;
+	for(auto byte: boot_sector->samples[0]) {
+		byte_sum += byte;
+	}
+	return byte_sum == 3;
+}
+
+}
+
+Analyser::Static::TargetList Analyser::Static::ZXSpectrum::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
+	TargetList destination;
+	auto target = std::make_unique<Target>();
+	target->confidence = 0.5;
+
+	if(!media.tapes.empty()) {
+		bool has_spectrum_tape = false;
+		for(auto &tape: media.tapes) {
+			has_spectrum_tape |= IsSpectrumTape(tape);
+		}
+
+		if(has_spectrum_tape) {
+			target->media.tapes = media.tapes;
+		}
+	}
+
+	if(!media.disks.empty()) {
+		bool has_spectrum_disk = false;
+
+		for(auto &disk: media.disks) {
+			has_spectrum_disk |= IsSpectrumDisk(disk);
+		}
+
+		if(has_spectrum_disk) {
+			target->media.disks = media.disks;
+			target->model = Target::Model::Plus3;
+		}
+	}
+
+	// If any media survived, add the target.
+	if(!target->media.empty()) {
+		target->should_hold_enter = true;	// To force entry into the 'loader' and thereby load the media.
+		destination.push_back(std::move(target));
+	}
+
+	return destination;
+}

Analyser/Static/ZXSpectrum/StaticAnalyser.hpp

@@ -0,0 +1,22 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 17/03/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_ZXSpectrum_StaticAnalyser_hpp
+#define Analyser_Static_ZXSpectrum_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser::Static::ZXSpectrum {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+
+#endif /* StaticAnalyser_hpp */