Merge pull request #543 from TomHarte/CFBundleTypeOSTypes

Removes `LSItemContentTypes` so as not to reject files.

.editorconfig

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

.gitignore

@@ -18,9 +18,14 @@ DerivedData
 *.xcuserstate
 .DS_Store
 
-# Exclude system ROMs
+# Exclude system ROMs and unit test ROMs
 ROMImages/*
-OSBindings/Mac/Clock SignalTests/Atari\ ROMs
+OSBindings/Mac/Clock SignalTests/Atari ROMs
+OSBindings/Mac/Clock SignalTests/MSX ROMs
+
+# Exclude intermediate build products
+*.o
+.sconsign.dblite
 
 # CocoaPods
 #

.travis.yml

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

Activity/Observer.hpp

@@ -0,0 +1,50 @@
+//
+//  ActivityObserver.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 07/05/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ActivityObserver_h
+#define ActivityObserver_h
+
+#include <string>
+
+namespace Activity {
+
+/*!
+	Provides a purely virtual base class for anybody that wants to receive notifications of
+	'activity': any feedback from an emulated system which a user could perceive other than
+	through the machine's native audio and video outputs.
+
+	So: status LEDs, drive activity, etc. A receiver may choose to make appropriate noises
+	and/or to show or unshow status indicators.
+*/
+class Observer {
+	public:
+		/// Announces to the receiver that there is an LED of name @c name.
+		virtual void register_led(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) {}
+
+		/// 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) {}
+
+		enum class DriveEvent {
+			StepNormal,
+			StepBelowZero,
+			StepBeyondMaximum
+		};
+
+		/// 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) {}
+
+		/// 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) {}
+};
+
+}
+
+#endif /* ActivityObserver_h */

Activity/Source.hpp

@@ -0,0 +1,24 @@
+//
+//  ActivitySource.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 07/05/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ActivitySource_h
+#define ActivitySource_h
+
+#include "Observer.hpp"
+
+namespace Activity {
+
+class Source {
+	public:
+		virtual void set_activity_observer(Observer *observer) = 0;
+};
+
+}
+
+
+#endif /* ActivitySource_h */

Analyser/Dynamic/ConfidenceCounter.cpp

@@ -0,0 +1,30 @@
+//
+//  ConfidenceCounter.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "ConfidenceCounter.hpp"
+
+using namespace Analyser::Dynamic;
+
+float ConfidenceCounter::get_confidence() {
+	return static_cast<float>(hits_) / static_cast<float>(hits_ + misses_);
+}
+
+void ConfidenceCounter::add_hit() {
+	hits_++;
+}
+
+void ConfidenceCounter::add_miss() {
+	misses_++;
+}
+
+void ConfidenceCounter::add_equivocal() {
+	if(hits_ > misses_) {
+		hits_++;
+		misses_++;
+	}
+}

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -0,0 +1,47 @@
+//
+//  ConfidenceCounter.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceCounter_hpp
+#define ConfidenceCounter_hpp
+
+#include "ConfidenceSource.hpp"
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a confidence source that calculates its probability by virtual of a history of events.
+
+	The initial value of the confidence counter is 0.5.
+*/
+class ConfidenceCounter: public ConfidenceSource {
+	public:
+		/*! @returns The computed probability, based on the history of events. */
+		float get_confidence() override;
+
+		/*! Records an event that implies this is the appropriate class: pushes probability up towards 1.0. */
+		void add_hit();
+
+		/*! Records an event that implies this is not the appropriate class: pushes probability down towards 0.0. */
+		void add_miss();
+
+		/*!
+			Records an event that could be correct but isn't necessarily so; which can push probability
+			down towards 0.5, but will never push it upwards.
+		*/
+		void add_equivocal();
+
+	private:
+		int hits_ = 1;
+		int misses_ = 1;
+};
+
+}
+}
+
+#endif /* ConfidenceCounter_hpp */

Analyser/Dynamic/ConfidenceSource.hpp

@@ -0,0 +1,28 @@
+//
+//  ConfidenceSource.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceSource_hpp
+#define ConfidenceSource_hpp
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides an abstract interface through which objects can declare the probability
+	that they are the proper target for their input; e.g. if an Acorn Electron is asked
+	to run an Atari 2600 program then its confidence should shrink towards 0.0; if the
+	program is handed to an Atari 2600 then its confidence should grow towards 1.0.
+*/
+struct ConfidenceSource {
+	virtual float get_confidence() = 0;
+};
+
+}
+}
+
+#endif /* ConfidenceSource_hpp */

Analyser/Dynamic/ConfidenceSummary.cpp

@@ -0,0 +1,28 @@
+//
+//  ConfidenceSummary.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "ConfidenceSummary.hpp"
+
+#include <cassert>
+#include <numeric>
+
+using namespace Analyser::Dynamic;
+
+ConfidenceSummary::ConfidenceSummary(const std::vector<ConfidenceSource *> &sources, const std::vector<float> &weights) :
+	sources_(sources), weights_(weights) {
+	assert(weights.size() == sources.size());
+	weight_sum_ = std::accumulate(weights.begin(), weights.end(), 0.0f);
+}
+
+float ConfidenceSummary::get_confidence() {
+	float result = 0.0f;
+	for(std::size_t index = 0; index < sources_.size(); ++index) {
+		result += sources_[index]->get_confidence() * weights_[index];
+	}
+	return result / weight_sum_;
+}

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -0,0 +1,46 @@
+//
+//  ConfidenceSummary.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceSummary_hpp
+#define ConfidenceSummary_hpp
+
+#include "ConfidenceSource.hpp"
+
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Summaries a collection of confidence sources by calculating their weighted sum.
+*/
+class ConfidenceSummary: public ConfidenceSource {
+	public:
+		/*!
+			Instantiates a summary that will produce the weighted sum of
+			@c sources, each using the corresponding entry of @c weights.
+
+			Requires that @c sources and @c weights are of the same length.
+		*/
+		ConfidenceSummary(
+			const std::vector<ConfidenceSource *> &sources,
+			const std::vector<float> &weights);
+
+		/*! @returns The weighted sum of all sources. */
+		float get_confidence() override;
+
+	private:
+		std::vector<ConfidenceSource *> sources_;
+		std::vector<float> weights_;
+		float weight_sum_;
+};
+
+}
+}
+
+#endif /* ConfidenceSummary_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.cpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.hpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.cpp

@@ -0,0 +1,64 @@
+//
+//  MultiConfigurable.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiConfigurable.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Dynamic;
+
+MultiConfigurable::MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		Configurable::Device *device = machine->configurable_device();
+		if(device) devices_.push_back(device);
+	}
+}
+
+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_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;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -0,0 +1,43 @@
+//
+//  MultiConfigurable.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiConfigurable_hpp
+#define MultiConfigurable_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the configurable interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiConfigurable: public Configurable::Device {
+	public:
+		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;
+
+	private:
+		std::vector<Configurable::Device *> devices_;
+};
+
+}
+}
+
+#endif /* MultiConfigurable_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.cpp

@@ -0,0 +1,86 @@
+//
+//  MultiJoystickMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiJoystickMachine.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Dynamic;
+
+namespace {
+
+class MultiJoystick: public Inputs::Joystick {
+	public:
+		MultiJoystick(std::vector<JoystickMachine::Machine *> &machines, std::size_t index) {
+			for(const auto &machine: machines) {
+				const auto &joysticks = machine->get_joysticks();
+				if(joysticks.size() >= index) {
+					joysticks_.push_back(joysticks[index].get());
+				}
+			}
+		}
+
+		std::vector<Input> &get_inputs() override {
+			if(inputs.empty()) {
+				for(const auto &joystick: joysticks_) {
+					std::vector<Input> joystick_inputs = joystick->get_inputs();
+					for(const auto &input: joystick_inputs) {
+						if(std::find(inputs.begin(), inputs.end(), input) != inputs.end()) {
+							inputs.push_back(input);
+						}
+					}
+				}
+			}
+
+			return inputs;
+		}
+
+		void set_input(const Input &digital_input, bool is_active) override {
+			for(const auto &joystick: joysticks_) {
+				joystick->set_input(digital_input, is_active);
+			}
+		}
+
+		void set_input(const Input &digital_input, float value) override {
+			for(const auto &joystick: joysticks_) {
+				joystick->set_input(digital_input, value);
+			}
+		}
+
+		void reset_all_inputs() override {
+			for(const auto &joystick: joysticks_) {
+				joystick->reset_all_inputs();
+			}
+		}
+
+	private:
+		std::vector<Input> inputs;
+		std::vector<Inputs::Joystick *> joysticks_;
+};
+
+}
+
+MultiJoystickMachine::MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	std::size_t total_joysticks = 0;
+	std::vector<JoystickMachine::Machine *> joystick_machines;
+	for(const auto &machine: machines) {
+		JoystickMachine::Machine *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());
+		}
+	}
+
+	for(std::size_t index = 0; index < total_joysticks; ++index) {
+		joysticks_.emplace_back(new MultiJoystick(joystick_machines, index));
+	}
+}
+
+std::vector<std::unique_ptr<Inputs::Joystick>> &MultiJoystickMachine::get_joysticks() {
+	return joysticks_;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -0,0 +1,40 @@
+//
+//  MultiJoystickMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiJoystickMachine_hpp
+#define MultiJoystickMachine_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the joystick machine interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiJoystickMachine: public JoystickMachine::Machine {
+	public:
+		MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard JoystickMachine::Machine interface; see there for documentation.
+		std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override;
+
+	private:
+		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+};
+
+}
+}
+
+#endif /* MultiJoystickMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -0,0 +1,43 @@
+//
+//  MultiKeyboardMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiKeyboardMachine.hpp"
+
+using namespace Analyser::Dynamic;
+
+MultiKeyboardMachine::MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		KeyboardMachine::Machine *keyboard_machine = machine->keyboard_machine();
+		if(keyboard_machine) machines_.push_back(keyboard_machine);
+	}
+}
+
+void MultiKeyboardMachine::clear_all_keys() {
+	for(const auto &machine: machines_) {
+		machine->clear_all_keys();
+	}
+}
+
+void MultiKeyboardMachine::set_key_state(uint16_t key, bool is_pressed) {
+	for(const auto &machine: machines_) {
+		machine->set_key_state(key, is_pressed);
+	}
+}
+
+void MultiKeyboardMachine::type_string(const std::string &string) {
+	for(const auto &machine: machines_) {
+		machine->type_string(string);
+	}
+}
+
+void MultiKeyboardMachine::keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) {
+	for(const auto &machine: machines_) {
+		uint16_t mapped_key = machine->get_keyboard_mapper()->mapped_key_for_key(key);
+		if(mapped_key != KeyNotMapped) machine->set_key_state(mapped_key, is_pressed);
+	}
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -0,0 +1,44 @@
+//
+//  MultiKeyboardMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiKeyboardMachine_hpp
+#define MultiKeyboardMachine_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Machines/KeyboardMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the keyboard machine interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiKeyboardMachine: public KeyboardMachine::Machine {
+	public:
+		MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard KeyboardMachine::Machine interface; see there for documentation.
+		void clear_all_keys() override;
+		void set_key_state(uint16_t key, bool is_pressed) override;
+		void type_string(const std::string &) override;
+		void keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) override;
+
+	private:
+		std::vector<::KeyboardMachine::Machine *> machines_;
+};
+
+}
+}
+
+#endif /* MultiKeyboardMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.cpp

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

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -0,0 +1,41 @@
+//
+//  MultiMediaTarget.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiMediaTarget_hpp
+#define MultiMediaTarget_hpp
+
+#include "../../../../Machines/MediaTarget.hpp"
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the media target interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+struct MultiMediaTarget: public MediaTarget::Machine {
+	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;
+
+	private:
+		std::vector<MediaTarget::Machine *> targets_;
+};
+
+}
+}
+
+#endif /* MultiMediaTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -0,0 +1,76 @@
+//
+//  MultiSpeaker.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiSpeaker.hpp"
+
+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();
+		if(speaker) speakers.push_back(speaker);
+	}
+	if(speakers.empty()) return nullptr;
+
+	return new MultiSpeaker(speakers);
+}
+
+MultiSpeaker::MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers) :
+	speakers_(speakers), front_speaker_(speakers.front()) {
+	for(const auto &speaker: speakers_) {
+		speaker->set_delegate(this);
+	}
+}
+
+float MultiSpeaker::get_ideal_clock_rate_in_range(float minimum, float maximum) {
+	float ideal = 0.0f;
+	for(const auto &speaker: speakers_) {
+		ideal += speaker->get_ideal_clock_rate_in_range(minimum, maximum);
+	}
+
+	return ideal / static_cast<float>(speakers_.size());
+}
+
+void MultiSpeaker::set_output_rate(float cycles_per_second, int buffer_size) {
+	for(const auto &speaker: speakers_) {
+		speaker->set_output_rate(cycles_per_second, buffer_size);
+	}
+}
+
+void MultiSpeaker::set_delegate(Outputs::Speaker::Speaker::Delegate *delegate) {
+	delegate_ = delegate;
+}
+
+void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) {
+	if(!delegate_) return;
+	{
+		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		if(speaker != front_speaker_) return;
+	}
+	delegate_->speaker_did_complete_samples(this, buffer);
+}
+
+void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
+	if(!delegate_) return;
+	{
+		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		if(speaker != front_speaker_) return;
+	}
+	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();
+	}
+	if(delegate_) {
+		delegate_->speaker_did_change_input_clock(this);
+	}
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -0,0 +1,59 @@
+//
+//  MultiSpeaker.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiSpeaker_hpp
+#define MultiSpeaker_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Outputs/Speaker/Speaker.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes calls to and from Outputs::Speaker::Speaker in order
+	transparently to connect a single caller to multiple destinations.
+
+	Makes a static internal copy of the list of machines; expects the owner to keep it
+	abreast of the current frontmost machine.
+*/
+class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker::Delegate {
+	public:
+		/*!
+			Provides a construction mechanism that may return nullptr, in the case that all included
+			machines return nullptr as their speaker.
+		*/
+		static MultiSpeaker *create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		/// This class requires the caller to nominate changes in the frontmost machine.
+		void set_new_front_machine(::Machine::DynamicMachine *machine);
+
+		// 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;
+
+	private:
+		void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) override;
+		void speaker_did_change_input_clock(Speaker *speaker) override;
+		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_;
+};
+
+}
+}
+
+#endif /* MultiSpeaker_hpp */

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -0,0 +1,113 @@
+//
+//  MultiMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 28/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiMachine.hpp"
+
+#include <algorithm>
+
+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),
+	keyboard_machine_(machines_),
+	media_target_(machines_) {
+	crt_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_;
+	}
+}
+
+CRTMachine::Machine *MultiMachine::crt_machine() {
+	if(has_picked_) {
+		return machines_.front()->crt_machine();
+	} else {
+		return &crt_machine_;
+	}
+}
+
+JoystickMachine::Machine *MultiMachine::joystick_machine() {
+	if(has_picked_) {
+		return machines_.front()->joystick_machine();
+	} else {
+		return &joystick_machine_;
+	}
+}
+
+KeyboardMachine::Machine *MultiMachine::keyboard_machine() {
+	if(has_picked_) {
+		return machines_.front()->keyboard_machine();
+	} else {
+		return &keyboard_machine_;
+	}
+}
+
+Configurable::Device *MultiMachine::configurable_device() {
+	if(has_picked_) {
+		return machines_.front()->configurable_device();
+	} else {
+		return &configurable_;
+	}
+}
+
+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());
+}
+
+void MultiMachine::multi_crt_did_run_machines() {
+	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
+#ifdef DEBUG
+	for(const auto &machine: machines_) {
+		CRTMachine::Machine *crt = machine->crt_machine();
+		printf("%0.2f ", crt->get_confidence());
+		crt->print_type();
+		printf("; ");
+	}
+	printf("\n");
+#endif
+
+	DynamicMachine *front = machines_.front().get();
+	std::stable_sort(machines_.begin(), machines_.end(),
+		[] (const std::unique_ptr<DynamicMachine> &lhs, const std::unique_ptr<DynamicMachine> &rhs){
+			CRTMachine::Machine *lhs_crt = lhs->crt_machine();
+			CRTMachine::Machine *rhs_crt = rhs->crt_machine();
+			return lhs_crt->get_confidence() > rhs_crt->get_confidence();
+		});
+
+	if(machines_.front().get() != front) {
+		crt_machine_.did_change_machine_order();
+	}
+
+	if(would_collapse(machines_)) {
+		pick_first();
+	}
+}
+
+void MultiMachine::pick_first() {
+	has_picked_ = true;
+//	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() {
+	return nullptr;
+}

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -0,0 +1,80 @@
+//
+//  MultiMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 28/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiMachine_hpp
+#define MultiMachine_hpp
+
+#include "../../../Machines/DynamicMachine.hpp"
+
+#include "Implementation/MultiConfigurable.hpp"
+#include "Implementation/MultiCRTMachine.hpp"
+#include "Implementation/MultiJoystickMachine.hpp"
+#include "Implementation/MultiKeyboardMachine.hpp"
+#include "Implementation/MultiMediaTarget.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides the same interface as to a single machine, while multiplexing all
+	underlying calls to an array of real dynamic machines.
+
+	Calls to crt_machine->get_crt will return that for the frontmost machine;
+	anything installed as the speaker's delegate will similarly receive
+	feedback only from that machine.
+
+	Following each crt_machine->run_for, reorders the supplied machines by
+	confidence.
+
+	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 {
+	public:
+		/*!
+			Allows a potential MultiMachine creator to enquire as to whether there's any benefit in
+			requesting this class as a proxy.
+
+			@returns @c true if the multimachine would discard all but the first machine in this list;
+				@c false otherwise.
+		*/
+		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;
+		KeyboardMachine::Machine *keyboard_machine() override;
+		MediaTarget::Machine *media_target() override;
+		void *raw_pointer() override;
+
+	private:
+		void multi_crt_did_run_machines() override;
+
+		std::vector<std::unique_ptr<DynamicMachine>> machines_;
+		std::mutex machines_mutex_;
+
+		MultiConfigurable configurable_;
+		MultiCRTMachine crt_machine_;
+		MultiJoystickMachine joystick_machine_;
+		MultiKeyboardMachine keyboard_machine_;
+		MultiMediaTarget media_target_;
+
+		void pick_first();
+		bool has_picked_ = false;
+};
+
+}
+}
+
+#endif /* MultiMachine_hpp */

Analyser/Machines.hpp

@@ -0,0 +1,28 @@
+//
+//  Machines.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 24/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_h
+#define Machines_h
+
+namespace Analyser {
+
+enum class Machine {
+	AmstradCPC,
+	AppleII,
+	Atari2600,
+	ColecoVision,
+	Electron,
+	MSX,
+	Oric,
+	Vic20,
+	ZX8081
+};
+
+}
+
+#endif /* Machines_h */

Analyser/Static/Acorn/Disk.cpp

@@ -0,0 +1,105 @@
+//
+//  Disk.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/09/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#include "Disk.hpp"
+
+#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "../../../NumberTheory/CRC.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Static::Acorn;
+
+std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+	// c.f. http://beebwiki.mdfs.net/Acorn_DFS_disc_format
+	std::unique_ptr<Catalogue> catalogue(new Catalogue);
+	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);
+
+	if(!names || !details) return nullptr;
+	if(names->samples.empty() || details->samples.empty()) return nullptr;
+	if(names->samples[0].size() != 256 || details->samples[0].size() != 256) return nullptr;
+
+	uint8_t final_file_offset = details->samples[0][5];
+	if(final_file_offset&7) return nullptr;
+	if(final_file_offset < 8) return nullptr;
+
+	char disk_name[13];
+	snprintf(disk_name, 13, "%.8s%.4s", &names->samples[0][0], &details->samples[0][0]);
+	catalogue->name = disk_name;
+
+	switch((details->samples[0][6] >> 4)&3) {
+		case 0: catalogue->bootOption = Catalogue::BootOption::None;		break;
+		case 1: catalogue->bootOption = Catalogue::BootOption::LoadBOOT;	break;
+		case 2: catalogue->bootOption = Catalogue::BootOption::RunBOOT;		break;
+		case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
+	}
+
+	for(std::size_t file_offset = 8; file_offset < final_file_offset; file_offset += 8) {
+		File new_file;
+		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);
+
+		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));
+		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));
+
+		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);
+			start_sector++;
+
+			Storage::Encodings::MFM::Sector *next_sector = parser.get_sector(0, track, sector);
+			if(!next_sector) break;
+
+			long length_from_sector = std::min(data_length, 256l);
+			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);
+	}
+
+	return catalogue;
+}
+std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+	std::unique_ptr<Catalogue> catalogue(new Catalogue);
+	Storage::Encodings::MFM::Parser parser(true, disk);
+
+	Storage::Encodings::MFM::Sector *free_space_map_second_half = parser.get_sector(0, 0, 1);
+	if(!free_space_map_second_half) return nullptr;
+
+	std::vector<uint8_t> root_directory;
+	root_directory.reserve(5 * 256);
+	for(uint8_t c = 2; c < 7; c++) {
+		Storage::Encodings::MFM::Sector *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());
+	}
+
+	// Quick sanity checks.
+	if(root_directory[0x4cb]) return nullptr;
+	if(root_directory[1] != 'H' || root_directory[2] != 'u' || root_directory[3] != 'g' || root_directory[4] != 'o') return nullptr;
+	if(root_directory[0x4FB] != 'H' || root_directory[0x4FC] != 'u' || root_directory[0x4FD] != 'g' || root_directory[0x4FE] != 'o') return nullptr;
+
+	switch(free_space_map_second_half->samples[0][0xfd]) {
+		default: catalogue->bootOption = Catalogue::BootOption::None;		break;
+		case 1: catalogue->bootOption = Catalogue::BootOption::LoadBOOT;	break;
+		case 2: catalogue->bootOption = Catalogue::BootOption::RunBOOT;		break;
+		case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
+	}
+
+	return catalogue;
+}

Analyser/Static/Acorn/Disk.hpp

@@ -3,22 +3,23 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 18/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef StaticAnalyser_Acorn_Disk_hpp
 #define StaticAnalyser_Acorn_Disk_hpp
 
 #include "File.hpp"
-#include "../../Storage/Disk/Disk.hpp"
+#include "../../../Storage/Disk/Disk.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
-/// Describes a DFS- or ADFS-format catalogue(/directory) — the list of files available and the catalogue's boot option.
+/// Describes a DFS- or ADFS-format catalogue(/directory): the list of files available and the catalogue's boot option.
 struct Catalogue {
 	std::string name;
-	std::list<File> files;
+	std::vector<File> files;
 	enum class BootOption {
 		None,
 		LoadBOOT,
@@ -30,6 +31,7 @@ struct Catalogue {
 std::unique_ptr<Catalogue> GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 std::unique_ptr<Catalogue> GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
+}
 }
 }
 

Analyser/Static/Acorn/File.hpp

@@ -3,18 +3,18 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 18/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#ifndef File_hpp
-#define File_hpp
+#ifndef StaticAnalyser_Acorn_File_hpp
+#define StaticAnalyser_Acorn_File_hpp
 
-#include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
 struct File {
@@ -38,9 +38,10 @@ struct File {
 		std::vector<uint8_t> data;
 	};
 
-	std::list<Chunk> chunks;
+	std::vector<Chunk> chunks;
 };
 
+}
 }
 }
 

Analyser/Static/Acorn/StaticAnalyser.cpp

@@ -3,29 +3,30 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 29/08/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "StaticAnalyser.hpp"
 
 #include "Disk.hpp"
 #include "Tape.hpp"
+#include "Target.hpp"
 
-using namespace StaticAnalyser::Acorn;
+using namespace Analyser::Static::Acorn;
 
-static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
-		AcornCartridgesFrom(const std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
-	std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> acorn_cartridges;
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		AcornCartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> acorn_cartridges;
 
-	for(std::shared_ptr<Storage::Cartridge::Cartridge> cartridge : cartridges) {
-		const std::list<Storage::Cartridge::Cartridge::Segment> &segments = cartridge->get_segments();
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
 
 		// only one mapped item is allowed
 		if(segments.size() != 1) continue;
 
-		// which must be 16 kb in size
-		Storage::Cartridge::Cartridge::Segment segment = segments.front();
-		if(segment.data.size() != 0x4000) continue;
+		// which must be 8 or 16 kb in size
+		const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
+		if(segment.data.size() != 0x4000 && segment.data.size() != 0x2000) continue;
 
 		// is a copyright string present?
 		uint8_t copyright_offset = segment.data[7];
@@ -49,36 +50,32 @@ static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
 		//		1/(2^32) *
 		//		( ((2^24)-1)/(2^24)*(1/4)		+		1/(2^24)	) *
 		//		1/4
-		//	= something very improbable — around 1/16th of 1 in 2^32, but not exactly.
+		//	= something very improbable, around 1/16th of 1 in 2^32, but not exactly.
 		acorn_cartridges.push_back(cartridge);
 	}
 
 	return acorn_cartridges;
 }
 
-void StaticAnalyser::Acorn::AddTargets(
-		const std::list<std::shared_ptr<Storage::Disk::Disk>> &disks,
-		const std::list<std::shared_ptr<Storage::Tape::Tape>> &tapes,
-		const std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges,
-		std::list<StaticAnalyser::Target> &destination) {
-	Target target;
-	target.machine = Target::Electron;
-	target.probability = 1.0; // TODO: a proper estimation
-	target.acorn.has_dfs = false;
-	target.acorn.has_adfs = false;
-	target.acorn.should_shift_restart = false;
+Analyser::Static::TargetList Analyser::Static::Acorn::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Electron;
+	target->confidence = 0.5; // TODO: a proper estimation
+	target->has_dfs = false;
+	target->has_adfs = false;
+	target->should_shift_restart = false;
 
 	// strip out inappropriate cartridges
-	target.cartridges = AcornCartridgesFrom(cartridges);
+	target->media.cartridges = AcornCartridgesFrom(media.cartridges);
 
 	// if there are any tapes, attempt to get data from the first
-	if(tapes.size() > 0) {
-		std::shared_ptr<Storage::Tape::Tape> tape = tapes.front();
-		std::list<File> files = GetFiles(tape);
+	if(!media.tapes.empty()) {
+		std::shared_ptr<Storage::Tape::Tape> tape = media.tapes.front();
+		std::vector<File> files = GetFiles(tape);
 		tape->reset();
 
 		// continue if there are any files
-		if(files.size()) {
+		if(!files.empty()) {
 			bool is_basic = true;
 
 			// protected files are always for *RUNning only
@@ -86,9 +83,9 @@ void StaticAnalyser::Acorn::AddTargets(
 
 			// 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
-			size_t pointer = 0;
+			std::size_t pointer = 0;
 			uint8_t *data = &files.front().data[0];
-			size_t data_size = files.front().data.size();
+			std::size_t data_size = files.front().data.size();
 			while(1) {
 				if(pointer >= data_size-1 || data[pointer] != 13) {
 					is_basic = false;
@@ -100,30 +97,33 @@ void StaticAnalyser::Acorn::AddTargets(
 
 			// Inspect first file. If it's protected or doesn't look like BASIC
 			// then the loading command is *RUN. Otherwise it's CHAIN"".
-			target.loadingCommand = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
+			target->loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
 
-			target.tapes = tapes;
+			target->media.tapes = media.tapes;
 		}
 	}
 
-	if(disks.size() > 0) {
-		std::shared_ptr<Storage::Disk::Disk> disk = disks.front();
+	if(!media.disks.empty()) {
+		std::shared_ptr<Storage::Disk::Disk> disk = media.disks.front();
 		std::unique_ptr<Catalogue> dfs_catalogue, adfs_catalogue;
 		dfs_catalogue = GetDFSCatalogue(disk);
 		if(dfs_catalogue == nullptr) adfs_catalogue = GetADFSCatalogue(disk);
 		if(dfs_catalogue || adfs_catalogue) {
-			target.disks = disks;
-			target.acorn.has_dfs = !!dfs_catalogue;
-			target.acorn.has_adfs = !!adfs_catalogue;
+			target->media.disks = media.disks;
+			target->has_dfs = !!dfs_catalogue;
+			target->has_adfs = !!adfs_catalogue;
 
 			Catalogue::BootOption bootOption = (dfs_catalogue ?: adfs_catalogue)->bootOption;
 			if(bootOption != Catalogue::BootOption::None)
-				target.acorn.should_shift_restart = true;
+				target->should_shift_restart = true;
 			else
-				target.loadingCommand = "*CAT\n";
+				target->loading_command = "*CAT\n";
 		}
 	}
 
-	if(target.tapes.size() || target.disks.size() || target.cartridges.size())
-		destination.push_back(target);
+	TargetList targets;
+	if(!target->media.empty()) {
+		targets.push_back(std::move(target));
+	}
+	return targets;
 }

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -0,0 +1,26 @@
+//
+//  AcornAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/08/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Acorn_StaticAnalyser_hpp
+#define StaticAnalyser_Acorn_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace Acorn {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+}
+}
+
+#endif /* AcornAnalyser_hpp */

Analyser/Static/Acorn/Tape.cpp

@@ -3,16 +3,17 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 29/08/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "Tape.hpp"
 
 #include <deque>
-#include "../../NumberTheory/CRC.hpp"
-#include "../../Storage/Tape/Parsers/Acorn.hpp"
 
-using namespace StaticAnalyser::Acorn;
+#include "../../../NumberTheory/CRC.hpp"
+#include "../../../Storage/Tape/Parsers/Acorn.hpp"
+
+using namespace Analyser::Static::Acorn;
 
 static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::Tape::Tape> &tape, Storage::Tape::Acorn::Parser &parser) {
 	std::unique_ptr<File::Chunk> new_chunk(new File::Chunk);
@@ -38,7 +39,7 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 
 	// read out name
 	char name[11];
-	size_t name_ptr = 0;
+	std::size_t name_ptr = 0;
 	while(!tape->is_at_end() && name_ptr < sizeof(name)) {
 		name[name_ptr] = (char)parser.get_next_byte(tape);
 		if(!name[name_ptr]) break;
@@ -50,14 +51,14 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 	// 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 = (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->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);
 
 	uint16_t calculated_header_crc = parser.get_crc();
-	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));
+	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));
 	new_chunk->header_crc_matched = stored_header_crc == calculated_header_crc;
 
 	if(!new_chunk->header_crc_matched) return nullptr;
@@ -65,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((uint8_t)parser.get_next_byte(tape));
+		new_chunk->data.push_back(static_cast<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 = (uint16_t)parser.get_next_short(tape);
-		stored_data_crc = (uint16_t)((stored_data_crc >> 8) | (stored_data_crc << 8));
+		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));
 		new_chunk->data_crc_matched = stored_data_crc == calculated_data_crc;
 	} else {
 		new_chunk->data_crc_matched = true;
@@ -118,7 +119,7 @@ static std::unique_ptr<File> GetNextFile(std::deque<File::Chunk> &chunks) {
 	return file;
 }
 
-std::list<File> StaticAnalyser::Acorn::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+std::vector<File> Analyser::Static::Acorn::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	Storage::Tape::Acorn::Parser parser;
 
 	// populate chunk list
@@ -131,7 +132,7 @@ std::list<File> StaticAnalyser::Acorn::GetFiles(const std::shared_ptr<Storage::T
 	}
 
 	// decompose into file list
-	std::list<File> file_list;
+	std::vector<File> file_list;
 
 	while(chunk_list.size()) {
 		std::unique_ptr<File> next_file = GetNextFile(chunk_list);

Analyser/Static/Acorn/Tape.hpp

@@ -3,7 +3,7 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 29/08/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef StaticAnalyser_Acorn_Tape_hpp
@@ -12,13 +12,15 @@
 #include <memory>
 
 #include "File.hpp"
-#include "../../Storage/Tape/Tape.hpp"
+#include "../../../Storage/Tape/Tape.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Acorn/Target.hpp

@@ -0,0 +1,30 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Acorn_Target_h
+#define Analyser_Static_Acorn_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace Acorn {
+
+struct Target: public ::Analyser::Static::Target {
+	bool has_adfs = false;
+	bool has_dfs = false;
+	bool should_shift_restart = false;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Acorn_Target_h */

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -0,0 +1,247 @@
+//
+//  AmstradCPC.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 30/07/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+#include "Target.hpp"
+
+#include "../../../Storage/Disk/Parsers/CPM.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+
+static bool strcmp_insensitive(const char *a, const char *b) {
+	if(std::strlen(a) != std::strlen(b)) return false;
+	while(*a) {
+		if(std::tolower(*a) != std::tolower(*b)) return false;
+		a++;
+		b++;
+	}
+	return true;
+}
+
+static bool is_implied_extension(const std::string &extension) {
+	return
+		extension == "   " ||
+		strcmp_insensitive(extension.c_str(), "BAS") ||
+		strcmp_insensitive(extension.c_str(), "BIN");
+}
+
+static void right_trim(std::string &string) {
+	string.erase(std::find_if(string.rbegin(), string.rend(), [](int ch) {
+		return !std::isspace(ch);
+	}).base(), string.end());
+}
+
+static std::string RunCommandFor(const Storage::Disk::CPM::File &file) {
+	// Trim spaces from the name.
+	std::string name = file.name;
+	right_trim(name);
+
+	// Form the basic command.
+	std::string command = "run\"" + name;
+
+	// Consider whether the extension is required.
+	if(!is_implied_extension(file.type)) {
+		std::string type = file.type;
+		right_trim(type);
+		command += "." + type;
+	}
+
+	// Add a newline and return.
+	return command + "\n";
+}
+
+static void InspectCatalogue(
+	const Storage::Disk::CPM::Catalogue &catalogue,
+	const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
+
+	std::vector<const Storage::Disk::CPM::File *> candidate_files;
+	candidate_files.reserve(catalogue.files.size());
+	for(const auto &file : catalogue.files) {
+		candidate_files.push_back(&file);
+	}
+
+	// Remove all files with untypable characters.
+	candidate_files.erase(
+		std::remove_if(candidate_files.begin(), candidate_files.end(), [](const Storage::Disk::CPM::File *file) {
+			for(const auto c : file->name + file->type) {
+				if(c < 32) return true;
+			}
+			return false;
+		}),
+		candidate_files.end());
+
+	// If that leaves a mix of 'system' (i.e. hidden) and non-system files, remove the system files.
+	bool are_all_system = true;
+	for(const auto &file : candidate_files) {
+		if(!file->system) {
+			are_all_system = false;
+			break;
+		}
+	}
+
+	if(!are_all_system) {
+		candidate_files.erase(
+			std::remove_if(candidate_files.begin(), candidate_files.end(), [](const Storage::Disk::CPM::File *file) {
+				return file->system;
+			}),
+			candidate_files.end());
+	}
+
+	// If there's just one file, run that.
+	if(candidate_files.size() == 1) {
+		target->loading_command = RunCommandFor(*candidate_files[0]);
+		return;
+	}
+
+	// If only one file is [potentially] BASIC, run that one; otherwise if only one has a suffix
+	// that AMSDOS allows to be omitted, pick that one.
+	int basic_files = 0;
+	int implicit_suffixed_files = 0;
+
+	std::size_t last_basic_file = 0;
+	std::size_t last_implicit_suffixed_file = 0;
+
+	for(std::size_t c = 0; c < candidate_files.size(); c++) {
+		// Files with nothing but spaces in their name can't be loaded by the user, so disregard them.
+		if(candidate_files[c]->type == "   " && candidate_files[c]->name == "        ")
+			continue;
+
+		// Check for whether this is [potentially] BASIC.
+		if(candidate_files[c]->data.size() >= 128 && !((candidate_files[c]->data[18] >> 1) & 7)) {
+			basic_files++;
+			last_basic_file = c;
+		}
+
+		// Check suffix for emptiness.
+		if(is_implied_extension(candidate_files[c]->type)) {
+			implicit_suffixed_files++;
+			last_implicit_suffixed_file = c;
+		}
+	}
+	if(basic_files == 1 || implicit_suffixed_files == 1) {
+		std::size_t selected_file = (basic_files == 1) ? last_basic_file : last_implicit_suffixed_file;
+		target->loading_command = RunCommandFor(*candidate_files[selected_file]);
+		return;
+	}
+
+	// One more guess: if only one remaining candidate file has a different name than the others,
+	// assume it is intended to stand out.
+	std::map<std::string, int> name_counts;
+	std::map<std::string, std::size_t> indices_by_name;
+	std::size_t index = 0;
+	for(const auto &file : candidate_files) {
+		name_counts[file->name]++;
+		indices_by_name[file->name] = index;
+		index++;
+	}
+	if(name_counts.size() == 2) {
+		for(const auto &pair : name_counts) {
+			if(pair.second == 1) {
+				target->loading_command = RunCommandFor(*candidate_files[indices_by_name[pair.first]]);
+				return;
+			}
+		}
+	}
+
+	// Desperation.
+	target->loading_command = "cat\n";
+}
+
+static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
+	Storage::Encodings::MFM::Parser parser(true, disk);
+	Storage::Encodings::MFM::Sector *boot_sector = parser.get_sector(0, 0, 0x41);
+	if(boot_sector != nullptr && !boot_sector->samples.empty() && boot_sector->samples[0].size() == 512) {
+		// Check that the first 64 bytes of the sector aren't identical; if they are then probably
+		// this disk was formatted and the filler byte never replaced.
+		bool matched = true;
+		for(std::size_t c = 1; c < 64; c++) {
+			if(boot_sector->samples[0][c] != boot_sector->samples[0][0]) {
+				matched = false;
+				break;
+			}
+		}
+
+		// This is a system disk, then launch it as though it were CP/M.
+		if(!matched) {
+			target->loading_command = "|cpm\n";
+			return true;
+		}
+	}
+
+	return false;
+}
+
+Analyser::Static::TargetList Analyser::Static::AmstradCPC::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	TargetList destination;
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::AmstradCPC;
+	target->confidence = 0.5;
+
+	target->model = Target::Model::CPC6128;
+
+	if(!media.tapes.empty()) {
+		// TODO: which of these are actually potentially CPC tapes?
+		target->media.tapes = media.tapes;
+
+		// Ugliness flows here: assume the CPC isn't smart enough to pause between pressing
+		// enter and responding to the follow-on prompt to press a key, so just type for
+		// a while. Yuck!
+		target->loading_command = "|tape\nrun\"\n1234567890";
+	}
+
+	if(!media.disks.empty()) {
+		Storage::Disk::CPM::ParameterBlock data_format;
+		data_format.sectors_per_track = 9;
+		data_format.tracks = 40;
+		data_format.block_size = 1024;
+		data_format.first_sector = 0xc1;
+		data_format.catalogue_allocation_bitmap = 0xc000;
+		data_format.reserved_tracks = 0;
+
+		Storage::Disk::CPM::ParameterBlock system_format;
+		system_format.sectors_per_track = 9;
+		system_format.tracks = 40;
+		system_format.block_size = 1024;
+		system_format.first_sector = 0x41;
+		system_format.catalogue_allocation_bitmap = 0xc000;
+		system_format.reserved_tracks = 2;
+
+		for(auto &disk: media.disks) {
+			// Check for an ordinary catalogue.
+			std::unique_ptr<Storage::Disk::CPM::Catalogue> data_catalogue = Storage::Disk::CPM::GetCatalogue(disk, data_format);
+			if(data_catalogue) {
+				InspectCatalogue(*data_catalogue, target);
+				target->media.disks.push_back(disk);
+				continue;
+			}
+
+			// Failing that check for a boot sector.
+			if(CheckBootSector(disk, target)) {
+				target->media.disks.push_back(disk);
+				continue;
+			}
+
+			// Failing that check for a system catalogue.
+			std::unique_ptr<Storage::Disk::CPM::Catalogue> system_catalogue = Storage::Disk::CPM::GetCatalogue(disk, system_format);
+			if(system_catalogue) {
+				InspectCatalogue(*system_catalogue, target);
+				target->media.disks.push_back(disk);
+				continue;
+			}
+		}
+	}
+
+	// If any media survived, add the target.
+	if(!target->media.empty())
+		destination.push_back(std::move(target));
+
+	return destination;
+}

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

@@ -0,0 +1,26 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 30/07/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AmstradCPC_StaticAnalyser_hpp
+#define Analyser_Static_AmstradCPC_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace AmstradCPC {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+}
+}
+
+#endif /* Analyser_Static_AmstradCPC_StaticAnalyser_hpp */

Analyser/Static/AmstradCPC/Target.hpp

@@ -0,0 +1,35 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AmstradCPC_Target_h
+#define Analyser_Static_AmstradCPC_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace AmstradCPC {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class Model {
+		CPC464,
+		CPC664,
+		CPC6128
+	};
+
+	Model model = Model::CPC464;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+
+#endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/AppleII/StaticAnalyser.cpp

@@ -0,0 +1,23 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/04/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+#include "Target.hpp"
+
+Analyser::Static::TargetList Analyser::Static::AppleII::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	auto target = std::unique_ptr<Target>(new Target);
+	target->machine = Machine::AppleII;
+	target->media = media;
+
+	if(!target->media.disks.empty())
+		target->disk_controller = Target::DiskController::SixteenSector;
+
+	TargetList targets;
+	targets.push_back(std::move(target));
+	return targets;
+}

Analyser/Static/AppleII/StaticAnalyser.hpp

@@ -0,0 +1,26 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/04/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AppleII_StaticAnalyser_hpp
+#define Analyser_Static_AppleII_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace AppleII {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+}
+}
+
+#endif /* Analyser_Static_AppleII_StaticAnalyser_hpp */

Analyser/Static/AppleII/Target.hpp

@@ -0,0 +1,39 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/04/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Target_h
+#define Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace AppleII {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class Model {
+		II,
+		IIplus,
+		IIe,
+		EnhancedIIe
+	};
+	enum class DiskController {
+		None,
+		SixteenSector,
+		ThirteenSector
+	};
+
+	Model model = Model::IIe;
+	DiskController disk_controller = DiskController::None;
+};
+
+}
+}
+}
+
+#endif /* Target_h */

Analyser/Static/Atari/StaticAnalyser.cpp

@@ -0,0 +1,204 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 15/09/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "Target.hpp"
+
+#include "../Disassembler/6502.hpp"
+
+using namespace Analyser::Static::Atari;
+
+static void DeterminePagingFor2kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+	// if this is a 2kb cartridge then it's definitely either unpaged or a CommaVid
+	uint16_t entry_address, break_address;
+
+	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
+	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);
+	};
+	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
+	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) {
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::Indirect;
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndexedIndirectX;
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndirectIndexedY;
+
+			if(has_wide_area_store) break;
+		}
+	}
+
+	// conclude that this is a CommaVid if it attempted to write something to the CommaVid RAM locations;
+	// caveat: false positives aren't likely to be problematic; a false positive is a 2KB ROM that always addresses
+	// itself so as to land in ROM even if mapped as a CommaVid and this code is on the fence as to whether it
+	// attempts to modify itself but it probably doesn't
+	if(has_wide_area_store) target.paging_model = Analyser::Static::Atari::Target::PagingModel::CommaVid;
+}
+
+static void DeterminePagingFor8kCartridge(Analyser::Static::Atari::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?)
+	if(
+		segment.data[4095] == 0xf0 && segment.data[4093] == 0xf0 && segment.data[4094] == 0x00 && segment.data[4092] == 0x00 &&
+		(segment.data[8191] != 0xf0 || segment.data[8189] != 0xf0 || segment.data[8190] != 0x00 || segment.data[8188] != 0x00) &&
+		segment.data[0] == 0x78
+	) {
+		target.paging_model = Analyser::Static::Atari::Target::PagingModel::ActivisionStack;
+		return;
+	}
+
+	// make an assumption that this is the Atari paging model
+	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari8k;
+
+	std::set<uint16_t> internal_accesses;
+	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
+	internal_accesses.insert(disassembly.internal_modifies.begin(), disassembly.internal_modifies.end());
+	internal_accesses.insert(disassembly.internal_loads.begin(), disassembly.internal_loads.end());
+
+	int atari_access_count = 0;
+	int parker_access_count = 0;
+	int tigervision_access_count = 0;
+	for(uint16_t address : internal_accesses) {
+		uint16_t masked_address = address & 0x1fff;
+		atari_access_count += masked_address >= 0x1ff8 && masked_address < 0x1ffa;
+		parker_access_count += masked_address >= 0x1fe0 && masked_address < 0x1ff8;
+	}
+	for(uint16_t address: disassembly.external_stores) {
+		uint16_t masked_address = address & 0x1fff;
+		tigervision_access_count += masked_address == 0x3f;
+	}
+
+	if(parker_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::ParkerBros;
+	else if(tigervision_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
+}
+
+static void DeterminePagingFor16kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
+	// make an assumption that this is the Atari paging model
+	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari16k;
+
+	std::set<uint16_t> internal_accesses;
+	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
+	internal_accesses.insert(disassembly.internal_modifies.begin(), disassembly.internal_modifies.end());
+	internal_accesses.insert(disassembly.internal_loads.begin(), disassembly.internal_loads.end());
+
+	int atari_access_count = 0;
+	int mnetwork_access_count = 0;
+	for(uint16_t address : internal_accesses) {
+		uint16_t masked_address = address & 0x1fff;
+		atari_access_count += masked_address >= 0x1ff6 && masked_address < 0x1ffa;
+		mnetwork_access_count += masked_address >= 0x1fe0 && masked_address < 0x1ffb;
+	}
+
+	if(mnetwork_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::MNetwork;
+}
+
+static void DeterminePagingFor64kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
+	// make an assumption that this is a Tigervision if there is a write to 3F
+	target.paging_model =
+		(disassembly.external_stores.find(0x3f) != disassembly.external_stores.end()) ?
+			Analyser::Static::Atari::Target::PagingModel::Tigervision : Analyser::Static::Atari::Target::PagingModel::MegaBoy;
+}
+
+static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+	if(segment.data.size() == 2048) {
+		DeterminePagingFor2kCartridge(target, segment);
+		return;
+	}
+
+	uint16_t entry_address, break_address;
+
+	entry_address = static_cast<uint16_t>(segment.data[segment.data.size() - 4] | (segment.data[segment.data.size() - 3] << 8));
+	break_address = static_cast<uint16_t>(segment.data[segment.data.size() - 2] | (segment.data[segment.data.size() - 1] << 8));
+
+	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);
+	};
+
+	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()) {
+		case 8192:
+			DeterminePagingFor8kCartridge(target, segment, disassembly);
+		break;
+		case 10495:
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Pitfall2;
+		break;
+		case 12288:
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::CBSRamPlus;
+		break;
+		case 16384:
+			DeterminePagingFor16kCartridge(target, segment, disassembly);
+		break;
+		case 32768:
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari32k;
+		break;
+		case 65536:
+			DeterminePagingFor64kCartridge(target, segment, disassembly);
+		break;
+		default:
+		break;
+	}
+
+	// check for a Super Chip. Atari ROM images [almost] always have the same value stored over RAM
+	// regions; when they don't they at least seem to have the first 128 bytes be the same as the
+	// next 128 bytes. So check for that.
+	if(	target.paging_model != Analyser::Static::Atari::Target::PagingModel::CBSRamPlus &&
+		target.paging_model != Analyser::Static::Atari::Target::PagingModel::MNetwork) {
+		bool has_superchip = true;
+		for(std::size_t address = 0; address < 128; address++) {
+			if(segment.data[address] != segment.data[address+128]) {
+				has_superchip = false;
+				break;
+			}
+		}
+		target.uses_superchip = has_superchip;
+	}
+
+	// check for a Tigervision or Tigervision-esque scheme
+	if(target.paging_model == Analyser::Static::Atari::Target::PagingModel::None && segment.data.size() > 4096) {
+		bool looks_like_tigervision = disassembly.external_stores.find(0x3f) != disassembly.external_stores.end();
+		if(looks_like_tigervision) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
+	}
+}
+
+Analyser::Static::TargetList Analyser::Static::Atari::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	// TODO: sanity checking; is this image really for an Atari 2600?
+	std::unique_ptr<Analyser::Static::Atari::Target> target(new Analyser::Static::Atari::Target);
+	target->machine = Machine::Atari2600;
+	target->confidence = 0.5;
+	target->media.cartridges = media.cartridges;
+	target->paging_model = Analyser::Static::Atari::Target::PagingModel::None;
+	target->uses_superchip = false;
+
+	// try to figure out the paging scheme
+	if(!media.cartridges.empty()) {
+		const auto &segments = media.cartridges.front()->get_segments();
+
+		if(segments.size() == 1) {
+			const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
+			DeterminePagingForCartridge(*target, segment);
+		}
+	}
+	TargetList destinations;
+	destinations.push_back(std::move(target));
+	return destinations;
+}

Analyser/Static/Atari/StaticAnalyser.hpp

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

Analyser/Static/Atari/Target.hpp

@@ -0,0 +1,43 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Atari_Target_h
+#define Analyser_Static_Atari_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace Atari {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class PagingModel {
+		None,
+		CommaVid,
+		Atari8k,
+		Atari16k,
+		Atari32k,
+		ActivisionStack,
+		ParkerBros,
+		Tigervision,
+		CBSRamPlus,
+		MNetwork,
+		MegaBoy,
+		Pitfall2
+	};
+
+	// TODO: shouldn't these be properties of the cartridge?
+	PagingModel paging_model = PagingModel::None;
+	bool uses_superchip = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/Coleco/StaticAnalyser.cpp

@@ -0,0 +1,64 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/02/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		ColecoCartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> coleco_cartridges;
+
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
+
+		// only one mapped item is allowed
+		if(segments.size() != 1) continue;
+		const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
+		const std::size_t data_size = segment.data.size();
+
+		// 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) {
+			start = &segment.data[segment.data.size() - 16384];
+		}
+		if(start[0] != 0xaa && start[0] != 0x55 && start[1] != 0xaa && start[1] != 0x55) continue;
+		if(start[0] == start[1]) continue;
+
+		// probability of a random binary blob that isn't a Coleco ROM proceeding to here is 1 - 1/32768.
+
+		// Round up to the next multiple of 8kb if this image is less than 32kb. Otherwise round down if
+		// this image is within a short distance of 32kb.
+		std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
+
+		size_t target_size;
+		if(data_size >= 32*1024 && data_size < 32*1024 + 512) {
+			target_size = 32 * 1024;
+		} else {
+			target_size = data_size + ((8192 - (data_size & 8191)) & 8191);
+		}
+
+		std::vector<uint8_t> truncated_data;
+		truncated_data = segment.data;
+		truncated_data.resize(target_size);
+		output_segments.emplace_back(0x8000, truncated_data);
+
+		coleco_cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
+	}
+
+	return coleco_cartridges;
+}
+
+Analyser::Static::TargetList Analyser::Static::Coleco::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	TargetList targets;
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::ColecoVision;
+	target->confidence = 1.0f - 1.0f / 32768.0f;
+	target->media.cartridges = ColecoCartridgesFrom(media.cartridges);
+	if(!target->media.empty())
+		targets.push_back(std::move(target));
+	return targets;
+}

Analyser/Static/Coleco/StaticAnalyser.hpp

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

Analyser/Static/Commodore/Disk.cpp

@@ -3,28 +3,28 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 13/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "Disk.hpp"
-#include "../../Storage/Disk/DiskController.hpp"
-#include "../../Storage/Disk/Encodings/CommodoreGCR.hpp"
-#include "../../Storage/Data/Commodore.hpp"
+#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "../../../Storage/Disk/Encodings/CommodoreGCR.hpp"
+#include "../../../Storage/Data/Commodore.hpp"
 
 #include <limits>
 #include <vector>
 #include <array>
 
-using namespace StaticAnalyser::Commodore;
+using namespace Analyser::Static::Commodore;
 
 class CommodoreGCRParser: public Storage::Disk::Controller {
 	public:
 		std::shared_ptr<Storage::Disk::Drive> drive;
 
-		CommodoreGCRParser() : Storage::Disk::Controller(4000000, 1, 300), shift_register_(0), track_(1) {
-			drive.reset(new Storage::Disk::Drive);
+		CommodoreGCRParser() : Storage::Disk::Controller(4000000), shift_register_(0), track_(1) {
+			drive.reset(new Storage::Disk::Drive(4000000, 300, 2));
 			set_drive(drive);
-			set_motor_on(true);
+			drive->set_motor_on(true);
 		}
 
 		struct Sector {
@@ -40,14 +40,16 @@ 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 = (int)track - (int)track_;
+			int difference = static_cast<int>(track) - static_cast<int>(track_);
 			track_ = track;
 
 			if(difference) {
 				int direction = difference < 0 ? -1 : 1;
-				difference *= 2 * direction;
+				difference *= direction;
 
-				for(int c = 0; c < difference; c++) step(direction);
+				for(int c = 0; c < difference; c++) {
+					get_drive().step(Storage::Disk::HeadPosition(direction));
+				}
 
 				unsigned int zone = 3;
 				if(track >= 18) zone = 2;
@@ -66,24 +68,24 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		uint8_t track_;
 		std::shared_ptr<Sector> sector_cache_[65536];
 
-		void process_input_bit(int value, unsigned int cycles_since_index_hole) {
-			shift_register_ = ((shift_register_ << 1) | (unsigned int)value) & 0x3ff;
+		void process_input_bit(int value) {
+			shift_register_ = ((shift_register_ << 1) | static_cast<unsigned int>(value)) & 0x3ff;
 			bit_count_++;
 		}
 
-		unsigned int proceed_to_next_block() {
+		unsigned int proceed_to_next_block(int max_index_count) {
 			// find GCR lead-in
 			proceed_to_shift_value(0x3ff);
 			if(shift_register_ != 0x3ff) return 0xff;
 
 			// find end of lead-in
-			while(shift_register_ == 0x3ff && index_count_ < 2) {
+			while(shift_register_ == 0x3ff && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 
 			// continue for a further nine bits
 			bit_count_ = 0;
-			while(bit_count_ < 9 && index_count_ < 2) {
+			while(bit_count_ < 9 && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 
@@ -97,8 +99,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 
 		void proceed_to_shift_value(unsigned int shift_value) {
-			index_count_ = 0;
-			while(shift_register_ != shift_value && index_count_ < 2) {
+			const int max_index_count = index_count_ + 2;
+			while(shift_register_ != shift_value && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 		}
@@ -108,7 +110,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 
 		std::shared_ptr<Sector> get_sector(uint8_t sector) {
-			uint16_t sector_address = (uint16_t)((track_ << 8) | sector);
+			uint16_t sector_address = static_cast<uint16_t>((track_ << 8) | sector);
 			if(sector_cache_[sector_address]) return sector_cache_[sector_address];
 
 			std::shared_ptr<Sector> first_sector = get_next_sector();
@@ -124,38 +126,38 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 		std::shared_ptr<Sector> get_next_sector() {
 			std::shared_ptr<Sector> sector(new Sector);
-			index_count_ = 0;
+			const int max_index_count = index_count_ + 2;
 
-			while(index_count_ < 2) {
+			while(index_count_ < max_index_count) {
 				// look for a sector header
 				while(1) {
-					if(proceed_to_next_block() == 0x08) break;
-					if(index_count_ >= 2) return nullptr;
+					if(proceed_to_next_block(max_index_count) == 0x08) break;
+					if(index_count_ >= max_index_count) return nullptr;
 				}
 
 				// get sector details, skip if this looks malformed
-				uint8_t checksum = (uint8_t)get_next_byte();
-				sector->sector = (uint8_t)get_next_byte();
-				sector->track = (uint8_t)get_next_byte();
+				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 disk_id[2];
-				disk_id[0] = (uint8_t)get_next_byte();
-				disk_id[1] = (uint8_t)get_next_byte();
+				disk_id[0] = static_cast<uint8_t>(get_next_byte());
+				disk_id[1] = static_cast<uint8_t>(get_next_byte());
 				if(checksum != (sector->sector ^ sector->track ^ disk_id[0] ^ disk_id[1])) continue;
 
 				// look for the following data
 				while(1) {
-					if(proceed_to_next_block() == 0x07) break;
-					if(index_count_ >= 2) return nullptr;
+					if(proceed_to_next_block(max_index_count) == 0x07) break;
+					if(index_count_ >= max_index_count) return nullptr;
 				}
 
 				checksum = 0;
-				for(size_t c = 0; c < 256; c++) {
-					sector->data[c] = (uint8_t)get_next_byte();
+				for(std::size_t c = 0; c < 256; c++) {
+					sector->data[c] = static_cast<uint8_t>(get_next_byte());
 					checksum ^= sector->data[c];
 				}
 
 				if(checksum == get_next_byte()) {
-					uint16_t sector_address = (uint16_t)((sector->track << 8) | sector->sector);
+					uint16_t sector_address = static_cast<uint16_t>((sector->track << 8) | sector->sector);
 					sector_cache_[sector_address] = sector;
 					return sector;
 				}
@@ -165,8 +167,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 };
 
-std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
-	std::list<File> files;
+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);
 
@@ -188,7 +190,7 @@ std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storag
 	}
 
 	// parse directory
-	size_t header_pointer = (size_t)-32;
+	std::size_t header_pointer = static_cast<std::size_t>(-32);
 	while(header_pointer+32+31 < directory.size()) {
 		header_pointer += 32;
 
@@ -207,12 +209,12 @@ std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storag
 		next_sector = directory[header_pointer + 4];
 
 		new_file.raw_name.reserve(16);
-		for(size_t c = 0; c < 16; c++) {
+		for(std::size_t c = 0; c < 16; c++) {
 			new_file.raw_name.push_back(directory[header_pointer + 5 + c]);
 		}
 		new_file.name = Storage::Data::Commodore::petscii_from_bytes(&new_file.raw_name[0], 16, false);
 
-		size_t number_of_sectors = (size_t)directory[header_pointer + 0x1e] + ((size_t)directory[header_pointer + 0x1f] << 8);
+		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);
 		new_file.data.reserve((number_of_sectors - 1) * 254 + 252);
 
 		bool is_first_sector = true;
@@ -223,7 +225,7 @@ std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storag
 			next_track = sector->data[0];
 			next_sector = sector->data[1];
 
-			if(is_first_sector) new_file.starting_address = (uint16_t)sector->data[2] | (uint16_t)(sector->data[3] << 8);
+			if(is_first_sector) new_file.starting_address = static_cast<uint16_t>(sector->data[2]) | static_cast<uint16_t>(sector->data[3] << 8);
 			if(next_track)
 				new_file.data.insert(new_file.data.end(), sector->data.begin() + (is_first_sector ? 4 : 2), sector->data.end());
 			else

Analyser/Static/Commodore/Disk.hpp

@@ -3,23 +3,25 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 13/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef StaticAnalyser_Commodore_Disk_hpp
 #define StaticAnalyser_Commodore_Disk_hpp
 
-#include "../../Storage/Disk/Disk.hpp"
+#include "../../../Storage/Disk/Disk.hpp"
 #include "File.hpp"
-#include <list>
 
-namespace StaticAnalyser {
+#include <vector>
+
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
 }
 }
-
+}
 
 #endif /* Disk_hpp */

Analyser/Static/Commodore/File.cpp

@@ -3,12 +3,12 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 10/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "File.hpp"
 
-bool StaticAnalyser::Commodore::File::is_basic() {
+bool Analyser::Static::Commodore::File::is_basic() {
 	// BASIC files are always relocatable (?)
 	if(type != File::RelocatableProgram) return false;
 
@@ -21,9 +21,9 @@ bool StaticAnalyser::Commodore::File::is_basic() {
 	//		[4 bytes: address of start of next line]
 	//		[4 bytes: this line number]
 	//		... null-terminated code ...
-	//	(with a next line address of 0000 indicating end of program)ß
+	//	(with a next line address of 0000 indicating end of program)
 	while(1) {
-		if(line_address - starting_address >= data.size() + 2) break;
+		if(static_cast<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 StaticAnalyser::Commodore::File::is_basic() {
 		}
 		if(next_line_address < line_address + 5) break;
 
-		if(line_address - starting_address >= data.size() + 5) break;
+		if(static_cast<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 = (uint16_t)next_line_number;
+		line_number = static_cast<uint16_t>(next_line_number);
 		line_address = next_line_address;
 	}
 

Analyser/Static/Commodore/File.hpp

@@ -3,7 +3,7 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 10/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef File_hpp
@@ -12,18 +12,17 @@
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
 struct File {
-	File() : is_closed(false), is_locked(false) {}
-
 	std::wstring name;
 	std::vector<uint8_t> raw_name;
 	uint16_t starting_address;
 	uint16_t ending_address;
-	bool is_locked;
-	bool is_closed;
+	bool is_locked = false;
+	bool is_closed = false;
 	enum {
 		RelocatableProgram,
 		NonRelocatableProgram,
@@ -36,6 +35,7 @@ struct File {
 	bool is_basic();
 };
 
+}
 }
 }
 

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -0,0 +1,161 @@
+//
+//  CommodoreAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 06/09/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "Disk.hpp"
+#include "File.hpp"
+#include "Tape.hpp"
+#include "Target.hpp"
+#include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
+
+#include <algorithm>
+#include <sstream>
+
+using namespace Analyser::Static::Commodore;
+
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		Vic20CartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> vic20_cartridges;
+
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
+
+		// only one mapped item is allowed
+		if(segments.size() != 1) continue;
+
+		// which must be 16 kb in size
+		Storage::Cartridge::Cartridge::Segment segment = segments.front();
+		if(segment.start_address != 0xa000) continue;
+		if(!Storage::Cartridge::Encodings::CommodoreROM::isROM(segment.data)) continue;
+
+		vic20_cartridges.push_back(cartridge);
+	}
+
+	return vic20_cartridges;
+}
+
+Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	TargetList destination;
+
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Vic20;	// TODO: machine estimation
+	target->confidence = 0.5; // TODO: a proper estimation
+
+	int device = 0;
+	std::vector<File> files;
+	bool is_disk = false;
+
+	// strip out inappropriate cartridges
+	target->media.cartridges = Vic20CartridgesFrom(media.cartridges);
+
+	// check disks
+	for(auto &disk : media.disks) {
+		std::vector<File> disk_files = GetFiles(disk);
+		if(!disk_files.empty()) {
+			is_disk = true;
+			files.insert(files.end(), disk_files.begin(), disk_files.end());
+			target->media.disks.push_back(disk);
+			if(!device) device = 8;
+		}
+	}
+
+	// check tapes
+	for(auto &tape : media.tapes) {
+		std::vector<File> tape_files = GetFiles(tape);
+		tape->reset();
+		if(!tape_files.empty()) {
+			files.insert(files.end(), tape_files.begin(), tape_files.end());
+			target->media.tapes.push_back(tape);
+			if(!device) device = 1;
+		}
+	}
+
+	if(!files.empty()) {
+		target->memory_model = Target::MemoryModel::Unexpanded;
+		std::ostringstream string_stream;
+		string_stream << "LOAD\"" << (is_disk ? "*" : "") << "\"," << device << ",";
+  		if(files.front().is_basic()) {
+			string_stream << "0";
+		} else {
+			string_stream << "1";
+		}
+		string_stream << "\nRUN\n";
+		target->loading_command = string_stream.str();
+
+		// make a first guess based on loading address
+		switch(files.front().starting_address) {
+			default:
+				printf("Starting address %04x?\n", files.front().starting_address);
+			case 0x1001:
+				target->memory_model = Target::MemoryModel::Unexpanded;
+			break;
+			case 0x1201:
+				target->memory_model = Target::MemoryModel::ThirtyTwoKB;
+			break;
+			case 0x0401:
+				target->memory_model = Target::MemoryModel::EightKB;
+			break;
+		}
+
+		// General approach: increase memory size conservatively such that the largest file found will fit.
+//		for(File &file : files) {
+//			std::size_t file_size = file.data.size();
+//			bool is_basic = file.is_basic();
+
+			/*if(is_basic)
+			{
+				// BASIC files may be relocated, so the only limit is size.
+				//
+				// An unexpanded machine has 3583 bytes free for BASIC;
+				// a 3kb expanded machine has 6655 bytes free.
+				if(file_size > 6655)
+					target->vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
+				else if(target->vic20.memory_model == Vic20MemoryModel::Unexpanded && file_size > 3583)
+					target->vic20.memory_model = Vic20MemoryModel::EightKB;
+			}
+			else
+			{*/
+//			if(!file.type == File::NonRelocatableProgram)
+//			{
+				// Non-BASIC files may be relocatable but, if so, by what logic?
+				// Given that this is unknown, take starting address as literal
+				// and check against memory windows.
+				//
+				// (ignoring colour memory...)
+				// An unexpanded Vic has memory between 0x0000 and 0x0400; and between 0x1000 and 0x2000.
+				// A 3kb expanded Vic fills in the gap and has memory between 0x0000 and 0x2000.
+				// A 32kb expanded Vic has memory in the entire low 32kb.
+//				uint16_t starting_address = file.starting_address;
+
+				// If anything above the 8kb mark is touched, mark as a 32kb machine; otherwise if the
+				// region 0x0400 to 0x1000 is touched and this is an unexpanded machine, mark as 3kb.
+//				if(starting_address + file_size > 0x2000)
+//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
+//				else if(target->memory_model == Target::MemoryModel::Unexpanded && !(starting_address >= 0x1000 || starting_address+file_size < 0x0400))
+//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
+//			}
+//		}
+	}
+
+	if(!target->media.empty()) {
+		// Inspect filename for a region hint.
+		std::string lowercase_name = file_name;
+		std::transform(lowercase_name.begin(), lowercase_name.end(), lowercase_name.begin(), ::tolower);
+		if(lowercase_name.find("ntsc") != std::string::npos) {
+			target->region = Analyser::Static::Commodore::Target::Region::American;
+		}
+
+		// Attach a 1540 if there are any disks here.
+		target->has_c1540 = !target->media.disks.empty();
+
+		destination.push_back(std::move(target));
+	}
+
+	return destination;
+}

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -0,0 +1,26 @@
+//
+//  CommodoreAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 06/09/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Commodore_StaticAnalyser_hpp
+#define StaticAnalyser_Commodore_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace Commodore {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+}
+}
+
+#endif /* CommodoreAnalyser_hpp */

Analyser/Static/Commodore/Tape.cpp

@@ -3,18 +3,18 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 24/08/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "Tape.hpp"
 
-#include "../../Storage/Tape/Parsers/Commodore.hpp"
+#include "../../../Storage/Tape/Parsers/Commodore.hpp"
 
-using namespace StaticAnalyser::Commodore;
+using namespace Analyser::Static::Commodore;
 
-std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	Storage::Tape::Commodore::Parser parser;
-	std::list<File> file_list;
+	std::vector<File> file_list;
 
 	std::unique_ptr<Storage::Tape::Commodore::Header> header = parser.get_next_header(tape);
 

Analyser/Static/Commodore/Tape.hpp

@@ -3,21 +3,22 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 24/08/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef StaticAnalyser_Commodore_Tape_hpp
 #define StaticAnalyser_Commodore_Tape_hpp
 
-#include "../../Storage/Tape/Tape.hpp"
+#include "../../../Storage/Tape/Tape.hpp"
 #include "File.hpp"
-#include <list>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Commodore/Target.hpp

@@ -0,0 +1,44 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Commodore_Target_h
+#define Analyser_Static_Commodore_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace Commodore {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class MemoryModel {
+		Unexpanded,
+		EightKB,
+		ThirtyTwoKB
+	};
+
+	enum class Region {
+		American,
+		Danish,
+		Japanese,
+		European,
+		Swedish
+	};
+
+	MemoryModel memory_model = MemoryModel::Unexpanded;
+	Region region = Region::European;
+	bool has_c1540 = false;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.cpp

@@ -3,27 +3,28 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 10/11/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
-#include "Disassembler6502.hpp"
-#include <map>
+#include "6502.hpp"
 
-using namespace StaticAnalyser::MOS6502;
+#include "Kernel.hpp"
 
-struct PartialDisassembly {
-	Disassembly disassembly;
-	std::vector<uint16_t> remaining_entry_points;
-};
+using namespace Analyser::Static::MOS6502;
+namespace  {
 
-static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<uint8_t> &memory, const std::function<size_t(uint16_t)> &address_mapper, uint16_t entry_point) {
+using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
+
+struct MOS6502Disassembler {
+
+static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<uint8_t> &memory, const std::function<std::size_t(uint16_t)> &address_mapper, uint16_t entry_point) {
 	disassembly.disassembly.internal_calls.insert(entry_point);
 	uint16_t address = entry_point;
-	while(1) {
-		size_t local_address = address_mapper(address);
+	while(true) {
+		std::size_t local_address = address_mapper(address);
 		if(local_address >= memory.size()) return;
 
-		struct Instruction instruction;
+		Instruction instruction;
 		instruction.address = address;
 		address++;
 
@@ -92,6 +93,10 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 #define IM_INSTRUCTION(base, op)	\
 	case base:	instruction.operation = op; break;
 		switch(operation) {
+			default:
+				instruction.operation = Instruction::KIL;
+			break;
+
 			IM_INSTRUCTION(0x00, Instruction::BRK)
 			IM_INSTRUCTION(0x20, Instruction::JSR)
 			IM_INSTRUCTION(0x40, Instruction::RTI)
@@ -229,7 +234,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			case Instruction::ZeroPage: case Instruction::ZeroPageX: case Instruction::ZeroPageY:
 			case Instruction::IndexedIndirectX: case Instruction::IndirectIndexedY:
 			case Instruction::Relative: {
-				size_t operand_address = address_mapper(address);
+				std::size_t operand_address = address_mapper(address);
 				if(operand_address >= memory.size()) return;
 				address++;
 
@@ -240,12 +245,12 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			// two-byte operands
 			case Instruction::Absolute: case Instruction::AbsoluteX: case Instruction::AbsoluteY:
 			case Instruction::Indirect: {
-				size_t low_operand_address = address_mapper(address);
-				size_t high_operand_address = address_mapper(address + 1);
+				std::size_t low_operand_address = address_mapper(address);
+				std::size_t high_operand_address = address_mapper(address + 1);
 				if(low_operand_address >= memory.size() || high_operand_address >= memory.size()) return;
 				address += 2;
 
-				instruction.operand = memory[low_operand_address] | (uint16_t)(memory[high_operand_address] << 8);
+				instruction.operand = memory[low_operand_address] | static_cast<uint16_t>(memory[high_operand_address] << 8);
 			}
 			break;
 		}
@@ -255,7 +260,7 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 
 		// TODO: something wider-ranging than this
 		if(instruction.addressing_mode == Instruction::Absolute || instruction.addressing_mode == Instruction::ZeroPage) {
-			size_t mapped_address = address_mapper(instruction.operand);
+			std::size_t mapped_address = address_mapper(instruction.operand);
 			bool is_external = mapped_address >= memory.size();
 
 			switch(instruction.operation) {
@@ -297,37 +302,19 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 			return;
 		}
 		if(instruction.addressing_mode == Instruction::Relative) {
-			uint16_t destination = (uint16_t)(address + (int8_t)instruction.operand);
+			uint16_t destination = static_cast<uint16_t>(address + (int8_t)instruction.operand);
 			disassembly.remaining_entry_points.push_back(destination);
 		}
 	}
 }
 
-Disassembly StaticAnalyser::MOS6502::Disassemble(const std::vector<uint8_t> &memory, const std::function<size_t(uint16_t)> &address_mapper, std::vector<uint16_t> entry_points) {
-	PartialDisassembly partialDisassembly;
-	partialDisassembly.remaining_entry_points = entry_points;
+};
 
-	while(!partialDisassembly.remaining_entry_points.empty()) {
-		// pull the next entry point from the back of the vector
-		uint16_t next_entry_point = partialDisassembly.remaining_entry_points.back();
-		partialDisassembly.remaining_entry_points.pop_back();
+}	// end of anonymous namespace
 
-		// if that address has already bene visited, forget about it
-		if(partialDisassembly.disassembly.instructions_by_address.find(next_entry_point) != partialDisassembly.disassembly.instructions_by_address.end()) continue;
-
-		// if it's outgoing, log it as such and forget about it; otherwise disassemble
-		size_t mapped_entry_point = address_mapper(next_entry_point);
-		if(mapped_entry_point >= memory.size())
-			partialDisassembly.disassembly.outward_calls.insert(next_entry_point);
-		else
-			AddToDisassembly(partialDisassembly, memory, address_mapper, next_entry_point);
-	}
-
-	return std::move(partialDisassembly.disassembly);
-}
-
-std::function<size_t(uint16_t)> StaticAnalyser::MOS6502::OffsetMapper(uint16_t start_address) {
-	return [start_address](uint16_t argument) {
-		return (size_t)(argument - start_address);
-	};
+Disassembly Analyser::Static::MOS6502::Disassemble(
+	const std::vector<uint8_t> &memory,
+	const std::function<std::size_t(uint16_t)> &address_mapper,
+	std::vector<uint16_t> entry_points) {
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, MOS6502Disassembler>(memory, address_mapper, entry_points);
 }

Analyser/Static/Disassembler/6502.hpp

@@ -0,0 +1,101 @@
+//
+//  6502.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/11/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Disassembler_6502_hpp
+#define StaticAnalyser_Disassembler_6502_hpp
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <vector>
+
+namespace Analyser {
+namespace Static {
+namespace MOS6502 {
+
+/*!
+	Describes a 6502 instruciton: its address, the operation it performs, its addressing mode
+	and its operand, if any.
+*/
+struct Instruction {
+	/*! The address this instruction starts at. This is a mapped address. */
+	uint16_t address = 0;
+	/*! The operation this instruction performs. */
+	enum {
+		BRK, JSR, RTI, RTS, JMP,
+		CLC, SEC, CLD, SED, CLI, SEI, CLV,
+		NOP,
+
+		SLO, RLA, SRE, RRA, ALR, ARR,
+		SAX, LAX, DCP, ISC,
+		ANC, XAA, AXS,
+		AND, EOR, ORA, BIT,
+		ADC, SBC,
+		AHX, SHY, SHX, TAS, LAS,
+
+		LDA, STA, LDX, STX, LDY, STY,
+
+		BPL, BMI, BVC, BVS, BCC, BCS, BNE, BEQ,
+
+		CMP, CPX, CPY,
+		INC, DEC, DEX, DEY, INX, INY,
+		ASL, ROL, LSR, ROR,
+		TAX, TXA, TAY, TYA, TSX, TXS,
+		PLA, PHA, PLP, PHP,
+
+		KIL
+	} operation = NOP;
+	/*! The addressing mode used by the instruction. */
+	enum {
+		Absolute,
+		AbsoluteX,
+		AbsoluteY,
+		Immediate,
+		Implied,
+		ZeroPage,
+		ZeroPageX,
+		ZeroPageY,
+		Indirect,
+		IndexedIndirectX,
+		IndirectIndexedY,
+		Relative,
+	} addressing_mode = Implied;
+	/*! The instruction's operand, if any. */
+	uint16_t operand = 0;
+};
+
+/*! Represents the disassembled form of a program. */
+struct Disassembly {
+	/*! All instructions found, mapped by address. */
+	std::map<uint16_t, Instruction> instructions_by_address;
+	/*! The set of all calls or jumps that land outside of the area covered by the data provided for disassembly. */
+	std::set<uint16_t> outward_calls;
+	/*! The set of all calls or jumps that land inside of the area covered by the data provided for disassembly. */
+	std::set<uint16_t> internal_calls;
+	/*! The sets of all stores, loads and modifies that occur to data outside of the area covered by the data provided for disassembly. */
+	std::set<uint16_t> external_stores, external_loads, external_modifies;
+	/*! The sets of all stores, loads and modifies that occur to data inside of the area covered by the data provided for disassembly. */
+	std::set<uint16_t> internal_stores, internal_loads, internal_modifies;
+};
+
+/*!
+	Disassembles the data provided as @c memory, mapping it into the 6502's full address range via the @c address_mapper,
+	starting disassembly from each of the @c entry_points.
+*/
+Disassembly Disassemble(
+	const std::vector<uint8_t> &memory,
+	const std::function<std::size_t(uint16_t)> &address_mapper,
+	std::vector<uint16_t> entry_points);
+
+}
+}
+}
+
+#endif /* Disassembler6502_hpp */

Analyser/Static/Disassembler/AddressMapper.cpp

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

@@ -0,0 +1,32 @@
+//
+//  AddressMapper.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 30/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef AddressMapper_hpp
+#define AddressMapper_hpp
+
+#include <functional>
+
+namespace Analyser {
+namespace Static {
+namespace Disassembler {
+
+/*!
+	Provides an address mapper that relocates a chunk of memory so that it starts at
+	address @c start_address.
+*/
+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);
+	};
+}
+
+}
+}
+}
+
+#endif /* AddressMapper_hpp */

Analyser/Static/Disassembler/Kernel.hpp

@@ -0,0 +1,52 @@
+//
+//  Kernel.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 31/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Kernel_hpp
+#define Kernel_hpp
+
+namespace Analyser {
+namespace Static {
+namespace Disassembly {
+
+template <typename D, typename S> struct PartialDisassembly {
+	D disassembly;
+	std::vector<S> remaining_entry_points;
+};
+
+template <typename D, typename S, typename Disassembler> D Disassemble(
+	const std::vector<uint8_t> &memory,
+	const std::function<std::size_t(S)> &address_mapper,
+	std::vector<S> entry_points) {
+	PartialDisassembly<D, S> partial_disassembly;
+	partial_disassembly.remaining_entry_points = entry_points;
+
+	while(!partial_disassembly.remaining_entry_points.empty()) {
+		// pull the next entry point from the back of the vector
+		S next_entry_point = partial_disassembly.remaining_entry_points.back();
+		partial_disassembly.remaining_entry_points.pop_back();
+
+		// if that address has already been visited, forget about it
+		if(	partial_disassembly.disassembly.instructions_by_address.find(next_entry_point)
+			!= partial_disassembly.disassembly.instructions_by_address.end()) continue;
+
+		// if it's outgoing, log it as such and forget about it; otherwise disassemble
+		std::size_t mapped_entry_point = address_mapper(next_entry_point);
+		if(mapped_entry_point >= memory.size())
+			partial_disassembly.disassembly.outward_calls.insert(next_entry_point);
+		else
+			Disassembler::AddToDisassembly(partial_disassembly, memory, address_mapper, next_entry_point);
+	}
+
+	return partial_disassembly.disassembly;
+}
+
+}
+}
+}
+
+#endif /* Kernel_hpp */

Analyser/Static/Disassembler/Z80.cpp

@@ -0,0 +1,619 @@
+//
+//  Z80.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 30/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "Z80.hpp"
+
+#include "Kernel.hpp"
+
+using namespace Analyser::Static::Z80;
+namespace  {
+
+using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
+
+class Accessor {
+	public:
+		Accessor(const std::vector<uint8_t> &memory, const std::function<std::size_t(uint16_t)> &address_mapper, uint16_t address) :
+			memory_(memory), address_mapper_(address_mapper), address_(address) {}
+
+		uint8_t byte() {
+			std::size_t mapped_address = address_mapper_(address_);
+			address_++;
+			if(mapped_address >= memory_.size()) {
+				overrun_ = true;
+				return 0xff;
+			}
+			return memory_[mapped_address];
+		}
+
+		uint16_t word() {
+			uint8_t low = byte();
+			uint8_t high = byte();
+			return static_cast<uint16_t>(low | (high << 8));
+		}
+
+		bool overrun() {
+			return overrun_;
+		}
+
+		bool at_end() {
+			std::size_t mapped_address = address_mapper_(address_);
+			return mapped_address >= memory_.size();
+		}
+
+		uint16_t address() {
+			return address_;
+		}
+
+	private:
+		const std::vector<uint8_t> &memory_;
+		const std::function<std::size_t(uint16_t)> &address_mapper_;
+		uint16_t address_;
+		bool overrun_ = false;
+};
+
+#define x(v) (v >> 6)
+#define y(v) ((v >> 3) & 7)
+#define q(v) ((v >> 3) & 1)
+#define p(v) ((v >> 4) & 3)
+#define z(v) (v & 7)
+
+Instruction::Condition condition_table[] = {
+	Instruction::Condition::NZ, 	Instruction::Condition::Z,
+	Instruction::Condition::NC, 	Instruction::Condition::C,
+	Instruction::Condition::PO, 	Instruction::Condition::PE,
+	Instruction::Condition::P,		Instruction::Condition::M
+};
+
+Instruction::Location register_pair_table[] = {
+	Instruction::Location::BC,
+	Instruction::Location::DE,
+	Instruction::Location::HL,
+	Instruction::Location::SP
+};
+
+Instruction::Location register_pair_table2[] = {
+	Instruction::Location::BC,
+	Instruction::Location::DE,
+	Instruction::Location::HL,
+	Instruction::Location::AF
+};
+
+Instruction::Location RegisterTableEntry(int offset, Accessor &accessor, Instruction &instruction, bool needs_indirect_offset) {
+	Instruction::Location register_table[] = {
+		Instruction::Location::B,	Instruction::Location::C,
+		Instruction::Location::D,	Instruction::Location::E,
+		Instruction::Location::H,	Instruction::Location::L,
+		Instruction::Location::HL_Indirect,
+		Instruction::Location::A
+	};
+
+	Instruction::Location location = register_table[offset];
+	if(location == Instruction::Location::HL_Indirect && needs_indirect_offset) {
+		instruction.offset = accessor.byte() - 128;
+	}
+
+	return location;
+}
+
+Instruction::Operation alu_table[] = {
+	Instruction::Operation::ADD,
+	Instruction::Operation::ADC,
+	Instruction::Operation::SUB,
+	Instruction::Operation::SBC,
+	Instruction::Operation::AND,
+	Instruction::Operation::XOR,
+	Instruction::Operation::OR,
+	Instruction::Operation::CP
+};
+
+Instruction::Operation rotation_table[] = {
+	Instruction::Operation::RLC,
+	Instruction::Operation::RRC,
+	Instruction::Operation::RL,
+	Instruction::Operation::RR,
+	Instruction::Operation::SLA,
+	Instruction::Operation::SRA,
+	Instruction::Operation::SLL,
+	Instruction::Operation::SRL
+};
+
+Instruction::Operation block_table[][4] = {
+	{Instruction::Operation::LDI, Instruction::Operation::CPI, Instruction::Operation::INI, Instruction::Operation::OUTI},
+	{Instruction::Operation::LDD, Instruction::Operation::CPD, Instruction::Operation::IND, Instruction::Operation::OUTD},
+	{Instruction::Operation::LDIR, Instruction::Operation::CPIR, Instruction::Operation::INIR, Instruction::Operation::OTIR},
+	{Instruction::Operation::LDDR, Instruction::Operation::CPDR, Instruction::Operation::INDR, Instruction::Operation::OTDR},
+};
+
+void DisassembleCBPage(Accessor &accessor, Instruction &instruction, bool needs_indirect_offset) {
+	const uint8_t operation = accessor.byte();
+
+	if(!x(operation)) {
+		instruction.operation = rotation_table[y(operation)];
+		instruction.source = instruction.destination = RegisterTableEntry(z(operation), accessor, instruction, needs_indirect_offset);
+	} else {
+		instruction.destination = RegisterTableEntry(z(operation), accessor, instruction, needs_indirect_offset);
+		instruction.source = Instruction::Location::Operand;
+		instruction.operand = y(operation);
+
+		switch(x(operation)) {
+			case 1:	instruction.operation = Instruction::Operation::BIT;	break;
+			case 2:	instruction.operation = Instruction::Operation::RES;	break;
+			case 3:	instruction.operation = Instruction::Operation::SET;	break;
+		}
+	}
+}
+
+void DisassembleEDPage(Accessor &accessor, Instruction &instruction, bool needs_indirect_offset) {
+	const uint8_t operation = accessor.byte();
+
+	switch(x(operation)) {
+		default:
+			instruction.operation = Instruction::Operation::Invalid;
+		break;
+		case 2:
+			if(z(operation) < 4 && y(operation) >= 4) {
+				instruction.operation = block_table[y(operation)-4][z(operation)];
+			} else {
+				instruction.operation = Instruction::Operation::Invalid;
+			}
+		break;
+		case 3:
+			switch(z(operation)) {
+				case 0:
+					instruction.operation = Instruction::Operation::IN;
+					instruction.source = Instruction::Location::BC_Indirect;
+					if(y(operation) == 6) {
+						instruction.destination = Instruction::Location::None;
+					} else {
+						instruction.destination = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+					}
+				break;
+				case 1:
+					instruction.operation = Instruction::Operation::OUT;
+					instruction.destination = Instruction::Location::BC_Indirect;
+					if(y(operation) == 6) {
+						instruction.source = Instruction::Location::None;
+					} else {
+						instruction.source = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+					}
+				break;
+				case 2:
+					instruction.operation = (y(operation)&1) ? Instruction::Operation::ADC : Instruction::Operation::SBC;
+					instruction.destination = Instruction::Location::HL;
+					instruction.source = register_pair_table[y(operation) >> 1];
+				break;
+				case 3:
+					instruction.operation = Instruction::Operation::LD;
+					if(q(operation)) {
+						instruction.destination = RegisterTableEntry(p(operation), accessor, instruction, needs_indirect_offset);
+						instruction.source = Instruction::Location::Operand_Indirect;
+					} else {
+						instruction.destination = Instruction::Location::Operand_Indirect;
+						instruction.source = RegisterTableEntry(p(operation), accessor, instruction, needs_indirect_offset);
+					}
+					instruction.operand = accessor.word();
+				break;
+				case 4:
+					instruction.operation = Instruction::Operation::NEG;
+				break;
+				case 5:
+					instruction.operation = (y(operation) == 1) ? Instruction::Operation::RETI : Instruction::Operation::RETN;
+				break;
+				case 6:
+					instruction.operation = Instruction::Operation::IM;
+					instruction.source = Instruction::Location::Operand;
+					switch(y(operation)&3) {
+						case 0:	instruction.operand = 0;	break;
+						case 1:	instruction.operand = 0;	break;
+						case 2:	instruction.operand = 1;	break;
+						case 3:	instruction.operand = 2;	break;
+					}
+				break;
+				case 7:
+					switch(y(operation)) {
+						case 0:
+							instruction.operation = Instruction::Operation::LD;
+							instruction.destination = Instruction::Location::I;
+							instruction.source = Instruction::Location::A;
+						break;
+						case 1:
+							instruction.operation = Instruction::Operation::LD;
+							instruction.destination = Instruction::Location::R;
+							instruction.source = Instruction::Location::A;
+						break;
+						case 2:
+							instruction.operation = Instruction::Operation::LD;
+							instruction.destination = Instruction::Location::A;
+							instruction.source = Instruction::Location::I;
+						break;
+						case 3:
+							instruction.operation = Instruction::Operation::LD;
+							instruction.destination = Instruction::Location::A;
+							instruction.source = Instruction::Location::R;
+						break;
+						case 4:		instruction.operation = Instruction::Operation::RRD;	break;
+						case 5:		instruction.operation = Instruction::Operation::RLD;	break;
+						default:	instruction.operation = Instruction::Operation::NOP;	break;
+					}
+				break;
+			}
+		break;
+	}
+}
+
+void DisassembleMainPage(Accessor &accessor, Instruction &instruction) {
+	bool needs_indirect_offset = false;
+	enum HLSubstitution {
+		None, IX, IY
+	} hl_substitution = None;
+
+	while(true) {
+		uint8_t operation = accessor.byte();
+
+		switch(x(operation)) {
+			case 0:
+				switch(z(operation)) {
+					case 0:
+						switch(y(operation)) {
+							case 0: instruction.operation = Instruction::Operation::NOP;		break;
+							case 1: instruction.operation = Instruction::Operation::EXAFAFd;	break;
+							case 2:
+								instruction.operation = Instruction::Operation::DJNZ;
+								instruction.operand = accessor.byte() - 128;
+							break;
+							default:
+								instruction.operation = Instruction::Operation::JR;
+								instruction.operand = accessor.byte() - 128;
+								if(y(operation) >= 4) instruction.condition = condition_table[y(operation) - 4];
+							break;
+						}
+					break;
+					case 1:
+						if(y(operation)&1) {
+							instruction.operation = Instruction::Operation::ADD;
+							instruction.destination = Instruction::Location::HL;
+							instruction.source = register_pair_table[y(operation) >> 1];
+						} else {
+							instruction.operation = Instruction::Operation::LD;
+							instruction.destination = register_pair_table[y(operation) >> 1];
+							instruction.source = Instruction::Location::Operand;
+							instruction.operand = accessor.word();
+						}
+					break;
+					case 2:
+						switch(y(operation)) {
+							case 0:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::BC_Indirect;
+								instruction.source = Instruction::Location::A;
+							break;
+							case 1:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::A;
+								instruction.source = Instruction::Location::BC_Indirect;
+							break;
+							case 2:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::DE_Indirect;
+								instruction.source = Instruction::Location::A;
+							break;
+							case 3:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::A;
+								instruction.source = Instruction::Location::DE_Indirect;
+							break;
+							case 4:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::Operand_Indirect;
+								instruction.source = Instruction::Location::HL;
+							break;
+							case 5:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::HL;
+								instruction.source = Instruction::Location::Operand_Indirect;
+							break;
+							case 6:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::Operand_Indirect;
+								instruction.source = Instruction::Location::A;
+							break;
+							case 7:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::A;
+								instruction.source = Instruction::Location::Operand_Indirect;
+							break;
+						}
+
+						if(y(operation) > 3) {
+							instruction.operand = accessor.word();
+						}
+					break;
+					case 3:
+						if(y(operation)&1) {
+							instruction.operation = Instruction::Operation::DEC;
+						} else {
+							instruction.operation = Instruction::Operation::INC;
+						}
+						instruction.source = instruction.destination = register_pair_table[y(operation) >> 1];
+					break;
+					case 4:
+						instruction.operation = Instruction::Operation::INC;
+						instruction.source = instruction.destination = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+					break;
+					case 5:
+						instruction.operation = Instruction::Operation::DEC;
+						instruction.source = instruction.destination = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+					break;
+					case 6:
+						instruction.operation = Instruction::Operation::LD;
+						instruction.destination = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+						instruction.source = Instruction::Location::Operand;
+						instruction.operand = accessor.byte();
+					break;
+					case 7:
+						switch(y(operation)) {
+							case 0:	instruction.operation = Instruction::Operation::RLCA;	break;
+							case 1:	instruction.operation = Instruction::Operation::RRCA;	break;
+							case 2:	instruction.operation = Instruction::Operation::RLA;	break;
+							case 3:	instruction.operation = Instruction::Operation::RRA;	break;
+							case 4:	instruction.operation = Instruction::Operation::DAA;	break;
+							case 5:	instruction.operation = Instruction::Operation::CPL;	break;
+							case 6:	instruction.operation = Instruction::Operation::SCF;	break;
+							case 7:	instruction.operation = Instruction::Operation::CCF;	break;
+						}
+					break;
+				}
+			break;
+			case 1:
+				if(y(operation) == 6 && z(operation) == 6) {
+					instruction.operation = Instruction::Operation::HALT;
+				} else {
+					instruction.operation = Instruction::Operation::LD;
+					instruction.source = RegisterTableEntry(z(operation), accessor, instruction, needs_indirect_offset);
+					instruction.destination = RegisterTableEntry(y(operation), accessor, instruction, needs_indirect_offset);
+				}
+			break;
+			case 2:
+				instruction.operation = alu_table[y(operation)];
+				instruction.source = RegisterTableEntry(z(operation), accessor, instruction, needs_indirect_offset);
+				instruction.destination = Instruction::Location::A;
+			break;
+			case 3:
+				switch(z(operation)) {
+					case 0:
+						instruction.operation = Instruction::Operation::RET;
+						instruction.condition = condition_table[y(operation)];
+					break;
+					case 1:
+						switch(y(operation)) {
+							default:
+								instruction.operation = Instruction::Operation::POP;
+								instruction.source = register_pair_table2[y(operation) >> 1];
+							break;
+							case 1:
+								instruction.operation = Instruction::Operation::RET;
+							break;
+							case 3:
+								instruction.operation = Instruction::Operation::EXX;
+							break;
+							case 5:
+								instruction.operation = Instruction::Operation::JP;
+								instruction.source = Instruction::Location::HL;
+							break;
+							case 7:
+								instruction.operation = Instruction::Operation::LD;
+								instruction.destination = Instruction::Location::SP;
+								instruction.source = Instruction::Location::HL;
+							break;
+						}
+					break;
+					case 2:
+						instruction.operation = Instruction::Operation::JP;
+						instruction.condition = condition_table[y(operation)];
+						instruction.operand = accessor.word();
+					break;
+					case 3:
+						switch(y(operation)) {
+							case 0:
+								instruction.operation = Instruction::Operation::JP;
+								instruction.source = Instruction::Location::Operand;
+								instruction.operand = accessor.word();
+							break;
+							case 1:
+								DisassembleCBPage(accessor, instruction, needs_indirect_offset);
+							break;
+							case 2:
+								instruction.operation = Instruction::Operation::OUT;
+								instruction.source = Instruction::Location::A;
+								instruction.destination = Instruction::Location::Operand_Indirect;
+								instruction.operand = accessor.byte();
+							break;
+							case 3:
+								instruction.operation = Instruction::Operation::IN;
+								instruction.destination = Instruction::Location::A;
+								instruction.source = Instruction::Location::Operand_Indirect;
+								instruction.operand = accessor.byte();
+							break;
+							case 4:
+								instruction.operation = Instruction::Operation::EX;
+								instruction.destination = Instruction::Location::SP_Indirect;
+								instruction.source = Instruction::Location::HL;
+							break;
+							case 5:
+								instruction.operation = Instruction::Operation::EX;
+								instruction.destination = Instruction::Location::DE;
+								instruction.source = Instruction::Location::HL;
+							break;
+							case 6:
+								instruction.operation = Instruction::Operation::DI;
+							break;
+							case 7:
+								instruction.operation = Instruction::Operation::EI;
+							break;
+						}
+					break;
+					case 4:
+						instruction.operation = Instruction::Operation::CALL;
+						instruction.source = Instruction::Location::Operand_Indirect;
+						instruction.operand = accessor.word();
+						instruction.condition = condition_table[y(operation)];
+					break;
+					case 5:
+						switch(y(operation)) {
+							default:
+								instruction.operation = Instruction::Operation::PUSH;
+								instruction.source = register_pair_table2[y(operation) >> 1];
+							break;
+							case 1:
+								instruction.operation = Instruction::Operation::CALL;
+								instruction.source = Instruction::Location::Operand;
+								instruction.operand = accessor.word();
+							break;
+							case 3:
+								needs_indirect_offset = true;
+								hl_substitution = IX;
+							continue;	// i.e. repeat loop.
+							case 5:
+								DisassembleEDPage(accessor, instruction, needs_indirect_offset);
+							break;
+							case 7:
+								needs_indirect_offset = true;
+								hl_substitution = IY;
+							continue;	// i.e. repeat loop.
+						}
+					break;
+					case 6:
+						instruction.operation = alu_table[y(operation)];
+						instruction.source = Instruction::Location::Operand;
+						instruction.destination = Instruction::Location::A;
+						instruction.operand = accessor.byte();
+					break;
+					case 7:
+						instruction.operation = Instruction::Operation::RST;
+						instruction.source = Instruction::Location::Operand;
+						instruction.operand = y(operation) << 3;
+					break;
+				}
+			break;
+		}
+
+		// This while(true) isn't an infinite loop for everything except those paths that opt in
+		// via continue.
+		break;
+	}
+
+	// Perform IX/IY substitution for HL, if applicable.
+	if(hl_substitution != None) {
+		// EX DE, HL is not affected.
+		if(instruction.operation == Instruction::Operation::EX) return;
+
+		// If an (HL) is involved, switch it for IX+d or IY+d.
+		if(	instruction.source == Instruction::Location::HL_Indirect ||
+			instruction.destination == Instruction::Location::HL_Indirect) {
+
+			if(instruction.source == Instruction::Location::HL_Indirect) {
+				instruction.source = (hl_substitution == IX) ? Instruction::Location::IX_Indirect_Offset : Instruction::Location::IY_Indirect_Offset;
+			}
+			if(instruction.destination == Instruction::Location::HL_Indirect) {
+				instruction.destination = (hl_substitution == IX) ? Instruction::Location::IX_Indirect_Offset : Instruction::Location::IY_Indirect_Offset;
+			}
+			return;
+		}
+
+		// Otherwise, switch either of H or L for I[X/Y]h and I[X/Y]l.
+		if(instruction.source == Instruction::Location::H) {
+			instruction.source = (hl_substitution == IX) ? Instruction::Location::IXh : Instruction::Location::IYh;
+		}
+		if(instruction.source == Instruction::Location::L) {
+			instruction.source = (hl_substitution == IX) ? Instruction::Location::IXl : Instruction::Location::IYl;
+		}
+		if(instruction.destination == Instruction::Location::H) {
+			instruction.destination = (hl_substitution == IX) ? Instruction::Location::IXh : Instruction::Location::IYh;
+		}
+		if(instruction.destination == Instruction::Location::L) {
+			instruction.destination = (hl_substitution == IX) ? Instruction::Location::IXl : Instruction::Location::IYl;
+		}
+	}
+}
+
+struct Z80Disassembler {
+	static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<uint8_t> &memory, const std::function<std::size_t(uint16_t)> &address_mapper, uint16_t entry_point) {
+		disassembly.disassembly.internal_calls.insert(entry_point);
+		Accessor accessor(memory, address_mapper, entry_point);
+
+		while(!accessor.at_end()) {
+			Instruction instruction;
+			instruction.address = accessor.address();
+
+			DisassembleMainPage(accessor, instruction);
+
+			// If any memory access was invalid, end disassembly.
+			if(accessor.overrun()) return;
+
+			// Store the instruction away.
+			disassembly.disassembly.instructions_by_address[instruction.address] = instruction;
+
+			// Update access tables.
+			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);
+			bool is_internal = address_mapper(address) < memory.size();
+			switch(access_type) {
+				default: break;
+				case 1:
+					if(is_internal) {
+						disassembly.disassembly.internal_loads.insert(address);
+					} else {
+						disassembly.disassembly.external_loads.insert(address);
+					}
+				break;
+				case 2:
+					if(is_internal) {
+						disassembly.disassembly.internal_stores.insert(address);
+					} else {
+						disassembly.disassembly.external_stores.insert(address);
+					}
+				break;
+				case 3:
+					if(is_internal) {
+						disassembly.disassembly.internal_modifies.insert(address);
+					} else {
+						disassembly.disassembly.internal_modifies.insert(address);
+					}
+				break;
+			}
+
+			// Add any (potentially) newly discovered entry point.
+			if(	instruction.operation == Instruction::Operation::JP ||
+				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));
+			}
+
+			// This is it if: an unconditional RET, RETI, RETN, JP or JR is found.
+			if(instruction.condition != Instruction::Condition::None)	continue;
+
+			if(instruction.operation == Instruction::Operation::RET)	return;
+			if(instruction.operation == Instruction::Operation::RETI)	return;
+			if(instruction.operation == Instruction::Operation::RETN)	return;
+			if(instruction.operation == Instruction::Operation::JP)		return;
+			if(instruction.operation == Instruction::Operation::JR)		return;
+		}
+	}
+};
+
+}	// end of anonymous namespace
+
+Disassembly Analyser::Static::Z80::Disassemble(
+	const std::vector<uint8_t> &memory,
+	const std::function<std::size_t(uint16_t)> &address_mapper,
+	std::vector<uint16_t> entry_points) {
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, Z80Disassembler>(memory, address_mapper, entry_points);
+}

Analyser/Static/Disassembler/Z80.hpp

@@ -0,0 +1,90 @@
+//
+//  Z80.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 30/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Disassembler_Z80_hpp
+#define StaticAnalyser_Disassembler_Z80_hpp
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <set>
+#include <vector>
+
+namespace Analyser {
+namespace Static {
+namespace Z80 {
+
+struct Instruction {
+	/*! The address this instruction starts at. This is a mapped address. */
+	uint16_t address = 0;
+
+	/*! The operation this instruction performs. */
+	enum class Operation {
+		NOP,
+		EXAFAFd, EXX, EX,
+		LD, HALT,
+		ADD, ADC, SUB, SBC, AND, XOR, OR, CP,
+		INC, DEC,
+		RLCA, RRCA, RLA, RRA, DAA, CPL, SCF, CCF,
+		RLD, RRD,
+		DJNZ, JR, JP, CALL, RST, RET, RETI, RETN,
+		PUSH, POP,
+		IN, OUT,
+		EI, DI,
+		RLC, RRC, RL, RR, SLA, SRA, SLL, SRL,
+		BIT, RES, SET,
+		LDI, CPI, INI, OUTI,
+		LDD, CPD, IND, OUTD,
+		LDIR, CPIR, INIR, OTIR,
+		LDDR, CPDR, INDR, OTDR,
+		NEG,
+		IM,
+		Invalid
+	} operation = Operation::NOP;
+
+	/*! The condition required for this instruction to take effect. */
+	enum class Condition {
+		None, NZ, Z, NC, C, PO, PE, P, M
+	} condition = Condition::None;
+
+	enum class Location {
+		B, C, D, E, H, L, HL_Indirect, A, I, R,
+		BC, DE, HL, SP, AF, Operand,
+		IX_Indirect_Offset, IY_Indirect_Offset, IXh, IXl, IYh, IYl,
+		Operand_Indirect,
+		BC_Indirect, DE_Indirect, SP_Indirect,
+		None
+	};
+	/*! The locations of source data for this instruction. */
+	Location source = Location::None;
+	/*! The locations of destination data from this instruction. */
+	Location destination = Location::None;
+	/*! The operand, if any; if this is used then it'll be referenced by either the source or destination location. */
+	int operand = 0;
+	/*! The offset to apply, if any; applies to IX_Indirect_Offset and IY_Indirect_Offset locations. */
+	int offset = 0;
+};
+
+struct Disassembly {
+	std::map<uint16_t, Instruction> instructions_by_address;
+	std::set<uint16_t> outward_calls;
+	std::set<uint16_t> internal_calls;
+	std::set<uint16_t> external_stores, external_loads, external_modifies;
+	std::set<uint16_t> internal_stores, internal_loads, internal_modifies;
+};
+
+Disassembly Disassemble(
+	const std::vector<uint8_t> &memory,
+	const std::function<std::size_t(uint16_t)> &address_mapper,
+	std::vector<uint16_t> entry_points);
+
+}
+}
+}
+
+#endif /* StaticAnalyser_Disassembler_Z80_hpp */

Analyser/Static/DiskII/StaticAnalyser.cpp

@@ -0,0 +1,125 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 03/05/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "../AppleII/Target.hpp"
+#include "../Oric/Target.hpp"
+#include "../Disassembler/6502.hpp"
+#include "../Disassembler/AddressMapper.hpp"
+
+#include "../../../Storage/Disk/Track/TrackSerialiser.hpp"
+#include "../../../Storage/Disk/Encodings/AppleGCR/SegmentParser.hpp"
+
+namespace {
+
+Analyser::Static::Target *AppleTarget(const Storage::Encodings::AppleGCR::Sector *sector_zero) {
+	using Target = Analyser::Static::AppleII::Target;
+	auto *target = new Target;
+	target->machine = Analyser::Machine::AppleII;
+
+	if(sector_zero && sector_zero->encoding == Storage::Encodings::AppleGCR::Sector::Encoding::FiveAndThree) {
+		target->disk_controller = Target::DiskController::ThirteenSector;
+	} else {
+		target->disk_controller = Target::DiskController::SixteenSector;
+	}
+
+	return target;
+}
+
+Analyser::Static::Target *OricTarget(const Storage::Encodings::AppleGCR::Sector *sector_zero) {
+	using Target = Analyser::Static::Oric::Target;
+	auto *target = new Target;
+	target->machine = Analyser::Machine::Oric;
+	target->rom = Target::ROM::Pravetz;
+	target->disk_interface = Target::DiskInterface::Pravetz;
+	target->loading_command = "CALL 800\n";
+	return target;
+}
+
+}
+
+Analyser::Static::TargetList Analyser::Static::DiskII::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	// This analyser can comprehend disks only.
+	if(media.disks.empty()) return {};
+
+	// 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(
+		Storage::Disk::track_serialisation(*track_zero, Storage::Time(1, 50000)));
+
+	const Storage::Encodings::AppleGCR::Sector *sector_zero = nullptr;
+	for(const auto &pair: sector_map) {
+		if(!pair.second.address.sector) {
+			sector_zero = &pair.second;
+			break;
+		}
+	}
+
+	// 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.back()->media = media;
+			return targets;
+		}
+	}
+
+	// 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});
+
+	bool did_read_shift_register = false;
+	bool is_oric = false;
+
+	// Look for a tight BPL loop reading the Oric's shift register address of 0x31c. The Apple II just has RAM there,
+	// so the probability of such a loop is infinitesimal.
+	for(const auto &instruction: disassembly.instructions_by_address) {
+		// Is this a read of the shift register?
+		if(
+			(
+				(instruction.second.operation == Analyser::Static::MOS6502::Instruction::LDA) ||
+				(instruction.second.operation == Analyser::Static::MOS6502::Instruction::LDX) ||
+				(instruction.second.operation == Analyser::Static::MOS6502::Instruction::LDY)
+			) &&
+			instruction.second.addressing_mode == Analyser::Static::MOS6502::Instruction::Absolute &&
+			instruction.second.address == 0x031c) {
+			did_read_shift_register = true;
+			continue;
+		}
+
+		if(did_read_shift_register) {
+			if(
+				instruction.second.operation == Analyser::Static::MOS6502::Instruction::BPL &&
+				instruction.second.address == 0xfb) {
+				is_oric = true;
+				break;
+			}
+
+			did_read_shift_register = false;
+		}
+	}
+
+	// Check also for calls into the 0x3xx page above 0x320, as that's where the Oric's boot ROM is.
+	for(const auto address: disassembly.outward_calls) {
+		is_oric |= address >= 0x320 && address < 0x400;
+	}
+
+	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.back()->media = media;
+	return targets;
+}

Analyser/Static/DiskII/StaticAnalyser.hpp

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

Analyser/Static/MSX/Cartridge.hpp

@@ -0,0 +1,40 @@
+//
+//  Cartridge.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/01/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Cartridge_hpp
+#define Cartridge_hpp
+
+#include "../../../Storage/Cartridge/Cartridge.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+/*!
+	Extends the base cartridge class by adding a (guess at) the banking scheme.
+*/
+struct Cartridge: public ::Storage::Cartridge::Cartridge {
+	enum Type {
+		None,
+		Konami,
+		KonamiWithSCC,
+		ASCII8kb,
+		ASCII16kb,
+		FMPac
+	};
+	const Type type;
+
+	Cartridge(const std::vector<Segment> &segments, Type type) :
+		Storage::Cartridge::Cartridge(segments), type(type) {}
+};
+
+}
+}
+}
+
+#endif /* Cartridge_hpp */

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -0,0 +1,299 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/11/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "Cartridge.hpp"
+#include "Tape.hpp"
+#include "Target.hpp"
+
+#include "../Disassembler/Z80.hpp"
+#include "../Disassembler/AddressMapper.hpp"
+
+#include <algorithm>
+
+static std::unique_ptr<Analyser::Static::Target> CartridgeTarget(
+	const Storage::Cartridge::Cartridge::Segment &segment,
+	uint16_t start_address,
+	Analyser::Static::MSX::Cartridge::Type type,
+	float confidence) {
+
+	// Size down to a multiple of 8kb in size and apply the start address.
+	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;
+		truncated_data.insert(truncated_data.begin(), segment.data.begin(), segment.data.begin() + truncated_size);
+		output_segments.emplace_back(start_address, truncated_data);
+	} else {
+		output_segments.emplace_back(start_address, segment.data);
+	}
+
+	std::unique_ptr<Analyser::Static::MSX::Target> target(new Analyser::Static::MSX::Target);
+	target->machine = Analyser::Machine::MSX;
+	target->confidence = confidence;
+
+	if(type == Analyser::Static::MSX::Cartridge::Type::None) {
+		target->media.cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
+	} else {
+		target->media.cartridges.emplace_back(new Analyser::Static::MSX::Cartridge(output_segments, type));
+	}
+
+	return target;
+}
+
+/*
+	Expected standard cartridge format:
+
+		DEFB "AB" ; expansion ROM header
+		DEFW initcode ; start of the init code, 0 if no initcode
+		DEFW callstat; pointer to CALL statement handler, 0 if no such handler
+		DEFW device; pointer to expansion device handler, 0 if no such handler
+		DEFW basic ; pointer to the start of a tokenized basicprogram, 0 if no basicprogram
+		DEFS 6,0 ; room reserved for future extensions
+
+	MSX cartridges often include banking hardware; those games were marketed as MegaROMs. The file
+	format that the MSX community has decided upon doesn't retain the type of hardware included, so
+	this analyser has to guess.
+
+	(additional audio hardware is also sometimes included, but it's implied by the banking hardware)
+*/
+static Analyser::Static::TargetList CartridgeTargetsFrom(
+	const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	// No cartridges implies no targets.
+	if(cartridges.empty()) {
+		return {};
+	}
+
+	Analyser::Static::TargetList targets;
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
+
+		// Only one mapped item is allowed.
+		if(segments.size() != 1) continue;
+
+		// Which must be no more than 63 bytes larger than a multiple of 8 kb in size.
+		Storage::Cartridge::Cartridge::Segment segment = segments.front();
+		const size_t data_size = segment.data.size();
+		if(data_size < 0x2000 || (data_size & 0x1fff) > 64) continue;
+
+		// Check for a ROM header at address 0; if it's not found then try 0x4000
+		// and adjust the start address;
+		uint16_t start_address = 0;
+		bool found_start = false;
+		if(segment.data[0] == 0x41 && segment.data[1] == 0x42) {
+			start_address = 0x4000;
+			found_start = true;
+		} else if(segment.data.size() >= 0x8000 && segment.data[0x4000] == 0x41 && segment.data[0x4001] == 0x42) {
+			start_address = 0;
+			found_start = true;
+		}
+
+		// 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));
+		// 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.
+		if(data_size <= 0xc000) {
+			targets.emplace_back(CartridgeTarget(segment, start_address, Analyser::Static::MSX::Cartridge::Type::None, 1.0));
+			continue;
+		}
+
+		// If this ROM is greater than 48kb in size then some sort of MegaROM scheme must
+		// be at play; disassemble to try to figure it out.
+		std::vector<uint8_t> first_8k;
+		first_8k.insert(first_8k.begin(), segment.data.begin(), segment.data.begin() + 8192);
+		Analyser::Static::Z80::Disassembly disassembly =
+			Analyser::Static::Z80::Disassemble(
+				first_8k,
+				Analyser::Static::Disassembler::OffsetMapper(start_address),
+				{ init_address }
+			);
+
+//		// Look for a indirect store followed by an unconditional JP or CALL into another
+//		// segment, that's a fairly explicit sign where found.
+		using Instruction = Analyser::Static::Z80::Instruction;
+		std::map<uint16_t, Instruction> &instructions = disassembly.instructions_by_address;
+		bool is_ascii = false;
+//		auto iterator = instructions.begin();
+//		while(iterator != instructions.end()) {
+//			auto next_iterator = iterator;
+//			next_iterator++;
+//			if(next_iterator == instructions.end()) break;
+//
+//			if(	iterator->second.operation == Instruction::Operation::LD &&
+//				iterator->second.destination == Instruction::Location::Operand_Indirect &&
+//				(
+//					iterator->second.operand == 0x5000 ||
+//					iterator->second.operand == 0x6000 ||
+//					iterator->second.operand == 0x6800 ||
+//					iterator->second.operand == 0x7000 ||
+//					iterator->second.operand == 0x77ff ||
+//					iterator->second.operand == 0x7800 ||
+//					iterator->second.operand == 0x8000 ||
+//					iterator->second.operand == 0x9000 ||
+//					iterator->second.operand == 0xa000
+//				) &&
+//				(
+//					next_iterator->second.operation == Instruction::Operation::CALL ||
+//					next_iterator->second.operation == Instruction::Operation::JP
+//				) &&
+//				((next_iterator->second.operand >> 13) != (0x4000 >> 13))
+//			) {
+//				const uint16_t address = static_cast<uint16_t>(next_iterator->second.operand);
+//				switch(iterator->second.operand) {
+//					case 0x6000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x6800:
+//						if(address >= 0x6000 && address < 0x6800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x7000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//						if(address >= 0x7000 && address < 0x7800) {
+//							is_ascii = true;
+//						}
+//					break;
+//					case 0x77ff:
+//						if(address >= 0x7000 && address < 0x7800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII16kb;
+//						}
+//					break;
+//					case 0x7800:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x8000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x9000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0xa000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::Konami;
+//						}
+//					break;
+//					case 0xb000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//				}
+//			}
+//
+//			iterator = next_iterator;
+
+		// Look for LD (nnnn), A instructions, and collate those addresses.
+		std::map<uint16_t, int> address_counts;
+		for(const auto &instruction_pair : instructions) {
+			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)]++;
+			}
+		}
+
+		// Weight confidences by number of observed hits.
+		float total_hits =
+			static_cast<float>(
+				address_counts[0x6000] + address_counts[0x6800] +
+				address_counts[0x7000] + address_counts[0x7800] +
+				address_counts[0x77ff] + address_counts[0x8000] +
+				address_counts[0xa000] + address_counts[0x5000] +
+				address_counts[0x9000] + address_counts[0xb000]
+			);
+
+		targets.push_back(CartridgeTarget(
+			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));
+		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));
+		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));
+		}
+		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));
+		}
+	}
+
+	return targets;
+}
+
+Analyser::Static::TargetList Analyser::Static::MSX::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	TargetList destination;
+
+	// Append targets for any cartridges that look correct.
+	auto cartridge_targets = CartridgeTargetsFrom(media.cartridges);
+	std::move(cartridge_targets.begin(), cartridge_targets.end(), std::back_inserter(destination));
+
+	// Consider building a target for disks and/or tapes.
+	std::unique_ptr<Target> target(new Target);
+
+	// Check tapes for loadable files.
+	for(auto &tape : media.tapes) {
+		std::vector<File> files_on_tape = GetFiles(tape);
+		if(!files_on_tape.empty()) {
+			switch(files_on_tape.front().type) {
+				case File::Type::ASCII:				target->loading_command = "RUN\"CAS:\r";		break;
+				case File::Type::TokenisedBASIC:	target->loading_command = "CLOAD\rRUN\r";		break;
+				case File::Type::Binary:			target->loading_command = "BLOAD\"CAS:\",R\r";	break;
+				default: break;
+			}
+			target->media.tapes.push_back(tape);
+		}
+	}
+
+	// Blindly accept disks for now.
+	target->media.disks = media.disks;
+	target->has_disk_drive = !media.disks.empty();
+
+	if(!target->media.empty()) {
+		target->machine = Machine::MSX;
+		target->confidence = 0.5;
+		destination.push_back(std::move(target));
+	}
+
+	return destination;
+}

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -0,0 +1,26 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/11/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_MSX_StaticAnalyser_hpp
+#define StaticAnalyser_MSX_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+TargetList GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms);
+
+}
+}
+}
+
+#endif /* StaticAnalyser_MSX_StaticAnalyser_hpp */

Analyser/Static/MSX/Tape.cpp

@@ -0,0 +1,165 @@
+//
+//  Tape.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "Tape.hpp"
+
+#include "../../../Storage/Tape/Parsers/MSX.hpp"
+
+using namespace Analyser::Static::MSX;
+
+File::File(File &&rhs) :
+	name(std::move(rhs.name)),
+	type(rhs.type),
+	data(std::move(rhs.data)),
+	starting_address(rhs.starting_address),
+	entry_address(rhs.entry_address) {}
+
+File::File() :
+	type(Type::Binary),
+	starting_address(0),
+	entry_address(0) {}	// For the sake of initialising in a defined state.
+
+std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	std::vector<File> files;
+
+	Storage::Tape::BinaryTapePlayer tape_player(1000000);
+	tape_player.set_motor_control(true);
+	tape_player.set_tape(tape);
+
+	using Parser = Storage::Tape::MSX::Parser;
+
+	// Get all recognisable files from the tape.
+	while(!tape->is_at_end()) {
+		// Try to locate and measure a header.
+		std::unique_ptr<Parser::FileSpeed> file_speed = Parser::find_header(tape_player);
+		if(!file_speed) continue;
+
+		// Check whether what follows is a recognisable file type.
+		uint8_t header[10] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+		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);
+		}
+
+		bool bytes_are_same = true;
+		for(std::size_t c = 1; c < sizeof(header); ++c)
+			bytes_are_same &= (header[c] == header[0]);
+
+		if(!bytes_are_same) continue;
+		if(header[0] != 0xd0 && header[0] != 0xd3 && header[0] != 0xea) continue;
+
+		File file;
+
+		// Determine file type from information already collected.
+		switch(header[0]) {
+			case 0xd0:	file.type = File::Type::Binary;			break;
+			case 0xd3:	file.type = File::Type::TokenisedBASIC;	break;
+			case 0xea:	file.type = File::Type::ASCII;			break;
+			default: break;	// Unreachable.
+		}
+
+		// 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[6] = '\0';
+		file.name = name;
+
+		// ASCII: Read 256-byte segments until one ends with an end-of-file character.
+		if(file.type == File::Type::ASCII) {
+			while(true) {
+				file_speed = Parser::find_header(tape_player);
+				if(!file_speed) break;
+				int c = 256;
+				bool contains_end_of_file = false;
+				while(c--) {
+					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));
+				}
+				if(c != -1) break;
+				if(contains_end_of_file) {
+					files.push_back(std::move(file));
+					break;
+				}
+			}
+			continue;
+		}
+
+		// Read a single additional segment, using the information at the begging to determine length.
+		file_speed = Parser::find_header(tape_player);
+		if(!file_speed) continue;
+
+		// Binary: read start address, end address, entry address, then that many bytes.
+		if(file.type == File::Type::Binary) {
+			uint8_t locations[6];
+			uint16_t end_address;
+			std::size_t c;
+			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);
+			}
+			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));
+
+			if(end_address < file.starting_address) continue;
+
+			std::size_t length = end_address - file.starting_address;
+			while(length--) {
+				int byte = Parser::get_byte(*file_speed, tape_player);
+				if(byte == -1) continue;
+				file.data.push_back(static_cast<uint8_t>(byte));
+			}
+
+			files.push_back(std::move(file));
+			continue;
+		}
+
+		// Tokenised BASIC, then: keep following 'next line' links from a hypothetical start of
+		// 0x8001, until finding the final line.
+		uint16_t current_address = 0x8001;
+		while(current_address) {
+			int next_address_buffer[2];
+			next_address_buffer[0] = Parser::get_byte(*file_speed, tape_player);
+			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]));
+
+			uint16_t next_address = static_cast<uint16_t>(next_address_buffer[0] | (next_address_buffer[1] << 8));
+			if(!next_address) {
+				files.push_back(std::move(file));
+				break;
+			}
+			if(next_address < current_address+2) break;
+
+			// This line makes sense, so push it all in.
+			std::size_t length = next_address - current_address - 2;
+			current_address = next_address;
+			bool found_error = false;
+			while(length--) {
+				int byte = Parser::get_byte(*file_speed, tape_player);
+				if(byte == -1) {
+					found_error = true;
+					break;
+				}
+				file.data.push_back(static_cast<uint8_t>(byte));
+			}
+			if(found_error) break;
+		}
+	}
+
+	return files;
+}

Analyser/Static/MSX/Tape.hpp

@@ -0,0 +1,44 @@
+//
+//  Tape.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/12/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_MSX_Tape_hpp
+#define StaticAnalyser_MSX_Tape_hpp
+
+#include "../../../Storage/Tape/Tape.hpp"
+
+#include <string>
+#include <vector>
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+struct File {
+	std::string name;
+	enum Type {
+		Binary,
+		TokenisedBASIC,
+		ASCII
+	} type;
+
+	std::vector<uint8_t> data;
+
+	uint16_t starting_address;	// Provided only for Type::Binary files.
+	uint16_t entry_address;		// Provided only for Type::Binary files.
+
+	File(File &&rhs);
+	File();
+};
+
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+
+}
+}
+}
+
+#endif /* StaticAnalyser_MSX_Tape_hpp */

Analyser/Static/MSX/Target.hpp

@@ -0,0 +1,28 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/04/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_MSX_Target_h
+#define Analyser_Static_MSX_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+struct Target: public ::Analyser::Static::Target {
+	bool has_disk_drive = false;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_MSX_Target_h */

Analyser/Static/Oric/StaticAnalyser.cpp

@@ -3,28 +3,35 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 11/10/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "StaticAnalyser.hpp"
 
 #include "Tape.hpp"
-#include "../Disassembler/Disassembler6502.hpp"
+#include "Target.hpp"
 
-using namespace StaticAnalyser::Oric;
+#include "../Disassembler/6502.hpp"
+#include "../Disassembler/AddressMapper.hpp"
 
-static int Score(const StaticAnalyser::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+
+#include <cstring>
+
+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) {
 	int score = 0;
 
-	for(auto address : disassembly.outward_calls)	score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1;
-	for(auto address : disassembly.external_stores)	score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
-	for(auto address : disassembly.external_loads)	score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
+	for(const auto address : disassembly.outward_calls)		score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1;
+	for(const auto address : disassembly.external_stores)	score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
+	for(const auto address : disassembly.external_loads)	score += (variable_locations.find(address) != variable_locations.end()) ? 1 : -1;
 
 	return score;
 }
 
-static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) {
-	std::set<uint16_t> rom_functions = {
+static int Basic10Score(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,
 		0xc773,	0xc824,	0xc832,	0xc841,	0xc8c1,	0xc8fe,	0xc91f,	0xc93f,	0xc941,	0xc91e,	0xc98b,	0xc996,	0xc9b3,	0xc9e0,	0xca0a,	0xca1c,
@@ -40,15 +47,15 @@ static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly)
 		0xf43c,	0xf4ef,	0xf523,	0xf561,	0xf535,	0xf57b,	0xf5d3,	0xf71a,	0xf73f,	0xf7e4,	0xf7e0,	0xf82f,	0xf88f,	0xf8af,	0xf8b5,	0xf920,
 		0xf967,	0xf960,	0xf9c9,	0xfa14,	0xfa85,	0xfa9b,	0xfab1,	0xfac7,	0xfafa,	0xfb10,	0xfb26,	0xfbb6,	0xfbfe
 	};
-	std::set<uint16_t> variable_locations = {
+	const std::set<uint16_t> variable_locations = {
 		0x0228, 0x0229, 0x022a, 0x022b, 0x022c, 0x022d, 0x0230
 	};
 
 	return Score(disassembly, rom_functions, variable_locations);
 }
 
-static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) {
-	std::set<uint16_t> rom_functions = {
+static int Basic11Score(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,
 		0xc748,	0xc7fd,	0xc809,	0xc816,	0xc82f,	0xc855,	0xc8c1,	0xc915,	0xc952,	0xc971,	0xc973,	0xc9a0,	0xc9bd,	0xc9c8,	0xc9e5,	0xca12,
@@ -65,34 +72,51 @@ static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly)
 		0xf88f,	0xf8af,	0xf8b5,	0xf920,	0xf967,	0xf9aa,	0xf9c9,	0xfa14,	0xfa9f,	0xfab5,	0xfacb,	0xfae1,	0xfb14,	0xfb2a,	0xfb40,	0xfbd0,
 		0xfc18
 	};
-	std::set<uint16_t> variable_locations = {
+	const std::set<uint16_t> variable_locations = {
 		0x0244, 0x0245, 0x0246, 0x0247, 0x0248, 0x0249, 0x024a, 0x024b, 0x024c
 	};
 
 	return Score(disassembly, rom_functions, variable_locations);
 }
 
-void StaticAnalyser::Oric::AddTargets(
-		const std::list<std::shared_ptr<Storage::Disk::Disk>> &disks,
-		const std::list<std::shared_ptr<Storage::Tape::Tape>> &tapes,
-		const std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges,
-		std::list<StaticAnalyser::Target> &destination) {
-	Target target;
-	target.machine = Target::Oric;
-	target.probability = 1.0;
+static bool IsMicrodisc(Storage::Encodings::MFM::Parser &parser) {
+	/*
+		The Microdisc boot sector is sector 2 of track 0 and contains a 23-byte signature.
+	*/
+	Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 2);
+	if(!sector) return false;
+	if(sector->samples.empty()) return false;
+
+	const std::vector<uint8_t> &first_sample = sector->samples[0];
+	if(first_sample.size() != 256) return false;
+
+	const uint8_t signature[] = {
+		0x00, 0x00, 0xFF, 0x00, 0xD0, 0x9F, 0xD0,
+		0x9F, 0x02, 0xB9, 0x01, 0x00, 0xFF, 0x00,
+		0x00, 0xB9, 0xE4, 0xB9, 0x00, 0x00, 0xE6,
+		0x12, 0x00
+	};
+
+	return !std::memcmp(signature, first_sample.data(), sizeof(signature));
+}
+
+Analyser::Static::TargetList Analyser::Static::Oric::GetTargets(const Media &media, const std::string &file_name, TargetPlatform::IntType potential_platforms) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Oric;
+	target->confidence = 0.5;
 
 	int basic10_votes = 0;
 	int basic11_votes = 0;
 
-	for(auto &tape : tapes) {
-		std::list<File> tape_files = GetFiles(tape);
+	for(auto &tape : media.tapes) {
+		std::vector<File> tape_files = GetFiles(tape);
 		tape->reset();
-		if(tape_files.size()) {
-			for(auto file : tape_files) {
+		if(!tape_files.empty()) {
+			for(const auto &file : tape_files) {
 				if(file.data_type == File::MachineCode) {
 					std::vector<uint16_t> entry_points = {file.starting_address};
-					StaticAnalyser::MOS6502::Disassembly disassembly =
-						StaticAnalyser::MOS6502::Disassemble(file.data, StaticAnalyser::MOS6502::OffsetMapper(file.starting_address), entry_points);
+					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);
@@ -100,23 +124,32 @@ void StaticAnalyser::Oric::AddTargets(
 				}
 			}
 
-			target.tapes.push_back(tape);
-			target.loadingCommand = "CLOAD\"\"\n";
+			target->media.tapes.push_back(tape);
+			target->loading_command = "CLOAD\"\"\n";
 		}
 	}
 
-	// trust that any disk supplied can be handled by the Microdisc. TODO: check.
-	if(!disks.empty()) {
-		target.oric.has_microdisc = true;
-		target.disks = disks;
-	} else {
-		target.oric.has_microdisc = false;
+	if(!media.disks.empty()) {
+		// Only the Microdisc is emulated right now, so accept only disks that it can boot from.
+		for(auto &disk: media.disks) {
+			Storage::Encodings::MFM::Parser parser(true, disk);
+			if(IsMicrodisc(parser)) {
+				target->disk_interface = Target::DiskInterface::Microdisc;
+				target->media.disks.push_back(disk);
+			}
+		}
 	}
+	else
+		target->disk_interface = Target::DiskInterface::None;
 
 	// TODO: really this should add two targets if not all votes agree
-	target.oric.use_atmos_rom = basic11_votes >= basic10_votes;
-	if(target.oric.has_microdisc) target.oric.use_atmos_rom = true;
+	if(basic11_votes >= basic10_votes || target->disk_interface == Target::DiskInterface::Microdisc)
+		target->rom = Target::ROM::BASIC11;
+	else
+		target->rom = Target::ROM::BASIC10;
 
-	if(target.tapes.size() || target.disks.size() || target.cartridges.size())
-		destination.push_back(target);
+	TargetList targets;
+	if(target->media.tapes.size() || target->media.disks.size() || target->media.cartridges.size())
+		targets.push_back(std::move(target));
+	return targets;
 }

Analyser/Static/Oric/StaticAnalyser.hpp

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

Analyser/Static/Oric/Tape.cpp

@@ -3,16 +3,16 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 06/11/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "Tape.hpp"
-#include "../../Storage/Tape/Parsers/Oric.hpp"
+#include "../../../Storage/Tape/Parsers/Oric.hpp"
 
-using namespace StaticAnalyser::Oric;
+using namespace Analyser::Static::Oric;
 
-std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
-	std::list<File> files;
+std::vector<File> Analyser::Static::Oric::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	std::vector<File> files;
 	Storage::Tape::Oric::Parser parser;
 
 	while(!tape->is_at_end()) {
@@ -49,10 +49,10 @@ std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Ta
 		}
 
 		// read end and start addresses
-		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);
+		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));
 
 		// skip an empty byte
 		parser.get_next_byte(tape, is_fast);
@@ -69,10 +69,10 @@ std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Ta
 		new_file.name = file_name;
 
 		// read body
-		size_t body_length = new_file.ending_address - new_file.starting_address + 1;
+		std::size_t body_length = new_file.ending_address - new_file.starting_address + 1;
 		new_file.data.reserve(body_length);
-		for(size_t c = 0; c < body_length; c++) {
-			new_file.data.push_back((uint8_t)parser.get_next_byte(tape, is_fast));
+		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)));
 		}
 
 		// only one validation check: was there enough tape?

Analyser/Static/Oric/Tape.hpp

@@ -3,18 +3,19 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 06/11/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef StaticAnalyser_Oric_Tape_hpp
 #define StaticAnalyser_Oric_Tape_hpp
 
-#include "../../Storage/Tape/Tape.hpp"
-#include <list>
+#include "../../../Storage/Tape/Tape.hpp"
+
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Oric {
 
 struct File {
@@ -30,8 +31,9 @@ struct File {
 	std::vector<uint8_t> data;
 };
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Oric/Target.hpp

@@ -0,0 +1,41 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Oric_Target_h
+#define Analyser_Static_Oric_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace Oric {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class ROM {
+		BASIC10,
+		BASIC11,
+		Pravetz
+	};
+
+	enum class DiskInterface {
+		Microdisc,
+		Pravetz,
+		None
+	};
+
+	ROM rom = ROM::BASIC11;
+	DiskInterface disk_interface = DiskInterface::None;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Oric_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -0,0 +1,193 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/08/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
+
+// Analysers
+#include "Acorn/StaticAnalyser.hpp"
+#include "AmstradCPC/StaticAnalyser.hpp"
+#include "AppleII/StaticAnalyser.hpp"
+#include "Atari/StaticAnalyser.hpp"
+#include "Coleco/StaticAnalyser.hpp"
+#include "Commodore/StaticAnalyser.hpp"
+#include "DiskII/StaticAnalyser.hpp"
+#include "MSX/StaticAnalyser.hpp"
+#include "Oric/StaticAnalyser.hpp"
+#include "ZX8081/StaticAnalyser.hpp"
+
+// Cartridges
+#include "../../Storage/Cartridge/Formats/BinaryDump.hpp"
+#include "../../Storage/Cartridge/Formats/PRG.hpp"
+
+// Disks
+#include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/AppleDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/D64.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/G64.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/DMK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/MSXDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/NIB.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/WOZ.hpp"
+
+// Tapes
+#include "../../Storage/Tape/Formats/CAS.hpp"
+#include "../../Storage/Tape/Formats/CommodoreTAP.hpp"
+#include "../../Storage/Tape/Formats/CSW.hpp"
+#include "../../Storage/Tape/Formats/OricTAP.hpp"
+#include "../../Storage/Tape/Formats/TapePRG.hpp"
+#include "../../Storage/Tape/Formats/TapeUEF.hpp"
+#include "../../Storage/Tape/Formats/TZX.hpp"
+#include "../../Storage/Tape/Formats/ZX80O81P.hpp"
+
+// Target Platform Types
+#include "../../Storage/TargetPlatforms.hpp"
+
+using namespace Analyser::Static;
+
+static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::IntType &potential_platforms) {
+	Media result;
+
+	// Get the extension, if any; it will be assumed that extensions are reliable, so an extension is a broad-phase
+	// test as to file format.
+	std::string::size_type final_dot = file_name.find_last_of(".");
+	if(final_dot == std::string::npos) return result;
+	std::string extension = file_name.substr(final_dot + 1);
+	std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
+
+#define Insert(list, class, platforms) \
+	list.emplace_back(new Storage::class(file_name));\
+	potential_platforms |= platforms;\
+	TargetPlatform::TypeDistinguisher *distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
+	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
+
+#define TryInsert(list, class, platforms) \
+	try {\
+		Insert(list, class, platforms) \
+	} catch(...) {}
+
+#define Format(ext, list, class, platforms) \
+	if(extension == ext)	{		\
+		TryInsert(list, class, platforms)	\
+	}
+
+	Format("80", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// 80
+	Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// 81
+	Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600)						// A26
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)		// ADF
+	Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge)					// BIN
+	Format("cas", result.tapes, Tape::CAS, TargetPlatform::MSX)												// CAS
+	Format("cdt", result.tapes, Tape::TZX, TargetPlatform::AmstradCPC)										// CDT
+	Format("col", result.cartridges, Cartridge::BinaryDump, TargetPlatform::ColecoVision)					// COL
+	Format("csw", result.tapes, Tape::CSW, TargetPlatform::AllTape)											// CSW
+	Format("d64", result.disks, Disk::DiskImageHolder<Storage::Disk::D64>, TargetPlatform::Commodore)		// D64
+	Format("dmk", result.disks, Disk::DiskImageHolder<Storage::Disk::DMK>, TargetPlatform::MSX)				// DMK
+	Format("do", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)		// DO
+	Format("dsd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)			// DSD
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::CPCDSK>, TargetPlatform::AmstradCPC)	// DSK (Amstrad CPC)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)		// DSK (Apple)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::MSXDSK>, TargetPlatform::MSX)			// DSK (MSX)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::OricMFMDSK>, TargetPlatform::Oric)		// DSK (Oric)
+	Format("g64", result.disks, Disk::DiskImageHolder<Storage::Disk::G64>, TargetPlatform::Commodore)		// G64
+	Format(	"hfe",
+			result.disks,
+			Disk::DiskImageHolder<Storage::Disk::HFE>,
+			TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric)
+			// HFE (TODO: switch to AllDisk once the MSX stops being so greedy)
+	Format("nib", result.disks, Disk::DiskImageHolder<Storage::Disk::NIB>, TargetPlatform::DiskII)			// NIB
+	Format("o", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// O
+	Format("p", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// P
+	Format("po", result.disks, Disk::DiskImageHolder<Storage::Disk::AppleDSK>, TargetPlatform::DiskII)		// PO
+	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// P81
+
+	// PRG
+	if(extension == "prg") {
+		// try instantiating as a ROM; failing that accept as a tape
+		try {
+			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore)
+		} catch(...) {
+			try {
+				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore)
+			} catch(...) {}
+		}
+	}
+
+	Format(	"rom",
+			result.cartridges,
+			Cartridge::BinaryDump,
+			TargetPlatform::AcornElectron | TargetPlatform::ColecoVision | TargetPlatform::MSX)				// ROM
+	Format("ssd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)			// SSD
+	Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore)								// TAP (Commodore)
+	Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric)										// TAP (Oric)
+	Format("tsx", result.tapes, Tape::TZX, TargetPlatform::MSX)												// TSX
+	Format("tzx", result.tapes, Tape::TZX, TargetPlatform::ZX8081)											// TZX
+	Format("uef", result.tapes, Tape::UEF, TargetPlatform::Acorn)											// UEF (tape)
+	Format("woz", result.disks, Disk::DiskImageHolder<Storage::Disk::WOZ>, TargetPlatform::DiskII)			// WOZ
+
+#undef Format
+#undef Insert
+#undef TryInsert
+
+	return result;
+}
+
+Media Analyser::Static::GetMedia(const std::string &file_name) {
+	TargetPlatform::IntType throwaway;
+	return GetMediaAndPlatforms(file_name, throwaway);
+}
+
+TargetList Analyser::Static::GetTargets(const std::string &file_name) {
+	TargetList targets;
+
+	// Collect all disks, tapes and ROMs as can be extrapolated from this file, forming the
+	// union of all platforms this file might be a target for.
+	TargetPlatform::IntType potential_platforms = 0;
+	Media media = GetMediaAndPlatforms(file_name, potential_platforms);
+
+	// Hand off to platform-specific determination of whether these things are actually compatible and,
+	// if so, how to load them.
+	#define Append(x) {\
+		auto new_targets = x::GetTargets(media, file_name, potential_platforms);\
+		std::move(new_targets.begin(), new_targets.end(), std::back_inserter(targets));\
+	}
+	if(potential_platforms & TargetPlatform::Acorn)			Append(Acorn);
+	if(potential_platforms & TargetPlatform::AmstradCPC)	Append(AmstradCPC);
+	if(potential_platforms & TargetPlatform::AppleII)		Append(AppleII);
+	if(potential_platforms & TargetPlatform::Atari2600)		Append(Atari);
+	if(potential_platforms & TargetPlatform::ColecoVision)	Append(Coleco);
+	if(potential_platforms & TargetPlatform::Commodore)		Append(Commodore);
+	if(potential_platforms & TargetPlatform::DiskII)		Append(DiskII);
+	if(potential_platforms & TargetPlatform::MSX)			Append(MSX);
+	if(potential_platforms & TargetPlatform::Oric)			Append(Oric);
+	if(potential_platforms & TargetPlatform::ZX8081)		Append(ZX8081);
+	#undef Append
+
+	// Reset any tapes to their initial position
+	for(const auto &target : targets) {
+		for(auto &tape : target->media.tapes) {
+			tape->reset();
+		}
+	}
+
+	// Sort by initial confidence. Use a stable sort in case any of the machine-specific analysers
+	// picked their insertion order carefully.
+	std::stable_sort(targets.begin(), targets.end(),
+		[] (const std::unique_ptr<Target> &a, const std::unique_ptr<Target> &b) {
+			return a->confidence > b->confidence;
+		});
+
+	return targets;
+}

Analyser/Static/StaticAnalyser.hpp

@@ -0,0 +1,66 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/08/2016.
+//  Copyright 2016 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_hpp
+#define StaticAnalyser_hpp
+
+#include "../Machines.hpp"
+
+#include "../../Storage/Tape/Tape.hpp"
+#include "../../Storage/Disk/Disk.hpp"
+#include "../../Storage/Cartridge/Cartridge.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Analyser {
+namespace Static {
+
+/*!
+	A list of disks, tapes and cartridges.
+*/
+struct Media {
+	std::vector<std::shared_ptr<Storage::Disk::Disk>> disks;
+	std::vector<std::shared_ptr<Storage::Tape::Tape>> tapes;
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> cartridges;
+
+	bool empty() const {
+		return disks.empty() && tapes.empty() && cartridges.empty();
+	}
+};
+
+/*!
+	A list of disks, tapes and cartridges plus information about the machine to which to attach them and its configuration,
+	and instructions on how to launch the software attached, plus a measure of confidence in this target's correctness.
+*/
+struct Target {
+	virtual ~Target() {}
+
+	Machine machine;
+	Media media;
+	float confidence;
+};
+typedef std::vector<std::unique_ptr<Target>> TargetList;
+
+/*!
+	Attempts, through any available means, to return a list of potential targets for the file with the given name.
+
+	@returns The list of potential targets, sorted from most to least probable.
+*/
+TargetList GetTargets(const std::string &file_name);
+
+/*!
+	Inspects the supplied file and determines the media included.
+*/
+Media GetMedia(const std::string &file_name);
+
+}
+}
+
+#endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.cpp

@@ -0,0 +1,70 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/06/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include <string>
+#include <vector>
+
+#include "Target.hpp"
+#include "../../../Storage/Tape/Parsers/ZX8081.hpp"
+
+static std::vector<Storage::Data::ZX8081::File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	std::vector<Storage::Data::ZX8081::File> files;
+	Storage::Tape::ZX8081::Parser parser;
+
+	while(!tape->is_at_end()) {
+		std::shared_ptr<Storage::Data::ZX8081::File> next_file = parser.get_next_file(tape);
+		if(next_file != nullptr) {
+			files.push_back(*next_file);
+		}
+	}
+
+	return files;
+}
+
+Analyser::Static::TargetList Analyser::Static::ZX8081::GetTargets(const Media &media, const std::string &file_name, 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;
+			destination.push_back(std::unique_ptr<::Analyser::Static::Target>(target));
+			target->machine = Machine::ZX8081;
+
+			// Guess the machine type from the file only if it isn't already known.
+			switch(potential_platforms & (TargetPlatform::ZX80 | TargetPlatform::ZX81)) {
+				default:
+					target->is_ZX81 = files.front().isZX81;
+				break;
+
+				case TargetPlatform::ZX80:	target->is_ZX81 = false;	break;
+				case TargetPlatform::ZX81:	target->is_ZX81 = true;		break;
+			}
+
+			/*if(files.front().data.size() > 16384) {
+				target->zx8081.memory_model = ZX8081MemoryModel::SixtyFourKB;
+			} else*/ if(files.front().data.size() > 1024) {
+				target->memory_model = Target::MemoryModel::SixteenKB;
+			} else {
+				target->memory_model = Target::MemoryModel::Unexpanded;
+			}
+			target->media.tapes = media.tapes;
+
+			// TODO: how to run software once loaded? Might require a BASIC detokeniser.
+			if(target->is_ZX81) {
+				target->loading_command = "J\"\"\n";
+			} else {
+				target->loading_command = "W\n";
+			}
+
+		}
+	}
+	return destination;
+}

Analyser/Static/ZX8081/StaticAnalyser.hpp

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

Analyser/Static/ZX8081/Target.hpp

@@ -0,0 +1,36 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_ZX8081_Target_h
+#define Analyser_Static_ZX8081_Target_h
+
+#include "../StaticAnalyser.hpp"
+#include <string>
+
+namespace Analyser {
+namespace Static {
+namespace ZX8081 {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class MemoryModel {
+		Unexpanded,
+		SixteenKB,
+		SixtyFourKB
+	};
+
+	MemoryModel memory_model = MemoryModel::Unexpanded;
+	bool is_ZX81 = false;
+	bool ZX80_uses_ZX81_ROM = false;
+	std::string loading_command;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_ZX8081_Target_h */

BUILD.txt

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

ClockReceiver/ClockDeferrer.hpp

@@ -0,0 +1,81 @@
+//
+//  ClockDeferrer.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/08/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ClockDeferrer_h
+#define ClockDeferrer_h
+
+#include <vector>
+
+/*!
+	A ClockDeferrer 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.
+*/
+template <typename TimeUnit> class ClockDeferrer {
+	public:
+		/// Constructs a ClockDeferrer that will call target(period) in between deferred actions.
+		ClockDeferrer(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);
+				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;
+
+				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);
+				}
+			}
+		}
+
+	private:
+		std::function<void(TimeUnit)> target_;
+
+		// The list of deferred actions.
+		struct DeferredAction {
+			TimeUnit delay;
+			std::function<void(void)> action;
+
+			DeferredAction(TimeUnit delay, const std::function<void(void)> &action) : delay(delay), action(std::move(action)) {}
+		};
+		std::vector<DeferredAction> pending_actions_;
+};
+
+#endif /* ClockDeferrer_h */

ClockReceiver/ClockReceiver.hpp

@@ -3,7 +3,7 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 22/07/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
+//  Copyright 2017 Thomas Harte. All rights reserved.
 //
 
 #ifndef ClockReceiver_hpp
@@ -52,71 +52,79 @@
 */
 template <class T> class WrappedInt {
 	public:
-		inline WrappedInt(int l) : length_(l) {}
-		inline WrappedInt() : length_(0) {}
+		constexpr WrappedInt(int l) : length_(l) {}
+		constexpr WrappedInt() : length_(0) {}
 
-		inline T &operator =(const T &rhs) {
+		T &operator =(const T &rhs) {
 			length_ = rhs.length_;
 			return *this;
 		}
 
-		inline T &operator +=(const T &rhs) {
+		T &operator +=(const T &rhs) {
 			length_ += rhs.length_;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator -=(const T &rhs) {
+		T &operator -=(const T &rhs) {
 			length_ -= rhs.length_;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator ++() {
+		T &operator ++() {
 			++ length_;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator ++(int) {
+		T &operator ++(int) {
 			length_ ++;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator --() {
+		T &operator --() {
 			-- length_;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator --(int) {
+		T &operator --(int) {
 			length_ --;
 			return *static_cast<T *>(this);
 		}
 
-		inline T &operator %=(const T &rhs) {
+		T &operator %=(const T &rhs) {
 			length_ %= rhs.length_;
 			return *static_cast<T *>(this);
 		}
 
-		inline T operator +(const T &rhs) const			{	return T(length_ + rhs.length_);	}
-		inline T operator -(const T &rhs) const			{	return T(length_ - rhs.length_);	}
+		T &operator &=(const T &rhs) {
+			length_ &= rhs.length_;
+			return *static_cast<T *>(this);
+		}
 
-		inline T operator -() const						{	return T(- length_);				}
+		constexpr T operator +(const T &rhs) const			{	return T(length_ + rhs.length_);	}
+		constexpr T operator -(const T &rhs) const			{	return T(length_ - rhs.length_);	}
 
-		inline bool operator <(const T &rhs) const		{	return length_ < rhs.length_;		}
-		inline bool operator >(const T &rhs) const		{	return length_ > rhs.length_;		}
-		inline bool operator <=(const T &rhs) const		{	return length_ <= rhs.length_;		}
-		inline bool operator >=(const T &rhs) const		{	return length_ >= rhs.length_;		}
-		inline bool operator ==(const T &rhs) const		{	return length_ == rhs.length_;		}
-		inline bool operator !=(const T &rhs) const		{	return length_ != rhs.length_;		}
+		constexpr T operator %(const T &rhs) const			{	return T(length_ % rhs.length_);	}
+		constexpr T operator &(const T &rhs) const			{	return T(length_ & rhs.length_);	}
 
-		inline bool operator !() const					{	return !length_;					}
+		constexpr T operator -() const						{	return T(- length_);				}
+
+		constexpr bool operator <(const T &rhs) const		{	return length_ < rhs.length_;		}
+		constexpr bool operator >(const T &rhs) const		{	return length_ > rhs.length_;		}
+		constexpr bool operator <=(const T &rhs) const		{	return length_ <= rhs.length_;		}
+		constexpr bool operator >=(const T &rhs) const		{	return length_ >= rhs.length_;		}
+		constexpr bool operator ==(const T &rhs) const		{	return length_ == rhs.length_;		}
+		constexpr bool operator !=(const T &rhs) const		{	return length_ != rhs.length_;		}
+
+		constexpr bool operator !() const					{	return !length_;					}
 		// bool operator () is not supported because it offers an implicit cast to int, which is prone silently to permit misuse
 
-		inline int as_int() const { return length_; }
+		constexpr int as_int() const { return length_; }
 
 		/*!
-			Severs from @c this the effect of dividing by @c divisor — @c this will end up with
+			Severs from @c this the effect of dividing by @c divisor; @c this will end up with
 			the value of @c this modulo @c divisor and @c divided by @c divisor is returned.
 		*/
-		inline T divide(const T &divisor) {
+		T divide(const T &divisor) {
 			T result(length_ / divisor.length_);
 			length_ %= divisor.length_;
 			return result;
@@ -126,7 +134,7 @@ template <class T> class WrappedInt {
 			Flushes the value in @c this. The current value is returned, and the internal value
 			is reset to zero.
 		*/
-		inline T flush() {
+		T flush() {
 			T result(length_);
 			length_ = 0;
 			return result;
@@ -139,34 +147,52 @@ template <class T> class WrappedInt {
 		int length_;
 };
 
-/// Describes an integer number of whole cycles — pairs of clock signal transitions.
+/// Describes an integer number of whole cycles: pairs of clock signal transitions.
 class Cycles: public WrappedInt<Cycles> {
 	public:
-		inline Cycles(int l) : WrappedInt<Cycles>(l) {}
-		inline Cycles() : WrappedInt<Cycles>() {}
-		inline Cycles(const Cycles &cycles) : WrappedInt<Cycles>(cycles.length_) {}
+		constexpr Cycles(int l) : WrappedInt<Cycles>(l) {}
+		constexpr Cycles() : WrappedInt<Cycles>() {}
+		constexpr Cycles(const Cycles &cycles) : WrappedInt<Cycles>(cycles.length_) {}
 };
 
-/// Describes an integer number of half cycles — single clock signal transitions.
+/// Describes an integer number of half cycles: single clock signal transitions.
 class HalfCycles: public WrappedInt<HalfCycles> {
 	public:
-		inline HalfCycles(int l) : WrappedInt<HalfCycles>(l) {}
-		inline HalfCycles() : WrappedInt<HalfCycles>() {}
+		constexpr HalfCycles(int l) : WrappedInt<HalfCycles>(l) {}
+		constexpr HalfCycles() : WrappedInt<HalfCycles>() {}
 
-		inline HalfCycles(const Cycles cycles) : WrappedInt<HalfCycles>(cycles.as_int() << 1) {}
-		inline HalfCycles(const HalfCycles &half_cycles) : WrappedInt<HalfCycles>(half_cycles.length_) {}
+		constexpr HalfCycles(const Cycles cycles) : WrappedInt<HalfCycles>(cycles.as_int() * 2) {}
+		constexpr HalfCycles(const HalfCycles &half_cycles) : WrappedInt<HalfCycles>(half_cycles.length_) {}
 
 		/// @returns The number of whole cycles completely covered by this span of half cycles.
-		inline Cycles cycles() {
+		constexpr Cycles cycles() const {
 			return Cycles(length_ >> 1);
 		}
 
-		///Flushes the whole cycles in @c this, subtracting that many from the total stored here.
-		inline Cycles flush_cycles() {
+		/// Flushes the whole cycles in @c this, subtracting that many from the total stored here.
+		Cycles flush_cycles() {
 			Cycles result(length_ >> 1);
 			length_ &= 1;
 			return result;
 		}
+
+		/// Flushes the half cycles in @c this, returning the number stored and setting this total to zero.
+		HalfCycles flush() {
+			HalfCycles result(length_);
+			length_ = 0;
+			return result;
+		}
+
+		/*!
+			Severs from @c this the effect of dividing by @c divisor; @c this will end up with
+			the value of @c this modulo @c divisor and @c divided by @c divisor is returned.
+		*/
+		Cycles divide_cycles(const Cycles &divisor) {
+			HalfCycles half_divisor = HalfCycles(divisor);
+			Cycles result(length_ / half_divisor.length_);
+			length_ %= half_divisor.length_;
+			return result;
+		}
 };
 
 /*!
@@ -177,7 +203,6 @@ template <class T> class HalfClockReceiver: public T {
 	public:
 		using T::T;
 
-		using T::run_for;
 		inline void run_for(const HalfCycles half_cycles) {
 			half_cycles_ += half_cycles;
 			T::run_for(half_cycles_.flush_cycles());

ClockReceiver/ClockingHintSource.hpp

@@ -0,0 +1,88 @@
+//
+//  ClockingHintSource.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/08/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef ClockingHintSource_hpp
+#define ClockingHintSource_hpp
+
+namespace ClockingHint {
+
+enum class Preference {
+	/// The component doesn't currently require a clock signal.
+	None,
+	/// The component can be clocked only immediate prior to (explicit) accesses.
+	JustInTime,
+	/// The component require real-time clocking.
+	RealTime
+};
+
+class Source;
+
+struct Observer {
+	/// Called to inform an observer that the component @c component has changed its clocking requirements.
+	virtual void set_component_prefers_clocking(Source *component, Preference clocking) = 0;
+};
+
+/*!
+	An clocking hint source is any component that can provide hints as to the type of
+	clocking required for accurate emulation. A disk controller is an archetypal example.
+
+	Types of clocking are:
+
+		- none:
+			a component that acts and reacts to direct contact but does not have a state that autonomously evolves.
+			E.g. a ROM, RAM, or some kinds of disk controller when not in the process of performing a command.
+
+		- just-in-time:
+			a component that has an evolving state but can receive clock updates only immediately before a
+			direct contact. This is possibly the most common kind of component.
+
+		- real-time:
+			a component that needs to be clocked in 'real time' (i.e. in terms of the emulated machine). For example
+			so that it can announce an interrupt at the proper moment, because it is monitoring some aspect of
+			the machine rather than waiting to be called upon, or because there's some other non-obvious relationship
+			at play.
+
+	A clocking hint source can signal changes in preferred clocking to an observer.
+
+	This is intended to allow for performance improvements to machines with components that can be messaged selectively.
+	The observer callout is virtual so the intended use case is that a machine holds a component that might go through
+	periods of different clocking requirements.
+
+	Transitions should be sufficiently infrequent that a virtual call to announce them costs little enough that
+	the saved or deferred ::run_fors add up to a substantial amount.
+
+	The hint provided is just that: a hint. Owners may perform ::run_for at a greater frequency.
+*/
+class Source {
+	public:
+		/// Registers @c observer as the new clocking observer.
+		void set_clocking_hint_observer(Observer *observer) {
+			observer_ = observer;
+			update_clocking_observer();
+		}
+
+		/// @returns the current preferred clocking strategy.
+		virtual Preference preferred_clocking() = 0;
+
+	private:
+		Observer *observer_ = nullptr;
+
+	protected:
+		/*!
+			Provided for subclasses; call this whenever the clocking preference might have changed.
+			This will notify the observer if there is one.
+		*/
+		void update_clocking_observer() {
+			if(!observer_) return;
+			observer_->set_component_prefers_clocking(this, preferred_clocking());
+		}
+};
+
+}
+
+#endif /* ClockingHintSource_h */

ClockReceiver/ForceInline.hpp

@@ -0,0 +1,26 @@
+//
+//  ForceInline.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/08/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef ForceInline_hpp
+#define ForceInline_hpp
+
+#ifdef DEBUG
+
+#define forceinline
+
+#else
+
+#ifdef __GNUC__
+#define forceinline __attribute__((always_inline)) inline
+#elif _MSC_VER
+#define forceinline __forceinline
+#endif
+
+#endif
+
+#endif /* ForceInline_h */

ClockReceiver/TimeTypes.hpp

@@ -0,0 +1,18 @@
+//
+//  TimeTypes.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/03/2018.
+//  Copyright 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef TimeTypes_h
+#define TimeTypes_h
+
+namespace Time {
+
+typedef double Seconds;
+
+}
+
+#endif /* TimeTypes_h */

Components/1770/1770.cpp

@@ -3,64 +3,41 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 17/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "1770.hpp"
-#include "../../Storage/Disk/Encodings/MFM.hpp"
+
+#include "../../Storage/Disk/Encodings/MFM/Constants.hpp"
+#include "../../Outputs/Log.hpp"
 
 using namespace WD;
 
-WD1770::Status::Status() :
-		type(Status::One),
-		write_protect(false),
-		record_type(false),
-		spin_up(false),
-		record_not_found(false),
-		crc_error(false),
-		seek_error(false),
-		lost_data(false),
-		data_request(false),
-		interrupt_request(false),
-		busy(false) {}
-
 WD1770::WD1770(Personality p) :
-		Storage::Disk::Controller(8000000, 16, 300),
-		crc_generator_(0x1021, 0xffff),
-		interesting_event_mask_(Event::Command),
-		resume_point_(0),
-		delay_time_(0),
-		index_hole_count_target_(-1),
-		is_awaiting_marker_value_(false),
-		data_mode_(DataMode::Scanning),
-		delegate_(nullptr),
+		Storage::Disk::MFMController(8000000),
 		personality_(p),
-		head_is_loaded_(false) {
+		interesting_event_mask_(static_cast<int>(Event1770::Command)) {
 	set_is_double_density(false);
-	posit_event(Event::Command);
-}
-
-void WD1770::set_is_double_density(bool is_double_density) {
-	is_double_density_ = is_double_density;
-	Storage::Time bit_length;
-	bit_length.length = 1;
-	bit_length.clock_rate = is_double_density ? 500000 : 250000;
-	set_expected_bit_length(bit_length);
-
-	if(!is_double_density) is_awaiting_marker_value_ = false;
+	posit_event(static_cast<int>(Event1770::Command));
 }
 
 void WD1770::set_register(int address, uint8_t value) {
 	switch(address&3) {
 		case 0: {
 			if((value&0xf0) == 0xd0) {
-				printf("!!!TODO: force interrupt!!!\n");
-				update_status([] (Status &status) {
-					status.type = Status::One;
-				});
+				if(value == 0xd0) {
+					// Force interrupt **immediately**.
+					LOG("Force interrupt immediately");
+					posit_event(static_cast<int>(Event1770::ForceInterrupt));
+				} else {
+					ERROR("!!!TODO: force interrupt!!!");
+					update_status([] (Status &status) {
+						status.type = Status::One;
+					});
+				}
 			} else {
 				command_ = value;
-				posit_event(Event::Command);
+				posit_event(static_cast<int>(Event1770::Command));
 			}
 		}
 		break;
@@ -88,7 +65,7 @@ uint8_t WD1770::get_register(int address) {
 			switch(status_.type) {
 				case Status::One:
 					status |=
-						(get_is_track_zero() ? Flag::TrackZero : 0) |
+						(get_drive().get_is_track_zero() ? Flag::TrackZero : 0) |
 						(status_.seek_error ? Flag::SeekError : 0);
 						// TODO: index hole
 				break;
@@ -104,11 +81,11 @@ uint8_t WD1770::get_register(int address) {
 			}
 
 			if(!has_motor_on_line()) {
-				status |= get_drive_is_ready() ? 0 : Flag::NotReady;
+				status |= get_drive().get_is_ready() ? 0 : Flag::NotReady;
 				if(status_.type == Status::One)
 					status |= (head_is_loaded_ ? Flag::HeadLoaded : 0);
 			} else {
-				status |= (get_motor_on() ? Flag::MotorOn : 0);
+				status |= (get_drive().get_motor_on() ? Flag::MotorOn : 0);
 				if(status_.type == Status::One)
 					status |= (status_.spin_up ? Flag::SpinUp : 0);
 			}
@@ -128,151 +105,27 @@ void WD1770::run_for(const Cycles cycles) {
 	Storage::Disk::Controller::run_for(cycles);
 
 	if(delay_time_) {
-		unsigned int number_of_cycles = (unsigned int)cycles.as_int();
+		unsigned int number_of_cycles = static_cast<unsigned int>(cycles.as_int());
 		if(delay_time_ <= number_of_cycles) {
 			delay_time_ = 0;
-			posit_event(Event::Timer);
+			posit_event(static_cast<int>(Event1770::Timer));
 		} else {
 			delay_time_ -= number_of_cycles;
 		}
 	}
 }
 
-void WD1770::process_input_bit(int value, unsigned int cycles_since_index_hole) {
-	if(data_mode_ == DataMode::Writing) return;
-
-	shift_register_ = (shift_register_ << 1) | value;
-	bits_since_token_++;
-
-	if(data_mode_ == DataMode::Scanning) {
-		Token::Type token_type = Token::Byte;
-		if(!is_double_density_) {
-			switch(shift_register_ & 0xffff) {
-				case Storage::Encodings::MFM::FMIndexAddressMark:
-					token_type = Token::Index;
-					crc_generator_.reset();
-					crc_generator_.add(latest_token_.byte_value = Storage::Encodings::MFM::IndexAddressByte);
-				break;
-				case Storage::Encodings::MFM::FMIDAddressMark:
-					token_type = Token::ID;
-					crc_generator_.reset();
-					crc_generator_.add(latest_token_.byte_value = Storage::Encodings::MFM::IDAddressByte);
-				break;
-				case Storage::Encodings::MFM::FMDataAddressMark:
-					token_type = Token::Data;
-					crc_generator_.reset();
-					crc_generator_.add(latest_token_.byte_value = Storage::Encodings::MFM::DataAddressByte);
-				break;
-				case Storage::Encodings::MFM::FMDeletedDataAddressMark:
-					token_type = Token::DeletedData;
-					crc_generator_.reset();
-					crc_generator_.add(latest_token_.byte_value = Storage::Encodings::MFM::DeletedDataAddressByte);
-				break;
-				default:
-				break;
-			}
-		} else {
-			switch(shift_register_ & 0xffff) {
-				case Storage::Encodings::MFM::MFMIndexSync:
-					bits_since_token_ = 0;
-					is_awaiting_marker_value_ = true;
-
-					token_type = Token::Sync;
-					latest_token_.byte_value = Storage::Encodings::MFM::MFMIndexSyncByteValue;
-				break;
-				case Storage::Encodings::MFM::MFMSync:
-					bits_since_token_ = 0;
-					is_awaiting_marker_value_ = true;
-					crc_generator_.set_value(Storage::Encodings::MFM::MFMPostSyncCRCValue);
-
-					token_type = Token::Sync;
-					latest_token_.byte_value = Storage::Encodings::MFM::MFMSyncByteValue;
-				break;
-				default:
-				break;
-			}
-		}
-
-		if(token_type != Token::Byte) {
-			latest_token_.type = token_type;
-			bits_since_token_ = 0;
-			posit_event(Event::Token);
-			return;
-		}
-	}
-
-	if(bits_since_token_ == 16) {
-		latest_token_.type = Token::Byte;
-		latest_token_.byte_value = (uint8_t)(
-			((shift_register_ & 0x0001) >> 0) |
-			((shift_register_ & 0x0004) >> 1) |
-			((shift_register_ & 0x0010) >> 2) |
-			((shift_register_ & 0x0040) >> 3) |
-			((shift_register_ & 0x0100) >> 4) |
-			((shift_register_ & 0x0400) >> 5) |
-			((shift_register_ & 0x1000) >> 6) |
-			((shift_register_ & 0x4000) >> 7));
-		bits_since_token_ = 0;
-
-		if(is_awaiting_marker_value_ && is_double_density_) {
-			is_awaiting_marker_value_ = false;
-			switch(latest_token_.byte_value) {
-				case Storage::Encodings::MFM::IndexAddressByte:
-					latest_token_.type = Token::Index;
-				break;
-				case Storage::Encodings::MFM::IDAddressByte:
-					latest_token_.type = Token::ID;
-				break;
-				case Storage::Encodings::MFM::DataAddressByte:
-					latest_token_.type = Token::Data;
-				break;
-				case Storage::Encodings::MFM::DeletedDataAddressByte:
-					latest_token_.type = Token::DeletedData;
-				break;
-				default: break;
-			}
-		}
-
-		crc_generator_.add(latest_token_.byte_value);
-		posit_event(Event::Token);
-		return;
-	}
-}
-
-void WD1770::process_index_hole() {
-	index_hole_count_++;
-	posit_event(Event::IndexHole);
-	if(index_hole_count_target_ == index_hole_count_) {
-		posit_event(Event::IndexHoleTarget);
-		index_hole_count_target_ = -1;
-	}
-
-	// motor power-down
-	if(index_hole_count_ == 9 && !status_.busy && has_motor_on_line()) {
-		set_motor_on(false);
-	}
-
-	// head unload
-	if(index_hole_count_ == 15 && !status_.busy && has_head_load_line()) {
-		set_head_load_request(false);
-	}
-}
-
-void WD1770::process_write_completed() {
-	posit_event(Event::DataWritten);
-}
-
-#define WAIT_FOR_EVENT(mask)	resume_point_ = __LINE__; interesting_event_mask_ = mask; return; case __LINE__:
-#define WAIT_FOR_TIME(ms)		resume_point_ = __LINE__; interesting_event_mask_ = Event::Timer; delay_time_ = ms * 8000; if(delay_time_) return; case __LINE__:
-#define WAIT_FOR_BYTES(count)	resume_point_ = __LINE__; interesting_event_mask_ = Event::Token; distance_into_section_ = 0; return; case __LINE__: if(latest_token_.type == Token::Byte) distance_into_section_++; if(distance_into_section_ < count) { interesting_event_mask_ = Event::Token; return; }
+#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__; delay_time_ = ms * 8000; WAIT_FOR_EVENT(Event1770::Timer);
+#define WAIT_FOR_BYTES(count)	resume_point_ = __LINE__; distance_into_section_ = 0; WAIT_FOR_EVENT(Event::Token); if(get_latest_token().type == Token::Byte) distance_into_section_++; if(distance_into_section_ < count) { interesting_event_mask_ = static_cast<int>(Event::Token); return; }
 #define BEGIN_SECTION()	switch(resume_point_) { default:
-#define END_SECTION()	0; }
+#define END_SECTION()	(void)0; }
 
 #define READ_ID()	\
-		if(new_event_type == Event::Token) {	\
-			if(!distance_into_section_ && latest_token_.type == Token::ID) {data_mode_ = DataMode::Reading; distance_into_section_++; }	\
-			else if(distance_into_section_ && distance_into_section_ < 7 && latest_token_.type == Token::Byte) {	\
-				header_[distance_into_section_ - 1] = latest_token_.byte_value;	\
+		if(new_event_type == static_cast<int>(Event::Token)) {	\
+			if(!distance_into_section_ && get_latest_token().type == Token::ID) {set_data_mode(DataMode::Reading); distance_into_section_++; }	\
+			else if(distance_into_section_ && distance_into_section_ < 7 && get_latest_token().type == Token::Byte) {	\
+				header_[distance_into_section_ - 1] = get_latest_token().byte_value;	\
 				distance_into_section_++;	\
 			}	\
 		}
@@ -285,7 +138,7 @@ void WD1770::process_write_completed() {
 		set_motor_on(true);	\
 		index_hole_count_ = 0;	\
 		index_hole_count_target_ = 6;	\
-		WAIT_FOR_EVENT(Event::IndexHoleTarget);	\
+		WAIT_FOR_EVENT(Event1770::IndexHoleTarget);	\
 		status_.spin_up = true;
 
 //     +--------+----------+-------------------------+
@@ -305,17 +158,45 @@ void WD1770::process_write_completed() {
 //     !	 4  ! Forc int !  1  1	0  1 i3 i2 i1 i0 !
 //     +--------+----------+-------------------------+
 
-void WD1770::posit_event(Event new_event_type) {
-	if(!(interesting_event_mask_ & (int)new_event_type)) return;
-	interesting_event_mask_ &= ~new_event_type;
+void WD1770::posit_event(int new_event_type) {
+	if(new_event_type == static_cast<int>(Event::IndexHole)) {
+		index_hole_count_++;
+		if(index_hole_count_target_ == index_hole_count_) {
+			posit_event(static_cast<int>(Event1770::IndexHoleTarget));
+			index_hole_count_target_ = -1;
+		}
+
+		// motor power-down
+		if(index_hole_count_ == 9 && !status_.busy && has_motor_on_line()) {
+			set_motor_on(false);
+		}
+
+		// head unload
+		if(index_hole_count_ == 15 && !status_.busy && has_head_load_line()) {
+			set_head_load_request(false);
+		}
+	}
+
+	if(new_event_type == static_cast<int>(Event1770::ForceInterrupt)) {
+		interesting_event_mask_ = 0;
+		resume_point_ = 0;
+		update_status([] (Status &status) {
+			status.type = Status::One;
+			status.data_request = false;
+		});
+	} else {
+		if(!(interesting_event_mask_ & static_cast<int>(new_event_type))) return;
+		interesting_event_mask_ &= ~new_event_type;
+	}
 
 	Status new_status;
 	BEGIN_SECTION()
 
 	// Wait for a new command, branch to the appropriate handler.
+	case 0:
 	wait_for_command:
-		printf("Idle...\n");
-		data_mode_ = DataMode::Scanning;
+		LOG("Idle...");
+		set_data_mode(DataMode::Scanning);
 		index_hole_count_ = 0;
 
 		update_status([] (Status &status) {
@@ -323,14 +204,14 @@ void WD1770::posit_event(Event new_event_type) {
 			status.interrupt_request = true;
 		});
 
-		WAIT_FOR_EVENT(Event::Command);
+		WAIT_FOR_EVENT(Event1770::Command);
 
 		update_status([] (Status &status) {
 			status.busy = true;
 			status.interrupt_request = false;
 		});
 
-		printf("Starting %02x\n", command_);
+		LOG("Starting " << std::hex << command_ << std::endl);
 
 		if(!(command_ & 0x80)) goto begin_type_1;
 		if(!(command_ & 0x40)) goto begin_type_2;
@@ -372,11 +253,11 @@ void WD1770::posit_event(Event new_event_type) {
 		}
 		set_head_load_request(true);
 		if(head_is_loaded_) goto test_type1_type;
-		WAIT_FOR_EVENT(Event::HeadLoad);
+		WAIT_FOR_EVENT(Event1770::HeadLoad);
 		goto test_type1_type;
 
 	begin_type1_spin_up:
-		if((command_&0x08) || get_motor_on()) goto test_type1_type;
+		if((command_&0x08) || get_drive().get_motor_on()) goto test_type1_type;
 		SPIN_UP();
 
 	test_type1_type:
@@ -399,11 +280,11 @@ void WD1770::posit_event(Event new_event_type) {
 		if(step_direction_) track_++; else track_--;
 
 	perform_step:
-		if(!step_direction_ && get_is_track_zero()) {
+		if(!step_direction_ && get_drive().get_is_track_zero()) {
 			track_ = 0;
 			goto verify;
 		}
-		step(step_direction_ ? 1 : -1);
+		get_drive().step(Storage::Disk::HeadPosition(step_direction_ ? 1 : -1));
 		unsigned int time_to_wait;
 		switch(command_ & 3) {
 			default:
@@ -429,7 +310,7 @@ void WD1770::posit_event(Event new_event_type) {
 		distance_into_section_ = 0;
 
 	verify_read_data:
-		WAIT_FOR_EVENT(Event::IndexHole | Event::Token);
+		WAIT_FOR_EVENT(static_cast<int>(Event::IndexHole) | static_cast<int>(Event::Token));
 		READ_ID();
 
 		if(index_hole_count_ == 6) {
@@ -439,8 +320,8 @@ void WD1770::posit_event(Event new_event_type) {
 			goto wait_for_command;
 		}
 		if(distance_into_section_ == 7) {
-			data_mode_ = DataMode::Scanning;
-			if(crc_generator_.get_value()) {
+			set_data_mode(DataMode::Scanning);
+			if(get_crc_generator().get_value()) {
 				update_status([] (Status &status) {
 					status.crc_error = true;
 				});
@@ -448,7 +329,7 @@ void WD1770::posit_event(Event new_event_type) {
 			}
 
 			if(header_[0] == track_) {
-				printf("Reached track %d\n", track_);
+				LOG("Reached track " << std::dec << track_);
 				update_status([] (Status &status) {
 					status.crc_error = false;
 				});
@@ -491,11 +372,11 @@ void WD1770::posit_event(Event new_event_type) {
 	begin_type2_load_head:
 		set_head_load_request(true);
 		if(head_is_loaded_) goto test_type2_delay;
-		WAIT_FOR_EVENT(Event::HeadLoad);
+		WAIT_FOR_EVENT(Event1770::HeadLoad);
 		goto test_type2_delay;
 
 	begin_type2_spin_up:
-		if(get_motor_on()) goto test_type2_delay;
+		if(get_drive().get_motor_on()) goto test_type2_delay;
 		// Perform spin up.
 		SPIN_UP();
 
@@ -505,7 +386,7 @@ void WD1770::posit_event(Event new_event_type) {
 		WAIT_FOR_TIME(30);
 
 	test_type2_write_protection:
-		if(command_&0x20 && get_drive_is_read_only()) {
+		if(command_&0x20 && get_drive().get_is_read_only()) {
 			update_status([] (Status &status) {
 				status.write_protect = true;
 			});
@@ -513,24 +394,24 @@ void WD1770::posit_event(Event new_event_type) {
 		}
 
 	type2_get_header:
-		WAIT_FOR_EVENT(Event::IndexHole | Event::Token);
+		WAIT_FOR_EVENT(static_cast<int>(Event::IndexHole) | static_cast<int>(Event::Token));
 		READ_ID();
 
 		if(index_hole_count_ == 5) {
-			printf("Failed to find sector %d\n", sector_);
+			LOG("Failed to find sector " << std::dec << sector_);
 			update_status([] (Status &status) {
 				status.record_not_found = true;
 			});
 			goto wait_for_command;
 		}
 		if(distance_into_section_ == 7) {
-			printf("Considering %d/%d\n", header_[0], header_[2]);
-			data_mode_ = DataMode::Scanning;
+			LOG("Considering " << std::dec << header_[0] << "/" << header_[2]);
+			set_data_mode(DataMode::Scanning);
 			if(		header_[0] == track_ && header_[2] == sector_ &&
 					(has_motor_on_line() || !(command_&0x02) || ((command_&0x08) >> 3) == header_[1])) {
-				printf("Found %d/%d\n", header_[0], header_[2]);
-				if(crc_generator_.get_value()) {
-					printf("CRC error; back to searching\n");
+				LOG("Found " << std::dec << header_[0] << "/" << header_[2]);
+				if(get_crc_generator().get_value()) {
+					LOG("CRC error; back to searching");
 					update_status([] (Status &status) {
 						status.crc_error = true;
 					});
@@ -554,20 +435,20 @@ void WD1770::posit_event(Event new_event_type) {
 	type2_read_data:
 		WAIT_FOR_EVENT(Event::Token);
 		// TODO: timeout
-		if(latest_token_.type == Token::Data || latest_token_.type == Token::DeletedData) {
+		if(get_latest_token().type == Token::Data || get_latest_token().type == Token::DeletedData) {
 			update_status([this] (Status &status) {
-				status.record_type = (latest_token_.type == Token::DeletedData);
+				status.record_type = (get_latest_token().type == Token::DeletedData);
 			});
 			distance_into_section_ = 0;
-			data_mode_ = DataMode::Reading;
+			set_data_mode(DataMode::Reading);
 			goto type2_read_byte;
 		}
 		goto type2_read_data;
 
 	type2_read_byte:
 		WAIT_FOR_EVENT(Event::Token);
-		if(latest_token_.type != Token::Byte) goto type2_read_byte;
-		data_ = latest_token_.byte_value;
+		if(get_latest_token().type != Token::Byte) goto type2_read_byte;
+		data_ = get_latest_token().byte_value;
 		update_status([] (Status &status) {
 			status.lost_data |= status.data_request;
 			status.data_request = true;
@@ -581,12 +462,12 @@ void WD1770::posit_event(Event new_event_type) {
 
 	type2_check_crc:
 		WAIT_FOR_EVENT(Event::Token);
-		if(latest_token_.type != Token::Byte) goto type2_read_byte;
-		header_[distance_into_section_] = latest_token_.byte_value;
+		if(get_latest_token().type != Token::Byte) goto type2_read_byte;
+		header_[distance_into_section_] = get_latest_token().byte_value;
 		distance_into_section_++;
 		if(distance_into_section_ == 2) {
-			if(crc_generator_.get_value()) {
-				printf("CRC error; terminating\n");
+			if(get_crc_generator().get_value()) {
+				LOG("CRC error; terminating");
 				update_status([this] (Status &status) {
 					status.crc_error = true;
 				});
@@ -597,7 +478,7 @@ void WD1770::posit_event(Event new_event_type) {
 				sector_++;
 				goto test_type2_write_protection;
 			}
-			printf("Read sector %d\n", sector_);
+			LOG("Finished reading sector " << std::dec << sector_);
 			goto wait_for_command;
 		}
 		goto type2_check_crc;
@@ -616,24 +497,24 @@ void WD1770::posit_event(Event new_event_type) {
 			goto wait_for_command;
 		}
 		WAIT_FOR_BYTES(1);
-		if(is_double_density_) {
+		if(get_is_double_density()) {
 			WAIT_FOR_BYTES(11);
 		}
 
-		data_mode_ = DataMode::Writing;
-		begin_writing();
-		for(int c = 0; c < (is_double_density_ ? 12 : 6); c++) {
+		set_data_mode(DataMode::Writing);
+		begin_writing(false);
+		for(int c = 0; c < (get_is_double_density() ? 12 : 6); c++) {
 			write_byte(0);
 		}
 		WAIT_FOR_EVENT(Event::DataWritten);
 
-		if(is_double_density_) {
-			crc_generator_.set_value(Storage::Encodings::MFM::MFMPostSyncCRCValue);
+		if(get_is_double_density()) {
+			get_crc_generator().set_value(Storage::Encodings::MFM::MFMPostSyncCRCValue);
 			for(int c = 0; c < 3; c++) write_raw_short(Storage::Encodings::MFM::MFMSync);
 			write_byte((command_&0x01) ? Storage::Encodings::MFM::DeletedDataAddressByte : Storage::Encodings::MFM::DataAddressByte);
 		} else {
-			crc_generator_.reset();
-			crc_generator_.add((command_&0x01) ? Storage::Encodings::MFM::DeletedDataAddressByte : Storage::Encodings::MFM::DataAddressByte);
+			get_crc_generator().reset();
+			get_crc_generator().add((command_&0x01) ? Storage::Encodings::MFM::DeletedDataAddressByte : Storage::Encodings::MFM::DataAddressByte);
 			write_raw_short((command_&0x01) ? Storage::Encodings::MFM::FMDeletedDataAddressMark : Storage::Encodings::MFM::FMDataAddressMark);
 		}
 
@@ -643,7 +524,7 @@ void WD1770::posit_event(Event new_event_type) {
 	type2_write_loop:
 		/*
 			This deviates from the data sheet slightly since that would prima facie request one more byte
-			of data than is actually written — the last time around the loop it has transferred from the
+			of data than is actually written; the last time around the loop it has transferred from the
 			data register to the data shift register, set data request, written the byte, checked that data
 			request has been satified, then finally considers whether all bytes are done. Based on both
 			natural expectations and the way that emulated machines responded, I believe that to be a
@@ -669,11 +550,8 @@ void WD1770::posit_event(Event new_event_type) {
 
 		goto type2_write_loop;
 
-	type2_write_crc: {
-			uint16_t crc = crc_generator_.get_value();
-			write_byte(crc >> 8);
-			write_byte(crc & 0xff);
-		}
+	type2_write_crc:
+		write_crc();
 		write_byte(0xff);
 		WAIT_FOR_EVENT(Event::DataWritten);
 		end_writing();
@@ -682,7 +560,7 @@ void WD1770::posit_event(Event new_event_type) {
 			sector_++;
 			goto test_type2_write_protection;
 		}
-		printf("Wrote sector %d\n", sector_);
+		LOG("Wrote sector " << std::dec << sector_);
 		goto wait_for_command;
 
 
@@ -712,11 +590,11 @@ void WD1770::posit_event(Event new_event_type) {
 	begin_type3_load_head:
 		set_head_load_request(true);
 		if(head_is_loaded_) goto type3_test_delay;
-		WAIT_FOR_EVENT(Event::HeadLoad);
+		WAIT_FOR_EVENT(Event1770::HeadLoad);
 		goto type3_test_delay;
 
 	begin_type3_spin_up:
-		if((command_&0x08) || get_motor_on()) goto type3_test_delay;
+		if((command_&0x08) || get_drive().get_motor_on()) goto type3_test_delay;
 		SPIN_UP();
 
 	type3_test_delay:
@@ -733,17 +611,17 @@ void WD1770::posit_event(Event new_event_type) {
 		distance_into_section_ = 0;
 
 	read_address_get_header:
-		WAIT_FOR_EVENT(Event::IndexHole | Event::Token);
-		if(new_event_type == Event::Token) {
-			if(!distance_into_section_ && latest_token_.type == Token::ID) {data_mode_ = DataMode::Reading; distance_into_section_++; }
-			else if(distance_into_section_ && distance_into_section_ < 7 && latest_token_.type == Token::Byte) {
+		WAIT_FOR_EVENT(static_cast<int>(Event::IndexHole) | static_cast<int>(Event::Token));
+		if(new_event_type == static_cast<int>(Event::Token)) {
+			if(!distance_into_section_ && get_latest_token().type == Token::ID) {set_data_mode(DataMode::Reading); distance_into_section_++; }
+			else if(distance_into_section_ && distance_into_section_ < 7 && get_latest_token().type == Token::Byte) {
 				if(status_.data_request) {
 					update_status([] (Status &status) {
 						status.lost_data = true;
 					});
 					goto wait_for_command;
 				}
-				header_[distance_into_section_ - 1] = data_ = latest_token_.byte_value;
+				header_[distance_into_section_ - 1] = data_ = get_latest_token().byte_value;
 				track_ = header_[0];
 				update_status([] (Status &status) {
 					status.data_request = true;
@@ -751,7 +629,7 @@ void WD1770::posit_event(Event new_event_type) {
 				distance_into_section_++;
 
 				if(distance_into_section_ == 7) {
-					if(crc_generator_.get_value()) {
+					if(get_crc_generator().get_value()) {
 						update_status([] (Status &status) {
 							status.crc_error = true;
 						});
@@ -774,7 +652,7 @@ void WD1770::posit_event(Event new_event_type) {
 		index_hole_count_ = 0;
 
 	read_track_read_byte:
-		WAIT_FOR_EVENT(Event::Token | Event::IndexHole);
+		WAIT_FOR_EVENT(static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole));
 		if(index_hole_count_) {
 			goto wait_for_command;
 		}
@@ -784,7 +662,7 @@ void WD1770::posit_event(Event new_event_type) {
 			});
 			goto wait_for_command;
 		}
-		data_ = latest_token_.byte_value;
+		data_ = get_latest_token().byte_value;
 		update_status([] (Status &status) {
 			status.data_request = true;
 		});
@@ -796,8 +674,7 @@ void WD1770::posit_event(Event new_event_type) {
 			status.lost_data = false;
 		});
 
-	write_track_test_write_protect:
-		if(get_drive_is_read_only()) {
+		if(get_drive().get_is_read_only()) {
 			update_status([] (Status &status) {
 				status.write_protect = true;
 			});
@@ -815,25 +692,23 @@ void WD1770::posit_event(Event new_event_type) {
 			goto wait_for_command;
 		}
 
-		WAIT_FOR_EVENT(Event::IndexHoleTarget);
-		begin_writing();
+		WAIT_FOR_EVENT(Event1770::IndexHoleTarget);
+		begin_writing(true);
 		index_hole_count_ = 0;
 
 	write_track_write_loop:
-		if(is_double_density_) {
+		if(get_is_double_density()) {
 			switch(data_) {
 				case 0xf5:
 					write_raw_short(Storage::Encodings::MFM::MFMSync);
-					crc_generator_.set_value(Storage::Encodings::MFM::MFMPostSyncCRCValue);
+					get_crc_generator().set_value(Storage::Encodings::MFM::MFMPostSyncCRCValue);
 				break;
 				case 0xf6:
 					write_raw_short(Storage::Encodings::MFM::MFMIndexSync);
 				break;
-				case 0xff: {
-					uint16_t crc = crc_generator_.get_value();
-					write_byte(crc >> 8);
-					write_byte(crc & 0xff);
-				} break;
+				case 0xff:
+					write_crc();
+				break;
 				default:
 					write_byte(data_);
 				break;
@@ -844,7 +719,7 @@ void WD1770::posit_event(Event new_event_type) {
 				case 0xfd: case 0xfe:
 					// clock is 0xc7 = 1010 0000 0010 1010 = 0xa022
 					write_raw_short(
-						(uint16_t)(
+						static_cast<uint16_t>(
 							0xa022 |
 							((data_ & 0x80) << 7) |
 							((data_ & 0x40) << 6) |
@@ -856,17 +731,15 @@ void WD1770::posit_event(Event new_event_type) {
 							(data_ & 0x01)
 						)
 					);
-					crc_generator_.reset();
-					crc_generator_.add(data_);
+					get_crc_generator().reset();
+					get_crc_generator().add(data_);
 				break;
 				case 0xfc:
 					write_raw_short(Storage::Encodings::MFM::FMIndexAddressMark);
 				break;
-				case 0xf7: {
-					uint16_t crc = crc_generator_.get_value();
-					write_byte(crc >> 8);
-					write_byte(crc & 0xff);
-				} break;
+				case 0xf7:
+					write_crc();
+				break;
 				default:
 					write_byte(data_);
 				break;
@@ -907,30 +780,9 @@ void WD1770::update_status(std::function<void(Status &)> updater) {
 }
 
 void WD1770::set_head_load_request(bool head_load) {}
+void WD1770::set_motor_on(bool motor_on) {}
 
 void WD1770::set_head_loaded(bool head_loaded) {
 	head_is_loaded_ = head_loaded;
-	if(head_loaded) posit_event(Event::HeadLoad);
-}
-
-void WD1770::write_bit(int bit) {
-	if(is_double_density_) {
-		Controller::write_bit(!bit && !last_bit_);
-		Controller::write_bit(!!bit);
-		last_bit_ = bit;
-	} else {
-		Controller::write_bit(true);
-		Controller::write_bit(!!bit);
-	}
-}
-
-void WD1770::write_byte(uint8_t byte) {
-	for(int c = 0; c < 8; c++) write_bit((byte << c)&0x80);
-	crc_generator_.add(byte);
-}
-
-void WD1770::write_raw_short(uint16_t value) {
-	for(int c = 0; c < 16; c++) {
-		Controller::write_bit(!!((value << c)&0x8000));
-	}
+	if(head_loaded) posit_event(static_cast<int>(Event1770::HeadLoad));
 }

Components/1770/1770.hpp

@@ -3,14 +3,13 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 17/09/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef _770_hpp
 #define _770_hpp
 
-#include "../../Storage/Disk/DiskController.hpp"
-#include "../../NumberTheory/CRC.hpp"
+#include "../../Storage/Disk/Controller/MFMDiskController.hpp"
 
 namespace WD {
 
@@ -18,7 +17,7 @@ namespace WD {
 	Provides an emulation of various Western Digital drive controllers, including the
 	WD1770, WD1772, FDC1773 and FDC1793.
 */
-class WD1770: public Storage::Disk::Controller {
+class WD1770: public Storage::Disk::MFMController {
 	public:
 		enum Personality {
 			P1770,	// implies automatic motor-on management, with Type 2 commands offering a spin-up disable
@@ -34,7 +33,7 @@ class WD1770: public Storage::Disk::Controller {
 		WD1770(Personality p);
 
 		/// Sets the value of the double-density input; when @c is_double_density is @c true, reads and writes double-density format data.
-		void set_is_double_density(bool is_double_density);
+		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);
@@ -44,7 +43,6 @@ class WD1770: public Storage::Disk::Controller {
 
 		/// Runs the controller for @c number_of_cycles cycles.
 		void run_for(const Cycles cycles);
-		using Storage::Disk::Controller::run_for;
 
 		enum Flag: uint8_t {
 			NotReady		= 0x80,
@@ -77,6 +75,7 @@ class WD1770: public Storage::Disk::Controller {
 
 	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);
 
 	private:
@@ -85,20 +84,19 @@ class WD1770: public Storage::Disk::Controller {
 		inline bool has_head_load_line() { return (personality_ == P1793 ); }
 
 		struct Status {
-			Status();
-			bool write_protect;
-			bool record_type;
-			bool spin_up;
-			bool record_not_found;
-			bool crc_error;
-			bool seek_error;
-			bool lost_data;
-			bool data_request;
-			bool interrupt_request;
-			bool busy;
+			bool write_protect = false;
+			bool record_type = false;
+			bool spin_up = false;
+			bool record_not_found = false;
+			bool crc_error = false;
+			bool seek_error = false;
+			bool lost_data = false;
+			bool data_request = false;
+			bool interrupt_request = false;
+			bool busy = false;
 			enum {
 				One, Two, Three
-			} type;
+			} type = One;
 		} status_;
 		uint8_t track_;
 		uint8_t sector_;
@@ -106,67 +104,33 @@ class WD1770: public Storage::Disk::Controller {
 		uint8_t command_;
 
 		int index_hole_count_;
-		int index_hole_count_target_;
-		int bits_since_token_;
+		int index_hole_count_target_ = -1;
 		int distance_into_section_;
-		bool is_awaiting_marker_value_;
 
 		int step_direction_;
 		void update_status(std::function<void(Status &)> updater);
 
-		// Tokeniser
-		enum DataMode {
-			Scanning,
-			Reading,
-			Writing
-		} data_mode_;
-		bool is_double_density_;
-		int shift_register_;
-		struct Token {
-			enum Type {
-				Index, ID, Data, DeletedData, Sync, Byte
-			} type;
-			uint8_t byte_value;
-		} latest_token_;
-
 		// Events
-		enum Event: int {
-			Command			= (1 << 0),	// Indicates receipt of a new command.
-			Token			= (1 << 1),	// Indicates recognition of a new token in the flux stream. Interrogate latest_token_ for details.
-			IndexHole		= (1 << 2),	// Indicates the passing of a physical index hole.
-			HeadLoad		= (1 << 3),	// Indicates the head has been loaded (1973 only).
-			DataWritten		= (1 << 4),	// Indicates that all queued bits have been written
-
+		enum Event1770: int {
+			Command			= (1 << 3),	// Indicates receipt of a new command.
+			HeadLoad		= (1 << 4),	// Indicates the head has been loaded (1973 only).
 			Timer			= (1 << 5),	// Indicates that the delay_time_-powered timer has timed out.
-			IndexHoleTarget	= (1 << 6)	// Indicates that index_hole_count_ has reached index_hole_count_target_.
+			IndexHoleTarget	= (1 << 6),	// Indicates that index_hole_count_ has reached index_hole_count_target_.
+			ForceInterrupt	= (1 << 7)	// Indicates a forced interrupt.
 		};
-		void posit_event(Event type);
+		void posit_event(int type);
 		int interesting_event_mask_;
-		int resume_point_;
-		unsigned int delay_time_;
-
-		// Output
-		int last_bit_;
-		void write_bit(int bit);
-		void write_byte(uint8_t byte);
-		void write_raw_short(uint16_t value);
+		int resume_point_ = 0;
+		unsigned int delay_time_ = 0;
 
 		// ID buffer
 		uint8_t header_[6];
 
-		// CRC generator
-		NumberTheory::CRC16 crc_generator_;
-
 		// 1793 head-loading logic
-		bool head_is_loaded_;
+		bool head_is_loaded_ = false;
 
 		// delegate
-		Delegate *delegate_;
-
-		// Storage::Disk::Controller
-		virtual void process_input_bit(int value, unsigned int cycles_since_index_hole);
-		virtual void process_index_hole();
-		virtual void process_write_completed();
+		Delegate *delegate_ = nullptr;
 };
 
 }

Components/6522/6522.hpp

@@ -3,7 +3,7 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 06/06/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef _522_hpp
@@ -13,9 +13,83 @@
 #include <typeinfo>
 #include <cstdio>
 
+#include "Implementation/6522Storage.hpp"
+
 #include "../../ClockReceiver/ClockReceiver.hpp"
 
 namespace MOS {
+namespace MOS6522 {
+
+enum Port {
+	A = 0,
+	B = 1
+};
+
+enum Line {
+	One = 0,
+	Two = 1
+};
+
+/*!
+	Provides the mechanism for just-int-time communication from a 6522; the normal use case is to compose a
+	6522 and a subclass of PortHandler in order to reproduce a 6522 and its original bus wiring.
+*/
+class PortHandler {
+	public:
+		/// Requests the current input value of @c port from the port handler.
+		uint8_t get_port_input(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)	{}
+
+		/// 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)			{}
+
+		/// Sets the current logical value of the interrupt line.
+		void set_interrupt_status(bool status)									{}
+};
+
+/*!
+	Provided as an optional alternative base to @c PortHandler for port handlers; via the delegate pattern adds
+	a virtual level of indirection for receiving changes to the interrupt line.
+*/
+class IRQDelegatePortHandler: public PortHandler {
+	public:
+		class Delegate {
+			public:
+				/// Indicates that the interrupt status has changed for the IRQDelegatePortHandler provided.
+				virtual void mos6522_did_change_interrupt_status(void *irq_delegate) = 0;
+		};
+
+		/// Sets the delegate that will receive notification of changes in the interrupt line.
+		void set_interrupt_delegate(Delegate *delegate);
+
+		/// Overrides PortHandler::set_interrupt_status, notifying the delegate if one is set.
+		void set_interrupt_status(bool new_status);
+
+	private:
+		Delegate *delegate_ = nullptr;
+};
+
+class MOS6522Base: public MOS6522Storage {
+	public:
+		/// Sets the input value of line @c line on port @c port.
+		void set_control_line_input(Port port, Line line, bool value);
+
+		/// Runs for a specified number of half cycles.
+		void run_for(const HalfCycles half_cycles);
+
+		/// Runs for a specified number of cycles.
+		void run_for(const Cycles cycles);
+
+		/// @returns @c true if the IRQ line is currently active; @c false otherwise.
+		bool get_interrupt_line();
+
+	private:
+		inline void do_phase1();
+		inline void do_phase2();
+		virtual void reevaluate_interrupts() = 0;
+};
 
 /*!
 	Implements a template for emulation of the MOS 6522 Versatile Interface Adaptor ('VIA').
@@ -28,353 +102,30 @@ namespace MOS {
 	Consumers should derive their own curiously-recurring-template-pattern subclass,
 	implementing bus communications as required.
 */
-template <class T> class MOS6522 {
-	private:
-		enum InterruptFlag: uint8_t {
-			CA2ActiveEdge	= 1 << 0,
-			CA1ActiveEdge	= 1 << 1,
-			ShiftRegister	= 1 << 2,
-			CB2ActiveEdge	= 1 << 3,
-			CB1ActiveEdge	= 1 << 4,
-			Timer2			= 1 << 5,
-			Timer1			= 1 << 6,
-		};
-
+template <class T> class MOS6522: public MOS6522Base {
 	public:
-		enum Port {
-			A = 0,
-			B = 1
-		};
-
-		enum Line {
-			One = 0,
-			Two = 1
-		};
+		MOS6522(T &bus_handler) noexcept : bus_handler_(bus_handler) {}
+		MOS6522(const MOS6522 &) = delete;
 
 		/*! Sets a register value. */
-		inline void set_register(int address, uint8_t value) {
-			address &= 0xf;
-//			printf("6522 [%s]: %0x <- %02x\n", typeid(*this).name(), address, value);
-			switch(address) {
-				case 0x0:
-					registers_.output[1] = value;
-					static_cast<T *>(this)->set_port_output(Port::B, value, registers_.data_direction[1]);	// TODO: handshake
-
-					registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | ((registers_.peripheral_control&0x20) ? 0 : InterruptFlag::CB2ActiveEdge));
-					reevaluate_interrupts();
-				break;
-				case 0xf:
-				case 0x1:
-					registers_.output[0] = value;
-					static_cast<T *>(this)->set_port_output(Port::A, value, registers_.data_direction[0]);	// TODO: handshake
-
-					registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | ((registers_.peripheral_control&0x02) ? 0 : InterruptFlag::CB2ActiveEdge));
-					reevaluate_interrupts();
-				break;
-//					// No handshake, so write directly
-//					registers_.output[0] = value;
-//					static_cast<T *>(this)->set_port_output(0, value);
-//				break;
-
-				case 0x2:
-					registers_.data_direction[1] = value;
-				break;
-				case 0x3:
-					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) | (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;
-					}
-					reevaluate_interrupts();
-				break;
-
-				// Timer 2
-				case 0x8:	registers_.timer_latch[1] = value;	break;
-				case 0x9:
-					registers_.interrupt_flags &= ~InterruptFlag::Timer2;
-					registers_.next_timer[1] = registers_.timer_latch[1] | (uint16_t)(value << 8);
-					timer_is_running_[1] = true;
-					reevaluate_interrupts();
-				break;
-
-				// Shift
-				case 0xa:	registers_.shift = value;				break;
-
-				// Control
-				case 0xb:
-					registers_.auxiliary_control = value;
-				break;
-				case 0xc:
-//					printf("Peripheral control %02x\n", value);
-					registers_.peripheral_control = value;
-
-					// TODO: simplify below; trying to avoid improper logging of unimplemented warnings in input mode
-					if(value & 0x08) {
-						switch(value & 0x0e) {
-							default: printf("Unimplemented control line mode %d\n", (value >> 1)&7); break;
-							case 0x0c:	static_cast<T *>(this)->set_control_line_output(Port::A, Line::Two, false);		break;
-							case 0x0e:	static_cast<T *>(this)->set_control_line_output(Port::A, Line::Two, true);		break;
-						}
-					}
-					if(value & 0x80) {
-						switch(value & 0xe0) {
-							default: printf("Unimplemented control line mode %d\n", (value >> 5)&7); break;
-							case 0xc0:	static_cast<T *>(this)->set_control_line_output(Port::B, Line::Two, false);		break;
-							case 0xe0:	static_cast<T *>(this)->set_control_line_output(Port::B, Line::Two, true);		break;
-						}
-					}
-				break;
-
-				// Interrupt control
-				case 0xd:
-					registers_.interrupt_flags &= ~value;
-					reevaluate_interrupts();
-				break;
-				case 0xe:
-					if(value&0x80)
-						registers_.interrupt_enable |= value;
-					else
-						registers_.interrupt_enable &= ~value;
-					reevaluate_interrupts();
-				break;
-			}
-		}
+		void set_register(int address, uint8_t value);
 
 		/*! Gets a register value. */
-		inline uint8_t get_register(int address) {
-			address &= 0xf;
-//			printf("6522 %p: %d\n", this, address);
-			switch(address) {
-				case 0x0:
-					registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | InterruptFlag::CB2ActiveEdge);
-					reevaluate_interrupts();
-				return get_port_input(Port::B, registers_.data_direction[1], registers_.output[1]);
-				case 0xf:	// TODO: handshake, latching
-				case 0x1:
-					registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | InterruptFlag::CA2ActiveEdge);
-					reevaluate_interrupts();
-				return get_port_input(Port::A, registers_.data_direction[0], registers_.output[0]);
+		uint8_t get_register(int address);
 
-				case 0x2:	return registers_.data_direction[1];
-				case 0x3:	return registers_.data_direction[0];
-
-				// Timer 1
-				case 0x4:
-					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;
-
-				// Timer 2
-				case 0x8:
-					registers_.interrupt_flags &= ~InterruptFlag::Timer2;
-					reevaluate_interrupts();
-				return registers_.timer[1] & 0x00ff;
-				case 0x9:	return registers_.timer[1] >> 8;
-
-				case 0xa:	return registers_.shift;
-
-				case 0xb:	return registers_.auxiliary_control;
-				case 0xc:	return registers_.peripheral_control;
-
-				case 0xd:	return registers_.interrupt_flags | (get_interrupt_line() ? 0x80 : 0x00);
-				case 0xe:	return registers_.interrupt_enable | 0x80;
-			}
-
-			return 0xff;
-		}
-
-		inline void set_control_line_input(Port port, Line line, bool value) {
-			switch(line) {
-				case Line::One:
-					if(	value != control_inputs_[port].line_one &&
-						value == !!(registers_.peripheral_control & (port ? 0x10 : 0x01))
-					) {
-						registers_.interrupt_flags |= port ? InterruptFlag::CB1ActiveEdge : InterruptFlag::CA1ActiveEdge;
-						reevaluate_interrupts();
-					}
-					control_inputs_[port].line_one = value;
-				break;
-
-				case Line::Two:
-					// TODO: output modes, but probably elsewhere?
-					if(	value != control_inputs_[port].line_two &&							// i.e. value has changed ...
-						!(registers_.peripheral_control & (port ? 0x80 : 0x08)) &&			// ... and line is input ...
-						value == !!(registers_.peripheral_control & (port ? 0x40 : 0x04))	// ... and it's either high or low, as required
-					) {
-						registers_.interrupt_flags |= port ? InterruptFlag::CB2ActiveEdge : InterruptFlag::CA2ActiveEdge;
-						reevaluate_interrupts();
-					}
-					control_inputs_[port].line_two = value;
-				break;
-			}
-		}
-
-#define phase2()	\
-	registers_.last_timer[0] = registers_.timer[0];\
-	registers_.last_timer[1] = registers_.timer[1];\
-\
-	if(registers_.timer_needs_reload) {\
-		registers_.timer_needs_reload = false;\
-		registers_.timer[0] = registers_.timer_latch[0];\
-	}\
-	else\
-		registers_.timer[0] --;\
-\
-	registers_.timer[1] --; \
-	if(registers_.next_timer[0] >= 0) { registers_.timer[0] = (uint16_t)registers_.next_timer[0]; registers_.next_timer[0] = -1; }\
-	if(registers_.next_timer[1] >= 0) { registers_.timer[1] = (uint16_t)registers_.next_timer[1]; registers_.next_timer[1] = -1; }\
-
-	// IRQ is raised on the half cycle after overflow
-#define phase1()	\
-	if((registers_.timer[1] == 0xffff) && !registers_.last_timer[1] && timer_is_running_[1]) {\
-		timer_is_running_[1] = false;\
-		registers_.interrupt_flags |= InterruptFlag::Timer2;\
-		reevaluate_interrupts();\
-	}\
-\
-	if((registers_.timer[0] == 0xffff) && !registers_.last_timer[0] && timer_is_running_[0]) {\
-		registers_.interrupt_flags |= InterruptFlag::Timer1;\
-		reevaluate_interrupts();\
-\
-		if(registers_.auxiliary_control&0x40)\
-			registers_.timer_needs_reload = true;\
-		else\
-			timer_is_running_[0] = false;\
-	}
-
-		/*! Runs for a specified number of half cycles. */
-		inline void run_for(const HalfCycles half_cycles) {
-			int number_of_half_cycles = half_cycles.as_int();
-
-			if(is_phase2_) {
-				phase2();
-				number_of_half_cycles--;
-			}
-
-			while(number_of_half_cycles >= 2) {
-				phase1();
-				phase2();
-				number_of_half_cycles -= 2;
-			}
-
-			if(number_of_half_cycles) {
-				phase1();
-				is_phase2_ = true;
-			} else {
-				is_phase2_ = false;
-			}
-		}
-
-		/*! Runs for a specified number of cycles. */
-		inline void run_for(const Cycles cycles) {
-			int number_of_cycles = cycles.as_int();
-			while(number_of_cycles--) {
-				phase1();
-				phase2();
-			}
-		}
-
-#undef phase1
-#undef phase2
-
-		/*! @returns @c true if the IRQ line is currently active; @c false otherwise. */
-		inline bool get_interrupt_line() {
-			uint8_t interrupt_status = registers_.interrupt_flags & registers_.interrupt_enable & 0x7f;
-			return !!interrupt_status;
-		}
-
-		MOS6522() :
-			timer_is_running_{false, false},
-			last_posted_interrupt_status_(false),
-			is_phase2_(false) {}
+		/*! @returns the bus handler. */
+		T &bus_handler();
 
 	private:
-		// Expected to be overridden
-		uint8_t get_port_input(Port port)										{	return 0xff;	}
-		void set_port_output(Port port, uint8_t value, uint8_t direction_mask)	{}
-		void set_control_line_output(Port port, Line line, bool value)			{}
-		void set_interrupt_status(bool status)									{}
+		T &bus_handler_;
 
-		// Input/output multiplexer
-		uint8_t get_port_input(Port port, uint8_t output_mask, uint8_t output) {
-			uint8_t input = static_cast<T *>(this)->get_port_input(port);
-			return (input & ~output_mask) | (output & output_mask);
-		}
-
-		// Phase toggle
-		bool is_phase2_;
-
-		// Delegate and communications
-		bool last_posted_interrupt_status_;
-		inline void reevaluate_interrupts() {
-			bool new_interrupt_status = get_interrupt_line();
-			if(new_interrupt_status != last_posted_interrupt_status_) {
-				last_posted_interrupt_status_ = new_interrupt_status;
-				static_cast<T *>(this)->set_interrupt_status(new_interrupt_status);
-			}
-		}
-
-		// The registers
-		struct Registers {
-			uint8_t output[2], input[2], data_direction[2];
-			uint16_t timer[2], timer_latch[2], last_timer[2];
-			int next_timer[2];
-			uint8_t shift;
-			uint8_t auxiliary_control, peripheral_control;
-			uint8_t interrupt_flags, interrupt_enable;
-			bool timer_needs_reload;
-
-			// "A  low  reset  (RES)  input  clears  all  R6522  internal registers to logic 0"
-			Registers() :
-				output{0, 0}, input{0, 0}, data_direction{0, 0},
-				auxiliary_control(0), peripheral_control(0),
-				interrupt_flags(0), interrupt_enable(0),
-				last_timer{0, 0}, timer_needs_reload(false),
-				next_timer{-1, -1} {}
-		} registers_;
-
-		// control state
-		struct {
-			bool line_one, line_two;
-		} control_inputs_[2];
-
-		// Internal state other than the registers
-		bool timer_is_running_[2];
+		uint8_t get_port_input(Port port, uint8_t output_mask, uint8_t output);
+		inline void reevaluate_interrupts();
 };
 
-/*!
-	Provided for optional composition with @c MOS6522, @c MOS6522IRQDelegate provides for a delegate
-	that will receive IRQ line change notifications.
-*/
-class MOS6522IRQDelegate {
-	public:
-		class Delegate {
-			public:
-				virtual void mos6522_did_change_interrupt_status(void *mos6522) = 0;
-		};
-
-		inline void set_interrupt_delegate(Delegate *delegate) {
-			delegate_ = delegate;
-		}
-
-		inline void set_interrupt_status(bool new_status) {
-			if(delegate_) delegate_->mos6522_did_change_interrupt_status(this);
-		}
-
-	private:
-		Delegate *delegate_;
-};
+#include "Implementation/6522Implementation.hpp"
 
+}
 }
 
 #endif /* _522_hpp */

Components/6522/Implementation/6522Base.cpp

@@ -0,0 +1,116 @@
+//
+//  6522Base.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/09/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "../6522.hpp"
+
+using namespace MOS::MOS6522;
+
+void MOS6522Base::set_control_line_input(Port port, Line line, bool value) {
+	switch(line) {
+		case Line::One:
+			if(	value != control_inputs_[port].line_one &&
+				value == !!(registers_.peripheral_control & (port ? 0x10 : 0x01))
+			) {
+				registers_.interrupt_flags |= port ? InterruptFlag::CB1ActiveEdge : InterruptFlag::CA1ActiveEdge;
+				reevaluate_interrupts();
+			}
+			control_inputs_[port].line_one = value;
+		break;
+
+		case Line::Two:
+			// TODO: output modes, but probably elsewhere?
+			if(	value != control_inputs_[port].line_two &&							// i.e. value has changed ...
+				!(registers_.peripheral_control & (port ? 0x80 : 0x08)) &&			// ... and line is input ...
+				value == !!(registers_.peripheral_control & (port ? 0x40 : 0x04))	// ... and it's either high or low, as required
+			) {
+				registers_.interrupt_flags |= port ? InterruptFlag::CB2ActiveEdge : InterruptFlag::CA2ActiveEdge;
+				reevaluate_interrupts();
+			}
+			control_inputs_[port].line_two = value;
+		break;
+	}
+}
+
+void MOS6522Base::do_phase2() {
+	registers_.last_timer[0] = registers_.timer[0];
+	registers_.last_timer[1] = registers_.timer[1];
+
+	if(registers_.timer_needs_reload) {
+		registers_.timer_needs_reload = false;
+		registers_.timer[0] = registers_.timer_latch[0];
+	} else {
+		registers_.timer[0] --;
+	}
+
+	registers_.timer[1] --;
+	if(registers_.next_timer[0] >= 0) {
+		registers_.timer[0] = static_cast<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_.next_timer[1] = -1;
+	}
+}
+
+void MOS6522Base::do_phase1() {
+	// IRQ is raised on the half cycle after overflow
+	if((registers_.timer[1] == 0xffff) && !registers_.last_timer[1] && timer_is_running_[1]) {
+		timer_is_running_[1] = false;
+		registers_.interrupt_flags |= InterruptFlag::Timer2;
+		reevaluate_interrupts();
+	}
+
+	if((registers_.timer[0] == 0xffff) && !registers_.last_timer[0] && timer_is_running_[0]) {
+		registers_.interrupt_flags |= InterruptFlag::Timer1;
+		reevaluate_interrupts();
+
+		if(registers_.auxiliary_control&0x40)
+			registers_.timer_needs_reload = true;
+		else
+			timer_is_running_[0] = false;
+	}
+}
+
+/*! Runs for a specified number of half cycles. */
+void MOS6522Base::run_for(const HalfCycles half_cycles) {
+	int number_of_half_cycles = half_cycles.as_int();
+
+	if(is_phase2_) {
+		do_phase2();
+		number_of_half_cycles--;
+	}
+
+	while(number_of_half_cycles >= 2) {
+		do_phase1();
+		do_phase2();
+		number_of_half_cycles -= 2;
+	}
+
+	if(number_of_half_cycles) {
+		do_phase1();
+		is_phase2_ = true;
+	} else {
+		is_phase2_ = false;
+	}
+}
+
+/*! Runs for a specified number of cycles. */
+void MOS6522Base::run_for(const Cycles cycles) {
+	int number_of_cycles = cycles.as_int();
+	while(number_of_cycles--) {
+		do_phase1();
+		do_phase2();
+	}
+}
+
+/*! @returns @c true if the IRQ line is currently active; @c false otherwise. */
+bool MOS6522Base::get_interrupt_line() {
+	uint8_t interrupt_status = registers_.interrupt_flags & registers_.interrupt_enable & 0x7f;
+	return !!interrupt_status;
+}

Components/6522/Implementation/6522Implementation.hpp

@@ -0,0 +1,159 @@
+//
+//  Implementation.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/09/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+template <typename T> void MOS6522<T>::set_register(int address, uint8_t value) {
+	address &= 0xf;
+	switch(address) {
+		case 0x0:
+			registers_.output[1] = value;
+			bus_handler_.set_port_output(Port::B, value, registers_.data_direction[1]);	// TODO: handshake
+
+			registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | ((registers_.peripheral_control&0x20) ? 0 : InterruptFlag::CB2ActiveEdge));
+			reevaluate_interrupts();
+		break;
+		case 0xf:
+		case 0x1:
+			registers_.output[0] = value;
+			bus_handler_.set_port_output(Port::A, value, registers_.data_direction[0]);	// TODO: handshake
+
+			registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | ((registers_.peripheral_control&0x02) ? 0 : InterruptFlag::CB2ActiveEdge));
+			reevaluate_interrupts();
+		break;
+
+		case 0x2:
+			registers_.data_direction[1] = value;
+		break;
+		case 0x3:
+			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;
+			}
+			reevaluate_interrupts();
+		break;
+
+		// Timer 2
+		case 0x8:	registers_.timer_latch[1] = value;	break;
+		case 0x9:
+			registers_.interrupt_flags &= ~InterruptFlag::Timer2;
+			registers_.next_timer[1] = registers_.timer_latch[1] | static_cast<uint16_t>(value << 8);
+			timer_is_running_[1] = true;
+			reevaluate_interrupts();
+		break;
+
+		// Shift
+		case 0xa:	registers_.shift = value;				break;
+
+		// Control
+		case 0xb:
+			registers_.auxiliary_control = value;
+		break;
+		case 0xc:
+//			printf("Peripheral control %02x\n", value);
+			registers_.peripheral_control = value;
+
+			// TODO: simplify below; trying to avoid improper logging of unimplemented warnings in input mode
+			if(value & 0x08) {
+				switch(value & 0x0e) {
+					default: printf("Unimplemented control line mode %d\n", (value >> 1)&7);		break;
+					case 0x0c:	bus_handler_.set_control_line_output(Port::A, Line::Two, false);	break;
+					case 0x0e:	bus_handler_.set_control_line_output(Port::A, Line::Two, true);		break;
+				}
+			}
+			if(value & 0x80) {
+				switch(value & 0xe0) {
+					default: printf("Unimplemented control line mode %d\n", (value >> 5)&7);		break;
+					case 0xc0:	bus_handler_.set_control_line_output(Port::B, Line::Two, false);	break;
+					case 0xe0:	bus_handler_.set_control_line_output(Port::B, Line::Two, true);		break;
+				}
+			}
+		break;
+
+		// Interrupt control
+		case 0xd:
+			registers_.interrupt_flags &= ~value;
+			reevaluate_interrupts();
+		break;
+		case 0xe:
+			if(value&0x80)
+				registers_.interrupt_enable |= value;
+			else
+				registers_.interrupt_enable &= ~value;
+			reevaluate_interrupts();
+		break;
+	}
+}
+
+template <typename T> uint8_t MOS6522<T>::get_register(int address) {
+	address &= 0xf;
+	switch(address) {
+		case 0x0:
+			registers_.interrupt_flags &= ~(InterruptFlag::CB1ActiveEdge | InterruptFlag::CB2ActiveEdge);
+			reevaluate_interrupts();
+		return get_port_input(Port::B, registers_.data_direction[1], registers_.output[1]);
+		case 0xf:	// TODO: handshake, latching
+		case 0x1:
+			registers_.interrupt_flags &= ~(InterruptFlag::CA1ActiveEdge | InterruptFlag::CA2ActiveEdge);
+			reevaluate_interrupts();
+		return get_port_input(Port::A, registers_.data_direction[0], registers_.output[0]);
+
+		case 0x2:	return registers_.data_direction[1];
+		case 0x3:	return registers_.data_direction[0];
+
+		// Timer 1
+		case 0x4:
+			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;
+
+		// Timer 2
+		case 0x8:
+			registers_.interrupt_flags &= ~InterruptFlag::Timer2;
+			reevaluate_interrupts();
+		return registers_.timer[1] & 0x00ff;
+		case 0x9:	return registers_.timer[1] >> 8;
+
+		case 0xa:	return registers_.shift;
+
+		case 0xb:	return registers_.auxiliary_control;
+		case 0xc:	return registers_.peripheral_control;
+
+		case 0xd:	return registers_.interrupt_flags | (get_interrupt_line() ? 0x80 : 0x00);
+		case 0xe:	return registers_.interrupt_enable | 0x80;
+	}
+
+	return 0xff;
+}
+
+template <typename T> uint8_t MOS6522<T>::get_port_input(Port port, uint8_t output_mask, uint8_t output) {
+	uint8_t input = bus_handler_.get_port_input(port);
+	return (input & ~output_mask) | (output & output_mask);
+}
+
+template <typename T> T &MOS6522<T>::bus_handler() {
+	return bus_handler_;
+}
+
+// Delegate and communications
+template <typename T> void MOS6522<T>::reevaluate_interrupts() {
+	bool new_interrupt_status = get_interrupt_line();
+	if(new_interrupt_status != last_posted_interrupt_status_) {
+		last_posted_interrupt_status_ = new_interrupt_status;
+		bus_handler_.set_interrupt_status(new_interrupt_status);
+	}
+}

Components/6522/Implementation/6522Storage.hpp

@@ -0,0 +1,63 @@
+//
+//  6522Storage.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/09/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef _522Storage_hpp
+#define _522Storage_hpp
+
+#include <cstdint>
+
+namespace MOS {
+namespace MOS6522 {
+
+class MOS6522Storage {
+	protected:
+		// Phase toggle
+		bool is_phase2_ = false;
+
+		// The registers
+		struct Registers {
+			// "A  low  reset  (RES)  input  clears  all  R6522  internal registers to logic 0"
+			uint8_t output[2] = {0, 0};
+			uint8_t input[2] = {0, 0};
+			uint8_t data_direction[2] = {0, 0};
+			uint16_t timer[2] = {0, 0};
+			uint16_t timer_latch[2] = {0, 0};
+			uint16_t last_timer[2] = {0, 0};
+			int next_timer[2] = {-1, -1};
+			uint8_t shift = 0;
+			uint8_t auxiliary_control = 0;
+			uint8_t peripheral_control = 0;
+			uint8_t interrupt_flags = 0;
+			uint8_t interrupt_enable = 0;
+			bool timer_needs_reload = false;
+		} registers_;
+
+		// control state
+		struct {
+			bool line_one = false;
+			bool line_two = false;
+		} control_inputs_[2];
+
+		bool timer_is_running_[2] = {false, false};
+		bool last_posted_interrupt_status_ = false;
+
+		enum InterruptFlag: uint8_t {
+			CA2ActiveEdge	= 1 << 0,
+			CA1ActiveEdge	= 1 << 1,
+			ShiftRegister	= 1 << 2,
+			CB2ActiveEdge	= 1 << 3,
+			CB1ActiveEdge	= 1 << 4,
+			Timer2			= 1 << 5,
+			Timer1			= 1 << 6,
+		};
+};
+
+}
+}
+
+#endif /* _522Storage_hpp */

Components/6522/Implementation/IRQDelegatePortHandler.cpp

@@ -0,0 +1,19 @@
+//
+//  IRQDelegatePortHandler.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/09/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "../6522.hpp"
+
+using namespace MOS::MOS6522;
+
+void IRQDelegatePortHandler::set_interrupt_delegate(Delegate *delegate) {
+	delegate_ = delegate;
+}
+
+void IRQDelegatePortHandler::set_interrupt_status(bool new_status) {
+	if(delegate_) delegate_->mos6522_did_change_interrupt_status(this);
+}

Components/6532/6532.hpp

@@ -3,7 +3,7 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 19/06/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef _532_hpp
@@ -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 = ((unsigned int)value << timer_.activeShift) ;
+						timer_.value = (static_cast<unsigned int>(value) << timer_.activeShift) ;
 						timer_.interrupt_enabled = !!(address&0x08);
 						interrupt_status_ &= ~InterruptFlag::Timer;
 						evaluate_interrupts();
@@ -79,7 +79,7 @@ template <class T> class MOS6532 {
 
 				// Timer and interrupt control
 				case 0x04: case 0x06: {
-					uint8_t value = (uint8_t)(timer_.value >> timer_.activeShift);
+					uint8_t value = static_cast<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 = (unsigned int)cycles.as_int();
+			unsigned int number_of_cycles = static_cast<unsigned int>(cycles.as_int());
 
 			// permit counting _to_ zero; counting _through_ zero initiates the other behaviour
 			if(timer_.value >= number_of_cycles) {
@@ -121,12 +121,9 @@ template <class T> class MOS6532 {
 			}
 		}
 
-		MOS6532() :
-			interrupt_status_(0),
-			port_{{.output_mask = 0, .output = 0}, {.output_mask = 0, .output = 0}},
-			a7_interrupt_({.last_port_value = 0, .enabled = false}),
-			interrupt_line_(false),
-			timer_{.value = (unsigned int)((rand() & 0xff) << 10), .activeShift = 10, .writtenShift = 10, .interrupt_enabled = false} {}
+		MOS6532() {
+			timer_.value = static_cast<unsigned int>((rand() & 0xff) << 10);
+		}
 
 		inline void set_port_did_change(int port) {
 			if(!port) {
@@ -154,26 +151,26 @@ template <class T> class MOS6532 {
 
 		struct {
 			unsigned int value;
-			unsigned int activeShift, writtenShift;
-			bool interrupt_enabled;
+			unsigned int activeShift = 10, writtenShift = 10;
+			bool interrupt_enabled = false;
 		} timer_;
 
 		struct {
-			bool enabled;
-			bool active_on_positive;
-			uint8_t last_port_value;
+			bool enabled = false;
+			bool active_on_positive = false;
+			uint8_t last_port_value = 0;
 		} a7_interrupt_;
 
 		struct {
-			uint8_t output_mask, output;
+			uint8_t output_mask = 0, output = 0;
 		} port_[2];
 
-		uint8_t interrupt_status_;
+		uint8_t interrupt_status_ = 0;
 		enum InterruptFlag: uint8_t {
 			Timer = 0x80,
 			PA7 = 0x40
 		};
-		bool interrupt_line_;
+		bool interrupt_line_ = false;
 
 		// expected to be overridden
 		uint8_t get_port_input(int port)										{	return 0xff;	}

Components/6560/6560.cpp

@@ -3,27 +3,27 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 05/06/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #include "6560.hpp"
 
-using namespace MOS;
+#include <cstring>
 
-Speaker::Speaker() :
-	volume_(0),
-	control_registers_{0, 0, 0, 0},
-	shift_registers_{0, 0, 0, 0},
-	counters_{2, 1, 0, 0} {}	// create a slight phase offset for the three channels
+using namespace MOS::MOS6560;
 
-void Speaker::set_volume(uint8_t volume) {
-	enqueue([=]() {
-		volume_ = volume;
+AudioGenerator::AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue) :
+	audio_queue_(audio_queue) {}
+
+
+void AudioGenerator::set_volume(uint8_t volume) {
+	audio_queue_.defer([=]() {
+		volume_ = static_cast<int16_t>(volume) * range_multiplier_;
 	});
 }
 
-void Speaker::set_control(int channel, uint8_t value) {
-	enqueue([=]() {
+void AudioGenerator::set_control(int channel, uint8_t value) {
+	audio_queue_.defer([=]() {
 		control_registers_[channel] = value;
 	});
 }
@@ -98,15 +98,15 @@ 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] = (unsigned int)(control_registers_[r]&0x7f) << m; }
+#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; }
 // Note on slightly askew test: as far as I can make out, if the value in the register is 0x7f then what's supposed to happen
 // is that the 0x7f is loaded, on the next clocked cycle the Vic spots a 0x7f, pumps the output, reloads, etc. No increment
 // ever occurs. It's conditional. I don't really want two conditionals if I can avoid it so I'm incrementing regardless and
 // testing against 0x80. The effect should be the same: loading with 0x7f means an output update every cycle, loading with 0x7e
 // means every second cycle, etc.
 
-void Speaker::get_samples(unsigned int number_of_samples, int16_t *target) {
-	for(unsigned int c = 0; c < number_of_samples; c++) {
+void AudioGenerator::get_samples(std::size_t number_of_samples, int16_t *target) {
+	for(unsigned int c = 0; c < number_of_samples; ++c) {
 		update(0, 2, shift);
 		update(1, 1, shift);
 		update(2, 0, shift);
@@ -114,17 +114,17 @@ void Speaker::get_samples(unsigned int 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] = (
+		target[c] = static_cast<int16_t>(
 			(shift_registers_[0]&1) +
 			(shift_registers_[1]&1) +
 			(shift_registers_[2]&1) +
 			((noise_pattern[shift_registers_[3] >> 3] >> (shift_registers_[3]&7))&(control_registers_[3] >> 7)&1)
-		) * volume_ * 700 + volume_ * 44;
+		) * volume_ + (volume_ >> 4);
 	}
 }
 
-void Speaker::skip_samples(unsigned int number_of_samples) {
-	for(unsigned int c = 0; c < number_of_samples; c++) {
+void AudioGenerator::skip_samples(std::size_t number_of_samples) {
+	for(unsigned int c = 0; c < number_of_samples; ++c) {
 		update(0, 2, shift);
 		update(1, 1, shift);
 		update(2, 0, shift);
@@ -132,6 +132,10 @@ void Speaker::skip_samples(unsigned int number_of_samples) {
 	}
 }
 
+void AudioGenerator::set_sample_volume_range(std::int16_t range) {
+	range_multiplier_ = static_cast<int16_t>(range / 64);
+}
+
 #undef shift
 #undef increment
 #undef update

Components/6560/6560.hpp

@@ -3,34 +3,53 @@
 //  Clock Signal
 //
 //  Created by Thomas Harte on 05/06/2016.
-//  Copyright © 2016 Thomas Harte. All rights reserved.
+//  Copyright 2016 Thomas Harte. All rights reserved.
 //
 
 #ifndef _560_hpp
 #define _560_hpp
 
-#include "../../Outputs/CRT/CRT.hpp"
-#include "../../Outputs/Speaker.hpp"
 #include "../../ClockReceiver/ClockReceiver.hpp"
+#include "../../Concurrency/AsyncTaskQueue.hpp"
+#include "../../Outputs/CRT/CRT.hpp"
+#include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
+#include "../../Outputs/Speaker/Implementation/SampleSource.hpp"
 
 namespace MOS {
+namespace MOS6560 {
 
 // audio state
-class Speaker: public ::Outputs::Filter<Speaker> {
+class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 	public:
-		Speaker();
+		AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue);
 
 		void set_volume(uint8_t volume);
 		void set_control(int channel, uint8_t value);
 
-		void get_samples(unsigned int number_of_samples, int16_t *target);
-		void skip_samples(unsigned int number_of_samples);
+		// For ::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);
 
 	private:
-		unsigned int counters_[4];
-		unsigned int shift_registers_[4];
-		uint8_t control_registers_[4];
-		uint8_t volume_;
+		Concurrency::DeferringAsyncTaskQueue &audio_queue_;
+
+		unsigned int counters_[4] = {2, 1, 0, 0}; 	// create a slight phase offset for the three channels
+		unsigned int shift_registers_[4] = {0, 0, 0, 0};
+		uint8_t control_registers_[4] = {0, 0, 0, 0};
+		int16_t volume_ = 0;
+		int16_t range_multiplier_ = 1;
+};
+
+struct BusHandler {
+	void perform_read(uint16_t address, uint8_t *pixel_data, uint8_t *colour_data) {
+		*pixel_data = 0xff;
+		*colour_data = 0xff;
+	}
+};
+
+enum class OutputMode {
+	PAL, NTSC
 };
 
 /*!
@@ -41,40 +60,46 @@ class Speaker: public ::Outputs::Filter<Speaker> {
 
 	@c set_register and @c get_register provide register access.
 */
-template <class T> class MOS6560 {
+template <class BusHandler> class MOS6560 {
 	public:
-		MOS6560() :
-				crt_(new Outputs::CRT::CRT(65*4, 4, Outputs::CRT::NTSC60, 2)),
-				speaker_(new Speaker),
-				horizontal_counter_(0),
-				vertical_counter_(0),
-				cycles_since_speaker_update_(0),
-				is_odd_frame_(false),
-				is_odd_line_(false) {
-			crt_->set_composite_sampling_function(
-				"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
+		MOS6560(BusHandler &bus_handler) :
+				bus_handler_(bus_handler),
+				crt_(new Outputs::CRT::CRT(65*4, 4, Outputs::CRT::DisplayType::NTSC60, 2)),
+				audio_generator_(audio_queue_),
+				speaker_(audio_generator_)
+		{
+			crt_->set_svideo_sampling_function(
+				"vec2 svideo_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
 				"{"
 					"vec2 yc = texture(texID, coordinate).rg / vec2(255.0);"
-					"float phaseOffset = 6.283185308 * 2.0 * yc.y;"
 
-					"float chroma = cos(phase + phaseOffset);"
-					"return mix(yc.x, step(yc.y, 0.75) * chroma, amplitude);"
+					"float phaseOffset = 6.283185308 * 2.0 * yc.y;"
+					"float chroma = step(yc.y, 0.75) * cos(phase + phaseOffset);"
+
+					"return vec2(yc.x, chroma);"
 				"}");
 
+			// default to s-video output
+			crt_->set_video_signal(Outputs::CRT::VideoSignal::SVideo);
+
 			// default to NTSC
 			set_output_mode(OutputMode::NTSC);
 		}
 
-		void set_clock_rate(double clock_rate) {
-			speaker_->set_input_rate((float)(clock_rate / 4.0));
+		~MOS6560() {
+			audio_queue_.flush();
 		}
 
-		std::shared_ptr<Outputs::CRT::CRT> get_crt() { return crt_; }
-		std::shared_ptr<Outputs::Speaker> get_speaker() { return speaker_; }
+		void set_clock_rate(double clock_rate) {
+			speaker_.set_input_rate(static_cast<float>(clock_rate / 4.0));
+		}
 
-		enum OutputMode {
-			PAL, NTSC
-		};
+		Outputs::CRT::CRT *get_crt() { return crt_.get(); }
+		Outputs::Speaker::Speaker *get_speaker() { return &speaker_; }
+
+		void set_high_frequency_cutoff(float cutoff) {
+			speaker_.set_high_frequency_cutoff(cutoff);
+		}
 
 		/*!
 			Sets the output mode to either PAL or NTSC.
@@ -82,66 +107,67 @@ template <class T> class MOS6560 {
 		void set_output_mode(OutputMode output_mode) {
 			output_mode_ = output_mode;
 
-			// Lumunances are encoded trivially: on a 0–255 scale.
+			// Luminances are encoded trivially: on a 0-255 scale.
 			const uint8_t luminances[16] = {
-				0,		255,	109,	189,
-				199,	144,	159,	161,
-				126,	227,	227,	207,
-				235,	173,	188,	196
+				0,		255,	64,		192,
+				128,	128,	64,		192,
+				128,	192,	128,	255,
+				192,	192,	128,	255
 			};
 
-			// Chrominances are encoded such that 0–128 is a complete revolution of phase;
+			// Chrominances are encoded such that 0-128 is a complete revolution of phase;
 			// anything above 191 disables the colour subcarrier. Phase is relative to the
 			// colour burst, so 0 is green.
 			const uint8_t pal_chrominances[16] = {
-				255,	255,	40,		112,
-				8,		88,		120,	56,
-				40,		48,		40,		112,
-				8,		88,		120,	56,
+				255,	255,	37,		101,
+				19,		86,		123,	59,
+				46,		53,		37,		101,
+				19,		86,		123,	59,
 			};
 			const uint8_t ntsc_chrominances[16] = {
-				255,	255,	40,		104,
-				64,		120,	80,		16,
-				32,		32,		40,		104,
-				64,		120,	80,		16,
+				255,	255,	121,	57,
+				103,	42,		80,		16,
+				0,		9,		121,	57,
+				103,	42,		80,		16,
 			};
 			const uint8_t *chrominances;
 			Outputs::CRT::DisplayType display_type;
 
 			switch(output_mode) {
-				case OutputMode::PAL:
+				default:
 					chrominances = pal_chrominances;
-					display_type = Outputs::CRT::PAL50;
+					display_type = Outputs::CRT::DisplayType::PAL50;
 					timing_.cycles_per_line = 71;
-					timing_.line_counter_increment_offset = 0;
+					timing_.line_counter_increment_offset = 4;
+					timing_.final_line_increment_position = timing_.cycles_per_line - timing_.line_counter_increment_offset;
 					timing_.lines_per_progressive_field = 312;
 					timing_.supports_interlacing = false;
 				break;
 
 				case OutputMode::NTSC:
 					chrominances = ntsc_chrominances;
-					display_type = Outputs::CRT::NTSC60;
+					display_type = Outputs::CRT::DisplayType::NTSC60;
 					timing_.cycles_per_line = 65;
-					timing_.line_counter_increment_offset = 65 - 33;	// TODO: this is a bit of a hack; separate vertical and horizontal counting
+					timing_.line_counter_increment_offset = 40;
+					timing_.final_line_increment_position = 58;
 					timing_.lines_per_progressive_field = 261;
 					timing_.supports_interlacing = true;
 				break;
 			}
 
-			crt_->set_new_display_type((unsigned int)(timing_.cycles_per_line*4), display_type);
-			crt_->set_visible_area(Outputs::CRT::Rect(0.05f, 0.05f, 0.9f, 0.9f));
+			crt_->set_new_display_type(static_cast<unsigned int>(timing_.cycles_per_line*4), display_type);
 
-//			switch(output_mode) {
-//				case OutputMode::PAL:
-//					crt_->set_visible_area(crt_->get_rect_for_area(16, 237, 15*4, 55*4, 4.0f / 3.0f));
-//				break;
-//				case OutputMode::NTSC:
-//					crt_->set_visible_area(crt_->get_rect_for_area(16, 237, 11*4, 55*4, 4.0f / 3.0f));
-//				break;
-//			}
+			switch(output_mode) {
+				case OutputMode::PAL:
+					crt_->set_visible_area(Outputs::CRT::Rect(0.1f, 0.07f, 0.9f, 0.9f));
+				break;
+				case OutputMode::NTSC:
+					crt_->set_visible_area(Outputs::CRT::Rect(0.05f, 0.05f, 0.9f, 0.9f));
+				break;
+			}
 
 			for(int c = 0; c < 16; c++) {
-				uint8_t *colour = (uint8_t *)&colours_[c];
+				uint8_t *colour = reinterpret_cast<uint8_t *>(&colours_[c]);
 				colour[0] = luminances[c];
 				colour[1] = chrominances[c];
 			}
@@ -161,7 +187,6 @@ template <class T> class MOS6560 {
 
 				// keep track of internal time relative to this scanline
 				horizontal_counter_++;
-				full_frame_counter_++;
 				if(horizontal_counter_ == timing_.cycles_per_line) {
 					if(horizontal_drawing_latch_) {
 						current_character_row_++;
@@ -183,9 +208,8 @@ template <class T> class MOS6560 {
 					horizontal_drawing_latch_ = false;
 
 					vertical_counter_ ++;
-					if(vertical_counter_ == (registers_.interlaced ? (is_odd_frame_ ? 262 : 263) : timing_.lines_per_progressive_field)) {
+					if(vertical_counter_ == lines_this_field()) {
 						vertical_counter_ = 0;
-						full_frame_counter_ = 0;
 
 						if(output_mode_ == OutputMode::NTSC) is_odd_frame_ ^= true;
 						current_row_ = 0;
@@ -218,7 +242,7 @@ template <class T> 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 = (uint16_t)(registers_.video_matrix_start_address + video_matrix_address_counter_);
+						fetch_address = static_cast<uint16_t>(registers_.video_matrix_start_address + video_matrix_address_counter_);
 						video_matrix_address_counter_++;
 						if(
 							(current_character_row_ == 15) ||
@@ -233,7 +257,7 @@ template <class T> class MOS6560 {
 
 				uint8_t pixel_data;
 				uint8_t colour_data;
-				static_cast<T *>(this)->perform_read(fetch_address, &pixel_data, &colour_data);
+				bus_handler_.perform_read(fetch_address, &pixel_data, &colour_data);
 
 				// TODO: there should be a further two-cycle delay on pixels being output; the reverse bit should
 				// divide the byte it is set for 3:1 and then continue as usual.
@@ -247,7 +271,7 @@ template <class T> class MOS6560 {
 
 				// apply vertical sync
 				if(
-					(vertical_counter_ < 3 && (is_odd_frame_ || !registers_.interlaced)) ||
+					(vertical_counter_ < 3 && is_odd_frame()) ||
 					(registers_.interlaced &&
 						(
 							(vertical_counter_ == 0 && horizontal_counter_ > 32) ||
@@ -263,19 +287,22 @@ template <class T> class MOS6560 {
 						case State::Sync:			crt_->output_sync(cycles_in_state_ * 4);														break;
 						case State::ColourBurst:	crt_->output_colour_burst(cycles_in_state_ * 4, (is_odd_frame_ || is_odd_line_) ? 128 : 0);		break;
 						case State::Border:			output_border(cycles_in_state_ * 4);															break;
-						case State::Pixels:			crt_->output_data(cycles_in_state_ * 4, 1);														break;
+						case State::Pixels:			crt_->output_data(cycles_in_state_ * 4);														break;
 					}
 					output_state_ = this_state_;
 					cycles_in_state_ = 0;
 
 					pixel_pointer = nullptr;
 					if(output_state_ == State::Pixels) {
-						pixel_pointer = (uint16_t *)crt_->allocate_write_area(260);
+						pixel_pointer = reinterpret_cast<uint16_t *>(crt_->allocate_write_area(260));
 					}
 				}
 				cycles_in_state_++;
 
 				if(this_state_ == State::Pixels) {
+					// TODO: palette changes can happen within half-characters; the below needs to be divided.
+					// Also: a perfect opportunity to rearrange this inner loop for no longer needing to be
+					// two parts with a cooperative owner?
 					if(column_counter_&1) {
 						character_value_ = pixel_data;
 
@@ -316,7 +343,10 @@ template <class T> class MOS6560 {
 						character_code_ = pixel_data;
 						character_colour_ = colour_data;
 					}
+				}
 
+				// Keep counting columns even if sync or the colour burst have interceded.
+				if(column_counter_ >= 0 && column_counter_ < columns_this_line_*2) {
 					column_counter_++;
 				}
 			}
@@ -325,7 +355,10 @@ template <class T> class MOS6560 {
 		/*!
 			Causes the 6560 to flush as much pending CRT and speaker communications as possible.
 		*/
-		inline void flush() { update_audio(); speaker_->flush(); }
+		inline void flush() {
+			update_audio();
+			audio_queue_.perform();
+		}
 
 		/*!
 			Writes to a 6560 register.
@@ -345,7 +378,7 @@ template <class T> class MOS6560 {
 
 				case 0x2:
 					registers_.number_of_columns = value & 0x7f;
-					registers_.video_matrix_start_address = (uint16_t)((registers_.video_matrix_start_address & 0x3c00) | ((value & 0x80) << 2));
+					registers_.video_matrix_start_address = static_cast<uint16_t>((registers_.video_matrix_start_address & 0x3c00) | ((value & 0x80) << 2));
 				break;
 
 				case 0x3:
@@ -354,8 +387,8 @@ template <class T> class MOS6560 {
 				break;
 
 				case 0x5:
-					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));
+					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));
 				break;
 
 				case 0xa:
@@ -363,13 +396,13 @@ template <class T> class MOS6560 {
 				case 0xc:
 				case 0xd:
 					update_audio();
-					speaker_->set_control(address - 0xa, value);
+					audio_generator_.set_control(address - 0xa, value);
 				break;
 
 				case 0xe:
 					update_audio();
 					registers_.auxiliary_colour = colours_[value >> 4];
-					speaker_->set_volume(value & 0xf);
+					audio_generator_.set_volume(value & 0xf);
 				break;
 
 				case 0xf: {
@@ -396,21 +429,24 @@ template <class T> class MOS6560 {
 		*/
 		uint8_t get_register(int address) {
 			address &= 0xf;
-			int current_line = (full_frame_counter_ + timing_.line_counter_increment_offset) / timing_.cycles_per_line;
 			switch(address) {
 				default: return registers_.direct_values[address];
-				case 0x03: return (uint8_t)(current_line << 7) | (registers_.direct_values[3] & 0x7f);
-				case 0x04: return (current_line >> 1) & 0xff;
+				case 0x03: return static_cast<uint8_t>(raster_value() << 7) | (registers_.direct_values[3] & 0x7f);
+				case 0x04: return (raster_value() >> 1) & 0xff;
 			}
 		}
 
 	private:
-		std::shared_ptr<Outputs::CRT::CRT> crt_;
+		BusHandler &bus_handler_;
+		std::unique_ptr<Outputs::CRT::CRT> crt_;
+
+		Concurrency::DeferringAsyncTaskQueue audio_queue_;
+		AudioGenerator audio_generator_;
+		Outputs::Speaker::LowpassSpeaker<AudioGenerator> speaker_;
 
-		std::shared_ptr<Speaker> speaker_;
 		Cycles cycles_since_speaker_update_;
 		void update_audio() {
-			speaker_->run_for(Cycles(cycles_since_speaker_update_.divide(Cycles(4))));
+			speaker_.run_for(audio_queue_, Cycles(cycles_since_speaker_update_.divide(Cycles(4))));
 		}
 
 		// register state
@@ -432,7 +468,29 @@ template <class T> class MOS6560 {
 		unsigned int cycles_in_state_;
 
 		// counters that cover an entire field
-		int horizontal_counter_, vertical_counter_, full_frame_counter_;
+		int horizontal_counter_ = 0, vertical_counter_ = 0;
+		const int lines_this_field() {
+			// 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() {
+			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();
+
+			if(line < final_line)
+				return line;
+
+			if(is_odd_frame()) {
+				return (horizontal_counter_ >= timing_.final_line_increment_position) ? 0 : final_line - 1;
+			} else {
+				return line % final_line;
+			}
+			// Cf. http://www.sleepingelephant.com/ipw-web/bulletin/bb/viewtopic.php?f=14&t=7237&start=15#p80737
+		}
+		bool is_odd_frame() {
+			return is_odd_frame_ || !registers_.interlaced;
+		}
 
 		// latches dictating start and length of drawing
 		bool vertical_drawing_latch_, horizontal_drawing_latch_;
@@ -447,14 +505,14 @@ template <class T> class MOS6560 {
 		// data latched from the bus
 		uint8_t character_code_, character_colour_, character_value_;
 
-		bool is_odd_frame_, is_odd_line_;
+		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 *pixel_pointer;
 		void output_border(unsigned int number_of_cycles) {
-			uint16_t *colour_pointer = (uint16_t *)crt_->allocate_write_area(1);
+			uint16_t *colour_pointer = reinterpret_cast<uint16_t *>(crt_->allocate_write_area(1));
 			if(colour_pointer) *colour_pointer = registers_.borderColour;
 			crt_->output_level(number_of_cycles);
 		}
@@ -462,12 +520,14 @@ template <class T> 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;
 		} timing_;
 		OutputMode output_mode_;
 };
 
+}
 }
 
 #endif /* _560_hpp */

Components/6845/CRTC6845.hpp

@@ -0,0 +1,275 @@
+//
+//  CRTC6845.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 31/07/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef CRTC6845_hpp
+#define CRTC6845_hpp
+
+#include "../../ClockReceiver/ClockReceiver.hpp"
+
+#include <cstdint>
+#include <cstdio>
+
+namespace Motorola {
+namespace CRTC {
+
+struct BusState {
+	bool display_enable = false;
+	bool hsync = false;
+	bool vsync = false;
+	bool cursor = false;
+	uint16_t refresh_address = 0;
+	uint16_t row_address = 0;
+};
+
+class BusHandler {
+	public:
+		/*!
+			Performs the first phase of a 6845 bus cycle; this is the phase in which it is intended that
+			systems using the 6845 respect the bus state and produce pixels, sync or whatever they require.
+		*/
+		void perform_bus_cycle_phase1(const BusState &) {}
+
+		/*!
+			Performs the second phase of a 6845 bus cycle. Some bus state, including sync, is updated
+			directly after phase 1 and hence is visible to an observer during phase 2. Handlers may therefore
+			implement @c perform_bus_cycle_phase2 to be notified of the availability of that state without
+			having to wait until the next cycle has begun.
+		*/
+		void perform_bus_cycle_phase2(const BusState &) {}
+};
+
+enum Personality {
+	HD6845S,	// Type 0 in CPC parlance. Zero-width HSYNC available, no status, programmable VSYNC length.
+				// Considered exactly identical to the UM6845, so this enum covers both.
+	UM6845R,	// Type 1 in CPC parlance. Status register, fixed-length VSYNC.
+	MC6845,		// Type 2. No status register, fixed-length VSYNC, no zero-length HSYNC.
+	AMS40226	// Type 3. Status is get register, fixed-length VSYNC, no zero-length HSYNC.
+};
+
+// TODO UM6845R and R12/R13; see http://www.cpcwiki.eu/index.php/CRTC#CRTC_Differences
+
+template <class T> class CRTC6845 {
+	public:
+
+		CRTC6845(Personality p, T &bus_handler) noexcept :
+			personality_(p), bus_handler_(bus_handler), status_(0) {}
+
+		void select_register(uint8_t r) {
+			selected_register_ = r;
+		}
+
+		uint8_t get_status() {
+			switch(personality_) {
+				case UM6845R:	return status_ | (bus_state_.vsync ? 0x20 : 0x00);
+				case AMS40226:	return get_register();
+				default:		return 0xff;
+			}
+			return 0xff;
+		}
+
+		uint8_t get_register() {
+			if(selected_register_ == 31) status_ &= ~0x80;
+			if(selected_register_ == 16 || selected_register_ == 17) status_ &= ~0x40;
+
+			if(personality_ == UM6845R && selected_register_ == 31) return dummy_register_;
+			if(selected_register_ < 12 || selected_register_ > 17) return 0xff;
+			return registers_[selected_register_];
+		}
+
+		void set_register(uint8_t value) {
+			static uint8_t masks[] = {
+				0xff, 0xff, 0xff, 0xff, 0x7f, 0x1f, 0x7f, 0x7f,
+				0xff, 0x1f, 0x7f, 0x1f, 0x3f, 0xff, 0x3f, 0xff
+			};
+
+			// Per CPC documentation, skew doesn't work on a "type 1 or 2", i.e. an MC6845 or a UM6845R.
+			if(selected_register_ == 8 && personality_ != UM6845R && personality_ != MC6845) {
+				switch((value >> 4)&3) {
+					default:	display_skew_mask_ = 1;		break;
+					case 1:		display_skew_mask_ = 2;		break;
+					case 2:		display_skew_mask_ = 4;		break;
+				}
+			}
+
+			if(selected_register_ < 16) {
+				registers_[selected_register_] = value & masks[selected_register_];
+			}
+			if(selected_register_ == 31 && personality_ == UM6845R) {
+				dummy_register_ = value;
+			}
+		}
+
+		void trigger_light_pen() {
+			registers_[17] = bus_state_.refresh_address & 0xff;
+			registers_[16] = bus_state_.refresh_address >> 8;
+			status_ |= 0x40;
+		}
+
+		void run_for(Cycles cycles) {
+			int cyles_remaining = cycles.as_int();
+			while(cyles_remaining--) {
+				// check for end of visible characters
+				if(character_counter_ == registers_[1]) {
+					// TODO: consider skew in character_is_visible_. Or maybe defer until perform_bus_cycle?
+					character_is_visible_ = false;
+					end_of_line_address_ = bus_state_.refresh_address;
+				}
+
+				perform_bus_cycle_phase1();
+				bus_state_.refresh_address = (bus_state_.refresh_address + 1) & 0x3fff;
+
+				// check for end-of-line
+				if(character_counter_ == registers_[0]) {
+					character_counter_ = 0;
+					do_end_of_line();
+					character_is_visible_ = true;
+				} else {
+					// increment counter
+					character_counter_++;
+				}
+
+				// check for start of horizontal sync
+				if(character_counter_ == registers_[2]) {
+					hsync_counter_ = 0;
+					bus_state_.hsync = true;
+				}
+
+				// check for end of horizontal sync; note that a sync time of zero will result in an immediate
+				// cancellation of the plan to perform sync if this is an HD6845S or UM6845R; otherwise zero
+				// will end up counting as 16 as it won't be checked until after overflow.
+				if(bus_state_.hsync) {
+					switch(personality_) {
+						case HD6845S:
+						case UM6845R:
+							bus_state_.hsync = hsync_counter_ != (registers_[3] & 15);
+							hsync_counter_ = (hsync_counter_ + 1) & 15;
+						break;
+						default:
+							hsync_counter_ = (hsync_counter_ + 1) & 15;
+							bus_state_.hsync = hsync_counter_ != (registers_[3] & 15);
+						break;
+					}
+				}
+
+				perform_bus_cycle_phase2();
+			}
+		}
+
+		const BusState &get_bus_state() const {
+			return bus_state_;
+		}
+
+	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_;
+			bus_handler_.perform_bus_cycle_phase1(bus_state_);
+		}
+
+		inline void perform_bus_cycle_phase2() {
+			bus_handler_.perform_bus_cycle_phase2(bus_state_);
+		}
+
+		inline void do_end_of_line() {
+			// check for end of vertical sync
+			if(bus_state_.vsync) {
+				vsync_counter_ = (vsync_counter_ + 1) & 15;
+				// on the UM6845R and AMS40226, honour the programmed vertical sync time; on the other CRTCs
+				// always use a vertical sync count of 16.
+				switch(personality_) {
+					case HD6845S:
+					case AMS40226:
+						bus_state_.vsync = vsync_counter_ != (registers_[3] >> 4);
+					break;
+					default:
+						bus_state_.vsync = vsync_counter_ != 0;
+					break;
+				}
+			}
+
+			if(is_in_adjustment_period_) {
+				line_counter_++;
+				if(line_counter_ == registers_[5]) {
+					is_in_adjustment_period_ = false;
+					do_end_of_frame();
+				}
+			} else {
+				// advance vertical counter
+				if(bus_state_.row_address == registers_[9]) {
+					bus_state_.row_address = 0;
+					line_address_ = end_of_line_address_;
+
+					// check for entry into the overflow area
+					if(line_counter_ == registers_[4]) {
+						if(registers_[5]) {
+							line_counter_ = 0;
+							is_in_adjustment_period_ = true;
+						} else {
+							do_end_of_frame();
+						}
+					} else {
+						line_counter_ = (line_counter_ + 1) & 0x7f;
+
+						// check for start of vertical sync
+						if(line_counter_ == registers_[7]) {
+							bus_state_.vsync = true;
+							vsync_counter_ = 0;
+						}
+
+						// check for end of visible lines
+						if(line_counter_ == registers_[6]) {
+							line_is_visible_ = false;
+						}
+					}
+				} else {
+					bus_state_.row_address = (bus_state_.row_address + 1) & 0x1f;
+				}
+			}
+
+			bus_state_.refresh_address = line_address_;
+			character_counter_ = 0;
+			character_is_visible_ = (registers_[1] != 0);
+		}
+
+		inline void do_end_of_frame() {
+			line_counter_ = 0;
+			line_is_visible_ = true;
+			line_address_ = static_cast<uint16_t>((registers_[12] << 8) | registers_[13]);
+			bus_state_.refresh_address = line_address_;
+		}
+
+		Personality personality_;
+		T &bus_handler_;
+		BusState bus_state_;
+
+		uint8_t registers_[18] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+		uint8_t dummy_register_ = 0;
+		int selected_register_ = 0;
+
+		uint8_t character_counter_ = 0;
+		uint8_t line_counter_ = 0;
+
+		bool character_is_visible_ = false, line_is_visible_ = false;
+
+		int hsync_counter_ = 0;
+		int vsync_counter_ = 0;
+		bool is_in_adjustment_period_ = false;
+
+		uint16_t line_address_ = 0;
+		uint16_t end_of_line_address_ = 0;
+		uint8_t status_ = 0;
+
+		int display_skew_mask_ = 1;
+		unsigned int character_is_visible_shifter_ = 0;
+};
+
+}
+}
+
+#endif /* CRTC6845_hpp */

Components/8255/i8255.hpp

@@ -0,0 +1,92 @@
+//
+//  i8255.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/08/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef i8255_hpp
+#define i8255_hpp
+
+namespace Intel {
+namespace i8255 {
+
+class PortHandler {
+	public:
+		void set_value(int port, uint8_t value) {}
+		uint8_t get_value(int port) { return 0xff; }
+};
+
+// TODO: Modes 1 and 2.
+template <class T> class i8255 {
+	public:
+		i8255(T &port_handler) : control_(0), outputs_{0, 0, 0}, port_handler_(port_handler) {}
+
+		/*!
+			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) {
+			switch(address & 3) {
+				case 0:
+					if(!(control_ & 0x10)) {
+						// TODO: so what would output be when switching from input to output mode?
+						outputs_[0] = value; port_handler_.set_value(0, value);
+					}
+				break;
+				case 1:
+					if(!(control_ & 0x02)) {
+						outputs_[1] = value; port_handler_.set_value(1, value);
+					}
+				break;
+				case 2:	outputs_[2] = value; port_handler_.set_value(2, value);	break;
+				case 3:
+					if(value & 0x80) {
+						control_ = value;
+					} else {
+						if(value & 1) {
+							outputs_[2] |= 1 << ((value >> 1)&7);
+						} else {
+							outputs_[2] &= ~(1 << ((value >> 1)&7));
+						}
+					}
+					update_outputs();
+				break;
+			}
+		}
+
+		/*!
+			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) {
+			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];
+				case 2:	{
+					if(!(control_ & 0x09)) return outputs_[2];
+					uint8_t input = port_handler_.get_value(2);
+					return ((control_ & 0x01) ? (input & 0x0f) : (outputs_[2] & 0x0f)) | ((control_ & 0x08) ? (input & 0xf0) : (outputs_[2] & 0xf0));
+				}
+				case 3:	return control_;
+			}
+			return 0xff;
+		}
+
+	private:
+		void update_outputs() {
+			if(!(control_ & 0x10)) port_handler_.set_value(0, outputs_[0]);
+			if(!(control_ & 0x02)) port_handler_.set_value(1, outputs_[1]);
+			port_handler_.set_value(2, outputs_[2]);
+		}
+
+		uint8_t control_;
+		uint8_t outputs_[3];
+		T &port_handler_;
+};
+
+}
+}
+
+#endif /* i8255_hpp */

Components/8272/i8272.cpp

@@ -0,0 +1,894 @@
+//
+//  i8272.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 05/08/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "i8272.hpp"
+
+#include "../../Outputs/Log.hpp"
+
+using namespace Intel::i8272;
+
+#define SetDataRequest()				(main_status_ |= 0x80)
+#define ResetDataRequest()				(main_status_ &= ~0x80)
+#define DataRequest()					(main_status_ & 0x80)
+
+#define SetDataDirectionToProcessor()	(main_status_ |= 0x40)
+#define SetDataDirectionFromProcessor()	(main_status_ &= ~0x40)
+#define DataDirectionToProcessor()		(main_status_ & 0x40)
+
+#define SetNonDMAExecution()			(main_status_ |= 0x20)
+#define ResetNonDMAExecution()			(main_status_ &= ~0x20)
+
+#define SetBusy()						(main_status_ |= 0x10)
+#define ResetBusy()						(main_status_ &= ~0x10)
+#define Busy()							(main_status_ & 0x10)
+
+#define SetAbnormalTermination()		(status_[0] |= 0x40)
+#define SetInvalidCommand()				(status_[0] |= 0x80)
+#define SetReadyChanged()				(status_[0] |= 0xc0)
+#define SetSeekEnd()					(status_[0] |= 0x20)
+#define SetEquipmentCheck()				(status_[0] |= 0x10)
+#define SetNotReady()					(status_[0] |= 0x08)
+#define SetSide2()						(status_[0] |= 0x04)
+
+#define SetEndOfCylinder()				(status_[1] |= 0x80)
+#define SetDataError()					(status_[1] |= 0x20)
+#define SetOverrun()					(status_[1] |= 0x10)
+#define SetNoData()						(status_[1] |= 0x04)
+#define SetNotWriteable()				(status_[1] |= 0x02)
+#define SetMissingAddressMark()			(status_[1] |= 0x01)
+
+#define SetControlMark()				(status_[2] |= 0x40)
+#define ClearControlMark()				(status_[2] &= ~0x40)
+#define ControlMark()					(status_[2] & 0x40)
+
+#define SetDataFieldDataError()			(status_[2] |= 0x20)
+#define SetWrongCyinder()				(status_[2] |= 0x10)
+#define SetScanEqualHit()				(status_[2] |= 0x08)
+#define SetScanNotSatisfied()			(status_[2] |= 0x04)
+#define SetBadCylinder()				(status_[2] |= 0x02)
+#define SetMissingDataAddressMark()		(status_[2] |= 0x01)
+
+namespace {
+	const uint8_t CommandReadData = 0x06;
+	const uint8_t CommandReadDeletedData = 0x0c;
+
+	const uint8_t CommandWriteData = 0x05;
+	const uint8_t CommandWriteDeletedData = 0x09;
+
+	const uint8_t CommandReadTrack = 0x02;
+	const uint8_t CommandReadID = 0x0a;
+	const uint8_t CommandFormatTrack = 0x0d;
+
+	const uint8_t CommandScanLow = 0x11;
+	const uint8_t CommandScanLowOrEqual = 0x19;
+	const uint8_t CommandScanHighOrEqual = 0x1d;
+
+	const uint8_t CommandRecalibrate = 0x07;
+	const uint8_t CommandSeek = 0x0f;
+
+	const uint8_t CommandSenseInterruptStatus = 0x08;
+	const uint8_t CommandSpecify = 0x03;
+	const uint8_t CommandSenseDriveStatus = 0x04;
+}
+
+i8272::i8272(BusHandler &bus_handler, Cycles clock_rate) :
+	Storage::Disk::MFMController(clock_rate),
+	bus_handler_(bus_handler) {
+	posit_event(static_cast<int>(Event8272::CommandByte));
+}
+
+ClockingHint::Preference i8272::preferred_clocking() {
+	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;
+}
+
+void i8272::run_for(Cycles cycles) {
+	Storage::Disk::MFMController::run_for(cycles);
+
+	if(is_sleeping_) return;
+
+	// check for an expired timer
+	if(delay_time_ > 0) {
+		if(cycles.as_int() >= delay_time_) {
+			delay_time_ = 0;
+			posit_event(static_cast<int>(Event8272::Timer));
+		} else {
+			delay_time_ -= cycles.as_int();
+		}
+	}
+
+	// update seek status of any drives presently seeking
+	if(drives_seeking_) {
+		int drives_left = drives_seeking_;
+		for(int c = 0; c < 4; c++) {
+			if(drives_[c].phase == Drive::Seeking) {
+				drives_[c].step_rate_counter += cycles.as_int();
+				int steps = drives_[c].step_rate_counter / (8000 * step_rate_time_);
+				drives_[c].step_rate_counter %= (8000 * step_rate_time_);
+				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));
+					select_drive(c);
+					get_drive().step(Storage::Disk::HeadPosition(direction));
+					if(drives_[c].target_head_position >= 0) drives_[c].head_position += direction;
+
+					// Check for completion.
+					if(seek_is_satisfied(c)) {
+						drives_[c].phase = Drive::CompletedSeeking;
+						drives_seeking_--;
+						break;
+					}
+				}
+
+				drives_left--;
+				if(!drives_left) break;
+			}
+		}
+	}
+
+	// check for any head unloads
+	if(head_timers_running_) {
+		int timers_left = head_timers_running_;
+		for(int c = 0; c < 8; c++) {
+			int drive = (c >> 1);
+			int head = c&1;
+
+			if(drives_[drive].head_unload_delay[head] > 0) {
+				if(cycles.as_int() >= drives_[drive].head_unload_delay[head]) {
+					drives_[drive].head_unload_delay[head] = 0;
+					drives_[drive].head_is_loaded[head] = false;
+					head_timers_running_--;
+				} else {
+					drives_[drive].head_unload_delay[head] -= cycles.as_int();
+				}
+				timers_left--;
+				if(!timers_left) break;
+			}
+		}
+	}
+
+	// check for busy plus ready disabled
+	if(is_executing_ && !get_drive().get_is_ready()) {
+		posit_event(static_cast<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) {
+	// don't consider attempted sets to the status register
+	if(!address) return;
+
+	// if not ready for commands, do nothing
+	if(!DataRequest() || DataDirectionToProcessor()) return;
+
+	if(expects_input_) {
+		input_ = value;
+		has_input_ = true;
+		ResetDataRequest();
+	} else {
+		// accumulate latest byte in the command byte sequence
+		command_.push_back(value);
+		posit_event(static_cast<int>(Event8272::CommandByte));
+	}
+}
+
+uint8_t i8272::get_register(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));
+
+		return result;
+	} else {
+		return main_status_;
+	}
+}
+
+#define BEGIN_SECTION()	switch(resume_point_) { default:
+#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 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_--; }	\
+	else if(get_latest_token().type == Token::ID) goto CONCAT(header_found, __LINE__);	\
+	\
+	if(index_hole_limit_) goto CONCAT(find_header, __LINE__);	\
+	CONCAT(header_found, __LINE__):	(void)0;\
+
+#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)) { \
+		if(get_latest_token().type == Token::Byte || get_latest_token().type == Token::Sync) goto CONCAT(find_data, __LINE__);	\
+	}
+
+#define READ_HEADER()	\
+	distance_into_section_ = 0;	\
+	set_data_mode(DataMode::Reading);	\
+	CONCAT(read_header, __LINE__): WAIT_FOR_EVENT(Event::Token); \
+	header_[distance_into_section_] = get_latest_token().byte_value;	\
+	distance_into_section_++; \
+	if(distance_into_section_ < 6) goto CONCAT(read_header, __LINE__);	\
+
+#define SET_DRIVE_HEAD_MFM()	\
+	active_drive_ = command_[1]&3;	\
+	active_head_ = (command_[1] >> 2)&1;	\
+	status_[0] = (command_[1]&7);	\
+	select_drive(active_drive_);	\
+	get_drive().set_head(active_head_);	\
+	set_is_double_density(command_[0] & 0x40);
+
+#define WAIT_FOR_BYTES(n) \
+	distance_into_section_ = 0;	\
+	CONCAT(wait_bytes, __LINE__): WAIT_FOR_EVENT(Event::Token);	\
+	if(get_latest_token().type == Token::Byte) distance_into_section_++;	\
+	if(distance_into_section_ < (n)) goto CONCAT(wait_bytes, __LINE__);
+
+#define LOAD_HEAD()	\
+	if(!drives_[active_drive_].head_is_loaded[active_head_]) {	\
+		drives_[active_drive_].head_is_loaded[active_head_] = true;	\
+		WAIT_FOR_TIME(head_load_time_);	\
+	} else {	\
+		if(drives_[active_drive_].head_unload_delay[active_head_] > 0) {	\
+			drives_[active_drive_].head_unload_delay[active_head_] = 0;	\
+			head_timers_running_--;	\
+		}	\
+	}
+
+#define SCHEDULE_HEAD_UNLOAD()	\
+	if(drives_[active_drive_].head_is_loaded[active_head_]) {\
+		if(drives_[active_drive_].head_unload_delay[active_head_] == 0) {	\
+			head_timers_running_++;	\
+			is_sleeping_ = false;	\
+			update_clocking_observer();	\
+		}	\
+		drives_[active_drive_].head_unload_delay[active_head_] = MS_TO_CYCLES(head_unload_time_);\
+	}
+
+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)) {
+		SetNotReady();
+		goto abort;
+	}
+	if(!(interesting_event_mask_ & event_type)) return;
+	interesting_event_mask_ &= ~event_type;
+
+	BEGIN_SECTION();
+
+	// Resets busy and non-DMA execution, clears the command buffer, sets the data mode to scanning and flows
+	// into wait_for_complete_command_sequence.
+	wait_for_command:
+			expects_input_ = false;
+			set_data_mode(Storage::Disk::MFMController::DataMode::Scanning);
+			ResetBusy();
+			ResetNonDMAExecution();
+			command_.clear();
+
+	// Sets the data request bit, and waits for a byte. Then sets the busy bit. Continues accepting bytes
+	// until it has a quantity that make up an entire command, then resets the data request bit and
+	// branches to that command.
+	wait_for_complete_command_sequence:
+			SetDataRequest();
+			SetDataDirectionFromProcessor();
+			WAIT_FOR_EVENT(Event8272::CommandByte)
+			SetBusy();
+
+			static const std::size_t required_lengths[32] = {
+				0,	0,	9,	3,	2,	9,	9,	2,
+				1,	9,	2,	0,	9,	6,	0,	3,
+				0,	9,	0,	0,	0,	0,	0,	0,
+				0,	9,	0,	0,	0,	9,	0,	0,
+			};
+
+			if(command_.size() < required_lengths[command_[0] & 0x1f]) goto wait_for_complete_command_sequence;
+			if(command_.size() == 9) {
+				cylinder_ = command_[2];
+				head_ = command_[3];
+				sector_ = command_[4];
+				size_ = command_[5];
+			}
+			ResetDataRequest();
+			status_[0] = status_[1] = status_[2] = 0;
+
+			// If this is not clearly a command that's safe to carry out in parallel to a seek, end all seeks.
+			switch(command_[0] & 0x1f) {
+				case CommandReadData:
+				case CommandReadDeletedData:
+				case CommandWriteData:
+				case CommandWriteDeletedData:
+				case CommandReadTrack:
+				case CommandReadID:
+				case CommandFormatTrack:
+				case CommandScanLow:
+				case CommandScanLowOrEqual:
+				case CommandScanHighOrEqual:
+					is_access_command_ = true;
+				break;
+
+				default:
+					is_access_command_ = false;
+				break;
+			}
+
+			if(is_access_command_) {
+				for(int c = 0; c < 4; c++) {
+					if(drives_[c].phase == Drive::Seeking) {
+						drives_[c].phase = Drive::NotSeeking;
+						drives_seeking_--;
+					}
+				}
+				// Establishes the drive and head being addressed, and whether in double density mode; populates the internal
+				// cylinder, head, sector and size registers from the command stream.
+				is_executing_ = true;
+				if(!dma_mode_) SetNonDMAExecution();
+				SET_DRIVE_HEAD_MFM();
+				LOAD_HEAD();
+				if(!get_drive().get_is_ready()) {
+					SetNotReady();
+					goto abort;
+				}
+			}
+
+			// Jump to the proper place.
+			switch(command_[0] & 0x1f) {
+				case CommandReadData:
+				case CommandReadDeletedData:
+					goto read_data;
+
+				case CommandWriteData:
+				case CommandWriteDeletedData:
+					goto write_data;
+
+				case CommandReadTrack:				goto read_track;
+				case CommandReadID:					goto read_id;
+				case CommandFormatTrack:			goto format_track;
+
+				case CommandScanLow:				goto scan_low;
+				case CommandScanLowOrEqual:			goto scan_low_or_equal;
+				case CommandScanHighOrEqual:		goto scan_high_or_equal;
+
+				case CommandRecalibrate:			goto recalibrate;
+				case CommandSeek:					goto seek;
+
+				case CommandSenseInterruptStatus:	goto sense_interrupt_status;
+				case CommandSpecify:				goto specify;
+				case CommandSenseDriveStatus:		goto sense_drive_status;
+
+				default:							goto invalid;
+			}
+
+	// Decodes drive, head and density, loads the head, loads the internal cylinder, head, sector and size registers,
+	// and searches for a sector that meets those criteria. If one is found, inspects the instruction in use and
+	// jumps to an appropriate handler.
+	read_write_find_header:
+
+		// Sets a maximum index hole limit of 2 then performs a find header/read header loop, continuing either until
+		// the index hole limit is breached or a sector is found with a cylinder, head, sector and size equal to the
+		// values in the internal registers.
+			index_hole_limit_ = 2;
+//			LOG("Seeking " << PADDEC(0) << cylinder_ << " " << head_ " " << sector_ << " " << size_);
+		find_next_sector:
+			FIND_HEADER();
+			if(!index_hole_limit_) {
+				// Two index holes have passed wihout finding the header sought.
+//				LOG("Not found");
+				SetNoData();
+				goto abort;
+			}
+			index_hole_count_ = 0;
+//			LOG("Header");
+			READ_HEADER();
+			if(index_hole_count_) {
+				// This implies an index hole was sighted within the header. Error out.
+				SetEndOfCylinder();
+				goto abort;
+			}
+			if(get_crc_generator().get_value()) {
+				// This implies a CRC error in the header; mark as such but continue.
+				SetDataError();
+			}
+//			LOG("Considering << PADHEX(2) << header_[0] << " " << header_[1] << " " << header_[2] << " " << header_[3] << " [" << get_crc_generator().get_value() << "]");
+			if(header_[0] != cylinder_ || header_[1] != head_ || header_[2] != sector_ || header_[3] != size_) goto find_next_sector;
+
+			// Branch to whatever is supposed to happen next
+//			LOG("Proceeding");
+			switch(command_[0] & 0x1f) {
+				case CommandReadData:
+				case CommandReadDeletedData:
+				goto read_data_found_header;
+
+				case CommandWriteData:	// write data
+				case CommandWriteDeletedData:	// write deleted data
+				goto write_data_found_header;
+			}
+
+
+	// 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]) << "]");
+		read_next_data:
+			goto read_write_find_header;
+
+		// Finds the next data block and sets data mode to reading, setting an error flag if the on-disk deleted
+		// flag doesn't match the sort the command was looking for.
+		read_data_found_header:
+			FIND_DATA();
+			ClearControlMark();
+			if(event_type == static_cast<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();
+					SetMissingDataAddressMark();
+					goto abort;	// TODO: or read_next_data?
+				} else {
+					if((get_latest_token().type == Token::Data) != ((command_[0] & 0x1f) == CommandReadData)) {
+						if(!(command_[0]&0x20)) {
+							// SK is not set; set the error flag but read this sector before finishing.
+							SetControlMark();
+						} else {
+							// SK is set; skip this sector.
+							goto read_next_data;
+						}
+					}
+				}
+			} else {
+				// An index hole appeared before the data mark.
+				SetEndOfCylinder();
+				goto abort;	// TODO: or read_next_data?
+			}
+
+			distance_into_section_ = 0;
+			set_data_mode(Reading);
+
+		// Waits for the next token, then supplies it to the CPU by: (i) setting data request and direction; and (ii) resetting
+		// data request once the byte has been taken. Continues until all bytes have been read.
+		//
+		// 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)) {
+				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));
+			}
+			switch(event_type) {
+				case static_cast<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
+					SetOverrun();
+					goto abort;
+				break;
+				case static_cast<int>(Event::IndexHole):
+					SetEndOfCylinder();
+					goto abort;
+				break;
+			}
+
+		// read CRC, without transferring it, then check it
+			WAIT_FOR_EVENT(Event::Token);
+			WAIT_FOR_EVENT(Event::Token);
+			if(get_crc_generator().get_value()) {
+				// This implies a CRC error in the sector; mark as such and temrinate.
+				SetDataError();
+				SetDataFieldDataError();
+				goto abort;
+			}
+
+		// check whether that's it: either the final requested sector has been read, or because
+		// a sector that was [/wasn't] marked as deleted when it shouldn't [/should] have been
+			if(sector_ != command_[6] && !ControlMark()) {
+				sector_++;
+				goto read_next_data;
+			}
+
+		// For a final result phase, post the standard ST0, ST1, ST2, C, H, R, N
+			goto post_st012chrn;
+
+	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]) << "]");
+
+			if(get_drive().get_is_read_only()) {
+				SetNotWriteable();
+				goto abort;
+			}
+
+		write_next_data:
+			goto read_write_find_header;
+
+		write_data_found_header:
+			WAIT_FOR_BYTES(get_is_double_density() ? 22 : 11);
+			begin_writing(true);
+
+			write_id_data_joiner((command_[0] & 0x1f) == CommandWriteDeletedData, true);
+
+			SetDataDirectionFromProcessor();
+			SetDataRequest();
+			expects_input_ = true;
+			distance_into_section_ = 0;
+
+		write_loop:
+			WAIT_FOR_EVENT(Event::DataWritten);
+			if(!has_input_) {
+				SetOverrun();
+				goto abort;
+			}
+			write_byte(input_);
+			has_input_ = false;
+			distance_into_section_++;
+			if(distance_into_section_ < (128 << size_)) {
+				SetDataRequest();
+				goto write_loop;
+			}
+
+			LOG("Wrote " << PADDEC(0) << distance_into_section_ << " bytes");
+			write_crc();
+			expects_input_ = false;
+			WAIT_FOR_EVENT(Event::DataWritten);
+			end_writing();
+
+			if(sector_ != command_[6]) {
+				sector_++;
+				goto write_next_data;
+			}
+
+		goto post_st012chrn;
+
+	// 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]) << "]");
+
+		// 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.
+			index_hole_limit_ = 2;
+			FIND_HEADER();
+			if(!index_hole_limit_) {
+				SetMissingAddressMark();
+				goto abort;
+			}
+			READ_HEADER();
+
+		// Sets internal registers from the discovered header and posts the standard ST0, ST1, ST2, C, H, R, N.
+			cylinder_ = header_[0];
+			head_ = header_[1];
+			sector_ = header_[2];
+			size_ = header_[3];
+
+			goto post_st012chrn;
+
+	// 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]) << "]");
+
+			// Wait for the index hole.
+			WAIT_FOR_EVENT(Event::IndexHole);
+
+			sector_ = 0;
+			index_hole_limit_ = 2;
+
+		// While not index hole again, stream all sector contents until EOT sectors have been read.
+		read_track_next_sector:
+			FIND_HEADER();
+			if(!index_hole_limit_) {
+				if(!sector_) {
+					SetMissingAddressMark();
+					goto abort;
+				} else {
+					goto post_st012chrn;
+				}
+			}
+			READ_HEADER();
+
+			FIND_DATA();
+			distance_into_section_ = 0;
+			SetDataDirectionToProcessor();
+		read_track_get_byte:
+			WAIT_FOR_EVENT(Event::Token);
+			result_stack_.push_back(get_latest_token().byte_value);
+			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));
+			ResetDataRequest();
+			if(distance_into_section_ < (128 << header_[2])) goto read_track_get_byte;
+
+			sector_++;
+			if(sector_ < command_[6]) goto read_track_next_sector;
+
+			goto post_st012chrn;
+
+	// Performs format [/write] track.
+	format_track:
+			LOG("Format track");
+			if(get_drive().get_is_read_only()) {
+				SetNotWriteable();
+				goto abort;
+			}
+
+			// Wait for the index hole.
+			WAIT_FOR_EVENT(Event::IndexHole);
+			index_hole_count_ = 0;
+			begin_writing(true);
+
+			// Write start-of-track.
+			write_start_of_track();
+			WAIT_FOR_EVENT(Event::DataWritten);
+			sector_ = 0;
+
+		format_track_write_sector:
+			write_id_joiner();
+
+			// Write the sector header, obtaining its contents
+			// from the processor.
+			SetDataDirectionFromProcessor();
+			SetDataRequest();
+			expects_input_ = true;
+			distance_into_section_ = 0;
+		format_track_write_header:
+			WAIT_FOR_EVENT(static_cast<int>(Event::DataWritten) | static_cast<int>(Event::IndexHole));
+			switch(event_type) {
+				case static_cast<int>(Event::IndexHole):
+					SetOverrun();
+					goto abort;
+				break;
+				case static_cast<int>(Event::DataWritten):
+					header_[distance_into_section_] = input_;
+					write_byte(input_);
+					has_input_ = false;
+					distance_into_section_++;
+					if(distance_into_section_ < 4) {
+						SetDataRequest();
+						goto format_track_write_header;
+					}
+				break;
+			}
+
+			LOG(PADHEX(2) << "W:"
+				<< static_cast<int>(header_[0]) << " "
+				<< static_cast<int>(header_[1]) << " "
+				<< static_cast<int>(header_[2]) << " "
+				<< static_cast<int>(header_[3]) << ", "
+				<< get_crc_generator().get_value());
+			write_crc();
+
+			// Write the sector body.
+			write_id_data_joiner(false, false);
+			write_n_bytes(128 << command_[2], command_[5]);
+			write_crc();
+
+			// Write the prescribed gap.
+			write_n_bytes(command_[4], get_is_double_density() ? 0x4e : 0xff);
+
+			// Consider repeating.
+			sector_++;
+			if(sector_ < command_[3] && !index_hole_count_)
+				goto format_track_write_sector;
+
+			// 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;
+
+			end_writing();
+
+			cylinder_ = header_[0];
+			head_ = header_[1];
+			sector_ = header_[2] + 1;
+			size_ = header_[3];
+
+		goto post_st012chrn;
+
+	scan_low:
+		ERROR("Scan low unimplemented!!");
+		goto wait_for_command;
+
+	scan_low_or_equal:
+		ERROR("Scan low or equal unimplemented!!");
+		goto wait_for_command;
+
+	scan_high_or_equal:
+		ERROR("Scan high or equal unimplemented!!");
+		goto wait_for_command;
+
+	// Performs both recalibrate and seek commands. These commands occur asynchronously, so the actual work
+	// occurs in ::run_for; this merely establishes that seeking should be ongoing.
+	recalibrate:
+	seek:
+			{
+				int drive = command_[1]&3;
+				select_drive(drive);
+
+				// Increment the seeking count if this drive wasn't already seeking.
+				if(drives_[drive].phase != Drive::Seeking) {
+					drives_seeking_++;
+					is_sleeping_ = false;
+					update_clocking_observer();
+				}
+
+				// Set currently seeking, with a step to occur right now (yes, it sounds like jamming these
+				// in could damage your drive motor).
+				drives_[drive].phase = Drive::Seeking;
+				drives_[drive].step_rate_counter = 8000 * step_rate_time_;
+				drives_[drive].steps_taken = 0;
+				drives_[drive].seek_failed = false;
+				main_status_ |= 1 << (command_[1]&3);
+
+				// If this is a seek, set the processor-supplied target location; otherwise it is a recalibrate,
+				// which means resetting the current state now but aiming to hit '-1' (which the stepping code
+				// 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]));
+				} else {
+					drives_[drive].target_head_position = -1;
+					drives_[drive].head_position = 0;
+					LOG("Recalibrate");
+				}
+
+				// Check whether any steps are even needed; if not then mark as completed already.
+				if(seek_is_satisfied(drive)) {
+					drives_[drive].phase = Drive::CompletedSeeking;
+					drives_seeking_--;
+				}
+			}
+			goto wait_for_command;
+
+	// Performs sense interrupt status.
+	sense_interrupt_status:
+			LOG("Sense interrupt status");
+			{
+				// Find the first drive that is in the CompletedSeeking state.
+				int found_drive = -1;
+				for(int c = 0; c < 4; c++) {
+					if(drives_[c].phase == Drive::CompletedSeeking) {
+						found_drive = c;
+						break;
+					}
+				}
+
+				// 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);
+					main_status_ &= ~(1 << found_drive);
+					SetSeekEnd();
+
+					result_stack_ = { drives_[found_drive].head_position, status_[0]};
+				} else {
+					result_stack_ = { 0x80 };
+				}
+			}
+			goto post_result;
+
+	// Performs specify.
+	specify:
+		// Just store the values, and terminate the command.
+			LOG("Specify");
+			step_rate_time_ = 16 - (command_[1] >> 4);			// i.e. 1 to 16ms
+			head_unload_time_ = (command_[1] & 0x0f) << 4;		// i.e. 16 to 240ms
+			head_load_time_ = command_[2] & ~1;					// i.e. 2 to 254 ms in increments of 2ms
+
+			if(!head_unload_time_) head_unload_time_ = 16;
+			if(!head_load_time_) head_load_time_ = 2;
+			dma_mode_ = !(command_[2] & 1);
+			goto wait_for_command;
+
+	sense_drive_status:
+			LOG("Sense drive status");
+			{
+				int drive = command_[1] & 3;
+				select_drive(drive);
+				result_stack_= {
+					static_cast<uint8_t>(
+						(command_[1] & 7) |	// drive and head number
+						0x08 |				// single sided
+						(get_drive().get_is_track_zero() ? 0x10 : 0x00)	|
+						(get_drive().get_is_ready() ? 0x20 : 0x00)		|
+						(get_drive().get_is_read_only() ? 0x40 : 0x00)
+					)
+				};
+			}
+			goto post_result;
+
+	// Performs any invalid command.
+	invalid:
+			// A no-op, but posts ST0 (but which ST0?)
+			result_stack_ = {0x80};
+			goto post_result;
+
+	// Sets abnormal termination of the current command and proceeds to an ST0, ST1, ST2, C, H, R, N result phase.
+	abort:
+		end_writing();
+		SetAbnormalTermination();
+		goto post_st012chrn;
+
+	// Posts ST0, ST1, ST2, C, H, R and N as a result phase.
+	post_st012chrn:
+			SCHEDULE_HEAD_UNLOAD();
+
+			result_stack_ = {size_, sector_, head_, cylinder_, status_[2], status_[1], status_[0]};
+
+			goto post_result;
+
+	// 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_) << "; ");
+			for(std::size_t c = 0; c < result_stack_.size(); c++) {
+				LOGNBR(" " << static_cast<int>(result_stack_[result_stack_.size() - 1 - c]));
+			}
+			LOGNBR(std::endl);
+
+			// Set ready to send data to the processor, no longer in non-DMA execution phase.
+			is_executing_ = false;
+			ResetNonDMAExecution();
+			SetDataRequest();
+			SetDataDirectionToProcessor();
+
+			// The actual stuff of unwinding result_stack_ is handled by ::get_register; wait
+			// until the processor has read all result bytes.
+			WAIT_FOR_EVENT(Event8272::ResultEmpty);
+
+			// Reset data direction and end the command.
+			goto wait_for_command;
+
+	END_SECTION()
+}
+
+bool i8272::seek_is_satisfied(int drive) {
+	return	(drives_[drive].target_head_position == drives_[drive].head_position) ||
+			(drives_[drive].target_head_position == -1 && get_drive().get_is_track_zero());
+}
+
+void i8272::set_dma_acknowledge(bool dack) {
+}
+
+void i8272::set_terminal_count(bool tc) {
+}
+
+void i8272::set_data_input(uint8_t value) {
+}
+
+uint8_t i8272::get_data_output() {
+	return 0xff;
+}

Components/8272/i8272.hpp

@@ -0,0 +1,135 @@
+//
+//  i8272.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 05/08/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef i8272_hpp
+#define i8272_hpp
+
+#include "../../Storage/Disk/Controller/MFMDiskController.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace Intel {
+namespace i8272 {
+
+class BusHandler {
+	public:
+		virtual void set_dma_data_request(bool drq) {}
+		virtual void set_interrupt(bool irq) {}
+};
+
+class i8272: public Storage::Disk::MFMController {
+	public:
+		i8272(BusHandler &bus_handler, Cycles clock_rate);
+
+		void run_for(Cycles);
+
+		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 set_dma_acknowledge(bool dack);
+		void set_terminal_count(bool tc);
+
+		ClockingHint::Preference preferred_clocking() override;
+
+	protected:
+		virtual void select_drive(int number) = 0;
+
+	private:
+		// The bus handler, for interrupt and DMA-driven usage.
+		BusHandler &bus_handler_;
+		std::unique_ptr<BusHandler> allocated_bus_handler_;
+
+		// Status registers.
+		uint8_t main_status_ = 0;
+		uint8_t status_[3] = {0, 0, 0};
+
+		// A buffer for accumulating the incoming command, and one for accumulating the result.
+		std::vector<uint8_t> command_;
+		std::vector<uint8_t> result_stack_;
+		uint8_t input_ = 0;
+		bool has_input_ = false;
+		bool expects_input_ = false;
+
+		// Event stream: the 8272-specific events, plus the current event state.
+		enum class Event8272: int {
+			CommandByte	= (1 << 3),
+			Timer = (1 << 4),
+			ResultEmpty = (1 << 5),
+			NoLongerReady = (1 << 6)
+		};
+		void posit_event(int type) override;
+		int interesting_event_mask_ = static_cast<int>(Event8272::CommandByte);
+		int resume_point_ = 0;
+		bool is_access_command_ = false;
+
+		// The counter used for ::Timer events.
+		int delay_time_ = 0;
+
+		// The connected drives.
+		struct Drive {
+			uint8_t head_position = 0;
+
+			// Seeking: persistent state.
+			enum Phase {
+				NotSeeking,
+				Seeking,
+				CompletedSeeking
+			} phase = NotSeeking;
+			bool did_seek = false;
+			bool seek_failed = false;
+
+			// Seeking: transient state.
+			int step_rate_counter = 0;
+			int steps_taken = 0;
+			int target_head_position = 0;	// either an actual number, or -1 to indicate to step until track zero
+
+			// Head state.
+			int head_unload_delay[2] = {0, 0};
+			bool head_is_loaded[2] = {false, false};
+
+		} drives_[4];
+		int drives_seeking_ = 0;
+
+		/// @returns @c true if the selected drive, which is number @c drive, can stop seeking.
+		bool seek_is_satisfied(int drive);
+
+		// User-supplied parameters; as per the specify command.
+		int step_rate_time_ = 1;
+		int head_unload_time_ = 1;
+		int head_load_time_ = 1;
+		bool dma_mode_ = false;
+		bool is_executing_ = false;
+
+		// A count of head unload timers currently running.
+		int head_timers_running_ = 0;
+
+		// Transient storage and counters used while reading the disk.
+		uint8_t header_[6] = {0, 0, 0, 0, 0, 0};
+		int distance_into_section_ = 0;
+		int index_hole_count_ = 0, index_hole_limit_ = 0;
+
+		// Keeps track of the drive and head in use during commands.
+		int active_drive_ = 0;
+		int active_head_ = 0;
+
+		// Internal registers.
+		uint8_t cylinder_ = 0, head_ = 0, sector_ = 0, size_ = 0;
+
+		// Master switch on not performing any work.
+		bool is_sleeping_ = false;
+};
+
+}
+}
+
+#endif /* i8272_hpp */

Components/9918/9918.cpp

@@ -0,0 +1,730 @@
+//
+//  9918.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/11/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#include "9918.hpp"
+
+#include <cassert>
+#include <cstring>
+
+using namespace TI;
+
+namespace {
+
+const 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;
+	result_ptr[1] = g;
+	result_ptr[2] = b;
+	result_ptr[3] = 0;
+	return result;
+}
+
+const uint32_t palette[16] = {
+	palette_pack(0, 0, 0),
+	palette_pack(0, 0, 0),
+	palette_pack(33, 200, 66),
+	palette_pack(94, 220, 120),
+
+	palette_pack(84, 85, 237),
+	palette_pack(125, 118, 252),
+	palette_pack(212, 82, 77),
+	palette_pack(66, 235, 245),
+
+	palette_pack(252, 85, 84),
+	palette_pack(255, 121, 120),
+	palette_pack(212, 193, 84),
+	palette_pack(230, 206, 128),
+
+	palette_pack(33, 176, 59),
+	palette_pack(201, 91, 186),
+	palette_pack(204, 204, 204),
+	palette_pack(255, 255, 255)
+};
+
+const uint8_t StatusInterrupt = 0x80;
+const uint8_t StatusFifthSprite = 0x40;
+
+const int StatusSpriteCollisionShift = 5;
+const uint8_t StatusSpriteCollision = 0x20;
+
+struct ReverseTable {
+	std::uint8_t map[256];
+
+	ReverseTable() {
+		for(int c = 0; c < 256; ++c) {
+			map[c] = static_cast<uint8_t>(
+				((c & 0x80) >> 7) |
+				((c & 0x40) >> 5) |
+				((c & 0x20) >> 3) |
+				((c & 0x10) >> 1) |
+				((c & 0x08) << 1) |
+				((c & 0x04) << 3) |
+				((c & 0x02) << 5) |
+				((c & 0x01) << 7)
+			);
+		}
+	}
+} reverse_table;
+
+// Bits are reversed in the internal mode value; they're stored
+// in the order M1 M2 M3. Hence the definitions below.
+enum ScreenMode {
+	Text = 4,
+	MultiColour = 2,
+	ColouredText = 0,
+	Graphics = 1
+};
+
+}
+
+TMS9918Base::TMS9918Base() :
+	// 342 internal cycles are 228/227.5ths of a line, so 341.25 cycles should be a whole
+	// line. Therefore multiply everything by four, but set line length to 1365 rather than 342*4 = 1368.
+	crt_(new Outputs::CRT::CRT(1365, 4, Outputs::CRT::DisplayType::NTSC60, 4)) {}
+
+TMS9918::TMS9918(Personality p) {
+	// Unimaginatively, this class just passes RGB through to the shader. Investigation is needed
+	// into whether there's a more natural form.
+	crt_->set_rgb_sampling_function(
+		"vec3 rgb_sample(usampler2D sampler, vec2 coordinate, vec2 icoordinate)"
+		"{"
+			"return texture(sampler, coordinate).rgb / vec3(255.0);"
+		"}");
+	crt_->set_video_signal(Outputs::CRT::VideoSignal::RGB);
+	crt_->set_visible_area(Outputs::CRT::Rect(0.055f, 0.025f, 0.9f, 0.9f));
+	crt_->set_input_gamma(2.8f);
+
+	// The TMS remains in-phase with the NTSC colour clock; this is an empirical measurement
+	// intended to produce the correct relationship between the hard edges between pixels and
+	// the colour clock. It was eyeballed rather than derived from any knowledge of the TMS
+	// colour burst generator because I've yet to find any.
+	crt_->set_immediate_default_phase(0.85f);
+}
+
+Outputs::CRT::CRT *TMS9918::get_crt() {
+	return crt_.get();
+}
+
+void TMS9918Base::test_sprite(int sprite_number, int screen_row) {
+	if(!(status_ & StatusFifthSprite)) {
+		status_ = static_cast<uint8_t>((status_ & ~31) | sprite_number);
+	}
+	if(sprites_stopped_)
+		return;
+
+	const int sprite_position = ram_[sprite_attribute_table_address_ + (sprite_number << 2)];
+	// A sprite Y of 208 means "don't scan the list any further".
+	if(sprite_position == 208) {
+		sprites_stopped_ = true;
+		return;
+	}
+
+	const int sprite_row = (screen_row - sprite_position)&255;
+	if(sprite_row < 0 || sprite_row >= sprite_height_) return;
+
+	const int active_sprite_slot = sprite_sets_[active_sprite_set_].active_sprite_slot;
+	if(active_sprite_slot == 4) {
+		status_ |= StatusFifthSprite;
+		return;
+	}
+
+	SpriteSet::ActiveSprite &sprite = sprite_sets_[active_sprite_set_].active_sprites[active_sprite_slot];
+	sprite.index = sprite_number;
+	sprite.row = sprite_row >> (sprites_magnified_ ? 1 : 0);
+	sprite_sets_[active_sprite_set_].active_sprite_slot++;
+}
+
+void TMS9918Base::get_sprite_contents(int field, int cycles_left, int screen_row) {
+	int sprite_id = field / 6;
+	field %= 6;
+
+	while(true) {
+		const int cycles_in_sprite = std::min(cycles_left, 6 - field);
+		cycles_left -= cycles_in_sprite;
+		const int final_field = cycles_in_sprite + field;
+
+		assert(sprite_id < 4);
+		SpriteSet::ActiveSprite &sprite = sprite_sets_[active_sprite_set_].active_sprites[sprite_id];
+
+		if(field < 4) {
+			std::memcpy(
+				&sprite.info[field],
+				&ram_[sprite_attribute_table_address_ + (sprite.index << 2) + field],
+				static_cast<size_t>(std::min(4, final_field) - field));
+		}
+
+		field = std::min(4, final_field);
+		const int sprite_offset = sprite.info[2] & ~(sprites_16x16_ ? 3 : 0);
+		const int sprite_address = sprite_generator_table_address_ + (sprite_offset << 3) + sprite.row; // TODO: recalclate sprite.row from screen_row (?)
+		while(field < final_field) {
+			sprite.image[field - 4] = ram_[sprite_address + ((field - 4) << 4)];
+			field++;
+		}
+
+		if(!cycles_left) return;
+		field = 0;
+		sprite_id++;
+	}
+}
+
+void TMS9918::run_for(const HalfCycles cycles) {
+	// As specific as I've been able to get:
+	// Scanline time is always 228 cycles.
+	// PAL output is 313 lines total. NTSC output is 262 lines total.
+	// Interrupt is signalled upon entering the lower border.
+
+	// Keep a count of cycles separate from internal counts to avoid
+	// potential errors mapping back and forth.
+	half_cycles_into_frame_ = (half_cycles_into_frame_ + cycles) % HalfCycles(frame_lines_ * 228 * 2);
+
+	// Convert 456 clocked half cycles per line to 342 internal cycles per line;
+	// the internal clock is 1.5 times the nominal 3.579545 Mhz that I've advertised
+	// for this part. So multiply by three quarters.
+	int int_cycles = (cycles.as_int() * 3) + cycles_error_;
+	cycles_error_ = int_cycles & 3;
+	int_cycles >>= 2;
+	if(!int_cycles) return;
+
+	while(int_cycles) {
+		// Determine how much time has passed in the remainder of this line, and proceed.
+		int cycles_left = std::min(342 - column_, int_cycles);
+
+
+
+		// ------------------------------------
+		// Potentially perform a memory access.
+		// ------------------------------------
+		if(queued_access_ != MemoryAccess::None) {
+			int time_until_access_slot = 0;
+			switch(line_mode_) {
+				case LineMode::Refresh:
+					if(column_ < 53 || column_ >= 307) time_until_access_slot = column_&1;
+					else time_until_access_slot = 3 - ((column_ - 53)&3);
+					// i.e. 53 -> 3, 52 -> 2, 51 -> 1, 50 -> 0, etc
+				break;
+				case LineMode::Text:
+					if(column_ < 59 || column_ >= 299) time_until_access_slot = column_&1;
+					else time_until_access_slot = 5 - ((column_ + 3)%6);
+					// i.e. 59 -> 3, 60 -> 2, 61 -> 1, etc
+				break;
+				case LineMode::Character:
+					if(column_ < 9) time_until_access_slot = column_&1;
+					else if(column_ < 30) time_until_access_slot = 30 - column_;
+					else if(column_ < 37) time_until_access_slot = column_&1;
+					else if(column_ < 311) time_until_access_slot = 31 - ((column_ + 7)&31);
+					// i.e. 53 -> 3, 54 -> 2, 55 -> 1, 56 -> 0, 57 -> 31, etc
+					else if(column_ < 313) time_until_access_slot = column_&1;
+					else time_until_access_slot = 342 - column_;
+				break;
+			}
+
+			if(cycles_left >= time_until_access_slot) {
+				if(queued_access_ == MemoryAccess::Write) {
+					ram_[ram_pointer_ & 16383] = read_ahead_buffer_;
+				} else {
+					read_ahead_buffer_ = ram_[ram_pointer_ & 16383];
+				}
+				ram_pointer_++;
+				queued_access_ = MemoryAccess::None;
+			}
+		}
+
+
+
+		column_ += cycles_left;		// column_ is now the column that has been reached in this line.
+		int_cycles -= cycles_left;	// Count down duration to run for.
+
+
+
+		// ------------------------------
+		// Perform video memory accesses.
+		// ------------------------------
+		if(((row_ < 192) || (row_ == frame_lines_-1)) && !blank_screen_) {
+			const int sprite_row = (row_ < 192) ? row_ : -1;
+			const int access_slot = column_ >> 1;	// There are only 171 available memory accesses per line.
+			switch(line_mode_) {
+				default: break;
+
+				case LineMode::Text:
+					access_pointer_ = std::min(30, access_slot);
+					if(access_pointer_ >= 30 && access_pointer_ < 150) {
+						const int row_base = pattern_name_address_ + (row_ >> 3) * 40;
+						const int end = std::min(150, access_slot);
+
+						// Pattern names are collected every third window starting from window 30.
+						const int pattern_names_start = (access_pointer_ - 30 + 2) / 3;
+						const int pattern_names_end = (end - 30 + 2) / 3;
+						std::memcpy(&pattern_names_[pattern_names_start], &ram_[row_base + pattern_names_start], static_cast<size_t>(pattern_names_end - pattern_names_start));
+
+						// Patterns are collected every third window starting from window 32.
+						const int pattern_buffer_start = (access_pointer_ - 32 + 2) / 3;
+						const int pattern_buffer_end = (end - 32 + 2) / 3;
+						for(int column = pattern_buffer_start; column < pattern_buffer_end; ++column) {
+							pattern_buffer_[column] = ram_[pattern_generator_table_address_ + (pattern_names_[column] << 3) + (row_ & 7)];
+						}
+					}
+				break;
+
+				case LineMode::Character:
+					// Four access windows: no collection.
+					if(access_pointer_ < 5)
+						access_pointer_ = std::min(5, access_slot);
+
+					// Then ten access windows are filled with collection of sprite 3 and 4 details.
+					if(access_pointer_ >= 5 && access_pointer_ < 15) {
+						int end = std::min(15, access_slot);
+						get_sprite_contents(access_pointer_ - 5 + 14, end - access_pointer_, sprite_row - 1);
+						access_pointer_ = std::min(15, access_slot);
+					}
+
+					// Four more access windows: no collection.
+					if(access_pointer_ >= 15 && access_pointer_ < 19) {
+						access_pointer_ = std::min(19, access_slot);
+
+						// Start new sprite set if this is location 19.
+						if(access_pointer_ == 19) {
+							active_sprite_set_ ^= 1;
+							sprite_sets_[active_sprite_set_].active_sprite_slot = 0;
+							sprites_stopped_ = false;
+						}
+					}
+
+					// Then eight access windows fetch the y position for the first eight sprites.
+					while(access_pointer_ < 27 && access_pointer_ < access_slot) {
+						test_sprite(access_pointer_ - 19, sprite_row);
+						access_pointer_++;
+					}
+
+					// The next 128 access slots are video and sprite collection interleaved.
+					if(access_pointer_ >= 27 && access_pointer_ < 155) {
+						int end = std::min(155, access_slot);
+
+						int row_base = pattern_name_address_;
+						int pattern_base = pattern_generator_table_address_;
+						int colour_base = colour_table_address_;
+						if(screen_mode_ == ScreenMode::Graphics) {
+							// If this is high resolution mode, allow the row number to affect the pattern and colour addresses.
+							pattern_base &= 0x2000 | ((row_ & 0xc0) << 5);
+							colour_base &= 0x2000 | ((row_ & 0xc0) << 5);
+						}
+						row_base += (row_ << 2)&~31;
+
+						// Pattern names are collected every fourth window starting from window 27.
+						const int pattern_names_start = (access_pointer_ - 27 + 3) >> 2;
+						const int pattern_names_end = (end - 27 + 3) >> 2;
+						std::memcpy(&pattern_names_[pattern_names_start], &ram_[row_base + pattern_names_start], static_cast<size_t>(pattern_names_end - pattern_names_start));
+
+						// Colours are collected every fourth window starting from window 29.
+						const int colours_start = (access_pointer_ - 29 + 3) >> 2;
+						const int colours_end = (end - 29 + 3) >> 2;
+						if(screen_mode_ != 1) {
+							for(int column = colours_start; column < colours_end; ++column) {
+								colour_buffer_[column] = ram_[colour_base + (pattern_names_[column] >> 3)];
+							}
+						} else {
+							for(int column = colours_start; column < colours_end; ++column) {
+								colour_buffer_[column] = ram_[colour_base + (pattern_names_[column] << 3) + (row_ & 7)];
+							}
+						}
+
+						// Patterns are collected ever fourth window starting from window 30.
+						const int pattern_buffer_start = (access_pointer_ - 30 + 3) >> 2;
+						const int pattern_buffer_end = (end - 30 + 3) >> 2;
+
+						// Multicolour mode uss a different function of row to pick bytes
+						const int row = (screen_mode_ != 2) ? (row_ & 7) : ((row_ >> 2) & 7);
+						for(int column = pattern_buffer_start; column < pattern_buffer_end; ++column) {
+							pattern_buffer_[column] = ram_[pattern_base + (pattern_names_[column] << 3) + row];
+						}
+
+						// Sprite slots occur in three quarters of ever fourth window starting from window 28.
+						const int sprite_start = (access_pointer_ - 28 + 3) >> 2;
+						const int sprite_end = (end - 28 + 3) >> 2;
+						for(int column = sprite_start; column < sprite_end; ++column) {
+							if(column&3) {
+								test_sprite(7 + column - (column >> 2), sprite_row);
+							}
+						}
+
+						access_pointer_ = std::min(155, access_slot);
+					}
+
+					// Two access windows: no collection.
+					if(access_pointer_ < 157)
+						access_pointer_ = std::min(157, access_slot);
+
+					// Fourteen access windows: collect initial sprite information.
+					if(access_pointer_ >= 157 && access_pointer_ < 171) {
+						int end = std::min(171, access_slot);
+						get_sprite_contents(access_pointer_ - 157, end - access_pointer_, sprite_row);
+						access_pointer_ = std::min(171, access_slot);
+					}
+				break;
+			}
+		}
+		// --------------------------
+		// End video memory accesses.
+		// --------------------------
+
+
+
+		// --------------------
+		// Output video stream.
+		// --------------------
+		if(row_	< 192 && !blank_screen_) {
+			// ----------------------
+			// Output horizontal sync
+			// ----------------------
+			if(!output_column_ && column_ >= 26) {
+				crt_->output_sync(13 * 4);
+				crt_->output_default_colour_burst(13 * 4);
+				output_column_ = 26;
+			}
+
+			// -------------------
+			// Output left border.
+			// -------------------
+			if(output_column_ >= 26) {
+				int pixels_end = std::min(first_pixel_column_, column_);
+				if(output_column_ < pixels_end) {
+					output_border(pixels_end - output_column_);
+					output_column_ = pixels_end;
+
+					// Grab a pointer for drawing pixels to, if the moment has arrived.
+					if(pixels_end == first_pixel_column_) {
+						pixel_base_ = pixel_target_ = reinterpret_cast<uint32_t *>(crt_->allocate_write_area(static_cast<unsigned int>(first_right_border_column_ - first_pixel_column_)));
+					}
+				}
+			}
+
+			// --------------
+			// Output pixels.
+			// --------------
+			if(output_column_ >= first_pixel_column_) {
+				int pixels_end = std::min(first_right_border_column_, column_);
+
+				if(output_column_ < pixels_end) {
+					switch(line_mode_) {
+						default: break;
+
+						case LineMode::Text: {
+							const uint32_t colours[2] = { palette[background_colour_], palette[text_colour_] };
+
+							const int shift = (output_column_ - first_pixel_column_) % 6;
+							int byte_column = (output_column_ - first_pixel_column_) / 6;
+							int pattern = reverse_table.map[pattern_buffer_[byte_column]] >> shift;
+							int pixels_left = pixels_end - output_column_;
+							int length = std::min(pixels_left, 6 - shift);
+							while(true) {
+								pixels_left -= length;
+								for(int c = 0; c < length; ++c) {
+									pixel_target_[c] = colours[pattern&0x01];
+									pattern >>= 1;
+								}
+								pixel_target_ += length;
+
+								if(!pixels_left) break;
+								length = std::min(6, pixels_left);
+								byte_column++;
+								pattern = reverse_table.map[pattern_buffer_[byte_column]];
+							}
+							output_column_ = pixels_end;
+						} break;
+
+						case LineMode::Character: {
+							// If this is the start of the visible area, seed sprite shifter positions.
+							SpriteSet &sprite_set = sprite_sets_[active_sprite_set_ ^ 1];
+							if(output_column_ == first_pixel_column_) {
+								int c = sprite_set.active_sprite_slot;
+								while(c--) {
+									SpriteSet::ActiveSprite &sprite = sprite_set.active_sprites[c];
+									sprite.shift_position = -sprite.info[1];
+									if(sprite.info[3] & 0x80) {
+										sprite.shift_position += 32;
+										if(sprite.shift_position > 0 && !sprites_magnified_)
+											sprite.shift_position *= 2;
+									}
+								}
+							}
+
+							// Paint the background tiles.
+							const int pixels_left = pixels_end - output_column_;
+							if(screen_mode_ == ScreenMode::MultiColour) {
+								int pixel_location = output_column_ - first_pixel_column_;
+								for(int c = 0; c < pixels_left; ++c) {
+									pixel_target_[c] = palette[
+										(pattern_buffer_[(pixel_location + c) >> 3] >> (((pixel_location + c) & 4)^4)) & 15
+									];
+								}
+								pixel_target_ += pixels_left;
+							} else {
+								const int shift = (output_column_ - first_pixel_column_) & 7;
+								int byte_column = (output_column_ - first_pixel_column_) >> 3;
+
+								int length = std::min(pixels_left, 8 - shift);
+
+								int pattern = reverse_table.map[pattern_buffer_[byte_column]] >> shift;
+								uint8_t colour = colour_buffer_[byte_column];
+								uint32_t colours[2] = {
+									palette[(colour & 15) ? (colour & 15) : background_colour_],
+									palette[(colour >> 4) ? (colour >> 4) : background_colour_]
+								};
+
+								int background_pixels_left = pixels_left;
+								while(true) {
+									background_pixels_left -= length;
+									for(int c = 0; c < length; ++c) {
+										pixel_target_[c] = colours[pattern&0x01];
+										pattern >>= 1;
+									}
+									pixel_target_ += length;
+
+									if(!background_pixels_left) break;
+									length = std::min(8, background_pixels_left);
+									byte_column++;
+
+									pattern = reverse_table.map[pattern_buffer_[byte_column]];
+									colour = colour_buffer_[byte_column];
+									colours[0] = palette[(colour & 15) ? (colour & 15) : background_colour_];
+									colours[1] = palette[(colour >> 4) ? (colour >> 4) : background_colour_];
+								}
+							}
+
+							// Paint sprites and check for collisions, but only if at least one sprite is active
+							// on this line.
+							if(sprite_set.active_sprite_slot) {
+								int sprite_pixels_left = pixels_left;
+								const int shift_advance = sprites_magnified_ ? 1 : 2;
+
+								static const uint32_t sprite_colour_selection_masks[2] = {0x00000000, 0xffffffff};
+								static const int colour_masks[16] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+
+								while(sprite_pixels_left--) {
+									// sprite_colour is the colour that's going to reach the display after sprite logic has been
+									// applied; by default assume that nothing is going to be drawn.
+									uint32_t sprite_colour = pixel_base_[output_column_ - first_pixel_column_];
+
+									// The sprite_mask is used to keep track of whether two sprites have both sought to output
+									// a pixel at the same location, and to feed that into the status register's sprite
+									// collision bit.
+									int sprite_mask = 0;
+
+									int c = sprite_set.active_sprite_slot;
+									while(c--) {
+										SpriteSet::ActiveSprite &sprite = sprite_set.active_sprites[c];
+
+										if(sprite.shift_position < 0) {
+											sprite.shift_position++;
+											continue;
+										} else if(sprite.shift_position < 32) {
+											int mask = sprite.image[sprite.shift_position >> 4] << ((sprite.shift_position&15) >> 1);
+											mask = (mask >> 7) & 1;
+
+											// Ignore the right half of whatever was collected if sprites are not in 16x16 mode.
+											if(sprite.shift_position < (sprites_16x16_ ? 32 : 16)) {
+												// If any previous sprite has been painted in this column and this sprite
+												// has this pixel set, set the sprite collision status bit.
+												status_ |= (mask & sprite_mask) << StatusSpriteCollisionShift;
+												sprite_mask |= mask;
+
+												// Check that the sprite colour is not transparent
+												mask &= colour_masks[sprite.info[3]&15];
+												sprite_colour = (sprite_colour & sprite_colour_selection_masks[mask^1]) | (palette[sprite.info[3]&15] & sprite_colour_selection_masks[mask]);
+											}
+
+											sprite.shift_position += shift_advance;
+										}
+									}
+
+									// Output whichever sprite colour was on top.
+									pixel_base_[output_column_ - first_pixel_column_] = sprite_colour;
+									output_column_++;
+								}
+							}
+
+							output_column_ = pixels_end;
+						} break;
+					}
+
+					if(output_column_ == first_right_border_column_) {
+						const unsigned int data_length = static_cast<unsigned int>(first_right_border_column_ - first_pixel_column_);
+						crt_->output_data(data_length * 4, data_length);
+						pixel_target_ = nullptr;
+					}
+				}
+			}
+
+			// --------------------
+			// Output right border.
+			// --------------------
+			if(output_column_ >= first_right_border_column_) {
+				output_border(column_ - output_column_);
+				output_column_ = column_;
+			}
+		} else if(row_ >= first_vsync_line_ && row_ < first_vsync_line_+3) {
+			// Vertical sync.
+			if(column_ == 342) {
+				crt_->output_sync(342 * 4);
+			}
+		} else {
+			// Blank.
+			if(!output_column_ && column_ >= 26) {
+				crt_->output_sync(13 * 4);
+				crt_->output_default_colour_burst(13 * 4);
+				output_column_ = 26;
+			}
+			if(output_column_ >= 26) {
+				output_border(column_ - output_column_);
+				output_column_ = column_;
+			}
+		}
+		// -----------------
+		// End video stream.
+		// -----------------
+
+
+
+		// -----------------------------------
+		// Prepare for next line, potentially.
+		// -----------------------------------
+		if(column_ == 342) {
+			access_pointer_ = column_ = output_column_ = 0;
+			row_ = (row_ + 1) % frame_lines_;
+			if(row_ == 192) status_ |= StatusInterrupt;
+
+			screen_mode_ = next_screen_mode_;
+			blank_screen_ = next_blank_screen_;
+			switch(screen_mode_) {
+				case ScreenMode::Text:
+					line_mode_ = LineMode::Text;
+					first_pixel_column_ = 69;
+					first_right_border_column_ = 309;
+				break;
+				default:
+					line_mode_ = LineMode::Character;
+					first_pixel_column_ = 63;
+					first_right_border_column_ = 319;
+				break;
+			}
+			if(blank_screen_ || (row_ >= 192 && row_ != frame_lines_-1)) line_mode_ = LineMode::Refresh;
+		}
+	}
+}
+
+void TMS9918Base::output_border(int cycles) {
+	pixel_target_ = reinterpret_cast<uint32_t *>(crt_->allocate_write_area(1));
+	if(pixel_target_) *pixel_target_ = palette[background_colour_];
+	crt_->output_level(static_cast<unsigned int>(cycles) * 4);
+}
+
+void TMS9918::set_register(int address, uint8_t value) {
+	// Writes to address 0 are writes to the video RAM. Store
+	// the value and return.
+	if(!(address & 1)) {
+		write_phase_ = false;
+
+		// Enqueue the write to occur at the next available slot.
+		read_ahead_buffer_ = value;
+		queued_access_ = MemoryAccess::Write;
+
+		return;
+	}
+
+	// Writes to address 1 are performed in pairs; if this is the
+	// low byte of a value, store it and wait for the high byte.
+	if(!write_phase_) {
+		low_write_ = value;
+		write_phase_ = true;
+		return;
+	}
+
+	write_phase_ = false;
+	if(value & 0x80) {
+		// This is a write to a register.
+		switch(value & 7) {
+			case 0:
+				next_screen_mode_ = (next_screen_mode_ & 6) | ((low_write_ & 2) >> 1);
+			break;
+
+			case 1:
+				next_blank_screen_ = !(low_write_ & 0x40);
+				generate_interrupts_ = !!(low_write_ & 0x20);
+				next_screen_mode_ = (next_screen_mode_ & 1) | ((low_write_ & 0x18) >> 2);
+				sprites_16x16_ = !!(low_write_ & 0x02);
+				sprites_magnified_ = !!(low_write_ & 0x01);
+
+				sprite_height_ = 8;
+				if(sprites_16x16_) sprite_height_ <<= 1;
+				if(sprites_magnified_) sprite_height_ <<= 1;
+			break;
+
+			case 2:
+				pattern_name_address_ = static_cast<uint16_t>((low_write_ & 0xf) << 10);
+			break;
+
+			case 3:
+				colour_table_address_ = static_cast<uint16_t>(low_write_ << 6);
+			break;
+
+			case 4:
+				pattern_generator_table_address_ = static_cast<uint16_t>((low_write_ & 0x07) << 11);
+			break;
+
+			case 5:
+				sprite_attribute_table_address_ = static_cast<uint16_t>((low_write_ & 0x7f) << 7);
+			break;
+
+			case 6:
+				sprite_generator_table_address_ = static_cast<uint16_t>((low_write_ & 0x07) << 11);
+			break;
+
+			case 7:
+				text_colour_ = low_write_ >> 4;
+				background_colour_ = low_write_ & 0xf;
+			break;
+		}
+	} else {
+		// This is a write to the RAM pointer.
+		ram_pointer_ = static_cast<uint16_t>(low_write_ | (value << 8));
+		if(!(value & 0x40)) {
+			// Officially a 'read' set, so perform lookahead.
+			queued_access_ = MemoryAccess::Read;
+		}
+	}
+}
+
+uint8_t TMS9918::get_register(int address) {
+	write_phase_ = false;
+
+	// Reads from address 0 read video RAM, via the read-ahead buffer.
+	if(!(address & 1)) {
+		// Enqueue the write to occur at the next available slot.
+		uint8_t result = read_ahead_buffer_;
+		queued_access_ = MemoryAccess::Read;
+		return result;
+	}
+
+	// Reads from address 1 get the status register.
+	uint8_t result = status_;
+	status_ &= ~(StatusInterrupt | StatusFifthSprite | StatusSpriteCollision);
+	return result;
+}
+
+ HalfCycles TMS9918::get_time_until_interrupt() {
+	if(!generate_interrupts_) return HalfCycles(-1);
+	if(get_interrupt_line()) return HalfCycles(0);
+
+	const int half_cycles_per_frame = frame_lines_ * 228 * 2;
+	int half_cycles_remaining = (192 * 228 * 2 + half_cycles_per_frame - half_cycles_into_frame_.as_int()) % half_cycles_per_frame;
+	return HalfCycles(half_cycles_remaining ? half_cycles_remaining : half_cycles_per_frame);
+}
+
+bool TMS9918::get_interrupt_line() {
+	return (status_ & StatusInterrupt) && generate_interrupts_;
+}

Components/9918/9918.hpp

@@ -0,0 +1,86 @@
+//
+//  9918.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/11/2017.
+//  Copyright 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef TMS9918_hpp
+#define TMS9918_hpp
+
+#include "../../Outputs/CRT/CRT.hpp"
+#include "../../ClockReceiver/ClockReceiver.hpp"
+
+#include "Implementation/9918Base.hpp"
+
+#include <cstdint>
+
+namespace TI {
+
+/*!
+	Provides emulation of the TMS9918a, TMS9928 and TMS9929. Likely in the future to be the
+	vessel for emulation of sufficiently close derivatives, such as the Master System VDP.
+
+	The TMS9918 and descendants are video display generators that own their own RAM, making it
+	accessible through an implicitly-timed register interface, and (depending on model) can generate
+	PAL and NTSC component and composite video.
+
+	These chips have only one non-on-demand interaction with the outside world: an interrupt line.
+	See get_time_until_interrupt and get_interrupt_line for asynchronous operation options.
+*/
+class TMS9918: public TMS9918Base {
+	public:
+		enum Personality {
+			TMS9918A,	// includes the 9928 and 9929; set TV standard and output device as desired.
+		};
+
+		/*!
+			Constructs an instance of the drive controller that behaves according to personality @c p.
+			@param p The type of controller to emulate.
+		*/
+		TMS9918(Personality p);
+
+		enum TVStandard {
+			/*! i.e. 50Hz output at around 312.5 lines/field */
+			PAL,
+			/*! i.e. 60Hz output at around 262.5 lines/field */
+			NTSC
+		};
+
+		/*! Sets the TV standard for this TMS, if that is hard-coded in hardware. */
+		void set_tv_standard(TVStandard standard);
+
+		/*! Provides the CRT this TMS is connected to. */
+		Outputs::CRT::CRT *get_crt();
+
+		/*!
+			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.
+		*/
+		void run_for(const HalfCycles cycles);
+
+		/*! Sets a register value. */
+		void set_register(int address, uint8_t value);
+
+		/*! Gets a register value. */
+		uint8_t get_register(int address);
+
+		/*!
+			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.
+
+			If get_interrupt_line is true now, returns zero. If get_interrupt_line would
+			never return true, returns -1.
+		*/
+		HalfCycles get_time_until_interrupt();
+
+		/*!
+			@returns @c true if the interrupt line is currently active; @c false otherwise.
+		*/
+		bool get_interrupt_line();
+};
+
+};
+
+#endif /* TMS9918_hpp */