Merge pull request #877 from TomHarte/MissingConstraints

Corrects minor macOS layout constraint issues.

.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

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

Activity/Observer.hpp

@@ -24,13 +24,13 @@ namespace Activity {
 class Observer {
 	public:
 		/// Announces to the receiver that there is an LED of name @c name.
-		virtual void register_led(const std::string &name) {}
+		virtual void register_led([[maybe_unused]] const std::string &name) {}
 
 		/// Announces to the receiver that there is a drive of name @c name.
-		virtual void register_drive(const std::string &name) {}
+		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) {}
+		virtual void set_led_status([[maybe_unused]] const std::string &name, [[maybe_unused]] bool lit) {}
 
 		enum class DriveEvent {
 			StepNormal,
@@ -39,10 +39,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) {}
+		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) {}
+		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

@@ -22,7 +22,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();

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -32,11 +32,11 @@ 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_;
 };
 

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.cpp

@@ -1,87 +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::recursive_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<decltype(machines_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<decltype(machines_mutex_)> machines_lock(machines_mutex_);
-	for(const auto &machine: machines_) {
-		CRTMachine::Machine *const crt_machine = machine->crt_machine();
-		if(crt_machine) function(crt_machine);
-	}
-}
-
-void MultiCRTMachine::set_scan_target(Outputs::Display::ScanTarget *scan_target) {
-	scan_target_ = scan_target;
-
-	CRTMachine::Machine *const crt_machine = machines_.front()->crt_machine();
-	if(crt_machine) crt_machine->set_scan_target(scan_target);
-}
-
-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(scan_target_) scan_target_->will_change_owner();
-
-	perform_serial([=](::CRTMachine::Machine *machine) {
-		machine->set_scan_target(nullptr);
-	});
-	CRTMachine::Machine *const crt_machine = machines_.front()->crt_machine();
-	if(crt_machine) crt_machine->set_scan_target(scan_target_);
-
-	if(speaker_) {
-		speaker_->set_new_front_machine(machines_.front().get());
-	}
-}

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,6 +10,7 @@
 #define MultiConfigurable_hpp
 
 #include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Configurable/Configurable.hpp"
 
 #include <memory>
 #include <vector>
@@ -28,10 +29,8 @@ 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_;

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,7 +25,7 @@ class MultiJoystick: public Inputs::Joystick {
 			}
 		}
 
-		std::vector<Input> &get_inputs() override {
+		const std::vector<Input> &get_inputs() final {
 			if(inputs.empty()) {
 				for(const auto &joystick: joysticks_) {
 					std::vector<Input> joystick_inputs = joystick->get_inputs();
@@ -40,19 +40,19 @@ class MultiJoystick: public Inputs::Joystick {
 			return inputs;
 		}
 
-		void set_input(const Input &digital_input, bool is_active) override {
+		void set_input(const Input &digital_input, bool is_active) final {
 			for(const auto &joystick: joysticks_) {
 				joystick->set_input(digital_input, is_active);
 			}
 		}
 
-		void set_input(const Input &digital_input, float value) 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() override {
+		void reset_all_inputs() final {
 			for(const auto &joystick: joysticks_) {
 				joystick->reset_all_inputs();
 			}
@@ -67,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());

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -23,12 +23,12 @@ 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.
-		const 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_;

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -10,12 +10,12 @@
 
 using namespace Analyser::Dynamic;
 
-MultiKeyboardMachine::MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) :
-	keyboard_(machines_) {
+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() {
@@ -36,11 +36,19 @@ void MultiKeyboardMachine::type_string(const std::string &string) {
 	}
 }
 
-Inputs::Keyboard &MultiKeyboardMachine::get_keyboard() {
-	return keyboard_;
+bool MultiKeyboardMachine::can_type(char c) const {
+	bool can_type = true;
+	for(const auto &machine: machines_) {
+		can_type &= machine->can_type(c);
+	}
+	return can_type;
 }
 
-MultiKeyboardMachine::MultiKeyboard::MultiKeyboard(const std::vector<::KeyboardMachine::Machine *> &machines)
+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());
@@ -48,10 +56,12 @@ MultiKeyboardMachine::MultiKeyboard::MultiKeyboard(const std::vector<::KeyboardM
 	}
 }
 
-void MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed) {
+bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed) {
+	bool was_consumed = false;
 	for(const auto &machine: machines_) {
-		machine->get_keyboard().set_key_pressed(key, value, is_pressed);
+		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed);
 	}
+	return was_consumed;
 }
 
 void MultiKeyboardMachine::MultiKeyboard::reset_all_keys() {
@@ -60,10 +70,10 @@ void MultiKeyboardMachine::MultiKeyboard::reset_all_keys() {
 	}
 }
 
-const std::set<Inputs::Keyboard::Key> &MultiKeyboardMachine::MultiKeyboard::observed_keys() {
+const std::set<Inputs::Keyboard::Key> &MultiKeyboardMachine::MultiKeyboard::observed_keys() const {
 	return observed_keys_;
 }
 
-bool MultiKeyboardMachine::MultiKeyboard::is_exclusive() {
+bool MultiKeyboardMachine::MultiKeyboard::is_exclusive() const {
 	return is_exclusive_;
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -24,34 +24,35 @@ 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<::KeyboardMachine::Machine *> machines_;
+		std::vector<MachineTypes::KeyboardMachine *> machines_;
 
 		class MultiKeyboard: public Inputs::Keyboard {
 			public:
-				MultiKeyboard(const std::vector<::KeyboardMachine::Machine *> &machines);
+				MultiKeyboard(const std::vector<MachineTypes::KeyboardMachine *> &machines);
 
-				void set_key_pressed(Key key, char value, bool is_pressed) override;
-				void reset_all_keys() override;
-				const std::set<Key> &observed_keys() override;
-				bool is_exclusive() override;
+				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<::KeyboardMachine::Machine *> &machines_;
+				const std::vector<MachineTypes::KeyboardMachine *> &machines_;
 				std::set<Key> observed_keys_;
 				bool is_exclusive_ = false;
 		};
-		MultiKeyboard keyboard_;
+		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;
-		Inputs::Keyboard &get_keyboard() override;
+		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;
 };
 
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.cpp

@@ -12,7 +12,7 @@ using namespace Analyser::Dynamic;
 
 MultiMediaTarget::MultiMediaTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
 	for(const auto &machine: machines) {
-		MediaTarget::Machine *media_target = machine->media_target();
+		auto media_target = machine->media_target();
 		if(media_target) targets_.push_back(media_target);
 	}
 }

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -24,15 +24,15 @@ namespace Dynamic {
 	Makes a static internal copy of the list of machines; makes no guarantees about the
 	order of delivered messages.
 */
-struct MultiMediaTarget: public MediaTarget::Machine {
+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) override;
+		bool insert_media(const Analyser::Static::Media &media) final;
 
 	private:
-		std::vector<MediaTarget::Machine *> targets_;
+		std::vector<MachineTypes::MediaTarget *> targets_;
 };
 
 }

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

@@ -1,16 +1,16 @@
 //
-//  MultiCRTMachine.hpp
+//  MultiProducer.hpp
 //  Clock Signal
 //
 //  Created by Thomas Harte on 29/01/2018.
 //  Copyright 2018 Thomas Harte. All rights reserved.
 //
 
-#ifndef MultiCRTMachine_hpp
-#define MultiCRTMachine_hpp
+#ifndef MultiProducer_hpp
+#define MultiProducer_hpp
 
 #include "../../../../Concurrency/AsyncTaskQueue.hpp"
-#include "../../../../Machines/CRTMachine.hpp"
+#include "../../../../Machines/MachineTypes.hpp"
 #include "../../../../Machines/DynamicMachine.hpp"
 
 #include "MultiSpeaker.hpp"
@@ -22,6 +22,91 @@
 namespace Analyser {
 namespace 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> 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.
 
@@ -29,60 +114,9 @@ namespace Dynamic {
 	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::recursive_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 set_scan_target(Outputs::Display::ScanTarget *scan_target) 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::recursive_mutex &machines_mutex_;
-		std::vector<Concurrency::AsyncTaskQueue> queues_;
-		MultiSpeaker *speaker_ = nullptr;
-		Delegate *delegate_ = nullptr;
-		Outputs::Display::ScanTarget *scan_target_ = 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 */
+#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

@@ -39,18 +39,20 @@ 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;
 };
 
 }

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -16,74 +16,55 @@ using namespace Analyser::Dynamic;
 MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines) :
 	machines_(std::move(machines)),
 	configurable_(machines_),
-	crt_machine_(machines_, machines_mutex_),
-	joystick_machine_(machines),
+	timed_machine_(machines_, machines_mutex_),
+	scan_producer_(machines_, machines_mutex_),
+	audio_producer_(machines_, machines_mutex_),
+	joystick_machine_(machines_),
 	keyboard_machine_(machines_),
 	media_target_(machines_) {
-	crt_machine_.set_delegate(this);
+	timed_machine_.set_delegate(this);
 }
 
 Activity::Source *MultiMachine::activity_source() {
 	return nullptr; // TODO
 }
 
-MediaTarget::Machine *MultiMachine::media_target() {
-	if(has_picked_) {
-		return machines_.front()->media_target();
-	} else {
-		return &media_target_;
+#define Provider(type, name, member)	\
+	type *MultiMachine::name() {	\
+		if(has_picked_) {	\
+			return machines_.front()->name();	\
+		} else {	\
+			return &member;	\
+		}	\
 	}
-}
 
-CRTMachine::Machine *MultiMachine::crt_machine() {
-	if(has_picked_) {
-		return machines_.front()->crt_machine();
-	} else {
-		return &crt_machine_;
-	}
-}
+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_)
 
-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_;
-	}
-}
-
-MouseMachine::Machine *MultiMachine::mouse_machine() {
+MachineTypes::MouseMachine *MultiMachine::mouse_machine() {
 	// TODO.
 	return nullptr;
 }
 
-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<decltype(machines_mutex_)> machines_lock(machines_mutex_);
+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();
-		LOGNBR(PADHEX(2) << crt->get_confidence() << " " << crt->debug_type() << "; ");
+		auto timed_machine = machine->timed_machine();
+		LOGNBR(PADHEX(2) << timed_machine->get_confidence() << " " << timed_machine->debug_type() << "; ");
 	}
 	LOGNBR(std::endl);
 #endif
@@ -91,13 +72,14 @@ void MultiMachine::multi_crt_did_run_machines() {
 	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_)) {
@@ -107,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,8 +11,9 @@
 
 #include "../../../Machines/DynamicMachine.hpp"
 
+#include "Implementation/MultiProducer.hpp"
 #include "Implementation/MultiConfigurable.hpp"
-#include "Implementation/MultiCRTMachine.hpp"
+#include "Implementation/MultiProducer.hpp"
 #include "Implementation/MultiJoystickMachine.hpp"
 #include "Implementation/MultiKeyboardMachine.hpp"
 #include "Implementation/MultiMediaTarget.hpp"
@@ -38,7 +39,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,23 +51,27 @@ 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;
-		Configurable::Device *configurable_device() override;
-		CRTMachine::Machine *crt_machine() override;
-		JoystickMachine::Machine *joystick_machine() override;
-		MouseMachine::Machine *mouse_machine() override;
-		KeyboardMachine::Machine *keyboard_machine() override;
-		MediaTarget::Machine *media_target() 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::recursive_mutex machines_mutex_;
 
 		MultiConfigurable configurable_;
-		MultiCRTMachine crt_machine_;
+		MultiTimedMachine timed_machine_;
+		MultiScanProducer scan_producer_;
+		MultiAudioProducer audio_producer_;
 		MultiJoystickMachine joystick_machine_;
 		MultiKeyboardMachine keyboard_machine_;
 		MultiMediaTarget media_target_;

Analyser/Machines.hpp

@@ -14,6 +14,7 @@ namespace Analyser {
 enum class Machine {
 	AmstradCPC,
 	AppleII,
+	AppleIIgs,
 	Atari2600,
 	AtariST,
 	ColecoVision,

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>
 
@@ -21,8 +21,8 @@ std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::s
 	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,11 +72,16 @@ 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) {
 	auto catalogue = std::make_unique<Catalogue>();
 	Storage::Encodings::MFM::Parser parser(true, disk);
@@ -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/File.hpp

@@ -19,19 +19,38 @@ namespace 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;

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,13 +59,8 @@ 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) {
+Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	auto target = std::make_unique<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;
 
 	// strip out inappropriate cartridges
 	target->media.cartridges = AcornCartridgesFrom(media.cartridges);
@@ -78,14 +75,14 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &me
 		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;
@@ -109,15 +106,60 @@ Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &me
 		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/Tape.cpp

@@ -10,7 +10,7 @@
 
 #include <deque>
 
-#include "../../../NumberTheory/CRC.hpp"
+#include "../../../Numeric/CRC.hpp"
 #include "../../../Storage/Tape/Parsers/Acorn.hpp"
 
 using namespace Analyser::Static::Acorn;
@@ -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;
@@ -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/Target.hpp

@@ -9,6 +9,7 @@
 #ifndef Analyser_Static_Acorn_Target_h
 #define Analyser_Static_Acorn_Target_h
 
+#include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 #include <string>
 
@@ -16,11 +17,24 @@ namespace Analyser {
 namespace Static {
 namespace 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);
+		}
+	}
 };
 
 }

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -179,10 +179,9 @@ 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) {
+Analyser::Static::TargetList Analyser::Static::AmstradCPC::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	TargetList destination;
 	auto target = std::make_unique<Target>();
-	target->machine = Machine::AmstradCPC;
 	target->confidence = 0.5;
 
 	target->model = Target::Model::CPC6128;

Analyser/Static/AmstradCPC/Target.hpp

@@ -9,6 +9,8 @@
 #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>
 
@@ -16,15 +18,17 @@ namespace Analyser {
 namespace Static {
 namespace AmstradCPC {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class Model {
-		CPC464,
-		CPC664,
-		CPC6128
-	};
-
+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);
+		}
+	}
 };
 
 }

Analyser/Static/AppleII/StaticAnalyser.cpp

@@ -9,9 +9,8 @@
 #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) {
+Analyser::Static::TargetList Analyser::Static::AppleII::GetTargets(const Media &media, const std::string &, TargetPlatform::IntType) {
 	auto target = std::make_unique<Target>();
-	target->machine = Machine::AppleII;
 	target->media = media;
 
 	if(!target->media.disks.empty())

Analyser/Static/AppleII/Target.hpp

@@ -6,34 +6,45 @@
 //  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 {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class Model {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model,
 		II,
 		IIplus,
 		IIe,
 		EnhancedIIe
-	};
-	enum class DiskController {
+	);
+	ReflectableEnum(DiskController,
 		None,
 		SixteenSector,
 		ThirteenSector
-	};
+	);
 
 	Model model = Model::IIe;
 	DiskController disk_controller = DiskController::None;
+
+	Target() : Analyser::Static::Target(Machine::AppleII) {
+		if(needs_declare()) {
+			DeclareField(model);
+			DeclareField(disk_controller);
+			AnnounceEnum(Model);
+			AnnounceEnum(DiskController);
+		}
+	}
 };
 
 }
 }
 }
 
-#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,26 @@
+//
+//  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 {
+namespace Static {
+namespace 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,49 @@
+//
+//  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 {
+namespace Static {
+namespace AppleIIgs {
+
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	ReflectableEnum(Model,
+		ROM00,
+		ROM01,
+		ROM03
+	);
+	ReflectableEnum(MemoryModel,
+		TwoHundredAndFiftySixKB,
+		OneMB,
+		EightMB
+	);
+
+	Model model = Model::ROM03;
+	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

@@ -16,24 +16,22 @@ using namespace Analyser::Static::Atari2600;
 using Target = Analyser::Static::Atari2600::Target;
 
 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
-	uint16_t entry_address, break_address;
+	// 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) {
@@ -45,17 +43,17 @@ static void DeterminePagingFor2kCartridge(Target &target, const Storage::Cartrid
 		}
 	}
 
-	// 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
+	// attempts to modify itself but it probably doesn't.
 	if(has_wide_area_store) target.paging_model = Target::PagingModel::CommaVid;
 }
 
 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) &&
@@ -65,7 +63,7 @@ static void DeterminePagingFor8kCartridge(Target &target, const Storage::Cartrid
 		return;
 	}
 
-	// make an assumption that this is the Atari paging model
+	// Make an assumption that this is the Atari paging model.
 	target.paging_model = Target::PagingModel::Atari8k;
 
 	std::set<uint16_t> internal_accesses;
@@ -90,8 +88,8 @@ static void DeterminePagingFor8kCartridge(Target &target, const Storage::Cartrid
 	else if(tigervision_access_count > atari_access_count) target.paging_model = Target::PagingModel::Tigervision;
 }
 
-static void DeterminePagingFor16kCartridge(Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
-	// make an assumption that this is the Atari paging model
+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;
@@ -110,8 +108,8 @@ static void DeterminePagingFor16kCartridge(Target &target, const Storage::Cartri
 	if(mnetwork_access_count > atari_access_count) target.paging_model = Target::PagingModel::MNetwork;
 }
 
-static void DeterminePagingFor64kCartridge(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()) ?
 			Target::PagingModel::Tigervision : Target::PagingModel::MegaBoy;
@@ -123,17 +121,15 @@ static void DeterminePagingForCartridge(Target &target, const Storage::Cartridge
 		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()) {
@@ -159,7 +155,7 @@ static void DeterminePagingForCartridge(Target &target, const Storage::Cartridge
 		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 != Target::PagingModel::CBSRamPlus &&
@@ -174,17 +170,16 @@ static void DeterminePagingForCartridge(Target &target, const Storage::Cartridge
 		target.uses_superchip = has_superchip;
 	}
 
-	// check for a Tigervision or Tigervision-esque scheme
+	// 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 = Target::PagingModel::Tigervision;
 	}
 }
 
-Analyser::Static::TargetList Analyser::Static::Atari2600::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?
 	auto target = std::make_unique<Target>();
-	target->machine = Machine::Atari2600;
 	target->confidence = 0.5;
 	target->media.cartridges = media.cartridges;
 	target->paging_model = Target::PagingModel::None;

Analyser/Static/Atari2600/Target.hpp

@@ -34,6 +34,8 @@ 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) {}
 };
 
 }

Analyser/Static/AtariST/StaticAnalyser.cpp

@@ -9,16 +9,15 @@
 #include "StaticAnalyser.hpp"
 #include "Target.hpp"
 
-Analyser::Static::TargetList Analyser::Static::AtariST::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+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::Target;
-	auto *target = new Target;
-	target->machine = Analyser::Machine::AtariST;
+	using Target = Analyser::Static::AtariST::Target;
+	auto *const target = new Target();
 	target->media = media;
 	targets.push_back(std::unique_ptr<Analyser::Static::Target>(target));
 

Analyser/Static/AtariST/Target.hpp

@@ -9,11 +9,15 @@
 #ifndef Analyser_Static_AtariST_Target_h
 #define Analyser_Static_AtariST_Target_h
 
+#include "../../../Reflection/Struct.hpp"
+#include "../StaticAnalyser.hpp"
+
 namespace Analyser {
 namespace Static {
 namespace AtariST {
 
-struct Target: public ::Analyser::Static::Target {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
+	Target() : Analyser::Static::Target(Machine::AtariST) {}
 };
 
 }

Analyser/Static/Coleco/StaticAnalyser.cpp

@@ -22,7 +22,7 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 
 		// 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;
@@ -52,10 +52,9 @@ static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	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;
-	auto target = std::make_unique<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/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 = std::make_shared<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,15 +112,15 @@ 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;
 			}
@@ -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/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/StaticAnalyser.cpp

@@ -42,7 +42,7 @@ 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;
 
 	auto target = std::make_unique<Target>();
@@ -94,6 +94,7 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 		switch(files.front().starting_address) {
 			default:
 				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) <<  files.front().starting_address);
+				[[fallthrough]];
 			case 0x1001:
 				memory_model = Target::MemoryModel::Unexpanded;
 			break;

Analyser/Static/Commodore/Target.hpp

@@ -9,6 +9,8 @@
 #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>
 
@@ -16,20 +18,20 @@ namespace Analyser {
 namespace Static {
 namespace 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) {
@@ -54,6 +56,19 @@ struct Target: public ::Analyser::Static::Target {
 	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);
+		}
+	}
 };
 
 }

Analyser/Static/Disassembler/6502.cpp

@@ -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/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

@@ -21,7 +21,7 @@ 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);
 	};
 }
 

Analyser/Static/Disassembler/Z80.cpp

@@ -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() {
@@ -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/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/MSX/StaticAnalyser.cpp

@@ -27,7 +27,7 @@ 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 {
@@ -35,7 +35,6 @@ static std::unique_ptr<Analyser::Static::Target> CartridgeTarget(
 	}
 
 	auto target = std::make_unique<Analyser::Static::MSX::Target>();
-	target->machine = Analyser::Machine::MSX;
 	target->confidence = confidence;
 
 	if(type == Analyser::Static::MSX::Cartridge::Type::None) {
@@ -97,7 +96,7 @@ 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.
@@ -147,7 +146,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 +207,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 +225,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.
@@ -295,7 +294,6 @@ Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &medi
 	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/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/Target.hpp

@@ -9,6 +9,8 @@
 #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>
 
@@ -16,15 +18,24 @@ namespace Analyser {
 namespace Static {
 namespace MSX {
 
-struct Target: public ::Analyser::Static::Target {
+struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	bool has_disk_drive = false;
 	std::string loading_command;
 
-	enum class Region {
+	ReflectableEnum(Region,
 		Japan,
 		USA,
 		Europe
-	} region = Region::USA;
+	);
+	Region region = Region::USA;
+
+	Target(): Analyser::Static::Target(Machine::MSX) {
+		if(needs_declare()) {
+			DeclareField(has_disk_drive);
+			DeclareField(region);
+			AnnounceEnum(Region);
+		}
+	}
 };
 
 }

Analyser/Static/Macintosh/StaticAnalyser.cpp

@@ -9,7 +9,7 @@
 #include "StaticAnalyser.hpp"
 #include "Target.hpp"
 
-Analyser::Static::TargetList Analyser::Static::Macintosh::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+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 {};
 
@@ -17,9 +17,21 @@ Analyser::Static::TargetList Analyser::Static::Macintosh::GetTargets(const Media
 	Analyser::Static::TargetList targets;
 
 	using Target = Analyser::Static::Macintosh::Target;
-	auto *target = new Target;
-	target->machine = Analyser::Machine::Macintosh;
+	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/Target.hpp

@@ -9,19 +9,25 @@
 #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 {
 namespace Static {
 namespace Macintosh {
 
-struct Target: public ::Analyser::Static::Target {
-	enum class Model {
-		Mac128k,
-		Mac512k,
-		Mac512ke,
-		MacPlus
-	};
-
+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);
+		}
+	}
 };
 
 }

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) {
+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->machine = Machine::Oric;
 	target->confidence = 0.5;
 
 	int basic10_votes = 0;
@@ -115,12 +159,10 @@ Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &med
 			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/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/Target.hpp

@@ -9,6 +9,8 @@
 #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>
 
@@ -16,22 +18,42 @@ namespace Analyser {
 namespace Static {
 namespace 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);
+		}
+	}
 };
 
 }

Analyser/Static/Sega/StaticAnalyser.cpp

@@ -13,15 +13,13 @@
 #include <algorithm>
 #include <cstring>
 
-Analyser::Static::TargetList Analyser::Static::Sega::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+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>();
 
-	target->machine = Machine::MasterSystem;
-
 	// 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;

Analyser/Static/Sega/Target.hpp

@@ -9,23 +9,27 @@
 #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 {
 namespace Static {
 namespace Sega {
 
-struct Target: public ::Analyser::Static::Target {
+struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	enum class Model {
 		SG1000,
 		MasterSystem,
 		MasterSystem2,
 	};
 
-	enum class Region {
+	ReflectableEnum(Region,
 		Japan,
 		USA,
 		Europe,
 		Brazil
-	};
+	);
 
 	enum class PagingScheme {
 		Sega,
@@ -35,6 +39,13 @@ struct Target: public ::Analyser::Static::Target {
 	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);
+		}
+	}
 };
 
 #define is_master_system(v) v >= Analyser::Static::Sega::Target::Model::MasterSystem

Analyser/Static/StaticAnalyser.cpp

@@ -17,6 +17,7 @@
 #include "Acorn/StaticAnalyser.hpp"
 #include "AmstradCPC/StaticAnalyser.hpp"
 #include "AppleII/StaticAnalyser.hpp"
+#include "AppleIIgs/StaticAnalyser.hpp"
 #include "Atari2600/StaticAnalyser.hpp"
 #include "AtariST/StaticAnalyser.hpp"
 #include "Coleco/StaticAnalyser.hpp"
@@ -33,6 +34,7 @@
 #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/AppleDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
@@ -47,9 +49,11 @@
 #include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/ST.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/HFV.hpp"
 
 // Tapes
@@ -77,36 +81,52 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	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());\
-	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
+	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)	\
+	}
+
+	// 2MG
+	if(extension == "2mg") {
+		// 2MG uses a factory method; defer to it.
+		try {
+			InsertInstance(result.disks, Storage::Disk::Disk2MG::open(file_name), TargetPlatform::DiskII)
+		} 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
+	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::ColecoVision)						// 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)		// DSK (Amstrad CPC)
+	Format(	"dsk",
+			result.disks,
+			Disk::DiskImageHolder<Storage::Disk::CPCDSK>,
+			TargetPlatform::AmstradCPC | TargetPlatform::Oric)													// DSK (Amstrad CPC)
 	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)
@@ -124,17 +144,23 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	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("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(...) {}
 		}
 	}
@@ -147,6 +173,7 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	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::ST>, 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("tsx", result.tapes, Tape::TZX, TargetPlatform::MSX)													// TSX
@@ -157,6 +184,7 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 #undef Format
 #undef Insert
 #undef TryInsert
+#undef InsertInstance
 
 	return result;
 }
@@ -183,6 +211,7 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 	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::AppleIIgs)		Append(AppleIIgs);
 	if(potential_platforms & TargetPlatform::Atari2600)		Append(Atari2600);
 	if(potential_platforms & TargetPlatform::AtariST)		Append(AtariST);
 	if(potential_platforms & TargetPlatform::ColecoVision)	Append(Coleco);

Analyser/Static/StaticAnalyser.hpp

@@ -35,6 +35,16 @@ struct Media {
 	bool empty() const {
 		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;
+	}
 };
 
 /*!
@@ -42,11 +52,12 @@ struct Media {
 	and instructions on how to launch the software attached, plus a measure of confidence in this target's correctness.
 */
 struct Target {
+	Target(Machine machine) : machine(machine) {}
 	virtual ~Target() {}
 
 	Machine machine;
 	Media media;
-	float confidence;
+	float confidence = 0.0f;
 };
 typedef std::vector<std::unique_ptr<Target>> TargetList;
 

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/Target.hpp

@@ -9,6 +9,8 @@
 #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>
 
@@ -16,17 +18,26 @@ namespace Analyser {
 namespace Static {
 namespace 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);
+		}
+	}
 };
 
 }

ClockReceiver/ClockReceiver.hpp

@@ -176,7 +176,6 @@ class Cycles: public WrappedInt<Cycles> {
 	public:
 		forceinline constexpr Cycles(IntType l) noexcept : WrappedInt<Cycles>(l) {}
 		forceinline constexpr Cycles() noexcept : WrappedInt<Cycles>() {}
-		forceinline constexpr Cycles(const Cycles &cycles) noexcept : WrappedInt<Cycles>(cycles.length_) {}
 
 	private:
 		friend WrappedInt;
@@ -198,7 +197,6 @@ class HalfCycles: public WrappedInt<HalfCycles> {
 		forceinline constexpr HalfCycles() noexcept : WrappedInt<HalfCycles>() {}
 
 		forceinline constexpr HalfCycles(const Cycles &cycles) noexcept : WrappedInt<HalfCycles>(cycles.as_integral() * 2) {}
-		forceinline constexpr HalfCycles(const HalfCycles &half_cycles) noexcept : WrappedInt<HalfCycles>(half_cycles.length_) {}
 
 		/// @returns The number of whole cycles completely covered by this span of half cycles.
 		forceinline constexpr Cycles cycles() const {

ClockReceiver/ClockingHintSource.hpp

@@ -67,7 +67,7 @@ class Source {
 		}
 
 		/// @returns the current preferred clocking strategy.
-		virtual Preference preferred_clocking() = 0;
+		virtual Preference preferred_clocking() const = 0;
 
 	private:
 		Observer *observer_ = nullptr;

ClockReceiver/DeferredQueue.hpp

@@ -13,62 +13,68 @@
 #include <vector>
 
 /*!
-	A DeferredQueue maintains a list of ordered actions and the times at which
-	they should happen, and divides a total execution period up into the portions
-	that occur between those actions, triggering each action when it is reached.
+	Provides the logic to insert into and traverse a list of future scheduled items.
 */
 template <typename TimeUnit> class DeferredQueue {
 	public:
-		/// Constructs a DeferredQueue that will call target(period) in between deferred actions.
-		DeferredQueue(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
-
 		/*!
 			Schedules @c action to occur in @c delay units of time.
-
-			Actions must be scheduled in the order they will occur. It is undefined behaviour
-			to schedule them out of order.
 		*/
 		void defer(TimeUnit delay, const std::function<void(void)> &action) {
-			pending_actions_.emplace_back(delay, action);
-		}
-
-		/*!
-			Runs for @c length units of time.
-
-			The constructor-supplied target will be called with one or more periods that add up to @c length;
-			any scheduled actions will be called between periods.
-		*/
-		void run_for(TimeUnit length) {
-			// If there are no pending actions, just run for the entire length.
-			// This should be the normal branch.
-			if(pending_actions_.empty()) {
-				target_(length);
+			// Apply immediately if there's no delay (or a negative delay).
+			if(delay <= TimeUnit(0)) {
+				action();
 				return;
 			}
 
-			// Divide the time to run according to the pending actions.
-			while(length > TimeUnit(0)) {
-				TimeUnit next_period = pending_actions_.empty() ? length : std::min(length, pending_actions_[0].delay);
-				target_(next_period);
-				length -= next_period;
+			if(!pending_actions_.empty()) {
+				// Otherwise enqueue, having subtracted the delay for any preceding events,
+				// and subtracting from the subsequent, if any.
+				auto insertion_point = pending_actions_.begin();
+				while(insertion_point != pending_actions_.end() && insertion_point->delay < delay) {
+					delay -= insertion_point->delay;
+					++insertion_point;
+				}
+				if(insertion_point != pending_actions_.end()) {
+					insertion_point->delay -= delay;
+				}
 
-				off_t performances = 0;
-				for(auto &action: pending_actions_) {
-					action.delay -= next_period;
-					if(!action.delay) {
-						action.action();
-						++performances;
-					}
-				}
-				if(performances) {
-					pending_actions_.erase(pending_actions_.begin(), pending_actions_.begin() + performances);
+				pending_actions_.emplace(insertion_point, delay, action);
+			} else {
+				pending_actions_.emplace_back(delay, action);
+			}
+		}
+
+		/*!
+			@returns The amount of time until the next enqueued action will occur,
+				or TimeUnit(-1) if the queue is empty.
+		*/
+		TimeUnit time_until_next_action() const {
+			if(pending_actions_.empty()) return TimeUnit(-1);
+			return pending_actions_.front().delay;
+		}
+
+		/*!
+			Advances the queue the specified amount of time, performing any actions it reaches.
+		*/
+		void advance(TimeUnit time) {
+			auto erase_iterator = pending_actions_.begin();
+			while(erase_iterator != pending_actions_.end()) {
+				erase_iterator->delay -= time;
+				if(erase_iterator->delay <= TimeUnit(0)) {
+					time = -erase_iterator->delay;
+					erase_iterator->action();
+					++erase_iterator;
+				} else {
+					break;
 				}
 			}
+			if(erase_iterator != pending_actions_.begin()) {
+				pending_actions_.erase(pending_actions_.begin(), erase_iterator);
+			}
 		}
 
 	private:
-		std::function<void(TimeUnit)> target_;
-
 		// The list of deferred actions.
 		struct DeferredAction {
 			TimeUnit delay;
@@ -79,4 +85,40 @@ template <typename TimeUnit> class DeferredQueue {
 		std::vector<DeferredAction> pending_actions_;
 };
 
+/*!
+	A DeferredQueue maintains a list of ordered actions and the times at which
+	they should happen, and divides a total execution period up into the portions
+	that occur between those actions, triggering each action when it is reached.
+
+	This list is efficient only for short queues.
+*/
+template <typename TimeUnit> class DeferredQueuePerformer: public DeferredQueue<TimeUnit> {
+	public:
+		/// Constructs a DeferredQueue that will call target(period) in between deferred actions.
+		constexpr DeferredQueuePerformer(std::function<void(TimeUnit)> &&target) : target_(std::move(target)) {}
+
+		/*!
+			Runs for @c length units of time.
+
+			The constructor-supplied target will be called with one or more periods that add up to @c length;
+			any scheduled actions will be called between periods.
+		*/
+		void run_for(TimeUnit length) {
+			auto time_to_next = DeferredQueue<TimeUnit>::time_until_next_action();
+			while(time_to_next != TimeUnit(-1) && time_to_next <= length) {
+				target_(time_to_next);
+				length -= time_to_next;
+				DeferredQueue<TimeUnit>::advance(time_to_next);
+			}
+
+			DeferredQueue<TimeUnit>::advance(length);
+			target_(length);
+
+			// TODO: optimise this to avoid the multiple std::vector deletes. Find a neat way to expose that solution, maybe?
+		}
+
+	private:
+		std::function<void(TimeUnit)> target_;
+};
+
 #endif /* DeferredQueue_h */

ClockReceiver/JustInTime.hpp

@@ -21,39 +21,89 @@
 
 	Machines that accumulate HalfCycle time but supply to a Cycle-counted device may supply a
 	separate @c TargetTimeScale at template declaration.
+
+	If the held object implements get_next_sequence_point() then it'll be used to flush implicitly
+	as and when sequence points are hit. Callers can use will_flush() to predict these.
 */
 template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = HalfCycles, class TargetTimeScale = LocalTimeScale> class JustInTimeActor {
+	private:
+		class SequencePointAwareDeleter {
+			public:
+				explicit SequencePointAwareDeleter(JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *actor) : actor_(actor) {}
+
+				void operator ()(const T *const) const {
+					if constexpr (has_sequence_points<T>::value) {
+						actor_->update_sequence_point();
+					}
+				}
+
+			private:
+				JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *const actor_;
+		};
+
 	public:
 		/// Constructs a new JustInTimeActor using the same construction arguments as the included object.
 		template<typename... Args> JustInTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {}
 
 		/// Adds time to the actor.
-		forceinline void operator += (const LocalTimeScale &rhs) {
+		forceinline void operator += (LocalTimeScale rhs) {
 			if constexpr (multiplier != 1) {
 				time_since_update_ += rhs * multiplier;
 			} else {
 				time_since_update_ += rhs;
 			}
 			is_flushed_ = false;
+
+			if constexpr (has_sequence_points<T>::value) {
+				time_until_event_ -= rhs;
+				if(time_until_event_ <= LocalTimeScale(0)) {
+					flush();
+					update_sequence_point();
+				}
+			}
 		}
 
 		/// Flushes all accumulated time and returns a pointer to the included object.
-		forceinline T *operator->() {
+		///
+		/// If this object provides sequence points, checks for changes to the next
+		/// sequence point upon deletion of the pointer.
+		forceinline auto operator->() {
 			flush();
-			return &object_;
+			return std::unique_ptr<T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(this));
 		}
 
-		/// Returns a pointer to the included object without flushing time.
+		/// Acts exactly as per the standard ->, but preserves constness.
+		///
+		/// Despite being const, this will flush the object and, if relevant, update the next sequence point.
+		forceinline auto operator -> () const {
+			auto non_const_this = const_cast<JustInTimeActor<T, multiplier, divider, LocalTimeScale, TargetTimeScale> *>(this);
+			non_const_this->flush();
+			return std::unique_ptr<const T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(non_const_this));
+		}
+
+		/// @returns a pointer to the included object, without flushing time.
 		forceinline T *last_valid() {
 			return &object_;
 		}
 
+		/// @returns the amount of time since the object was last flushed, in the target time scale.
+		forceinline TargetTimeScale time_since_flush() const {
+			// TODO: does this handle conversions properly where TargetTimeScale != LocalTimeScale?
+			if constexpr (divider == 1) {
+				return time_since_update_;
+			}
+			return TargetTimeScale(time_since_update_.as_integral() / divider);
+		}
+
 		/// Flushes all accumulated time.
+		///
+		/// This does not affect this actor's record of when the next sequence point will occur.
 		forceinline void flush() {
 			if(!is_flushed_) {
-				is_flushed_ = true;
+				did_flush_ = is_flushed_ = true;
 				if constexpr (divider == 1) {
-					object_.run_for(time_since_update_.template flush<TargetTimeScale>());
+					const auto duration = time_since_update_.template flush<TargetTimeScale>();
+					object_.run_for(duration);
 				} else {
 					const auto duration = time_since_update_.template divide<TargetTimeScale>(LocalTimeScale(divider));
 					if(duration > TargetTimeScale(0))
@@ -62,10 +112,85 @@ template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = H
 			}
 		}
 
+		/// Indicates whether a flush has occurred since the last call to did_flush().
+		forceinline bool did_flush() {
+			const bool did_flush = did_flush_;
+			did_flush_ = false;
+			return did_flush;
+		}
+
+		/// @returns the number of cycles until the next sequence-point-based flush, if the embedded object
+		/// supports sequence points; @c LocalTimeScale() otherwise.
+		LocalTimeScale cycles_until_implicit_flush() const {
+			return time_until_event_;
+		}
+
+		/// Indicates whether a sequence-point-caused flush will occur if the specified period is added.
+		forceinline bool will_flush(LocalTimeScale rhs) const {
+			if constexpr (!has_sequence_points<T>::value) {
+				return false;
+			}
+			return rhs >= time_until_event_;
+		}
+
+		/// Updates this template's record of the next sequence point.
+		void update_sequence_point() {
+			if constexpr (has_sequence_points<T>::value) {
+				time_until_event_ = object_.get_next_sequence_point();
+				assert(time_until_event_ > LocalTimeScale(0));
+			}
+		}
+
 	private:
 		T object_;
-		LocalTimeScale time_since_update_;
+		LocalTimeScale time_since_update_, time_until_event_;
 		bool is_flushed_ = true;
+		bool did_flush_ = false;
+
+		template <typename S, typename = void> struct has_sequence_points : std::false_type {};
+		template <typename S> struct has_sequence_points<S, decltype(void(std::declval<S &>().get_next_sequence_point()))> : std::true_type {};
+};
+
+/*!
+	A RealTimeActor presents the same interface as a JustInTimeActor but doesn't defer work.
+	Time added will be performed immediately.
+
+	Its primary purpose is to allow consumers to remain flexible in their scheduling.
+*/
+template <class T, int multiplier = 1, int divider = 1, class LocalTimeScale = HalfCycles, class TargetTimeScale = LocalTimeScale> class RealTimeActor {
+	public:
+		template<typename... Args> RealTimeActor(Args&&... args) : object_(std::forward<Args>(args)...) {}
+
+		forceinline void operator += (const LocalTimeScale &rhs) {
+			if constexpr (multiplier == 1 && divider == 1) {
+				object_.run_for(TargetTimeScale(rhs));
+				return;
+			}
+
+			if constexpr (multiplier == 1) {
+				accumulated_time_ += rhs;
+			} else {
+				accumulated_time_ += rhs * multiplier;
+			}
+
+			if constexpr (divider == 1) {
+				const auto duration = accumulated_time_.template flush<TargetTimeScale>();
+				object_.run_for(duration);
+			} else {
+				const auto duration = accumulated_time_.template divide<TargetTimeScale>(LocalTimeScale(divider));
+				if(duration > TargetTimeScale(0))
+					object_.run_for(duration);
+			}
+		}
+
+		forceinline T *operator->()				{	return &object_;	}
+		forceinline const T *operator->() const	{	return &object_;	}
+		forceinline T *last_valid() 			{	return &object_;	}
+		forceinline void flush()				{}
+
+	private:
+		T object_;
+		LocalTimeScale accumulated_time_;
 };
 
 /*!

ClockReceiver/ScanSynchroniser.hpp

@@ -0,0 +1,88 @@
+//
+//  ScanSynchroniser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#ifndef ScanSynchroniser_h
+#define ScanSynchroniser_h
+
+#include "../Outputs/ScanTarget.hpp"
+
+#include <cmath>
+
+namespace Time {
+
+/*!
+	Where an emulated machine is sufficiently close to a host machine's frame rate that a small nudge in
+	its speed multiplier will bring it into frame synchronisation, the ScanSynchroniser provides a sequence of
+	speed multipliers designed both to adjust the machine to the proper speed and, in a reasonable amount
+	of time, to bring it into phase.
+*/
+class ScanSynchroniser {
+	public:
+		/*!
+			@returns @c true if the emulated machine can be synchronised with the host frame output based on its
+				current @c [scan]status and the host machine's @c frame_duration; @c false otherwise.
+		*/
+		bool can_synchronise(const Outputs::Display::ScanStatus &scan_status, double frame_duration) {
+			ratio_ = 1.0;
+			if(scan_status.field_duration_gradient < 0.00001) {
+				// Check out the machine's current frame time.
+				// If it's within 3% of a non-zero integer multiple of the
+				// display rate, mark this time window to be split over the sync.
+				ratio_ = (frame_duration * base_multiplier_) / scan_status.field_duration;
+				const double integer_ratio = round(ratio_);
+				if(integer_ratio > 0.0) {
+					ratio_ /= integer_ratio;
+					return ratio_ <= maximum_rate_adjustment && ratio_ >= 1.0 / maximum_rate_adjustment;
+				}
+			}
+			return false;
+		}
+
+		/*!
+			@returns The appropriate speed multiplier for the next frame based on the inputs previously supplied to @c can_synchronise.
+				Results are undefined if @c can_synchroise returned @c false.
+		*/
+		double next_speed_multiplier(const Outputs::Display::ScanStatus &scan_status) {
+			// The host versus emulated ratio is calculated based on the current perceived frame duration of the machine.
+			// Either that number is exactly correct or it's already the result of some sort of low-pass filter. So there's
+			// no benefit to second guessing it here — just take it to be correct.
+			//
+			// ... with one slight caveat, which is that it is desireable to adjust phase here, to align vertical sync points.
+			// So the set speed multiplier may be adjusted slightly to aim for that.
+			double speed_multiplier = 1.0 / (ratio_ / base_multiplier_);
+			if(scan_status.current_position > 0.0) {
+				if(scan_status.current_position < 0.5) speed_multiplier /= phase_adjustment_ratio;
+				else speed_multiplier *= phase_adjustment_ratio;
+			}
+			speed_multiplier_ = (speed_multiplier_ * 0.95) + (speed_multiplier * 0.05);
+			return speed_multiplier_ * base_multiplier_;
+		}
+
+		void set_base_speed_multiplier(double multiplier) {
+			base_multiplier_ = multiplier;
+		}
+
+		double get_base_speed_multiplier() {
+			return base_multiplier_;
+		}
+
+	private:
+		static constexpr double maximum_rate_adjustment = 1.03;
+		static constexpr double phase_adjustment_ratio = 1.005;
+
+		// Managed local state.
+		double speed_multiplier_ = 1.0;
+		double base_multiplier_ = 1.0;
+
+		// Temporary storage to bridge the can_synchronise -> next_speed_multiplier gap.
+		double ratio_ = 1.0;
+};
+
+}
+
+#endif /* ScanSynchroniser_h */

ClockReceiver/TimeTypes.hpp

@@ -9,9 +9,16 @@
 #ifndef TimeTypes_h
 #define TimeTypes_h
 
+#include <chrono>
+
 namespace Time {
 
 typedef double Seconds;
+typedef int64_t Nanos;
+
+inline Nanos nanos_now() {
+	return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+}
 
 }
 

ClockReceiver/VSyncPredictor.hpp

@@ -0,0 +1,155 @@
+//
+//  VSyncPredictor.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/06/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#ifndef VSyncPredictor_hpp
+#define VSyncPredictor_hpp
+
+#include "TimeTypes.hpp"
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+
+namespace Time {
+
+/*!
+	For platforms that provide no avenue into vsync tracking other than block-until-sync,
+	this class tracks: (i) how long frame draw takes; (ii) the apparent frame period; and
+	(iii) optionally, timer jitter; in order to suggest when you should next start drawing.
+*/
+class VSyncPredictor {
+	public:
+		/*!
+			Announces to the predictor that the work of producing an output frame has begun.
+		*/
+		void begin_redraw() {
+			redraw_begin_time_ = nanos_now();
+		}
+
+		/*!
+			Announces to the predictor that the work of producing an output frame has ended;
+			the predictor will use the amount of time between each begin/end pair to modify
+			its expectations as to how long it takes to draw a frame.
+		*/
+		void end_redraw() {
+			redraw_period_.post(nanos_now() - redraw_begin_time_);
+		}
+
+		/*!
+			Informs the predictor that a block-on-vsync has just ended, i.e. that the moment this
+			machine calls retrace is now. The predictor uses these notifications to estimate output
+			frame rate.
+		*/
+		void announce_vsync() {
+			const auto now = nanos_now();
+
+			if(last_vsync_) {
+				last_vsync_ += frame_duration_;
+				vsync_jitter_.post(last_vsync_ - now);
+				last_vsync_ = (last_vsync_ + now) >> 1;
+			} else {
+				last_vsync_ = now;
+			}
+		}
+
+		/*!
+			Sets the frame rate for the target display.
+		*/
+		void set_frame_rate(float rate) {
+			frame_duration_ = Nanos(1'000'000'000.0f / rate);
+		}
+
+		/*!
+			@returns The time this class currently believes a whole frame occupies.
+		*/
+		Time::Nanos frame_duration() {
+			return frame_duration_;
+		}
+
+		/*!
+			Adds a record of how much jitter was experienced in scheduling; these values will be
+			factored into the @c suggested_draw_time if supplied.
+
+			A positive number means the timer occurred late. A negative number means it occurred early.
+		*/
+		void add_timer_jitter(Time::Nanos jitter) {
+			timer_jitter_.post(jitter);
+		}
+
+		/*!
+			Announces to the vsync predictor that output is now paused. This ends frame period
+			calculations until the next announce_vsync() restarts frame-length counting.
+		*/
+		void pause() {
+			last_vsync_ = 0;
+		}
+
+		/*!
+			@return The time at which redrawing should begin, given the predicted frame period, how
+			long it appears to take to draw a frame and how much jitter there is in scheduling
+			(if those figures are being supplied).
+		*/
+		Nanos suggested_draw_time() {
+			const auto mean = redraw_period_.mean() + timer_jitter_.mean() + vsync_jitter_.mean();
+			const auto variance = redraw_period_.variance() + timer_jitter_.variance() + vsync_jitter_.variance();
+
+			// Permit three standard deviations from the mean, to cover 99.9% of cases.
+			const auto period = mean + Nanos(3.0f * sqrt(float(variance)));
+
+			return last_vsync_ + frame_duration_ - period;
+		}
+
+	private:
+		class VarianceCollector {
+			public:
+				VarianceCollector(Time::Nanos default_value) {
+					sum_ = default_value * 128;
+					for(int c = 0; c < 128; ++c) {
+						history_[c] = default_value;
+					}
+				}
+
+				void post(Time::Nanos value) {
+					sum_ -= history_[write_pointer_];
+					sum_ += value;
+					history_[write_pointer_] = value;
+					write_pointer_ = (write_pointer_ + 1) & 127;
+				}
+
+				Time::Nanos mean() {
+					return sum_ / 128;
+				}
+
+				Time::Nanos variance() {
+					// I haven't yet come up with a better solution that calculating this
+					// in whole every time, given the way that the mean mutates.
+					Time::Nanos variance = 0;
+					for(int c = 0; c < 128; ++c) {
+						const auto difference = ((history_[c] * 128) - sum_) / 128;
+						variance += (difference * difference);
+					}
+					return variance / 128;
+				}
+
+			private:
+				Time::Nanos sum_;
+				Time::Nanos history_[128];
+				size_t write_pointer_ = 0;
+		};
+
+		Nanos redraw_begin_time_ = 0;
+		Nanos last_vsync_ = 0;
+		Nanos frame_duration_ = 1'000'000'000 / 60;
+
+		VarianceCollector vsync_jitter_{0};
+		VarianceCollector redraw_period_{1'000'000'000 / 60};	// A less convincing first guess.
+		VarianceCollector timer_jitter_{0};						// Seed at 0 in case this feature isn't used by the owner.
+};
+
+}
+
+#endif /* VSyncPredictor_hpp */

Components/1770/1770.cpp

@@ -23,7 +23,7 @@ WD1770::WD1770(Personality p) :
 	posit_event(int(Event1770::Command));
 }
 
-void WD1770::set_register(int address, uint8_t value) {
+void WD1770::write(int address, uint8_t value) {
 	switch(address&3) {
 		case 0: {
 			if((value&0xf0) == 0xd0) {
@@ -54,7 +54,7 @@ void WD1770::set_register(int address, uint8_t value) {
 	}
 }
 
-uint8_t WD1770::get_register(int address) {
+uint8_t WD1770::read(int address) {
 	switch(address&3) {
 		default: {
 			update_status([] (Status &status) {
@@ -336,6 +336,7 @@ void WD1770::posit_event(int new_event_type) {
 		READ_ID();
 
 		if(index_hole_count_ == 6) {
+			LOG("Nothing found to verify");
 			update_status([] (Status &status) {
 				status.seek_error = true;
 			});
@@ -480,7 +481,7 @@ void WD1770::posit_event(int new_event_type) {
 			status.data_request = true;
 		});
 		distance_into_section_++;
-		if(distance_into_section_ == 128 << header_[3]) {
+		if(distance_into_section_ == 128 << (header_[3]&3)) {
 			distance_into_section_ = 0;
 			goto type2_check_crc;
 		}
@@ -497,7 +498,7 @@ void WD1770::posit_event(int new_event_type) {
 
 			if(get_crc_generator().get_value()) {
 				LOG("CRC error; terminating");
-				update_status([this] (Status &status) {
+				update_status([] (Status &status) {
 					status.crc_error = true;
 				});
 				goto wait_for_command;
@@ -563,7 +564,7 @@ void WD1770::posit_event(int new_event_type) {
 		*/
 		write_byte(data_);
 		distance_into_section_++;
-		if(distance_into_section_ == 128 << header_[3]) {
+		if(distance_into_section_ == 128 << (header_[3]&3)) {
 			goto type2_write_crc;
 		}
 
@@ -815,15 +816,19 @@ void WD1770::update_status(std::function<void(Status &)> updater) {
 	if(status_.busy != old_status.busy) update_clocking_observer();
 }
 
-void WD1770::set_head_load_request(bool head_load) {}
-void WD1770::set_motor_on(bool motor_on) {}
+void WD1770::set_head_load_request(bool) {}
+void WD1770::set_motor_on(bool) {}
 
 void WD1770::set_head_loaded(bool head_loaded) {
 	head_is_loaded_ = head_loaded;
 	if(head_loaded) posit_event(int(Event1770::HeadLoad));
 }
 
-ClockingHint::Preference WD1770::preferred_clocking() {
+bool WD1770::get_head_loaded() const {
+	return head_is_loaded_;
+}
+
+ClockingHint::Preference WD1770::preferred_clocking() const {
 	if(status_.busy) return ClockingHint::Preference::RealTime;
 	return Storage::Disk::MFMController::preferred_clocking();
 }

Components/1770/1770.hpp

@@ -31,59 +31,63 @@ class WD1770: public Storage::Disk::MFMController {
 			@param p The type of controller to emulate.
 		*/
 		WD1770(Personality p);
+		virtual ~WD1770() {}
 
 		/// Sets the value of the double-density input; when @c is_double_density is @c true, reads and writes double-density format data.
 		using Storage::Disk::MFMController::set_is_double_density;
 
 		/// Writes @c value to the register at @c address. Only the low two bits of the address are decoded.
-		void set_register(int address, uint8_t value);
+		void write(int address, uint8_t value);
 
 		/// Fetches the value of the register @c address. Only the low two bits of the address are decoded.
-		uint8_t get_register(int address);
+		uint8_t read(int address);
 
 		/// Runs the controller for @c number_of_cycles cycles.
 		void run_for(const Cycles cycles);
 
 		enum Flag: uint8_t {
-			NotReady		= 0x80,
+			NotReady		= 0x80,		// 0x80
 			MotorOn			= 0x80,
-			WriteProtect	= 0x40,
-			RecordType		= 0x20,
+			WriteProtect	= 0x40,		// 0x40
+			RecordType		= 0x20,		// 0x20
 			SpinUp			= 0x20,
 			HeadLoaded		= 0x20,
-			RecordNotFound	= 0x10,
+			RecordNotFound	= 0x10,		// 0x10
 			SeekError		= 0x10,
-			CRCError		= 0x08,
-			LostData		= 0x04,
+			CRCError		= 0x08,		// 0x08
+			LostData		= 0x04,		// 0x04
 			TrackZero		= 0x04,
-			DataRequest		= 0x02,
+			DataRequest		= 0x02,		// 0x02
 			Index			= 0x02,
-			Busy			= 0x01
+			Busy			= 0x01		// 0x01
 		};
 
 		/// @returns The current value of the IRQ line output.
-		inline bool get_interrupt_request_line()		{	return status_.interrupt_request;	}
+		inline bool get_interrupt_request_line() const	{	return status_.interrupt_request;	}
 
 		/// @returns The current value of the DRQ line output.
-		inline bool get_data_request_line()				{	return status_.data_request;		}
+		inline bool get_data_request_line() const		{	return status_.data_request;		}
 
 		class Delegate {
 			public:
 				virtual void wd1770_did_change_output(WD1770 *wd1770) = 0;
 		};
-		inline void set_delegate(Delegate *delegate)	{	delegate_ = delegate;			}
+		inline void set_delegate(Delegate *delegate)	{	delegate_ = delegate;				}
 
-		ClockingHint::Preference preferred_clocking() final;
+		ClockingHint::Preference preferred_clocking() const final;
 
 	protected:
 		virtual void set_head_load_request(bool head_load);
 		virtual void set_motor_on(bool motor_on);
 		void set_head_loaded(bool head_loaded);
 
+		/// @returns The last value posted to @c set_head_loaded.
+		bool get_head_loaded() const;
+
 	private:
-		Personality personality_;
-		inline bool has_motor_on_line() { return (personality_ != P1793 ) && (personality_ != P1773); }
-		inline bool has_head_load_line() { return (personality_ == P1793 ); }
+		const Personality personality_;
+		bool has_motor_on_line() const { return (personality_ != P1793 ) && (personality_ != P1773); }
+		bool has_head_load_line() const { return (personality_ == P1793 ); }
 
 		struct Status {
 			bool write_protect = false;

Components/5380/ncr5380.cpp

@@ -18,9 +18,14 @@ NCR5380::NCR5380(SCSI::Bus &bus, int clock_rate) :
 	clock_rate_(clock_rate) {
 	device_id_ = bus_.add_device();
 	bus_.add_observer(this);
+
+	// TODO: use clock rate and expected phase. This implementation currently
+	// provides only CPU-driven polling behaviour.
+	(void)clock_rate_;
+	(void)expected_phase_;
 }
 
-void NCR5380::write(int address, uint8_t value, bool dma_acknowledge) {
+void NCR5380::write(int address, uint8_t value, bool) {
 	switch(address & 7) {
 		case 0:
 //			LOG("[SCSI 0] Set current SCSI bus state to " << PADHEX(2) << int(value));
@@ -128,7 +133,7 @@ void NCR5380::write(int address, uint8_t value, bool dma_acknowledge) {
 	}
 }
 
-uint8_t NCR5380::read(int address, bool dma_acknowledge) {
+uint8_t NCR5380::read(int address, bool) {
 	switch(address & 7) {
 		case 0:
 //			LOG("[SCSI 0] Get current SCSI bus state: " << PADHEX(2) << (bus_.get_state() & 0xff));
@@ -258,6 +263,7 @@ void NCR5380::scsi_bus_did_change(SCSI::Bus *, SCSI::BusState new_state, double
 		case ExecutionState::WaitingForBusy:
 			if(!(new_state & SCSI::Line::Busy) || time_since_change < SCSI::DeskewDelay) return;
 			state_ = ExecutionState::WatchingBusy;
+			[[fallthrough]];
 
 		case ExecutionState::WatchingBusy:
 			if(!(new_state & SCSI::Line::Busy)) {

Components/6522/6522.hpp

@@ -37,22 +37,22 @@ enum Line {
 class PortHandler {
 	public:
 		/// Requests the current input value of @c port from the port handler.
-		uint8_t get_port_input(Port port)										{	return 0xff;	}
+	uint8_t get_port_input([[maybe_unused]] Port port)										{	return 0xff;	}
 
 		/// Sets the current output value of @c port and provides @c direction_mask, indicating which pins are marked as output.
-		void set_port_output(Port port, uint8_t value, uint8_t direction_mask)	{}
+		void set_port_output([[maybe_unused]] Port port, [[maybe_unused]] uint8_t value, [[maybe_unused]] uint8_t direction_mask)	{}
 
 		/// Sets the current logical output level for line @c line on port @c port.
-		void set_control_line_output(Port port, Line line, bool value)			{}
+		void set_control_line_output([[maybe_unused]] Port port, [[maybe_unused]] Line line, [[maybe_unused]] bool value)			{}
 
 		/// Sets the current logical value of the interrupt line.
-		void set_interrupt_status(bool status)									{}
+		void set_interrupt_status([[maybe_unused]] bool status)									{}
 
 		/// Provides a measure of time elapsed between other calls.
-		void run_for(HalfCycles duration)										{}
+		void run_for([[maybe_unused]] HalfCycles duration)										{}
 
 		/// Receives passed-on flush() calls from the 6522.
-		void flush()															{}
+		void flush()																			{}
 };
 
 /*!
@@ -94,10 +94,10 @@ template <class T> class MOS6522: public MOS6522Storage {
 		MOS6522(const MOS6522 &) = delete;
 
 		/*! Sets a register value. */
-		void set_register(int address, uint8_t value);
+		void write(int address, uint8_t value);
 
 		/*! Gets a register value. */
-		uint8_t get_register(int address);
+		uint8_t read(int address);
 
 		/*! @returns the bus handler. */
 		T &bus_handler();
@@ -112,7 +112,7 @@ template <class T> class MOS6522: public MOS6522Storage {
 		void run_for(const Cycles cycles);
 
 		/// @returns @c true if the IRQ line is currently active; @c false otherwise.
-		bool get_interrupt_line();
+		bool get_interrupt_line() const;
 
 		/// Updates the port handler to the current time and then requests that it flush.
 		void flush();
@@ -128,13 +128,14 @@ template <class T> class MOS6522: public MOS6522Storage {
 
 		void access(int address);
 
-		uint8_t get_port_input(Port port, uint8_t output_mask, uint8_t output);
+		uint8_t get_port_input(Port port, uint8_t output_mask, uint8_t output, uint8_t timer_mask);
 		inline void reevaluate_interrupts();
 
 		/// Sets the current intended output value for the port and line;
 		/// if this affects the visible output, it will be passed to the handler.
 		void set_control_line_output(Port port, Line line, LineState value);
 		void evaluate_cb2_output();
+		void evaluate_port_b_output();
 };
 
 }

Components/6522/Implementation/6522Implementation.hpp

@@ -8,6 +8,10 @@
 
 #include "../../../Outputs/Log.hpp"
 
+// As-yet unimplemented (incomplete list):
+//
+//	PB6 count-down mode for timer 2.
+
 namespace MOS {
 namespace MOS6522 {
 
@@ -30,22 +34,22 @@ template <typename T> void MOS6522<T>::access(int address) {
 	}
 }
 
-template <typename T> void MOS6522<T>::set_register(int address, uint8_t value) {
+template <typename T> void MOS6522<T>::write(int address, uint8_t value) {
 	address &= 0xf;
 	access(address);
 	switch(address) {
-		case 0x0:	// Write Port B.
+		case 0x0:	// Write Port B. ('ORB')
 			// Store locally and communicate outwards.
 			registers_.output[1] = value;
 
 			bus_handler_.run_for(time_since_bus_handler_call_.flush<HalfCycles>());
-			bus_handler_.set_port_output(Port::B, value, registers_.data_direction[1]);
+			evaluate_port_b_output();
 
 			registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | ((registers_.peripheral_control&0x20) ? 0 : InterruptFlag::CB2ActiveEdge));
 			reevaluate_interrupts();
 		break;
 		case 0xf:
-		case 0x1:	// Write Port A.
+		case 0x1:	// Write Port A. ('ORA')
 			registers_.output[0] = value;
 
 			bus_handler_.run_for(time_since_bus_handler_call_.flush<HalfCycles>());
@@ -59,36 +63,52 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
 			reevaluate_interrupts();
 		break;
 
-		case 0x2:	// Port B direction.
+		case 0x2:	// Port B direction ('DDRB').
 			registers_.data_direction[1] = value;
 		break;
-		case 0x3:	// Port A direction.
+		case 0x3:	// Port A direction ('DDRA').
 			registers_.data_direction[0] = value;
 		break;
 
 		// Timer 1
-		case 0x6:	case 0x4:	registers_.timer_latch[0] = (registers_.timer_latch[0]&0xff00) | value;	break;
-		case 0x5:	case 0x7:
-			registers_.timer_latch[0] = (registers_.timer_latch[0]&0x00ff) | static_cast<uint16_t>(value << 8);
-			registers_.interrupt_flags &= ~InterruptFlag::Timer1;
-			if(address == 0x05) {
-				registers_.next_timer[0] = registers_.timer_latch[0];
-				timer_is_running_[0] = true;
+		case 0x6:	case 0x4:	// ('T1L-L' and 'T1C-L')
+			registers_.timer_latch[0] = (registers_.timer_latch[0]&0xff00) | value;
+		break;
+		case 0x7:	// Timer 1 latch, high ('T1L-H').
+			registers_.timer_latch[0] = (registers_.timer_latch[0]&0x00ff) | uint16_t(value << 8);
+		break;
+		case 0x5:	// Timer 1 counter, high ('T1C-H').
+			// Fill latch.
+			registers_.timer_latch[0] = (registers_.timer_latch[0]&0x00ff) | uint16_t(value << 8);
+
+			// Restart timer.
+			registers_.next_timer[0] = registers_.timer_latch[0];
+			timer_is_running_[0] = true;
+
+			// If PB7 output mode is active, set it low.
+			if(timer1_is_controlling_pb7()) {
+				registers_.timer_port_b_output &= 0x7f;
+				evaluate_port_b_output();
 			}
+
+			// Clear existing interrupt flag.
+			registers_.interrupt_flags &= ~InterruptFlag::Timer1;
 			reevaluate_interrupts();
 		break;
 
 		// Timer 2
-		case 0x8:	registers_.timer_latch[1] = value;	break;
-		case 0x9:
+		case 0x8:	// ('T2C-L')
+			registers_.timer_latch[1] = value;
+		break;
+		case 0x9:	// ('T2C-H')
 			registers_.interrupt_flags &= ~InterruptFlag::Timer2;
-			registers_.next_timer[1] = registers_.timer_latch[1] | static_cast<uint16_t>(value << 8);
+			registers_.next_timer[1] = registers_.timer_latch[1] | uint16_t(value << 8);
 			timer_is_running_[1] = true;
 			reevaluate_interrupts();
 		break;
 
 		// Shift
-		case 0xa:
+		case 0xa:	// ('SR')
 			registers_.shift = value;
 			shift_bits_remaining_ = 8;
 			registers_.interrupt_flags &= ~InterruptFlag::ShiftRegister;
@@ -96,11 +116,18 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
 		break;
 
 		// Control
-		case 0xb:
+		case 0xb:	// Auxiliary control ('ACR').
 			registers_.auxiliary_control = value;
 			evaluate_cb2_output();
+
+			// This is a bit of a guess: reset the timer-based PB7 output to its default high level
+			// any timer that timer-linked PB7 output is disabled.
+			if(!timer1_is_controlling_pb7()) {
+				registers_.timer_port_b_output |= 0x80;
+			}
+			evaluate_port_b_output();
 		break;
-		case 0xc: {
+		case 0xc: {	// Peripheral control ('PCR').
 //			const auto old_peripheral_control = registers_.peripheral_control;
 			registers_.peripheral_control = value;
 
@@ -141,11 +168,11 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
 		} break;
 
 		// Interrupt control
-		case 0xd:
+		case 0xd:	// Interrupt flag regiser ('IFR').
 			registers_.interrupt_flags &= ~value;
 			reevaluate_interrupts();
 		break;
-		case 0xe:
+		case 0xe:	// Interrupt enable register ('IER').
 			if(value&0x80)
 				registers_.interrupt_enable |= value;
 			else
@@ -155,58 +182,59 @@ template <typename T> void MOS6522<T>::set_register(int address, uint8_t value)
 	}
 }
 
-template <typename T> uint8_t MOS6522<T>::get_register(int address) {
+template <typename T> uint8_t MOS6522<T>::read(int address) {
 	address &= 0xf;
 	access(address);
 	switch(address) {
-		case 0x0:
+		case 0x0:	// Read Port B ('IRB').
 			registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | InterruptFlag::CB2ActiveEdge);
 			reevaluate_interrupts();
-		return get_port_input(Port::B, registers_.data_direction[1], registers_.output[1]);
+		return get_port_input(Port::B, registers_.data_direction[1], registers_.output[1], registers_.auxiliary_control & 0x80);
 		case 0xf:
-		case 0x1:
+		case 0x1:	// Read Port A ('IRA').
 			registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | InterruptFlag::CA2ActiveEdge);
 			reevaluate_interrupts();
-		return get_port_input(Port::A, registers_.data_direction[0], registers_.output[0]);
+		return get_port_input(Port::A, registers_.data_direction[0], registers_.output[0], 0);
 
-		case 0x2:	return registers_.data_direction[1];
-		case 0x3:	return registers_.data_direction[0];
+		case 0x2:	return registers_.data_direction[1];	// Port B direction ('DDRB').
+		case 0x3:	return registers_.data_direction[0];	// Port A direction ('DDRA').
 
 		// Timer 1
-		case 0x4:
+		case 0x4:	// Timer 1 low-order latches ('T1L-L').
 			registers_.interrupt_flags &= ~InterruptFlag::Timer1;
 			reevaluate_interrupts();
 		return registers_.timer[0] & 0x00ff;
-		case 0x5:	return registers_.timer[0] >> 8;
-		case 0x6:	return registers_.timer_latch[0] & 0x00ff;
-		case 0x7:	return registers_.timer_latch[0] >> 8;
+		case 0x5:	return registers_.timer[0] >> 8;			// Timer 1 high-order counter ('T1C-H')
+		case 0x6:	return registers_.timer_latch[0] & 0x00ff;	// Timer 1 low-order latches ('T1L-L').
+		case 0x7:	return registers_.timer_latch[0] >> 8;		// Timer 1 high-order latches ('T1L-H').
 
 		// Timer 2
-		case 0x8:
+		case 0x8:	// Timer 2 low-order counter ('T2C-L').
 			registers_.interrupt_flags &= ~InterruptFlag::Timer2;
 			reevaluate_interrupts();
 		return registers_.timer[1] & 0x00ff;
-		case 0x9:	return registers_.timer[1] >> 8;
+		case 0x9:	return registers_.timer[1] >> 8;	// Timer 2 high-order counter ('T2C-H').
 
-		case 0xa:
+		case 0xa:	// Shift register ('SR').
 			shift_bits_remaining_ = 8;
 			registers_.interrupt_flags &= ~InterruptFlag::ShiftRegister;
 			reevaluate_interrupts();
 		return registers_.shift;
 
-		case 0xb:	return registers_.auxiliary_control;
-		case 0xc:	return registers_.peripheral_control;
+		case 0xb:	return registers_.auxiliary_control;	// Auxiliary control ('ACR').
+		case 0xc:	return registers_.peripheral_control;	// Peripheral control ('PCR').
 
-		case 0xd:	return registers_.interrupt_flags | (get_interrupt_line() ? 0x80 : 0x00);
-		case 0xe:	return registers_.interrupt_enable | 0x80;
+		case 0xd:	return registers_.interrupt_flags | (get_interrupt_line() ? 0x80 : 0x00);	// Interrupt flag register ('IFR').
+		case 0xe:	return registers_.interrupt_enable | 0x80;									// Interrupt enable register ('IER').
 	}
 
 	return 0xff;
 }
 
-template <typename T> uint8_t MOS6522<T>::get_port_input(Port port, uint8_t output_mask, uint8_t output) {
+template <typename T> uint8_t MOS6522<T>::get_port_input(Port port, uint8_t output_mask, uint8_t output, uint8_t timer_mask) {
 	bus_handler_.run_for(time_since_bus_handler_call_.flush<HalfCycles>());
 	const uint8_t input = bus_handler_.get_port_input(port);
+	output = (output & ~timer_mask) | (registers_.timer_port_b_output & timer_mask);
 	return (input & ~output_mask) | (output & output_mask);
 }
 
@@ -276,16 +304,19 @@ template <typename T> void MOS6522<T>::do_phase2() {
 		registers_.timer_needs_reload = false;
 		registers_.timer[0] = registers_.timer_latch[0];
 	} else {
-		registers_.timer[0] --;
+		-- registers_.timer[0];
 	}
 
-	registers_.timer[1] --;
+	// Count down timer 2 if it is in timed interrupt mode (i.e. auxiliary control bit 5 is clear).
+	registers_.timer[1] -= timer2_clock_decrement();
+
+	// TODO: can eliminate conditional branches here.
 	if(registers_.next_timer[0] >= 0) {
-		registers_.timer[0] = static_cast<uint16_t>(registers_.next_timer[0]);
+		registers_.timer[0] = uint16_t(registers_.next_timer[0]);
 		registers_.next_timer[0] = -1;
 	}
 	if(registers_.next_timer[1] >= 0) {
-		registers_.timer[1] = static_cast<uint16_t>(registers_.next_timer[1]);
+		registers_.timer[1] = uint16_t(registers_.next_timer[1]);
 		registers_.next_timer[1] = -1;
 	}
 
@@ -330,20 +361,29 @@ template <typename T> void MOS6522<T>::do_phase1() {
 		reevaluate_interrupts();
 
 		// Determine whether to reload.
-		if(registers_.auxiliary_control&0x40)
+		if(timer1_is_continuous())
 			registers_.timer_needs_reload = true;
 		else
 			timer_is_running_[0] = false;
 
 		// Determine whether to toggle PB7.
-		if(registers_.auxiliary_control&0x80) {
-			registers_.output[1] ^= 0x80;
+		if(timer1_is_controlling_pb7()) {
+			registers_.timer_port_b_output ^= 0x80;
 			bus_handler_.run_for(time_since_bus_handler_call_.flush<HalfCycles>());
-			bus_handler_.set_port_output(Port::B, registers_.output[1], registers_.data_direction[1]);
+			evaluate_port_b_output();
 		}
 	}
 }
 
+template <typename T> void MOS6522<T>::evaluate_port_b_output() {
+	// Apply current timer-linked PB7 output if any atop the stated output.
+	const uint8_t timer_control_bit = registers_.auxiliary_control & 0x80;
+	bus_handler_.set_port_output(
+		Port::B,
+		(registers_.output[1] & (0xff ^ timer_control_bit)) | timer_control_bit,
+		registers_.data_direction[1] | timer_control_bit);
+}
+
 /*! Runs for a specified number of half cycles. */
 template <typename T> void MOS6522<T>::run_for(const HalfCycles half_cycles) {
 	auto number_of_half_cycles = half_cycles.as_integral();
@@ -383,9 +423,9 @@ template <typename T> void MOS6522<T>::run_for(const Cycles cycles) {
 }
 
 /*! @returns @c true if the IRQ line is currently active; @c false otherwise. */
-template <typename T> bool MOS6522<T>::get_interrupt_line() {
+template <typename T> bool MOS6522<T>::get_interrupt_line() const {
 	uint8_t interrupt_status = registers_.interrupt_flags & registers_.interrupt_enable & 0x7f;
-	return !!interrupt_status;
+	return interrupt_status;
 }
 
 template <typename T> void MOS6522<T>::evaluate_cb2_output() {
@@ -438,10 +478,11 @@ template <typename T> void MOS6522<T>::shift_in() {
 }
 
 template <typename T> void MOS6522<T>::shift_out() {
-	// When shifting out, the shift register rotates rather than strictly shifts.
-	// TODO: is that true for all modes?
-	if(shift_mode() == ShiftMode::OutUnderT2FreeRunning || shift_bits_remaining_) {
-		registers_.shift = uint8_t((registers_.shift << 1) | (registers_.shift >> 7));
+	const bool is_free_running = shift_mode() == ShiftMode::OutUnderT2FreeRunning;
+	if(is_free_running || shift_bits_remaining_) {
+		// Recirculate bits only if in free-running mode (?)
+		const uint8_t incoming_bit = (registers_.shift >> 7) * is_free_running;
+		registers_.shift = uint8_t(registers_.shift << 1) | incoming_bit;
 		evaluate_cb2_output();
 
 		--shift_bits_remaining_;

Components/6522/Implementation/6522Storage.hpp

@@ -34,7 +34,9 @@ class MOS6522Storage {
 			uint8_t peripheral_control = 0;
 			uint8_t interrupt_flags = 0;
 			uint8_t interrupt_enable = 0;
+
 			bool timer_needs_reload = false;
+			uint8_t timer_port_b_output = 0xff;
 		} registers_;
 
 		// Control state.
@@ -79,12 +81,30 @@ class MOS6522Storage {
 			OutUnderPhase2 = 6,
 			OutUnderCB1 = 7
 		};
-		ShiftMode shift_mode() const {
-			return ShiftMode((registers_.auxiliary_control >> 2) & 7);
+		bool timer1_is_controlling_pb7() const {
+			return registers_.auxiliary_control & 0x80;
+		}
+		bool timer1_is_continuous() const {
+			return registers_.auxiliary_control & 0x40;
 		}
 		bool is_shifting_out() const {
 			return registers_.auxiliary_control & 0x10;
 		}
+		int timer2_clock_decrement() const {
+			return 1 ^ ((registers_.auxiliary_control >> 5)&1);
+		}
+		int timer2_pb6_decrement() const {
+			return (registers_.auxiliary_control >> 5)&1;
+		}
+		ShiftMode shift_mode() const {
+			return ShiftMode((registers_.auxiliary_control >> 2) & 7);
+		}
+		bool portb_is_latched() const {
+			return registers_.auxiliary_control & 0x02;
+		}
+		bool port1_is_latched() const {
+			return registers_.auxiliary_control & 0x01;
+		}
 };
 
 }

Components/6522/Implementation/IRQDelegatePortHandler.cpp

@@ -14,6 +14,6 @@ void IRQDelegatePortHandler::set_interrupt_delegate(Delegate *delegate) {
 	delegate_ = delegate;
 }
 
-void IRQDelegatePortHandler::set_interrupt_status(bool new_status) {
+void IRQDelegatePortHandler::set_interrupt_status(bool) {
 	if(delegate_) delegate_->mos6522_did_change_interrupt_status(this);
 }

Components/6532/6532.hpp

@@ -32,7 +32,7 @@ template <class T> class MOS6532 {
 		inline void set_ram(uint16_t address, uint8_t value)	{	ram_[address&0x7f] = value;		}
 		inline uint8_t get_ram(uint16_t address)				{	return ram_[address & 0x7f];	}
 
-		inline void set_register(int address, uint8_t value) {
+		inline void write(int address, uint8_t value) {
 			const uint8_t decodedAddress = address & 0x07;
 			switch(decodedAddress) {
 				// Port output
@@ -51,7 +51,7 @@ template <class T> class MOS6532 {
 				case 0x04: case 0x05: case 0x06: case 0x07:
 					if(address & 0x10) {
 						timer_.writtenShift = timer_.activeShift = (decodedAddress - 0x04) * 3 + (decodedAddress / 0x07);	// i.e. 0, 3, 6, 10
-						timer_.value = (static_cast<unsigned int>(value) << timer_.activeShift) ;
+						timer_.value = (unsigned(value) << timer_.activeShift) ;
 						timer_.interrupt_enabled = !!(address&0x08);
 						interrupt_status_ &= ~InterruptFlag::Timer;
 						evaluate_interrupts();
@@ -63,7 +63,7 @@ template <class T> class MOS6532 {
 			}
 		}
 
-		inline uint8_t get_register(int address) {
+		inline uint8_t read(int address) {
 			const uint8_t decodedAddress = address & 0x7;
 			switch(decodedAddress) {
 				// Port input
@@ -79,7 +79,7 @@ template <class T> class MOS6532 {
 
 				// Timer and interrupt control
 				case 0x04: case 0x06: {
-					uint8_t value = static_cast<uint8_t>(timer_.value >> timer_.activeShift);
+					uint8_t value = uint8_t(timer_.value >> timer_.activeShift);
 					timer_.interrupt_enabled = !!(address&0x08);
 					interrupt_status_ &= ~InterruptFlag::Timer;
 					evaluate_interrupts();
@@ -107,7 +107,7 @@ template <class T> class MOS6532 {
 		}
 
 		inline void run_for(const Cycles cycles) {
-			unsigned int number_of_cycles = static_cast<unsigned int>(cycles.as_integral());
+			unsigned int number_of_cycles = unsigned(cycles.as_integral());
 
 			// permit counting _to_ zero; counting _through_ zero initiates the other behaviour
 			if(timer_.value >= number_of_cycles) {
@@ -122,7 +122,7 @@ template <class T> class MOS6532 {
 		}
 
 		MOS6532() {
-			timer_.value = static_cast<unsigned int>((rand() & 0xff) << 10);
+			timer_.value = unsigned((rand() & 0xff) << 10);
 		}
 
 		inline void set_port_did_change(int port) {
@@ -142,7 +142,7 @@ template <class T> class MOS6532 {
 			}
 		}
 
-		inline bool get_inerrupt_line() {
+		inline bool get_inerrupt_line() const {
 			return interrupt_line_;
 		}
 
@@ -173,9 +173,11 @@ template <class T> class MOS6532 {
 		bool interrupt_line_ = false;
 
 		// expected to be overridden
-		uint8_t get_port_input(int port)										{	return 0xff;	}
-		void set_port_output(int port, uint8_t value, uint8_t output_mask)		{}
-		void set_irq_line(bool new_value)										{}
+		void set_port_output([[maybe_unused]] int port, [[maybe_unused]] uint8_t value, [[maybe_unused]] uint8_t output_mask) {}
+		uint8_t get_port_input([[maybe_unused]] int port) {
+			return 0xff;
+		}
+		void set_irq_line(bool) {}
 
 		inline void evaluate_interrupts() {
 			interrupt_line_ =

Components/6560/6560.cpp

@@ -17,13 +17,13 @@ AudioGenerator::AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue
 
 
 void AudioGenerator::set_volume(uint8_t volume) {
-	audio_queue_.defer([=]() {
-		volume_ = static_cast<int16_t>(volume) * range_multiplier_;
+	audio_queue_.defer([this, volume]() {
+		volume_ = int16_t(volume) * range_multiplier_;
 	});
 }
 
 void AudioGenerator::set_control(int channel, uint8_t value) {
-	audio_queue_.defer([=]() {
+	audio_queue_.defer([this, channel, value]() {
 		control_registers_[channel] = value;
 	});
 }
@@ -98,7 +98,7 @@ static uint8_t noise_pattern[] = {
 
 #define shift(r) shift_registers_[r] = (shift_registers_[r] << 1) | (((shift_registers_[r]^0x80)&control_registers_[r]) >> 7)
 #define increment(r) shift_registers_[r] = (shift_registers_[r]+1)%8191
-#define update(r, m, up) counters_[r]++; if((counters_[r] >> m) == 0x80) { up(r); counters_[r] = static_cast<unsigned int>(control_registers_[r]&0x7f) << m; }
+#define update(r, m, up) counters_[r]++; if((counters_[r] >> m) == 0x80) { up(r); counters_[r] = unsigned(control_registers_[r]&0x7f) << m; }
 // Note on slightly askew test: as far as I can make out, if the value in the register is 0x7f then what's supposed to happen
 // is that the 0x7f is loaded, on the next clocked cycle the Vic spots a 0x7f, pumps the output, reloads, etc. No increment
 // ever occurs. It's conditional. I don't really want two conditionals if I can avoid it so I'm incrementing regardless and
@@ -114,7 +114,7 @@ void AudioGenerator::get_samples(std::size_t number_of_samples, int16_t *target)
 
 		// this sums the output of all three sounds channels plus a DC offset for volume;
 		// TODO: what's the real ratio of this stuff?
-		target[c] = static_cast<int16_t>(
+		target[c] = int16_t(
 			(shift_registers_[0]&1) +
 			(shift_registers_[1]&1) +
 			(shift_registers_[2]&1) +
@@ -133,7 +133,7 @@ void AudioGenerator::skip_samples(std::size_t number_of_samples) {
 }
 
 void AudioGenerator::set_sample_volume_range(std::int16_t range) {
-	range_multiplier_ = static_cast<int16_t>(range / 64);
+	range_multiplier_ = int16_t(range / 64);
 }
 
 #undef shift

Components/6560/6560.hpp

@@ -30,6 +30,7 @@ class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 		void get_samples(std::size_t number_of_samples, int16_t *target);
 		void skip_samples(std::size_t number_of_samples);
 		void set_sample_volume_range(std::int16_t range);
+		static constexpr bool get_is_stereo() { return false; }
 
 	private:
 		Concurrency::DeferringAsyncTaskQueue &audio_queue_;
@@ -42,7 +43,7 @@ class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 };
 
 struct BusHandler {
-	void perform_read(uint16_t address, uint8_t *pixel_data, uint8_t *colour_data) {
+	void perform_read([[maybe_unused]] uint16_t address, [[maybe_unused]] uint8_t *pixel_data, [[maybe_unused]] uint8_t *colour_data) {
 		*pixel_data = 0xff;
 		*colour_data = 0xff;
 	}
@@ -58,7 +59,7 @@ enum class OutputMode {
 	To run the VIC for a cycle, the caller should call @c get_address, make the requested bus access
 	and call @c set_graphics_value with the result.
 
-	@c set_register and @c get_register provide register access.
+	@c write and @c read provide register access.
 */
 template <class BusHandler> class MOS6560 {
 	public:
@@ -80,12 +81,14 @@ template <class BusHandler> class MOS6560 {
 		}
 
 		void set_clock_rate(double clock_rate) {
-			speaker_.set_input_rate(static_cast<float>(clock_rate / 4.0));
+			speaker_.set_input_rate(float(clock_rate / 4.0));
 		}
 
-		void set_scan_target(Outputs::Display::ScanTarget *scan_target)		{ crt_.set_scan_target(scan_target); 	}
-		void set_display_type(Outputs::Display::DisplayType display_type)	{ crt_.set_display_type(display_type); 	}
-		Outputs::Speaker::Speaker *get_speaker() { return &speaker_; }
+		void set_scan_target(Outputs::Display::ScanTarget *scan_target)		{ crt_.set_scan_target(scan_target); 			}
+		Outputs::Display::ScanStatus get_scaled_scan_status() const			{ return crt_.get_scaled_scan_status() / 4.0f;	}
+		void set_display_type(Outputs::Display::DisplayType display_type)	{ crt_.set_display_type(display_type); 			}
+		Outputs::Display::DisplayType get_display_type() const				{ return crt_.get_display_type(); 				}
+		Outputs::Speaker::Speaker *get_speaker()	 						{ return &speaker_; 							}
 
 		void set_high_frequency_cutoff(float cutoff) {
 			speaker_.set_high_frequency_cutoff(cutoff);
@@ -232,7 +235,7 @@ template <class BusHandler> class MOS6560 {
 					if(column_counter_&1) {
 						fetch_address = registers_.character_cell_start_address + (character_code_*(registers_.tall_characters ? 16 : 8)) + current_character_row_;
 					} else {
-						fetch_address = static_cast<uint16_t>(registers_.video_matrix_start_address + video_matrix_address_counter_);
+						fetch_address = uint16_t(registers_.video_matrix_start_address + video_matrix_address_counter_);
 						video_matrix_address_counter_++;
 						if(
 							(current_character_row_ == 15) ||
@@ -353,7 +356,7 @@ template <class BusHandler> class MOS6560 {
 		/*!
 			Writes to a 6560 register.
 		*/
-		void set_register(int address, uint8_t value) {
+		void write(int address, uint8_t value) {
 			address &= 0xf;
 			registers_.direct_values[address] = value;
 			switch(address) {
@@ -368,7 +371,7 @@ template <class BusHandler> class MOS6560 {
 
 				case 0x2:
 					registers_.number_of_columns = value & 0x7f;
-					registers_.video_matrix_start_address = static_cast<uint16_t>((registers_.video_matrix_start_address & 0x3c00) | ((value & 0x80) << 2));
+					registers_.video_matrix_start_address = uint16_t((registers_.video_matrix_start_address & 0x3c00) | ((value & 0x80) << 2));
 				break;
 
 				case 0x3:
@@ -377,8 +380,8 @@ template <class BusHandler> class MOS6560 {
 				break;
 
 				case 0x5:
-					registers_.character_cell_start_address = static_cast<uint16_t>((value & 0x0f) << 10);
-					registers_.video_matrix_start_address = static_cast<uint16_t>((registers_.video_matrix_start_address & 0x0200) | ((value & 0xf0) << 6));
+					registers_.character_cell_start_address = uint16_t((value & 0x0f) << 10);
+					registers_.video_matrix_start_address = uint16_t((registers_.video_matrix_start_address & 0x0200) | ((value & 0xf0) << 6));
 				break;
 
 				case 0xa:
@@ -417,11 +420,11 @@ template <class BusHandler> class MOS6560 {
 		/*
 			Reads from a 6560 register.
 		*/
-		uint8_t get_register(int address) {
+		uint8_t read(int address) const {
 			address &= 0xf;
 			switch(address) {
 				default: return registers_.direct_values[address];
-				case 0x03: return static_cast<uint8_t>(raster_value() << 7) | (registers_.direct_values[3] & 0x7f);
+				case 0x03: return uint8_t(raster_value() << 7) | (registers_.direct_values[3] & 0x7f);
 				case 0x04: return (raster_value() >> 1) & 0xff;
 			}
 		}
@@ -442,28 +445,28 @@ template <class BusHandler> class MOS6560 {
 		// register state
 		struct {
 			bool interlaced = false, tall_characters = false;
-			uint8_t first_column_location, first_row_location;
-			uint8_t number_of_columns, number_of_rows;
-			uint16_t character_cell_start_address, video_matrix_start_address;
-			uint16_t backgroundColour, borderColour, auxiliary_colour;
+			uint8_t first_column_location = 0, first_row_location = 0;
+			uint8_t number_of_columns = 0, number_of_rows = 0;
+			uint16_t character_cell_start_address = 0, video_matrix_start_address = 0;
+			uint16_t backgroundColour = 0, borderColour = 0, auxiliary_colour = 0;
 			bool invertedCells = false;
 
-			uint8_t direct_values[16];
+			uint8_t direct_values[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 		} registers_;
 
 		// output state
 		enum State {
 			Sync, ColourBurst, Border, Pixels
-		} this_state_, output_state_;
-		int cycles_in_state_;
+		} this_state_ = State::Sync, output_state_ = State::Sync;
+		int cycles_in_state_ = 0;
 
 		// counters that cover an entire field
 		int horizontal_counter_ = 0, vertical_counter_ = 0;
-		const int lines_this_field() {
+		int lines_this_field() const {
 			// Necessary knowledge here: only the NTSC 6560 supports interlaced video.
 			return registers_.interlaced ? (is_odd_frame_ ? 262 : 263) : timing_.lines_per_progressive_field;
 		}
-		const int raster_value() {
+		int raster_value() const {
 			const int bonus_line = (horizontal_counter_ + timing_.line_counter_increment_offset) / timing_.cycles_per_line;
 			const int line = vertical_counter_ + bonus_line;
 			const int final_line = lines_this_field();
@@ -478,29 +481,29 @@ template <class BusHandler> class MOS6560 {
 			}
 			// Cf. http://www.sleepingelephant.com/ipw-web/bulletin/bb/viewtopic.php?f=14&t=7237&start=15#p80737
 		}
-		bool is_odd_frame() {
+		bool is_odd_frame() const {
 			return is_odd_frame_ || !registers_.interlaced;
 		}
 
 		// latches dictating start and length of drawing
 		bool vertical_drawing_latch_ = false, horizontal_drawing_latch_ = false;
-		int rows_this_field_, columns_this_line_;
+		int rows_this_field_ = 0, columns_this_line_ = 0;
 
 		// current drawing position counter
-		int pixel_line_cycle_, column_counter_;
-		int current_row_;
-		uint16_t current_character_row_;
-		uint16_t video_matrix_address_counter_, base_video_matrix_address_counter_;
+		int pixel_line_cycle_ = 0, column_counter_ = 0;
+		int current_row_ = 0;
+		uint16_t current_character_row_ = 0;
+		uint16_t video_matrix_address_counter_ = 0, base_video_matrix_address_counter_ = 0;
 
 		// data latched from the bus
-		uint8_t character_code_, character_colour_, character_value_;
+		uint8_t character_code_ = 0, character_colour_ = 0, character_value_ = 0;
 
 		bool is_odd_frame_ = false, is_odd_line_ = false;
 
 		// lookup table from 6560 colour index to appropriate PAL/NTSC value
-		uint16_t colours_[16];
+		uint16_t colours_[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-		uint16_t *pixel_pointer;
+		uint16_t *pixel_pointer = nullptr;
 		void output_border(int number_of_cycles) {
 			uint16_t *colour_pointer = reinterpret_cast<uint16_t *>(crt_.begin_data(1));
 			if(colour_pointer) *colour_pointer = registers_.borderColour;
@@ -508,13 +511,13 @@ template <class BusHandler> class MOS6560 {
 		}
 
 		struct {
-			int cycles_per_line;
-			int line_counter_increment_offset;
-			int final_line_increment_position;
-			int lines_per_progressive_field;
-			bool supports_interlacing;
+			int cycles_per_line = 0;
+			int line_counter_increment_offset = 0;
+			int final_line_increment_position = 0;
+			int lines_per_progressive_field = 0;
+			bool supports_interlacing = 0;
 		} timing_;
-		OutputMode output_mode_;
+		OutputMode output_mode_ = OutputMode::NTSC;
 };
 
 }

Components/6845/CRTC6845.hpp

@@ -167,8 +167,8 @@ template <class T> class CRTC6845 {
 	private:
 		inline void perform_bus_cycle_phase1() {
 			// Skew theory of operation: keep a history of the last three states, and apply whichever is selected.
-			character_is_visible_shifter_ = (character_is_visible_shifter_ << 1) | static_cast<unsigned int>(character_is_visible_);
-			bus_state_.display_enable = (static_cast<int>(character_is_visible_shifter_) & display_skew_mask_) && line_is_visible_;
+			character_is_visible_shifter_ = (character_is_visible_shifter_ << 1) | unsigned(character_is_visible_);
+			bus_state_.display_enable = (int(character_is_visible_shifter_) & display_skew_mask_) && line_is_visible_;
 			bus_handler_.perform_bus_cycle_phase1(bus_state_);
 		}
 
@@ -240,7 +240,7 @@ template <class T> class CRTC6845 {
 		inline void do_end_of_frame() {
 			line_counter_ = 0;
 			line_is_visible_ = true;
-			line_address_ = static_cast<uint16_t>((registers_[12] << 8) | registers_[13]);
+			line_address_ = uint16_t((registers_[12] << 8) | registers_[13]);
 			bus_state_.refresh_address = line_address_;
 		}
 

Components/6850/6850.cpp

@@ -120,7 +120,7 @@ void ACIA::consider_transmission() {
 	}
 }
 
-ClockingHint::Preference ACIA::preferred_clocking() {
+ClockingHint::Preference ACIA::preferred_clocking() const {
 	// Real-time clocking is required if a transmission is ongoing; this is a courtesy for whomever
 	// is on the receiving end.
 	if(transmit.transmission_data_time_remaining() > 0) return ClockingHint::Preference::RealTime;
@@ -148,7 +148,7 @@ uint8_t ACIA::parity(uint8_t value) {
 	return value ^ (parity_ == Parity::Even);
 }
 
-bool ACIA::serial_line_did_produce_bit(Serial::Line *line, int bit) {
+bool ACIA::serial_line_did_produce_bit(Serial::Line *, int bit) {
 	// Shift this bit into the 11-bit input register; this is big enough to hold
 	// the largest transmission symbol.
 	++bits_received_;

Components/6850/6850.hpp

@@ -86,7 +86,7 @@ class ACIA: public ClockingHint::Source, private Serial::Line::ReadDelegate {
 		Serial::Line request_to_send;
 
 		// ClockingHint::Source.
-		ClockingHint::Preference preferred_clocking() final;
+		ClockingHint::Preference preferred_clocking() const final;
 
 		struct InterruptDelegate {
 			virtual void acia6850_did_change_interrupt_status(ACIA *acia) = 0;

Components/68901/MFP68901.cpp

@@ -20,7 +20,7 @@
 
 using namespace Motorola::MFP68901;
 
-ClockingHint::Preference MFP68901::preferred_clocking() {
+ClockingHint::Preference MFP68901::preferred_clocking() const {
 	// Rule applied: if any timer is actively running and permitted to produce an
 	// interrupt, request real-time running.
 	return

Components/68901/MFP68901.hpp

@@ -76,7 +76,7 @@ class MFP68901: public ClockingHint::Source {
 		void set_interrupt_delegate(InterruptDelegate *delegate);
 
 		// ClockingHint::Source.
-		ClockingHint::Preference preferred_clocking() final;
+		ClockingHint::Preference preferred_clocking() const final;
 
 	private:
 		// MARK: - Timers

Components/8255/i8255.hpp

@@ -9,13 +9,15 @@
 #ifndef i8255_hpp
 #define i8255_hpp
 
+#include <cstdint>
+
 namespace Intel {
 namespace i8255 {
 
 class PortHandler {
 	public:
-		void set_value(int port, uint8_t value) {}
-		uint8_t get_value(int port) { return 0xff; }
+		void set_value([[maybe_unused]] int port, [[maybe_unused]] uint8_t value) {}
+		uint8_t get_value([[maybe_unused]] int port) { return 0xff; }
 };
 
 // TODO: Modes 1 and 2.
@@ -27,7 +29,7 @@ template <class T> class i8255 {
 			Stores the value @c value to the register at @c address. If this causes a change in 8255 output
 			then the PortHandler will be informed.
 		*/
-		void set_register(int address, uint8_t value) {
+		void write(int address, uint8_t value) {
 			switch(address & 3) {
 				case 0:
 					if(!(control_ & 0x10)) {
@@ -60,7 +62,7 @@ template <class T> class i8255 {
 			Obtains the current value for the register at @c address. If this provides a reading
 			of input then the PortHandler will be queried.
 		*/
-		uint8_t get_register(int address) {
+		uint8_t read(int address) {
 			switch(address & 3) {
 				case 0:	return (control_ & 0x10) ? port_handler_.get_value(0) : outputs_[0];
 				case 1:	return (control_ & 0x02) ? port_handler_.get_value(1) : outputs_[1];

Components/8272/i8272.cpp

@@ -79,10 +79,14 @@ namespace {
 i8272::i8272(BusHandler &bus_handler, Cycles clock_rate) :
 	Storage::Disk::MFMController(clock_rate),
 	bus_handler_(bus_handler) {
-	posit_event(static_cast<int>(Event8272::CommandByte));
+	posit_event(int(Event8272::CommandByte));
+
+	// TODO: implement DMA, etc. I have a vague intention to implement the IBM PC
+	// one day, that should help to force that stuff.
+	(void)bus_handler_;
 }
 
-ClockingHint::Preference i8272::preferred_clocking() {
+ClockingHint::Preference i8272::preferred_clocking() const {
 	const auto mfm_controller_preferred_clocking = Storage::Disk::MFMController::preferred_clocking();
 	if(mfm_controller_preferred_clocking != ClockingHint::Preference::None) return mfm_controller_preferred_clocking;
 	return is_sleeping_ ? ClockingHint::Preference::None : ClockingHint::Preference::JustInTime;
@@ -97,7 +101,7 @@ void i8272::run_for(Cycles cycles) {
 	if(delay_time_ > 0) {
 		if(cycles.as_integral() >= delay_time_) {
 			delay_time_ = 0;
-			posit_event(static_cast<int>(Event8272::Timer));
+			posit_event(int(Event8272::Timer));
 		} else {
 			delay_time_ -= cycles.as_integral();
 		}
@@ -114,7 +118,7 @@ void i8272::run_for(Cycles cycles) {
 				while(steps--) {
 					// Perform a step.
 					int direction = (drives_[c].target_head_position < drives_[c].head_position) ? -1 : 1;
-					LOG("Target " << PADDEC(0) << drives_[c].target_head_position << " versus believed " << static_cast<int>(drives_[c].head_position));
+					LOG("Target " << PADDEC(0) << drives_[c].target_head_position << " versus believed " << int(drives_[c].head_position));
 					select_drive(c);
 					get_drive().step(Storage::Disk::HeadPosition(direction));
 					if(drives_[c].target_head_position >= 0) drives_[c].head_position += direction;
@@ -156,14 +160,14 @@ void i8272::run_for(Cycles cycles) {
 
 	// check for busy plus ready disabled
 	if(is_executing_ && !get_drive().get_is_ready()) {
-		posit_event(static_cast<int>(Event8272::NoLongerReady));
+		posit_event(int(Event8272::NoLongerReady));
 	}
 
 	is_sleeping_ = !delay_time_ && !drives_seeking_ && !head_timers_running_;
 	if(is_sleeping_) update_clocking_observer();
 }
 
-void i8272::set_register(int address, uint8_t value) {
+void i8272::write(int address, uint8_t value) {
 	// don't consider attempted sets to the status register
 	if(!address) return;
 
@@ -177,16 +181,16 @@ void i8272::set_register(int address, uint8_t value) {
 	} else {
 		// accumulate latest byte in the command byte sequence
 		command_.push_back(value);
-		posit_event(static_cast<int>(Event8272::CommandByte));
+		posit_event(int(Event8272::CommandByte));
 	}
 }
 
-uint8_t i8272::get_register(int address) {
+uint8_t i8272::read(int address) {
 	if(address) {
 		if(result_stack_.empty()) return 0xff;
 		uint8_t result = result_stack_.back();
 		result_stack_.pop_back();
-		if(result_stack_.empty()) posit_event(static_cast<int>(Event8272::ResultEmpty));
+		if(result_stack_.empty()) posit_event(int(Event8272::ResultEmpty));
 
 		return result;
 	} else {
@@ -198,16 +202,16 @@ uint8_t i8272::get_register(int address) {
 #define END_SECTION()	}
 
 #define MS_TO_CYCLES(x)			x * 8000
-#define WAIT_FOR_EVENT(mask)	resume_point_ = __LINE__; interesting_event_mask_ = static_cast<int>(mask); return; case __LINE__:
-#define WAIT_FOR_TIME(ms)		resume_point_ = __LINE__; interesting_event_mask_ = static_cast<int>(Event8272::Timer); delay_time_ = MS_TO_CYCLES(ms); is_sleeping_ = false; update_clocking_observer(); case __LINE__: if(delay_time_) return;
+#define WAIT_FOR_EVENT(mask)	resume_point_ = __LINE__; interesting_event_mask_ = int(mask); return; case __LINE__:
+#define WAIT_FOR_TIME(ms)		resume_point_ = __LINE__; interesting_event_mask_ = int(Event8272::Timer); delay_time_ = MS_TO_CYCLES(ms); is_sleeping_ = false; update_clocking_observer(); case __LINE__: if(delay_time_) return;
 
 #define PASTE(x, y) x##y
 #define CONCAT(x, y) PASTE(x, y)
 
 #define FIND_HEADER()	\
 	set_data_mode(DataMode::Scanning);	\
-	CONCAT(find_header, __LINE__): WAIT_FOR_EVENT(static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole)); \
-	if(event_type == static_cast<int>(Event::IndexHole)) { index_hole_limit_--; }	\
+	CONCAT(find_header, __LINE__): WAIT_FOR_EVENT(int(Event::Token) | int(Event::IndexHole)); \
+	if(event_type == int(Event::IndexHole)) { index_hole_limit_--; }	\
 	else if(get_latest_token().type == Token::ID) goto CONCAT(header_found, __LINE__);	\
 	\
 	if(index_hole_limit_) goto CONCAT(find_header, __LINE__);	\
@@ -215,8 +219,8 @@ uint8_t i8272::get_register(int address) {
 
 #define FIND_DATA()	\
 	set_data_mode(DataMode::Scanning);	\
-	CONCAT(find_data, __LINE__): WAIT_FOR_EVENT(static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole)); \
-	if(event_type == static_cast<int>(Event::Token)) { \
+	CONCAT(find_data, __LINE__): WAIT_FOR_EVENT(int(Event::Token) | int(Event::IndexHole)); \
+	if(event_type == int(Event::Token)) { \
 		if(get_latest_token().type == Token::Byte || get_latest_token().type == Token::Sync) goto CONCAT(find_data, __LINE__);	\
 	}
 
@@ -264,8 +268,8 @@ uint8_t i8272::get_register(int address) {
 	}
 
 void i8272::posit_event(int event_type) {
-	if(event_type == static_cast<int>(Event::IndexHole)) index_hole_count_++;
-	if(event_type == static_cast<int>(Event8272::NoLongerReady)) {
+	if(event_type == int(Event::IndexHole)) index_hole_count_++;
+	if(event_type == int(Event8272::NoLongerReady)) {
 		SetNotReady();
 		goto abort;
 	}
@@ -425,12 +429,12 @@ void i8272::posit_event(int event_type) {
 	// Performs the read data or read deleted data command.
 	read_data:
 			LOG(PADHEX(2) << "Read [deleted] data ["
-				<< static_cast<int>(command_[2]) << " "
-				<< static_cast<int>(command_[3]) << " "
-				<< static_cast<int>(command_[4]) << " "
-				<< static_cast<int>(command_[5]) << " ... "
-				<< static_cast<int>(command_[6]) << " "
-				<< static_cast<int>(command_[8]) << "]");
+				<< int(command_[2]) << " "
+				<< int(command_[3]) << " "
+				<< int(command_[4]) << " "
+				<< int(command_[5]) << " ... "
+				<< int(command_[6]) << " "
+				<< int(command_[8]) << "]");
 		read_next_data:
 			goto read_write_find_header;
 
@@ -439,7 +443,7 @@ void i8272::posit_event(int event_type) {
 		read_data_found_header:
 			FIND_DATA();
 			ClearControlMark();
-			if(event_type == static_cast<int>(Event::Token)) {
+			if(event_type == int(Event::Token)) {
 				if(get_latest_token().type != Token::Data && get_latest_token().type != Token::DeletedData) {
 					// Something other than a data mark came next, impliedly an ID or index mark.
 					SetMissingAddressMark();
@@ -470,24 +474,24 @@ void i8272::posit_event(int event_type) {
 		//
 		// TODO: consider DTL.
 		read_data_get_byte:
-			WAIT_FOR_EVENT(static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole));
-			if(event_type == static_cast<int>(Event::Token)) {
+			WAIT_FOR_EVENT(int(Event::Token) | int(Event::IndexHole));
+			if(event_type == int(Event::Token)) {
 				result_stack_.push_back(get_latest_token().byte_value);
 				distance_into_section_++;
 				SetDataRequest();
 				SetDataDirectionToProcessor();
-				WAIT_FOR_EVENT(static_cast<int>(Event8272::ResultEmpty) | static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole));
+				WAIT_FOR_EVENT(int(Event8272::ResultEmpty) | int(Event::Token) | int(Event::IndexHole));
 			}
 			switch(event_type) {
-				case static_cast<int>(Event8272::ResultEmpty):	// The caller read the byte in time; proceed as normal.
+				case int(Event8272::ResultEmpty):	// The caller read the byte in time; proceed as normal.
 					ResetDataRequest();
 					if(distance_into_section_ < (128 << size_)) goto read_data_get_byte;
 				break;
-				case static_cast<int>(Event::Token):				// The caller hasn't read the old byte yet and a new one has arrived
+				case int(Event::Token):				// The caller hasn't read the old byte yet and a new one has arrived
 					SetOverrun();
 					goto abort;
 				break;
-				case static_cast<int>(Event::IndexHole):
+				case int(Event::IndexHole):
 					SetEndOfCylinder();
 					goto abort;
 				break;
@@ -515,12 +519,12 @@ void i8272::posit_event(int event_type) {
 
 	write_data:
 			LOG(PADHEX(2) << "Write [deleted] data ["
-				<< static_cast<int>(command_[2]) << " "
-				<< static_cast<int>(command_[3]) << " "
-				<< static_cast<int>(command_[4]) << " "
-				<< static_cast<int>(command_[5]) << " ... "
-				<< static_cast<int>(command_[6]) << " "
-				<< static_cast<int>(command_[8]) << "]");
+				<< int(command_[2]) << " "
+				<< int(command_[3]) << " "
+				<< int(command_[4]) << " "
+				<< int(command_[5]) << " ... "
+				<< int(command_[6]) << " "
+				<< int(command_[8]) << "]");
 
 			if(get_drive().get_is_read_only()) {
 				SetNotWriteable();
@@ -571,7 +575,7 @@ void i8272::posit_event(int event_type) {
 	// Performs the read ID command.
 	read_id:
 		// Establishes the drive and head being addressed, and whether in double density mode.
-			LOG(PADHEX(2) << "Read ID [" << static_cast<int>(command_[0]) << " " << static_cast<int>(command_[1]) << "]");
+			LOG(PADHEX(2) << "Read ID [" << int(command_[0]) << " " << int(command_[1]) << "]");
 
 		// Sets a maximum index hole limit of 2 then waits either until it finds a header mark or sees too many index holes.
 		// If a header mark is found, reads in the following bytes that produce a header. Otherwise branches to data not found.
@@ -594,10 +598,10 @@ void i8272::posit_event(int event_type) {
 	// Performs read track.
 	read_track:
 			LOG(PADHEX(2) << "Read track ["
-				<< static_cast<int>(command_[2]) << " "
-				<< static_cast<int>(command_[3]) << " "
-				<< static_cast<int>(command_[4]) << " "
-				<< static_cast<int>(command_[5]) << "]");
+				<< int(command_[2]) << " "
+				<< int(command_[3]) << " "
+				<< int(command_[4]) << " "
+				<< int(command_[5]) << "]");
 
 			// Wait for the index hole.
 			WAIT_FOR_EVENT(Event::IndexHole);
@@ -627,7 +631,7 @@ void i8272::posit_event(int event_type) {
 			distance_into_section_++;
 			SetDataRequest();
 			// TODO: other possible exit conditions; find a way to merge with the read_data version of this.
-			WAIT_FOR_EVENT(static_cast<int>(Event8272::ResultEmpty));
+			WAIT_FOR_EVENT(int(Event8272::ResultEmpty));
 			ResetDataRequest();
 			if(distance_into_section_ < (128 << header_[2])) goto read_track_get_byte;
 
@@ -664,13 +668,13 @@ void i8272::posit_event(int event_type) {
 			expects_input_ = true;
 			distance_into_section_ = 0;
 		format_track_write_header:
-			WAIT_FOR_EVENT(static_cast<int>(Event::DataWritten) | static_cast<int>(Event::IndexHole));
+			WAIT_FOR_EVENT(int(Event::DataWritten) | int(Event::IndexHole));
 			switch(event_type) {
-				case static_cast<int>(Event::IndexHole):
+				case int(Event::IndexHole):
 					SetOverrun();
 					goto abort;
 				break;
-				case static_cast<int>(Event::DataWritten):
+				case int(Event::DataWritten):
 					header_[distance_into_section_] = input_;
 					write_byte(input_);
 					has_input_ = false;
@@ -683,10 +687,10 @@ void i8272::posit_event(int event_type) {
 			}
 
 			LOG(PADHEX(2) << "W:"
-				<< static_cast<int>(header_[0]) << " "
-				<< static_cast<int>(header_[1]) << " "
-				<< static_cast<int>(header_[2]) << " "
-				<< static_cast<int>(header_[3]) << ", "
+				<< int(header_[0]) << " "
+				<< int(header_[1]) << " "
+				<< int(header_[2]) << " "
+				<< int(header_[3]) << ", "
 				<< get_crc_generator().get_value());
 			write_crc();
 
@@ -706,8 +710,8 @@ void i8272::posit_event(int event_type) {
 			// Otherwise, pad out to the index hole.
 		format_track_pad:
 			write_byte(get_is_double_density() ? 0x4e : 0xff);
-			WAIT_FOR_EVENT(static_cast<int>(Event::DataWritten) | static_cast<int>(Event::IndexHole));
-			if(event_type != static_cast<int>(Event::IndexHole)) goto format_track_pad;
+			WAIT_FOR_EVENT(int(Event::DataWritten) | int(Event::IndexHole));
+			if(event_type != int(Event::IndexHole)) goto format_track_pad;
 
 			end_writing();
 
@@ -758,7 +762,7 @@ void i8272::posit_event(int event_type) {
 				// up in run_for understands to mean 'keep going until track 0 is active').
 				if(command_.size() > 2) {
 					drives_[drive].target_head_position = command_[2];
-					LOG(PADHEX(2) << "Seek to " << static_cast<int>(command_[2]));
+					LOG(PADHEX(2) << "Seek to " << int(command_[2]));
 				} else {
 					drives_[drive].target_head_position = -1;
 					drives_[drive].head_position = 0;
@@ -789,7 +793,7 @@ void i8272::posit_event(int event_type) {
 				// If a drive was found, return its results. Otherwise return a single 0x80.
 				if(found_drive != -1) {
 					drives_[found_drive].phase = Drive::NotSeeking;
-					status_[0] = static_cast<uint8_t>(found_drive);
+					status_[0] = uint8_t(found_drive);
 					main_status_ &= ~(1 << found_drive);
 					SetSeekEnd();
 
@@ -819,7 +823,7 @@ void i8272::posit_event(int event_type) {
 				int drive = command_[1] & 3;
 				select_drive(drive);
 				result_stack_= {
-					static_cast<uint8_t>(
+					uint8_t(
 						(command_[1] & 7) |	// drive and head number
 						0x08 |				// single sided
 						(get_drive().get_is_track_zero() ? 0x10 : 0x00)	|
@@ -853,9 +857,9 @@ void i8272::posit_event(int event_type) {
 	// Posts whatever is in result_stack_ as a result phase. Be aware that it is a stack, so the
 	// last thing in it will be returned first.
 	post_result:
-			LOGNBR(PADHEX(2) << "Result to " << static_cast<int>(command_[0] & 0x1f) << ", main " << static_cast<int>(main_status_) << "; ");
+			LOGNBR(PADHEX(2) << "Result to " << int(command_[0] & 0x1f) << ", main " << int(main_status_) << "; ");
 			for(std::size_t c = 0; c < result_stack_.size(); c++) {
-				LOGNBR(" " << static_cast<int>(result_stack_[result_stack_.size() - 1 - c]));
+				LOGNBR(" " << int(result_stack_[result_stack_.size() - 1 - c]));
 			}
 			LOGNBR(std::endl);
 
@@ -865,7 +869,7 @@ void i8272::posit_event(int event_type) {
 			SetDataRequest();
 			SetDataDirectionToProcessor();
 
-			// The actual stuff of unwinding result_stack_ is handled by ::get_register; wait
+			// The actual stuff of unwinding result_stack_ is handled by ::read; wait
 			// until the processor has read all result bytes.
 			WAIT_FOR_EVENT(Event8272::ResultEmpty);
 
@@ -880,13 +884,13 @@ bool i8272::seek_is_satisfied(int drive) {
 			(drives_[drive].target_head_position == -1 && get_drive().get_is_track_zero());
 }
 
-void i8272::set_dma_acknowledge(bool dack) {
+void i8272::set_dma_acknowledge(bool) {
 }
 
-void i8272::set_terminal_count(bool tc) {
+void i8272::set_terminal_count(bool) {
 }
 
-void i8272::set_data_input(uint8_t value) {
+void i8272::set_data_input(uint8_t) {
 }
 
 uint8_t i8272::get_data_output() {

Components/8272/i8272.hpp

@@ -20,8 +20,9 @@ namespace i8272 {
 
 class BusHandler {
 	public:
-		virtual void set_dma_data_request(bool drq) {}
-		virtual void set_interrupt(bool irq) {}
+		virtual ~BusHandler() {}
+		virtual void set_dma_data_request([[maybe_unused]] bool drq) {}
+		virtual void set_interrupt([[maybe_unused]] bool irq) {}
 };
 
 class i8272 : public Storage::Disk::MFMController {
@@ -33,19 +34,19 @@ class i8272 : public Storage::Disk::MFMController {
 		void set_data_input(uint8_t value);
 		uint8_t get_data_output();
 
-		void set_register(int address, uint8_t value);
-		uint8_t get_register(int address);
+		void write(int address, uint8_t value);
+		uint8_t read(int address);
 
 		void set_dma_acknowledge(bool dack);
 		void set_terminal_count(bool tc);
 
-		ClockingHint::Preference preferred_clocking() final;
+		ClockingHint::Preference preferred_clocking() const final;
 
 	protected:
 		virtual void select_drive(int number) = 0;
 
 	private:
-		// The bus handler, for interrupt and DMA-driven usage.
+		// The bus handler, for interrupt and DMA-driven usage. [TODO]
 		BusHandler &bus_handler_;
 		std::unique_ptr<BusHandler> allocated_bus_handler_;
 
@@ -67,8 +68,8 @@ class i8272 : public Storage::Disk::MFMController {
 			ResultEmpty = (1 << 5),
 			NoLongerReady = (1 << 6)
 		};
-		void posit_event(int type) override;
-		int interesting_event_mask_ = static_cast<int>(Event8272::CommandByte);
+		void posit_event(int type) final;
+		int interesting_event_mask_ = int(Event8272::CommandByte);
 		int resume_point_ = 0;
 		bool is_access_command_ = false;
 

Components/8530/z8530.cpp

@@ -8,6 +8,11 @@
 
 #include "z8530.hpp"
 
+#ifndef NDEBUG
+#define NDEBUG
+#endif
+
+#define LOG_PREFIX "[SCC] "
 #include "../../Outputs/Log.hpp"
 
 using namespace Zilog::SCC;
@@ -16,7 +21,7 @@ void z8530::reset() {
 	// TODO.
 }
 
-bool z8530::get_interrupt_line() {
+bool z8530::get_interrupt_line() const {
 	return
 		(master_interrupt_control_ & 0x8) &&
 		(
@@ -25,22 +30,30 @@ bool z8530::get_interrupt_line() {
 		);
 }
 
+/*
+	Per the standard defined in the header file, this implementation follows
+	an addressing convention of:
+
+	A0 = A/B		(i.e. channel select)
+	A1 = C/D		(i.e. control or data)
+*/
+
 std::uint8_t z8530::read(int address) {
 	if(address & 2) {
-		// Read data register for channel
-		return 0x00;
+		// Read data register for channel.
+		return channels_[address & 1].read(true, pointer_);
 	} else {
 		// Read control register for channel.
 		uint8_t result = 0;
 
 		switch(pointer_) {
 			default:
-				result = channels_[address & 1].read(address & 2, pointer_);
+				result = channels_[address & 1].read(false, pointer_);
 			break;
 
 			case 2:		// Handled non-symmetrically between channels.
 				if(address & 1) {
-					LOG("[SCC] Unimplemented: register 2 status bits");
+					LOG("Unimplemented: register 2 status bits");
 				} else {
 					result = interrupt_vector_;
 
@@ -63,7 +76,11 @@ std::uint8_t z8530::read(int address) {
 			break;
 		}
 
+		// Cf. the two-step control register selection process in ::write. Since this
+		// definitely wasn't a *write* to register 0, it follows that the next selected
+		// control register will be 0.
 		pointer_ = 0;
+
 		update_delegate();
 		return result;
 	}
@@ -73,24 +90,31 @@ std::uint8_t z8530::read(int address) {
 
 void z8530::write(int address, std::uint8_t value) {
 	if(address & 2) {
-		// Write data register for channel.
+		// Write data register for channel. This is completely independent
+		// of whatever is going on over in the control realm.
+		channels_[address & 1].write(true, pointer_, value);
 	} else {
-		// Write control register for channel.
+		// Write control register for channel; there's a two-step sequence
+		// here for the programmer. Initially the selected register
+		// (i.e. `pointer_`) is zero. That register includes a field to
+		// set the next selected register. After any other register has
+		// been written to, register 0 is selected again.
 
-		// Most registers are per channel, but a couple are shared; sever
-		// them here.
+		// Most registers are per channel, but a couple are shared;
+		// sever them here, send the rest to the appropriate chnanel.
 		switch(pointer_) {
 			default:
-				channels_[address & 1].write(address & 2, pointer_, value);
+				channels_[address & 1].write(false, pointer_, value);
 			break;
 
-			case 2:	// Interrupt vector register; shared between both channels.
+			case 2:	// Interrupt vector register; used only by Channel B.
+					// So there's only one of these.
 				interrupt_vector_ = value;
-				LOG("[SCC] Interrupt vector set to " << PADHEX(2) << int(value));
+				LOG("Interrupt vector set to " << PADHEX(2) << int(value));
 			break;
 
-			case 9:	// Master interrupt and reset register; also shared between both channels.
-				LOG("[SCC] Master interrupt and reset register: " << PADHEX(2) << int(value));
+			case 9:	// Master interrupt and reset register; there is also only one of these.
+				LOG("Master interrupt and reset register: " << PADHEX(2) << int(value));
 				master_interrupt_control_ = value;
 			break;
 		}
@@ -105,7 +129,8 @@ void z8530::write(int address, std::uint8_t value) {
 			pointer_ = value & 7;
 
 			// If the command part of the byte is a 'point high', also set the
-			// top bit of the pointer.
+			// top bit of the pointer. Channels themselves therefore need not
+			// (/should not) respond to the point high command.
 			if(((value >> 3)&7) == 1) {
 				pointer_ |= 8;
 			}
@@ -126,16 +151,79 @@ uint8_t z8530::Channel::read(bool data, uint8_t pointer) {
 	if(data) {
 		return data_;
 	} else {
+		LOG("Control read from register " << int(pointer));
 		// Otherwise, this is a control read...
 		switch(pointer) {
 			default:
-				LOG("[SCC] Unrecognised control read from register " << int(pointer));
 			return 0x00;
 
-			case 0:
+			case 0x0:	// Read Register 0; see p.37 (PDF p.45).
+				// b0: Rx character available.
+				// b1: zero count.
+				// b2: Tx buffer empty.
+				// b3: DCD.
+				// b4: sync/hunt.
+				// b5: CTS.
+				// b6: Tx underrun/EOM.
+				// b7: break/abort.
 			return dcd_ ? 0x8 : 0x0;
 
-			case 0xf:
+			case 0x1:	// Read Register 1; see p.37 (PDF p.45).
+				// b0: all sent.
+				// b1: residue code 0.
+				// b2: residue code 1.
+				// b3: residue code 2.
+				// b4: parity error.
+				// b5: Rx overrun error.
+				// b6: CRC/framing error.
+				// b7: end of frame (SDLC).
+			return 0x01;
+
+			case 0x2:	// Read Register 2; see p.37 (PDF p.45).
+				// Interrupt vector — modified by status information in B channel.
+			return 0x00;
+
+			case 0x3:	// Read Register 3; see p.37 (PDF p.45).
+				// B channel: all bits are 0.
+				// A channel:
+				// b0: Channel B ext/status IP.
+				// b1: Channel B Tx IP.
+				// b2: Channel B Rx IP.
+				// b3: Channel A ext/status IP.
+				// b4: Channel A Tx IP.
+				// b5: Channel A Rx IP.
+				// b6, b7: 0.
+			return 0x00;
+
+			case 0xa:	// Read Register 10; see p.37 (PDF p.45).
+				// b0: 0
+				// b1: On loop.
+				// b2: 0
+				// b3: 0
+				// b4: Loop sending.
+				// b5: 0
+				// b6: Two clocks missing.
+				// b7: One clock missing.
+			return 0x00;
+
+			case 0xc:	// Read Register 12; see p.37 (PDF p.45).
+				// Lower byte of time constant.
+			return 0x00;
+
+			case 0xd:	// Read Register 13; see p.38 (PDF p.46).
+				// Upper byte of time constant.
+			return 0x00;
+
+			case 0xf:	// Read Register 15; see p.38 (PDF p.46).
+				// External interrupt status:
+				// b0: 0
+				// b1: Zero count.
+				// b2: 0
+				// b3: DCD.
+				// b4: Sync/hunt.
+				// b5: CTS.
+				// b6: Tx underrun/EOM.
+				// b7: Break/abort.
 			return external_interrupt_status_;
 		}
 	}
@@ -148,9 +236,10 @@ void z8530::Channel::write(bool data, uint8_t pointer, uint8_t value) {
 		data_ = value;
 		return;
 	} else {
+		LOG("Control write: " << PADHEX(2) << int(value) << " to register " << int(pointer));
 		switch(pointer) {
 			default:
-				LOG("[SCC] Unrecognised control write: " << PADHEX(2) << int(value) << " to register " << int(pointer));
+				LOG("Unrecognised control write: " << PADHEX(2) << int(value) << " to register " << int(pointer));
 			break;
 
 			case 0x0:	// Write register 0 — CRC reset and other functions.
@@ -158,13 +247,13 @@ void z8530::Channel::write(bool data, uint8_t pointer, uint8_t value) {
 				switch(value >> 6) {
 					default:	/* Do nothing. */		break;
 					case 1:
-						LOG("[SCC] TODO: reset Rx CRC checker.");
+						LOG("TODO: reset Rx CRC checker.");
 					break;
 					case 2:
-						LOG("[SCC] TODO: reset Tx CRC checker.");
+						LOG("TODO: reset Tx CRC checker.");
 					break;
 					case 3:
-						LOG("[SCC] TODO: reset Tx underrun/EOM latch.");
+						LOG("TODO: reset Tx underrun/EOM latch.");
 					break;
 				}
 
@@ -172,32 +261,84 @@ void z8530::Channel::write(bool data, uint8_t pointer, uint8_t value) {
 				switch((value >> 3)&7) {
 					default:	/* Do nothing. */		break;
 					case 2:
-//						LOG("[SCC] reset ext/status interrupts.");
+//						LOG("reset ext/status interrupts.");
 						external_status_interrupt_ = false;
 						external_interrupt_status_ = 0;
 					break;
 					case 3:
-						LOG("[SCC] TODO: send abort (SDLC).");
+						LOG("TODO: send abort (SDLC).");
 					break;
 					case 4:
-						LOG("[SCC] TODO: enable interrupt on next Rx character.");
+						LOG("TODO: enable interrupt on next Rx character.");
 					break;
 					case 5:
-						LOG("[SCC] TODO: reset Tx interrupt pending.");
+						LOG("TODO: reset Tx interrupt pending.");
 					break;
 					case 6:
-						LOG("[SCC] TODO: reset error.");
+						LOG("TODO: reset error.");
 					break;
 					case 7:
-						LOG("[SCC] TODO: reset highest IUS.");
+						LOG("TODO: reset highest IUS.");
 					break;
 				}
 			break;
 
 			case 0x1:	// Write register 1 — Transmit/Receive Interrupt and Data Transfer Mode Definition.
 				interrupt_mask_ = value;
+
+				/*
+					b7 = 0 => Wait/Request output is inactive; 1 => output is informative.
+					b6 = Wait/request output is for...
+						0 => wait: floating when inactive, low if CPU is attempting to transfer data the SCC isn't yet ready for.
+						1 => request: high if inactive, low if SCC is ready to transfer data.
+					b5 = 1 => wait/request is relative to read buffer; 0 => relative to write buffer.
+
+					b4/b3:
+						00 = disable receive interrupt
+						01 = interrupt on first character or special condition
+						10 = interrupt on all characters and special conditions
+						11 = interrupt only upon special conditions.
+
+					b2 = 1 => parity error is a special condition; 0 => it isn't.
+					b1 = 1 => transmit buffer empty interrupt is enabled; 0 => it isn't.
+					b0 = 1 => external interrupt is enabled; 0 => it isn't.
+				*/
+				LOG("Interrupt mask: " << PADHEX(2) << int(value));
 			break;
 
+			case 0x2:	// Write register 2 - interrupt vector.
+			break;
+
+			case 0x3: {	// Write register 3 — Receive Parameters and Control.
+				// Get bit count.
+				int receive_bit_count = 8;
+				switch(value >> 6) {
+					default:	receive_bit_count = 5;	break;
+					case 1:		receive_bit_count = 7;	break;
+					case 2:		receive_bit_count = 6;	break;
+					case 3:		receive_bit_count = 8;	break;
+				}
+				LOG("Receive bit count: " << receive_bit_count);
+
+				(void)receive_bit_count;
+
+				/*
+					b7,b6:
+						00 = 5 receive bits per character
+						01 = 7 bits
+						10 = 6 bits
+						11 = 8 bits
+
+					b5 = 1 => DCD and CTS outputs are set automatically; 0 => they're inputs to read register 0.
+								(DCD is ignored in local loopback; CTS is ignored in both auto echo and local loopback).
+					b4: enter hunt mode (if set to 1, presumably?)
+					b3 = 1 => enable receiver CRC generation; 0 => don't.
+					b2: address search mode (SDLC)
+					b1: sync character load inhibit.
+					b0: Rx enable.
+				*/
+			} break;
+
 			case 0x4:	// Write register 4 — Transmit/Receive Miscellaneous Parameters and Modes.
 				// Bits 0 and 1 select parity mode.
 				if(!(value&1)) {
@@ -236,6 +377,23 @@ void z8530::Channel::write(bool data, uint8_t pointer, uint8_t value) {
 				}
 			break;
 
+			case 0x5:
+				// b7: DTR
+				// b6/b5:
+				//	00 = Tx 5 bits (or less) per character
+				//	01 = Tx 7 bits per character
+				//	10 = Tx 6 bits per character
+				//	11 = Tx 8 bits per character
+				// b4: send break.
+				// b3: Tx enable.
+				// b2: SDLC (if 0) / CRC-16 (if 1)
+				// b1: RTS
+				// b0: Tx CRC enable.
+			break;
+
+			case 0x6:
+			break;
+
 			case 0xf:	// Write register 15 — External/Status Interrupt Control.
 				external_interrupt_mask_ = value;
 			break;
@@ -253,12 +411,17 @@ void z8530::Channel::set_dcd(bool level) {
 	}
 }
 
-bool z8530::Channel::get_interrupt_line() {
+bool z8530::Channel::get_interrupt_line() const {
 	return
 		(interrupt_mask_ & 1) && external_status_interrupt_;
 	// TODO: other potential causes of an interrupt.
 }
 
+/*!
+	Evaluates the new level of the interrupt line and notifies the delegate if
+	both: (i) there is one; and (ii) the interrupt line has changed since last
+	the delegate was notified.
+*/
 void z8530::update_delegate() {
 	const bool interrupt_line = get_interrupt_line();
 	if(interrupt_line != previous_interrupt_line_) {

Components/8530/z8530.hpp

@@ -30,16 +30,33 @@ class z8530 {
 				A/B = A0
 				C/D = A1
 		*/
+
+		/// Performs a read from the SCC; see above for conventions as to 'address'.
 		std::uint8_t read(int address);
+		/// Performs a write to the SCC; see above for conventions as to 'address'.
 		void write(int address, std::uint8_t value);
+		/// Resets the SCC.
 		void reset();
-		bool get_interrupt_line();
+
+		/// @returns The current value of the status output: @c true for active; @c false for inactive.
+		bool get_interrupt_line() const;
 
 		struct Delegate {
-			virtual void did_change_interrupt_status(z8530 *, bool new_status) = 0;
+			/*!
+				Communicates that @c scc now has the interrupt line status @c new_status.
+			*/
+			virtual void did_change_interrupt_status(z8530 *scc, bool new_status) = 0;
 		};
+
+		/*!
+			Sets the delegate for this SCC. If this is a new delegate it is sent
+			an immediate did_change_interrupt_status message, to get it
+			up to speed.
+		*/
 		void set_delegate(Delegate *delegate) {
+			if(delegate_ == delegate) return;
 			delegate_ = delegate;
+			delegate_->did_change_interrupt_status(this, get_interrupt_line());
 		}
 
 		/*
@@ -53,7 +70,7 @@ class z8530 {
 				uint8_t read(bool data, uint8_t pointer);
 				void write(bool data, uint8_t pointer, uint8_t value);
 				void set_dcd(bool level);
-				bool get_interrupt_line();
+				bool get_interrupt_line() const;
 
 			private:
 				uint8_t data_ = 0xff;

Components/9918/9918.cpp

@@ -33,7 +33,7 @@ struct ReverseTable {
 
 	ReverseTable() {
 		for(int c = 0; c < 256; ++c) {
-			map[c] = static_cast<uint8_t>(
+			map[c] = uint8_t(
 				((c & 0x80) >> 7) |
 				((c & 0x40) >> 5) |
 				((c & 0x20) >> 3) |
@@ -117,10 +117,22 @@ void TMS9918::set_scan_target(Outputs::Display::ScanTarget *scan_target) {
 	crt_.set_scan_target(scan_target);
 }
 
+Outputs::Display::ScanStatus TMS9918::get_scaled_scan_status() const {
+	// The input was scaled by 3/4 to convert half cycles to internal ticks,
+	// so undo that and also allow for: (i) the multiply by 4 that it takes
+	// to reach the CRT; and (ii) the fact that the half-cycles value was scaled,
+	// and this should really reply in whole cycles.
+	return crt_.get_scaled_scan_status() * (4.0f / (3.0f * 8.0f));
+}
+
 void TMS9918::set_display_type(Outputs::Display::DisplayType display_type) {
 	crt_.set_display_type(display_type);
 }
 
+Outputs::Display::DisplayType TMS9918::get_display_type() const {
+	return crt_.get_display_type();
+}
+
 void Base::LineBuffer::reset_sprite_collection() {
 	sprites_stopped = false;
 	active_sprite_slot = 0;
@@ -132,7 +144,7 @@ void Base::LineBuffer::reset_sprite_collection() {
 
 void Base::posit_sprite(LineBuffer &buffer, int sprite_number, int sprite_position, int screen_row) {
 	if(!(status_ & StatusSpriteOverflow)) {
-		status_ = static_cast<uint8_t>((status_ & ~0x1f) | (sprite_number & 0x1f));
+		status_ = uint8_t((status_ & ~0x1f) | (sprite_number & 0x1f));
 	}
 	if(buffer.sprites_stopped)
 		return;
@@ -178,7 +190,9 @@ void TMS9918::run_for(const HalfCycles cycles) {
 	int read_cycles_pool = int_cycles;
 
 	while(write_cycles_pool || read_cycles_pool) {
+#ifndef NDEBUG
 		LineBufferPointer backup = read_pointer_;
+#endif
 
 		if(write_cycles_pool) {
 			// Determine how much writing to do.
@@ -317,8 +331,10 @@ void TMS9918::run_for(const HalfCycles cycles) {
 		}
 
 
+#ifndef NDEBUG
 		assert(backup.row == read_pointer_.row && backup.column == read_pointer_.column);
 		backup = write_pointer_;
+#endif
 
 
 		if(read_cycles_pool) {
@@ -492,7 +508,7 @@ void Base::output_border(int cycles, uint32_t cram_dot) {
 	}
 }
 
-void TMS9918::set_register(int address, uint8_t value) {
+void TMS9918::write(int address, uint8_t value) {
 	// Writes to address 0 are writes to the video RAM. Store
 	// the value and return.
 	if(!(address & 1)) {
@@ -519,7 +535,7 @@ void TMS9918::set_register(int address, uint8_t value) {
 
 	// The RAM pointer is always set on a second write, regardless of
 	// whether the caller is intending to enqueue a VDP operation.
-	ram_pointer_ = (ram_pointer_ & 0x00ff) | static_cast<uint16_t>(value << 8);
+	ram_pointer_ = (ram_pointer_ & 0x00ff) | uint16_t(value << 8);
 
 	write_phase_ = false;
 	if(value & 0x80) {
@@ -653,7 +669,7 @@ uint8_t TMS9918::get_current_line() {
 		}
 	}
 
-	return static_cast<uint8_t>(source_row);
+	return uint8_t(source_row);
 }
 
 uint8_t TMS9918::get_latched_horizontal_counter() {
@@ -670,7 +686,7 @@ void TMS9918::latch_horizontal_counter() {
 	latched_column_ = write_pointer_.column;
 }
 
-uint8_t TMS9918::get_register(int address) {
+uint8_t TMS9918::read(int address) {
 	write_phase_ = false;
 
 	// Reads from address 0 read video RAM, via the read-ahead buffer.

Components/9918/9918.hpp

@@ -44,9 +44,15 @@ class TMS9918: public Base {
 		/*! Sets the scan target this TMS will post content to. */
 		void set_scan_target(Outputs::Display::ScanTarget *);
 
+		/// Gets the current scan status.
+		Outputs::Display::ScanStatus get_scaled_scan_status() const;
+
 		/*! Sets the type of display the CRT will request. */
 		void set_display_type(Outputs::Display::DisplayType);
 
+		/*! Gets the type of display the CRT will request. */
+		Outputs::Display::DisplayType get_display_type() const;
+
 		/*!
 			Runs the VCP for the number of cycles indicate; it is an implicit assumption of the code
 			that the input clock rate is 3579545 Hz, the NTSC colour clock rate.
@@ -54,10 +60,10 @@ class TMS9918: public Base {
 		void run_for(const HalfCycles cycles);
 
 		/*! Sets a register value. */
-		void set_register(int address, uint8_t value);
+		void write(int address, uint8_t value);
 
 		/*! Gets a register value. */
-		uint8_t get_register(int address);
+		uint8_t read(int address);
 
 		/*! Gets the current scan line; provided by the Master System only. */
 		uint8_t get_current_line();
@@ -69,8 +75,8 @@ class TMS9918: public Base {
 		void latch_horizontal_counter();
 
 		/*!
-			Returns the amount of time until get_interrupt_line would next return true if
-			there are no interceding calls to set_register or get_register.
+			Returns the amount of time until @c get_interrupt_line would next return true if
+			there are no interceding calls to @c write or to @c read.
 
 			If get_interrupt_line is true now, returns zero. If get_interrupt_line would
 			never return true, returns -1.

Components/9918/Implementation/9918Base.hpp

@@ -40,7 +40,7 @@ enum class TVStandard {
 
 class Base {
 	public:
-		static const uint32_t palette_pack(uint8_t r, uint8_t g, uint8_t b) {
+		static uint32_t palette_pack(uint8_t r, uint8_t g, uint8_t b) {
 			uint32_t result = 0;
 			uint8_t *const result_ptr = reinterpret_cast<uint8_t *>(&result);
 			result_ptr[0] = r;
@@ -51,7 +51,7 @@ class Base {
 		}
 
 	protected:
-		const static int output_lag = 11;	// i.e. pixel output will occur 11 cycles after corresponding data read.
+		static constexpr int output_lag = 11;	// i.e. pixel output will occur 11 cycles after corresponding data read.
 
 		// The default TMS palette.
 		const uint32_t palette[16] = {
@@ -352,9 +352,9 @@ class Base {
 					if(master_system_.cram_is_selected) {
 						// Adjust the palette.
 						master_system_.colour_ram[ram_pointer_ & 0x1f] = palette_pack(
-							static_cast<uint8_t>(((read_ahead_buffer_ >> 0) & 3) * 255 / 3),
-							static_cast<uint8_t>(((read_ahead_buffer_ >> 2) & 3) * 255 / 3),
-							static_cast<uint8_t>(((read_ahead_buffer_ >> 4) & 3) * 255 / 3)
+							uint8_t(((read_ahead_buffer_ >> 0) & 3) * 255 / 3),
+							uint8_t(((read_ahead_buffer_ >> 2) & 3) * 255 / 3),
+							uint8_t(((read_ahead_buffer_ >> 4) & 3) * 255 / 3)
 						);
 
 						// Schedule a CRAM dot; this is scheduled for wherever it should appear
@@ -421,7 +421,8 @@ class Base {
 */
 
 #define slot(n)	\
-		if(use_end && end == n) return;\
+		if(use_end && end == n) return;	\
+		[[fallthrough]];				\
 		case n
 
 #define external_slot(n)	\
@@ -449,7 +450,7 @@ class Base {
 
 
 /***********************************************
-             TMS9918 Fetching Code
+	TMS9918 Fetching Code
 ************************************************/
 
 		template<bool use_end> void fetch_tms_refresh(int start, int end) {
@@ -518,7 +519,7 @@ class Base {
 	fetch_columns_4(location+12, column+4);
 
 			LineBuffer &line_buffer = line_buffers_[write_pointer_.row];
-			const size_t row_base = pattern_name_address_ & (0x3c00 | static_cast<size_t>(write_pointer_.row >> 3) * 40);
+			const size_t row_base = pattern_name_address_ & (0x3c00 | size_t(write_pointer_.row >> 3) * 40);
 			const size_t row_offset = pattern_generator_table_address_ & (0x3800 | (write_pointer_.row & 7));
 
 			switch(start) {
@@ -693,7 +694,7 @@ class Base {
 
 
 /***********************************************
-          Master System Fetching Code
+	Master System Fetching Code
 ************************************************/
 
 		template<bool use_end> void fetch_sms(int start, int end) {
@@ -731,7 +732,7 @@ class Base {
 		const size_t scrolled_column = (column - horizontal_offset) & 0x1f;\
 		const size_t address = row_info.pattern_address_base + (scrolled_column << 1);	\
 		line_buffer.names[column].flags = ram_[address+1];	\
-		line_buffer.names[column].offset = static_cast<size_t>(	\
+		line_buffer.names[column].offset = size_t(	\
 			(((line_buffer.names[column].flags&1) << 8) | ram_[address]) << 5	\
 		) + row_info.sub_row[(line_buffer.names[column].flags&4) >> 2];	\
 	}
@@ -785,7 +786,7 @@ class Base {
 			};
 			const RowInfo scrolled_row_info = {
 				(pattern_name_address & size_t(((scrolled_row & ~7) << 3) | 0x3800)) - pattern_name_offset,
-				{static_cast<size_t>((scrolled_row & 7) << 2), 28 ^ static_cast<size_t>((scrolled_row & 7) << 2)}
+				{size_t((scrolled_row & 7) << 2), 28 ^ size_t((scrolled_row & 7) << 2)}
 			};
 			RowInfo row_info;
 			if(master_system_.vertical_scroll_lock) {

Components/AY38910/AY38910.cpp

@@ -6,13 +6,17 @@
 //  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
+#include <cmath>
+
 #include "AY38910.hpp"
 
-#include <cmath>
+//namespace GI {
+//namespace AY38910 {
 
 using namespace GI::AY38910;
 
-AY38910::AY38910(Personality personality, Concurrency::DeferringAsyncTaskQueue &task_queue) : task_queue_(task_queue) {
+template <bool is_stereo>
+AY38910<is_stereo>::AY38910(Personality personality, Concurrency::DeferringAsyncTaskQueue &task_queue) : task_queue_(task_queue) {
 	// Don't use the low bit of the envelope position if this is an AY.
 	envelope_position_mask_ |= personality == Personality::AY38910;
 
@@ -70,17 +74,34 @@ AY38910::AY38910(Personality personality, Concurrency::DeferringAsyncTaskQueue &
 	set_sample_volume_range(0);
 }
 
-void AY38910::set_sample_volume_range(std::int16_t range) {
-	// set up volume lookup table
+template <bool is_stereo> void AY38910<is_stereo>::set_sample_volume_range(std::int16_t range) {
+	// Set up volume lookup table; the function below is based on a combination of the graph
+	// from the YM's datasheet, showing a clear power curve, and fitting that to observed
+	// values reported elsewhere.
 	const float max_volume = float(range) / 3.0f;	// As there are three channels.
 	constexpr float root_two = 1.414213562373095f;
 	for(int v = 0; v < 32; v++) {
-		volumes_[v] = int(max_volume / powf(root_two, float(v ^ 0x1f) / 2.0f));
+		volumes_[v] = int(max_volume / powf(root_two, float(v ^ 0x1f) / 3.18f));
 	}
+
+	// Tie level 0 to silence.
+	for(int v = 31; v >= 0; --v) {
+		volumes_[v] -= volumes_[0];
+	}
+
 	evaluate_output_volume();
 }
 
-void AY38910::get_samples(std::size_t number_of_samples, int16_t *target) {
+template <bool is_stereo> void AY38910<is_stereo>::set_output_mixing(float a_left, float b_left, float c_left, float a_right, float b_right, float c_right) {
+	a_left_ = uint8_t(a_left * 255.0f);
+	b_left_ = uint8_t(b_left * 255.0f);
+	c_left_ = uint8_t(c_left * 255.0f);
+	a_right_ = uint8_t(a_right * 255.0f);
+	b_right_ = uint8_t(b_right * 255.0f);
+	c_right_ = uint8_t(c_right * 255.0f);
+}
+
+template <bool is_stereo> void AY38910<is_stereo>::get_samples(std::size_t number_of_samples, int16_t *target) {
 	// Note on structure below: the real AY has a built-in divider of 8
 	// prior to applying its tone and noise dividers. But the YM fills the
 	// same total periods for noise and tone with double-precision envelopes.
@@ -92,7 +113,11 @@ void AY38910::get_samples(std::size_t number_of_samples, int16_t *target) {
 
 	std::size_t c = 0;
 	while((master_divider_&3) && c < number_of_samples) {
-		target[c] = output_volume_;
+		if constexpr (is_stereo) {
+			reinterpret_cast<uint32_t *>(target)[c] = output_volume_;
+		} else {
+			target[c] = int16_t(output_volume_);
+		}
 		master_divider_++;
 		c++;
 	}
@@ -134,7 +159,11 @@ void AY38910::get_samples(std::size_t number_of_samples, int16_t *target) {
 		evaluate_output_volume();
 
 		for(int ic = 0; ic < 4 && c < number_of_samples; ic++) {
-			target[c] = output_volume_;
+			if constexpr (is_stereo) {
+				reinterpret_cast<uint32_t *>(target)[c] = output_volume_;
+			} else {
+				target[c] = int16_t(output_volume_);
+			}
 			c++;
 			master_divider_++;
 		}
@@ -143,7 +172,7 @@ void AY38910::get_samples(std::size_t number_of_samples, int16_t *target) {
 	master_divider_ &= 3;
 }
 
-void AY38910::evaluate_output_volume() {
+template <bool is_stereo> void AY38910<is_stereo>::evaluate_output_volume() {
 	int envelope_volume = envelope_shapes_[output_registers_[13]][envelope_position_ | envelope_position_mask_];
 
 	// The output level for a channel is:
@@ -161,10 +190,20 @@ void AY38910::evaluate_output_volume() {
 	};
 #undef level
 
+	// This remapping table seeks to map 'channel volumes', i.e. the levels produced from the
+	// 16-step progammatic volumes set per channel to 'envelope volumes', i.e. the 32-step
+	// volumes that are produced by the envelope generators (on a YM at least). My reading of
+	// the data sheet is that '0' is still off, but 15 should be as loud as peak envelope. So
+	// I've thrown in the discontinuity at the low end, where it'll be very quiet.
+	const int channel_volumes[] = {
+		0, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31
+	};
+	static_assert(sizeof(channel_volumes) == 16*sizeof(int));
+
 		// Channel volume is a simple selection: if the bit at 0x10 is set, use the envelope volume; otherwise use the lower four bits,
 		// mapped to the range 1–31 in case this is a YM.
 #define channel_volume(c)	\
-	((output_registers_[c] >> 4)&1) * envelope_volume + (((output_registers_[c] >> 4)&1)^1) * (((output_registers_[c]&0xf) << 1) + 1)
+	((output_registers_[c] >> 4)&1) * envelope_volume + (((output_registers_[c] >> 4)&1)^1) * channel_volumes[output_registers_[c]&0xf]
 
 	const int volumes[3] = {
 		channel_volume(8),
@@ -173,34 +212,47 @@ void AY38910::evaluate_output_volume() {
 	};
 #undef channel_volume
 
-	// Mix additively.
-	output_volume_ = static_cast<int16_t>(
-		volumes_[volumes[0]] * channel_levels[0] +
-		volumes_[volumes[1]] * channel_levels[1] +
-		volumes_[volumes[2]] * channel_levels[2]
-	);
+	// Mix additively, weighting if in stereo.
+	if constexpr (is_stereo) {
+		int16_t *const output_volumes = reinterpret_cast<int16_t *>(&output_volume_);
+		output_volumes[0] = int16_t((
+			volumes_[volumes[0]] * channel_levels[0] * a_left_ +
+			volumes_[volumes[1]] * channel_levels[1] * b_left_ +
+			volumes_[volumes[2]] * channel_levels[2] * c_left_
+		) >> 8);
+		output_volumes[1] = int16_t((
+			volumes_[volumes[0]] * channel_levels[0] * a_right_ +
+			volumes_[volumes[1]] * channel_levels[1] * b_right_ +
+			volumes_[volumes[2]] * channel_levels[2] * c_right_
+		) >> 8);
+	} else {
+		output_volume_ = uint32_t(
+			volumes_[volumes[0]] * channel_levels[0] +
+			volumes_[volumes[1]] * channel_levels[1] +
+			volumes_[volumes[2]] * channel_levels[2]
+		);
+	}
 }
 
-bool AY38910::is_zero_level() {
+template <bool is_stereo> bool AY38910<is_stereo>::is_zero_level() const {
 	// Confirm that the AY is trivially at the zero level if all three volume controls are set to fixed zero.
 	return output_registers_[0x8] == 0 && output_registers_[0x9] == 0 && output_registers_[0xa] == 0;
 }
 
 // MARK: - Register manipulation
 
-void AY38910::select_register(uint8_t r) {
+template <bool is_stereo> void AY38910<is_stereo>::select_register(uint8_t r) {
 	selected_register_ = r;
 }
 
-void AY38910::set_register_value(uint8_t value) {
+template <bool is_stereo> void AY38910<is_stereo>::set_register_value(uint8_t value) {
 	// There are only 16 registers.
 	if(selected_register_ > 15) return;
 
 	// If this is a register that affects audio output, enqueue a mutation onto the
 	// audio generation thread.
 	if(selected_register_ < 14) {
-		const int selected_register = selected_register_;
-		task_queue_.defer([=] () {
+		task_queue_.defer([this, selected_register = selected_register_, value] () {
 			// Perform any register-specific mutation to output generation.
 			uint8_t masked_value = value;
 			switch(selected_register) {
@@ -209,7 +261,7 @@ void AY38910::set_register_value(uint8_t value) {
 					int channel = selected_register >> 1;
 
 					if(selected_register & 1)
-						tone_periods_[channel] = (tone_periods_[channel] & 0xff) | static_cast<uint16_t>((value&0xf) << 8);
+						tone_periods_[channel] = (tone_periods_[channel] & 0xff) | uint16_t((value&0xf) << 8);
 					else
 						tone_periods_[channel] = (tone_periods_[channel] & ~0xff) | value;
 				}
@@ -224,7 +276,7 @@ void AY38910::set_register_value(uint8_t value) {
 				break;
 
 				case 12:
-					envelope_period_ = (envelope_period_ & 0xff) | static_cast<int>(value << 8);
+					envelope_period_ = (envelope_period_ & 0xff) | int(value << 8);
 				break;
 
 				case 13:
@@ -262,7 +314,7 @@ void AY38910::set_register_value(uint8_t value) {
 	if(update_port_a) set_port_output(false);
 }
 
-uint8_t AY38910::get_register_value() {
+template <bool is_stereo> uint8_t AY38910<is_stereo>::get_register_value() {
 	// This table ensures that bits that aren't defined within the AY are returned as 0s
 	// when read, conforming to CPC-sourced unit tests.
 	const uint8_t register_masks[16] = {
@@ -276,24 +328,24 @@ uint8_t AY38910::get_register_value() {
 
 // MARK: - Port querying
 
-uint8_t AY38910::get_port_output(bool port_b) {
+template <bool is_stereo> uint8_t AY38910<is_stereo>::get_port_output(bool port_b) {
 	return registers_[port_b ? 15 : 14];
 }
 
 // MARK: - Bus handling
 
-void AY38910::set_port_handler(PortHandler *handler) {
+template <bool is_stereo> void AY38910<is_stereo>::set_port_handler(PortHandler *handler) {
 	port_handler_ = handler;
 	set_port_output(true);
 	set_port_output(false);
 }
 
-void AY38910::set_data_input(uint8_t r) {
+template <bool is_stereo> void AY38910<is_stereo>::set_data_input(uint8_t r) {
 	data_input_ = r;
 	update_bus();
 }
 
-void AY38910::set_port_output(bool port_b) {
+template <bool is_stereo> void AY38910<is_stereo>::set_port_output(bool port_b) {
 	// Per the data sheet: "each [IO] pin is provided with an on-chip pull-up resistor,
 	// so that when in the "input" mode, all pins will read normally high". Therefore,
 	// report programmer selection of input mode as creating an output of 0xff.
@@ -303,7 +355,7 @@ void AY38910::set_port_output(bool port_b) {
 	}
 }
 
-uint8_t AY38910::get_data_output() {
+template <bool is_stereo> uint8_t AY38910<is_stereo>::get_data_output() {
 	if(control_state_ == Read && selected_register_ >= 14 && selected_register_ < 16) {
 		// Per http://cpctech.cpc-live.com/docs/psgnotes.htm if a port is defined as output then the
 		// value returned to the CPU when reading it is the and of the output value and any input.
@@ -319,22 +371,22 @@ uint8_t AY38910::get_data_output() {
 	return data_output_;
 }
 
-void AY38910::set_control_lines(ControlLines control_lines) {
-	switch(static_cast<int>(control_lines)) {
+template <bool is_stereo> void AY38910<is_stereo>::set_control_lines(ControlLines control_lines) {
+	switch(int(control_lines)) {
 		default:					control_state_ = Inactive;		break;
 
-		case static_cast<int>(BDIR | BC2 | BC1):
+		case int(BDIR | BC2 | BC1):
 		case BDIR:
 		case BC1:					control_state_ = LatchAddress;	break;
 
-		case static_cast<int>(BC2 | BC1):		control_state_ = Read;			break;
-		case static_cast<int>(BDIR | BC2):		control_state_ = Write;			break;
+		case int(BC2 | BC1):		control_state_ = Read;			break;
+		case int(BDIR | BC2):		control_state_ = Write;			break;
 	}
 
 	update_bus();
 }
 
-void AY38910::update_bus() {
+template <bool is_stereo> void AY38910<is_stereo>::update_bus() {
 	// Assume no output, unless this turns out to be a read.
 	data_output_ = 0xff;
 	switch(control_state_) {
@@ -344,3 +396,7 @@ void AY38910::update_bus() {
 		case Read:			data_output_ = get_register_value();	break;
 	}
 }
+
+// Ensure both mono and stereo versions of the AY are built.
+template class GI::AY38910::AY38910<true>;
+template class GI::AY38910::AY38910<false>;

Components/AY38910/AY38910.hpp

@@ -30,7 +30,7 @@ class PortHandler {
 
 			@param port_b @c true if the input being queried is Port B. @c false if it is Port A.
 		*/
-		virtual uint8_t get_port_input(bool port_b) {
+		virtual uint8_t get_port_input([[maybe_unused]] bool port_b) {
 			return 0xff;
 		}
 
@@ -40,7 +40,7 @@ class PortHandler {
 			@param port_b @c true if the output being posted is Port B. @c false if it is Port A.
 			@param value the value now being output.
 		*/
-		virtual void set_port_output(bool port_b, uint8_t value) {}
+		virtual void set_port_output([[maybe_unused]] bool port_b, [[maybe_unused]] uint8_t value) {}
 };
 
 /*!
@@ -63,8 +63,10 @@ enum class Personality {
 	Provides emulation of an AY-3-8910 / YM2149, which is a three-channel sound chip with a
 	noise generator and a volume envelope generator, which also provides two bidirectional
 	interface ports.
+
+	This AY has an attached mono or stereo mixer.
 */
-class AY38910: public ::Outputs::Speaker::SampleSource {
+template <bool is_stereo> class AY38910: public ::Outputs::Speaker::SampleSource {
 	public:
 		/// Creates a new AY38910.
 		AY38910(Personality, Concurrency::DeferringAsyncTaskQueue &);
@@ -91,10 +93,23 @@ class AY38910: public ::Outputs::Speaker::SampleSource {
 		*/
 		void set_port_handler(PortHandler *);
 
+		/*!
+			Enables or disables stereo output; if stereo output is enabled then also sets the weight of each of the AY's
+			channels in each of the output channels.
+
+			If a_left_ = b_left = c_left = a_right = b_right = c_right = 1.0 then you'll get output that's effectively mono.
+
+			a_left = 0.0, a_right = 1.0 will make A full volume on the right output, and silent on the left.
+
+			a_left = 0.5, a_right = 0.5 will make A half volume on both outputs.
+		*/
+		void set_output_mixing(float a_left, float b_left, float c_left, float a_right = 1.0, float b_right = 1.0, float c_right = 1.0);
+
 		// to satisfy ::Outputs::Speaker (included via ::Outputs::Filter.
 		void get_samples(std::size_t number_of_samples, int16_t *target);
-		bool is_zero_level();
+		bool is_zero_level() const;
 		void set_sample_volume_range(std::int16_t range);
+		static constexpr bool get_is_stereo() { return is_stereo; }
 
 	private:
 		Concurrency::DeferringAsyncTaskQueue &task_queue_;
@@ -135,14 +150,21 @@ class AY38910: public ::Outputs::Speaker::SampleSource {
 
 		uint8_t data_input_, data_output_;
 
-		int16_t output_volume_;
-		void evaluate_output_volume();
+		uint32_t output_volume_;
 
 		void update_bus();
 		PortHandler *port_handler_ = nullptr;
 		void set_port_output(bool port_b);
+
+		void evaluate_output_volume();
+
+		// Output mixing control.
+		uint8_t a_left_ = 255, a_right_ = 255;
+		uint8_t b_left_ = 255, b_right_ = 255;
+		uint8_t c_left_ = 255, c_right_ = 255;
 };
 
+
 }
 }
 

Components/AppleClock/AppleClock.hpp

@@ -0,0 +1,290 @@
+//
+//  RealTimeClock.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 07/05/2019.
+//  Copyright © 2019 Thomas Harte. All rights reserved.
+//
+
+#ifndef Apple_RealTimeClock_hpp
+#define Apple_RealTimeClock_hpp
+
+namespace Apple {
+namespace Clock {
+
+/*!
+	Models Apple's real-time clocks, as contained in the Macintosh and IIgs.
+
+	Since tracking of time is pushed to this class, it is assumed
+	that whomever is translating real time into emulated time
+	will also signal interrupts — this is just the storage and time counting.
+*/
+class ClockStorage {
+	public:
+		ClockStorage() {
+			// TODO: this should persist, if possible, rather than
+			// being default initialised.
+			constexpr uint8_t default_data[] = {
+				0xa8, 0x00, 0x00, 0x00,
+				0xcc, 0x0a, 0xcc, 0x0a,
+				0x00, 0x00, 0x00, 0x00,
+				0x00, 0x02, 0x63, 0x00,
+				0x03, 0x88, 0x00, 0x4c
+			};
+			memcpy(data_, default_data, sizeof(default_data));
+			memset(&data_[sizeof(default_data)], 0xff, sizeof(data_) - sizeof(default_data));
+		}
+
+		/*!
+			Advances the clock by 1 second.
+
+			The caller should also signal an interrupt.
+		*/
+		void update() {
+			for(int c = 0; c < 4; ++c) {
+				++seconds_[c];
+				if(seconds_[c]) break;
+			}
+		}
+
+	protected:
+		static constexpr uint16_t NoResult = 0x100;
+		static constexpr uint16_t DidComplete = 0x101;
+		uint16_t perform(uint8_t command) {
+			/*
+				Documented commands:
+
+					z0000001		Seconds register 0 (lowest order byte)
+					z0000101		Seconds register 1
+					z0001001		Seconds register 2
+					z0001101		Seconds register 3
+					00110001		Test register (write only)
+					00110101		Write-protect register (write only)
+					z010aa01		RAM addresses 0x10 - 0x13
+					z1aaaa01		RAM addresses 0x00 – 0x0f
+
+					z0111abc, followed by 0defgh00
+									RAM address abcdefgh
+
+					z = 1 => a read; z = 0 => a write.
+
+				The top bit of the write-protect register enables (0) or disables (1)
+				writes to other locations.
+
+				All the documentation says about the test register is to set the top
+				two bits to 0 for normal operation. Abnormal operation is undefined.
+			*/
+			switch(phase_) {
+				case Phase::Command:
+					// Decode an address.
+					switch(command & 0x70) {
+						default:
+							if(command & 0x40) {
+								// RAM addresses 0x00 – 0x0f.
+								address_ = (command >> 2) & 0xf;
+							} else return DidComplete;	// Unrecognised.
+						break;
+
+						case 0x00:
+							// A time access.
+							address_ = SecondsBuffer + ((command >> 2)&3);
+						break;
+						case 0x30:
+							// Either a register access or an extended instruction.
+							if(command & 0x08) {
+								address_ = (command & 0x7) << 5;
+								phase_ = (command & 0x80) ? Phase::SecondAddressByteRead : Phase::SecondAddressByteWrite;
+								return NoResult;
+							} else {
+								address_ = (command & 4) ? RegisterWriteProtect : RegisterTest;
+							}
+						break;
+						case 0x20:
+							// RAM addresses 0x10 – 0x13.
+							address_ = 0x10 + ((command >> 2) & 0x3);
+						break;
+					}
+
+					// If this is a read, return a result; otherwise prepare to write.
+					if(command & 0x80) {
+						// The two registers are write-only.
+						if(address_ == RegisterTest || address_ == RegisterWriteProtect) {
+							return DidComplete;
+						}
+						return (address_ >= SecondsBuffer) ? seconds_[address_ & 0xff] : data_[address_];
+					}
+					phase_ = Phase::WriteData;
+				return NoResult;
+
+				case Phase::SecondAddressByteRead:
+				case Phase::SecondAddressByteWrite:
+					if(command & 0x83) {
+						return DidComplete;
+					}
+					address_ |= command >> 2;
+
+					if(phase_ == Phase::SecondAddressByteRead) {
+						phase_ = Phase::Command;
+						return data_[address_];	// Only RAM accesses can get this far.
+					} else {
+						phase_ = Phase::WriteData;
+					}
+				return NoResult;
+
+				case Phase::WriteData:
+					// First test: is this to the write-protect register?
+					if(address_ == RegisterWriteProtect) {
+						write_protect_ = command;
+						return DidComplete;
+					}
+
+					if(address_ == RegisterTest) {
+						// No documentation here.
+						return DidComplete;
+					}
+
+					// No other writing is permitted if the write protect
+					// register won't allow it.
+					if(!(write_protect_ & 0x80)) {
+						if(address_ >= SecondsBuffer) {
+							seconds_[address_ & 0xff] = command;
+						} else {
+							data_[address_] = command;
+						}
+					}
+
+					phase_ = Phase::Command;
+				return DidComplete;
+			}
+
+			return NoResult;
+		}
+
+
+	private:
+		uint8_t data_[256];
+		uint8_t seconds_[4];
+		uint8_t write_protect_;
+		int address_;
+
+		static constexpr int SecondsBuffer = 0x100;
+		static constexpr int RegisterTest = 0x200;
+		static constexpr int RegisterWriteProtect = 0x201;
+
+		enum class Phase {
+			Command,
+			SecondAddressByteRead,
+			SecondAddressByteWrite,
+			WriteData
+		};
+		Phase phase_ = Phase::Command;
+
+};
+
+/*!
+	Provides the serial interface implemented by the Macintosh.
+*/
+class SerialClock: public ClockStorage {
+	public:
+		/*!
+			Sets the current clock and data inputs to the clock.
+		*/
+		void set_input(bool clock, bool data) {
+			// 	The data line is valid when the clock transitions to level 0.
+			if(clock && !previous_clock_) {
+				// Shift into the command_ register, no matter what.
+				command_ = uint16_t((command_ << 1) | (data ? 1 : 0));
+				result_ <<= 1;
+
+				// Increment phase.
+				++phase_;
+
+				// If a whole byte has been collected, push it onwards.
+				if(!(phase_&7)) {
+					// Begin pessimistically.
+					const auto effect = perform(uint8_t(command_));
+
+					switch(effect) {
+						case ClockStorage::NoResult:
+						break;
+						default:
+							result_ = uint8_t(effect);
+						break;
+						case ClockStorage::DidComplete:
+							abort();
+						break;
+					}
+				}
+			}
+
+			previous_clock_ = clock;
+		}
+
+		/*!
+			Reads the current data output level from the clock.
+		*/
+		bool get_data() {
+			return !!(result_ & 0x80);
+		}
+
+		/*!
+			Announces that a serial command has been aborted.
+		*/
+		void abort() {
+			result_ = 0;
+			phase_ = 0;
+			command_ = 0;
+		}
+
+	private:
+		int phase_ = 0;
+		uint16_t command_;
+		uint8_t result_ = 0;
+
+		bool previous_clock_ = false;
+};
+
+/*!
+	Provides the parallel interface implemented by the IIgs.
+*/
+class ParallelClock: public ClockStorage {
+	public:
+		void set_control(uint8_t control) {
+			if(!(control&0x80)) return;
+
+			if(control & 0x40) {
+				// Read from the RTC.
+				// A no-op for now.
+			} else {
+				// Write to the RTC. Which in this implementation also sets up a future read.
+				data_ = uint8_t(perform(data_));
+			}
+
+			// MAGIC! The transaction took 0 seconds.
+			// TODO: no magic.
+			control_ = control & 0x7f;
+
+			// Bit 5 is also meant to be 1 or 0 to indicate the final byte.
+		}
+
+		uint8_t get_control() {
+			return control_;
+		}
+
+		void set_data(uint8_t data) {
+			data_ = data;
+		}
+
+		uint8_t get_data() {
+			return data_;
+		}
+
+	private:
+		uint8_t data_;
+		uint8_t control_;
+};
+
+}
+}
+
+#endif /* Apple_RealTimeClock_hpp */

Components/AudioToggle/AudioToggle.cpp

@@ -23,16 +23,16 @@ void Toggle::set_sample_volume_range(std::int16_t range) {
 	volume_ = range;
 }
 
-void Toggle::skip_samples(const std::size_t number_of_samples) {}
+void Toggle::skip_samples(std::size_t) {}
 
 void Toggle::set_output(bool enabled) {
 	if(is_enabled_ == enabled) return;
 	is_enabled_ = enabled;
-	audio_queue_.defer([=] {
+	audio_queue_.defer([this, enabled] {
 		level_ = enabled ? volume_ : 0;
 	});
 }
 
-bool Toggle::get_output() {
+bool Toggle::get_output() const {
 	return is_enabled_;
 }

Components/AudioToggle/AudioToggle.hpp

@@ -26,7 +26,7 @@ class Toggle: public Outputs::Speaker::SampleSource {
 		void skip_samples(const std::size_t number_of_samples);
 
 		void set_output(bool enabled);
-		bool get_output();
+		bool get_output() const;
 
 	private:
 		// Accessed on the calling thread.

Components/DiskII/DiskII.cpp

@@ -85,13 +85,13 @@ void DiskII::run_for(const Cycles cycles) {
 			--flux_duration_;
 			if(!flux_duration_) inputs_ |= input_flux;
 		}
-		state_ = state_machine_[static_cast<std::size_t>(address)];
+		state_ = state_machine_[size_t(address)];
 		switch(state_ & 0xf) {
-			default:	shift_register_ = 0;													break;	// clear
-			case 0x8:																			break;	// nop
+			default:	shift_register_ = 0;										break;	// clear
+			case 0x8:																break;	// nop
 
-			case 0x9:	shift_register_ = static_cast<uint8_t>(shift_register_ << 1);			break;	// shift left, bringing in a zero
-			case 0xd:	shift_register_ = static_cast<uint8_t>((shift_register_ << 1) | 1);		break;	// shift left, bringing in a one
+			case 0x9:	shift_register_ = uint8_t(shift_register_ << 1);			break;	// shift left, bringing in a zero
+			case 0xd:	shift_register_ = uint8_t((shift_register_ << 1) | 1);		break;	// shift left, bringing in a one
 
 			case 0xa:	// shift right, bringing in write protected status
 				shift_register_ = (shift_register_ >> 1) | (is_write_protected() ? 0x80 : 0x00);
@@ -105,7 +105,7 @@ void DiskII::run_for(const Cycles cycles) {
 					return;
 				}
 			break;
-			case 0xb:	shift_register_ = data_input_;											break;	// load data register from data bus
+			case 0xb:	shift_register_ = data_input_;								break;	// load data register from data bus
 		}
 
 		// Currently writing?
@@ -180,30 +180,40 @@ void DiskII::set_state_machine(const std::vector<uint8_t> &state_machine) {
 	if(state_machine[0] != 0x18) {
 		for(size_t source_address = 0; source_address < 256; ++source_address) {
 			// Remap into Beneath Apple Pro-DOS address form.
-			size_t destination_address =
-				((source_address&0x80) ? 0x10 : 0x00) |
-				((source_address&0x01) ? 0x20 : 0x00) |
-				((source_address&0x40) ? 0x40 : 0x00) |
+			const size_t destination_address =
 				((source_address&0x20) ? 0x80 : 0x00) |
-				((source_address&0x10) ? 0x01 : 0x00) |
+				((source_address&0x40) ? 0x40 : 0x00) |
+				((source_address&0x01) ? 0x20 : 0x00) |
+				((source_address&0x80) ? 0x10 : 0x00) |
 				((source_address&0x08) ? 0x08 : 0x00) |
 				((source_address&0x04) ? 0x04 : 0x00) |
-				((source_address&0x02) ? 0x02 : 0x00);
-			uint8_t source_value = state_machine[source_address];
+				((source_address&0x02) ? 0x02 : 0x00) |
+				((source_address&0x10) ? 0x01 : 0x00);
 
-			// Remap into Beneath Apple Pro-DOS value form.
-			source_value =
+			// Store.
+			const uint8_t source_value = state_machine[source_address];
+			state_machine_[destination_address] =
 				((source_value & 0x80) ? 0x10 : 0x0) |
 				((source_value & 0x40) ? 0x20 : 0x0) |
 				((source_value & 0x20) ? 0x40 : 0x0) |
 				((source_value & 0x10) ? 0x80 : 0x0) |
 				(source_value & 0x0f);
-
-			// Store.
-			state_machine_[destination_address] = source_value;
 		}
 	} else {
-		memcpy(&state_machine_[0], &state_machine[0], 128);
+		for(size_t source_address = 0; source_address < 256; ++source_address) {
+			// Reshuffle ordering of bytes only, to retain indexing by the high nibble.
+			const size_t destination_address =
+				((source_address&0x80) ? 0x80 : 0x00) |
+				((source_address&0x40) ? 0x40 : 0x00) |
+				((source_address&0x01) ? 0x20 : 0x00) |
+				((source_address&0x20) ? 0x10 : 0x00) |
+				((source_address&0x08) ? 0x08 : 0x00) |
+				((source_address&0x04) ? 0x04 : 0x00) |
+				((source_address&0x02) ? 0x02 : 0x00) |
+				((source_address&0x10) ? 0x01 : 0x00);
+
+			state_machine_[destination_address] = state_machine[source_address];
+		}
 	}
 }
 
@@ -219,13 +229,13 @@ void DiskII::process_event(const Storage::Disk::Drive::Event &event) {
 	}
 }
 
-void DiskII::set_component_prefers_clocking(ClockingHint::Source *component, ClockingHint::Preference preference) {
+void DiskII::set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference) {
 	drive_is_sleeping_[0] = drives_[0].preferred_clocking() == ClockingHint::Preference::None;
 	drive_is_sleeping_[1] = drives_[1].preferred_clocking() == ClockingHint::Preference::None;
 	decide_clocking_preference();
 }
 
-ClockingHint::Preference DiskII::preferred_clocking() {
+ClockingHint::Preference DiskII::preferred_clocking() const {
 	return clocking_preference_;
 }
 

Components/DiskII/DiskII.hpp

@@ -26,7 +26,7 @@ namespace Apple {
 /*!
 	Provides an emulation of the Apple Disk II.
 */
-class DiskII final:
+class DiskII :
 	public Storage::Disk::Drive::EventDelegate,
 	public ClockingHint::Source,
 	public ClockingHint::Observer {
@@ -76,7 +76,7 @@ class DiskII final:
 		void set_disk(const std::shared_ptr<Storage::Disk::Disk> &disk, int drive);
 
 		// As per Sleeper.
-		ClockingHint::Preference preferred_clocking() final;
+		ClockingHint::Preference preferred_clocking() const final;
 
 		// The Disk II functions as a potential target for @c Activity::Sources.
 		void set_activity_observer(Activity::Observer *observer);
@@ -98,8 +98,8 @@ class DiskII final:
 		void select_drive(int drive);
 
 		uint8_t trigger_address(int address, uint8_t value);
-		void process_event(const Storage::Disk::Drive::Event &event) override;
-		void set_component_prefers_clocking(ClockingHint::Source *component, ClockingHint::Preference preference) override;
+		void process_event(const Storage::Disk::Drive::Event &event) final;
+		void set_component_prefers_clocking(ClockingHint::Source *component, ClockingHint::Preference preference) final;
 
 		const Cycles::IntType clock_rate_ = 0;
 

Components/DiskII/DiskIIDrive.cpp

@@ -0,0 +1,45 @@
+//
+//  DiskIIDrive.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/11/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#include "DiskIIDrive.hpp"
+
+using namespace Apple::Disk;
+
+DiskIIDrive::DiskIIDrive(int input_clock_rate) :
+	IWMDrive(input_clock_rate, 1) {
+	Drive::set_rotation_speed(300.0f);
+}
+
+void DiskIIDrive::set_enabled(bool enabled) {
+	set_motor_on(enabled);
+}
+
+void DiskIIDrive::set_control_lines(int lines) {
+	// If the stepper magnet selections have changed, and any is on, see how
+	// that moves the head.
+	if(lines ^ stepper_mask_ && lines) {
+		// Convert from a representation of bits set to the centre of pull.
+		int direction = 0;
+		if(lines&1) direction += (((stepper_position_ - 0) + 4)&7) - 4;
+		if(lines&2) direction += (((stepper_position_ - 2) + 4)&7) - 4;
+		if(lines&4) direction += (((stepper_position_ - 4) + 4)&7) - 4;
+		if(lines&8) direction += (((stepper_position_ - 6) + 4)&7) - 4;
+		const int bits_set = (lines&1) + ((lines >> 1)&1) + ((lines >> 2)&1) + ((lines >> 3)&1);
+		direction /= bits_set;
+
+		// Compare to the stepper position to decide whether that pulls in the
+		// current cog notch, or grabs a later one.
+		step(Storage::Disk::HeadPosition(-direction, 4));
+		stepper_position_ = (stepper_position_ - direction + 8) & 7;
+	}
+	stepper_mask_ = lines;
+}
+
+bool DiskIIDrive::read() {
+	return !!(stepper_mask_ & 2) || get_is_read_only();
+}