Corrected name of build tool.

Provided exposition of new platform support.

.gitignore

@@ -22,6 +22,10 @@ DerivedData
 ROMImages/*
 OSBindings/Mac/Clock SignalTests/Atari\ ROMs
 
+# Exclude intermediate build products
+*.o
+.sconsign.dblite
+
 # CocoaPods
 #
 # We recommend against adding the Pods directory to your .gitignore. However

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

@@ -161,7 +161,7 @@ class HalfCycles: public WrappedInt<HalfCycles> {
 		inline HalfCycles(int l) : WrappedInt<HalfCycles>(l) {}
 		inline HalfCycles() : WrappedInt<HalfCycles>() {}
 
-		inline HalfCycles(const Cycles cycles) : WrappedInt<HalfCycles>(cycles.as_int() << 1) {}
+		inline HalfCycles(const Cycles cycles) : WrappedInt<HalfCycles>(cycles.as_int() * 2) {}
 		inline HalfCycles(const HalfCycles &half_cycles) : WrappedInt<HalfCycles>(half_cycles.length_) {}
 
 		/// @returns The number of whole cycles completely covered by this span of half cycles.

ClockReceiver/ForceInline.hpp

@@ -6,8 +6,14 @@
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef ForceInline_h
-#define ForceInline_h
+#ifndef ForceInline_hpp
+#define ForceInline_hpp
+
+#ifdef DEBUG
+
+#define forceinline
+
+#else
 
 #ifdef __GNUC__
 #define forceinline __attribute__((always_inline)) inline
@@ -15,4 +21,6 @@
 #define forceinline __forceinline
 #endif
 
+#endif
+
 #endif /* ForceInline_h */

ClockReceiver/Sleeper.hpp

@@ -0,0 +1,60 @@
+//
+//  Sleeper.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/08/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Sleeper_hpp
+#define Sleeper_hpp
+
+/*!
+	A sleeper is any component that sometimes requires a clock but at other times is 'asleep' — i.e. is not doing
+	any clock-derived work, so needn't receive a clock. A disk controller is an archetypal example.
+
+	A sleeper will signal sleeps and wakes to an observer.
+
+	This is intended to allow for performance improvements to machines with components that can sleep. The observer
+	callout is virtual so the intended use case is that a machine holds a component that might sleep. Its transitions
+	into and out of sleep are sufficiently infrequent that a virtual call to announce them costs sufficiently little that
+	the saved ::run_fors add up to a substantial amount.
+
+	By convention, sleeper components must be willing to accept ::run_for even after announcing sleep. It's a hint,
+	not a command.
+*/
+class Sleeper {
+	public:
+		Sleeper() : sleep_observer_(nullptr) {}
+
+		class SleepObserver {
+			public:
+				/// Called to inform an observer that the component @c component has either gone to sleep or become awake.
+				virtual void set_component_is_sleeping(void *component, bool is_sleeping) = 0;
+		};
+
+		/// Registers @c observer as the new sleep observer;
+		void set_sleep_observer(SleepObserver *observer) {
+			sleep_observer_ = observer;
+		}
+
+		/// @returns @c true if the component is currently sleeping; @c false otherwise.
+		virtual bool is_sleeping() = 0;
+
+	protected:
+		/// Provided for subclasses; send sleep announcements to the sleep_observer_.
+		SleepObserver *sleep_observer_;
+
+		/*!
+			Provided for subclasses; call this whenever is_sleeping might have changed, and the observer will be notified,
+			if one exists.
+
+			@c is_sleeping will be called only if there is an observer.
+		*/
+		void update_sleep_observer() {
+			if(!sleep_observer_) return;
+			sleep_observer_->set_component_is_sleeping(this, is_sleeping());
+		}
+};
+
+#endif /* Sleeper_h */

Components/1770/1770.cpp

@@ -7,34 +7,16 @@
 //
 
 #include "1770.hpp"
-#include "../../Storage/Disk/Encodings/MFM.hpp"
+#include "../../Storage/Disk/Encodings/MFM/Constants.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::MFMController(8000000, 16, 300),
-		interesting_event_mask_((int)Event1770::Command),
-		resume_point_(0),
-		delay_time_(0),
-		index_hole_count_target_(-1),
-		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((int)Event1770::Command);
+	posit_event(static_cast<int>(Event1770::Command));
 }
 
 void WD1770::set_register(int address, uint8_t value) {
@@ -47,7 +29,7 @@ void WD1770::set_register(int address, uint8_t value) {
 				});
 			} else {
 				command_ = value;
-				posit_event((int)Event1770::Command);
+				posit_event(static_cast<int>(Event1770::Command));
 			}
 		}
 		break;
@@ -75,7 +57,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;
@@ -91,11 +73,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);
 			}
@@ -115,24 +97,24 @@ 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((int)Event1770::Timer);
+			posit_event(static_cast<int>(Event1770::Timer));
 		} else {
 			delay_time_ -= number_of_cycles;
 		}
 	}
 }
 
-#define WAIT_FOR_EVENT(mask)	resume_point_ = __LINE__; interesting_event_mask_ = (int)mask; return; case __LINE__:
+#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_ = (int)Event::Token; return; }
+#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 == (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) {	\
 				header_[distance_into_section_ - 1] = get_latest_token().byte_value;	\
@@ -169,10 +151,10 @@ void WD1770::run_for(const Cycles cycles) {
 //     +--------+----------+-------------------------+
 
 void WD1770::posit_event(int new_event_type) {
-	if(new_event_type == (int)Event::IndexHole) {
+	if(new_event_type == static_cast<int>(Event::IndexHole)) {
 		index_hole_count_++;
 		if(index_hole_count_target_ == index_hole_count_) {
-			posit_event((int)Event1770::IndexHoleTarget);
+			posit_event(static_cast<int>(Event1770::IndexHoleTarget));
 			index_hole_count_target_ = -1;
 		}
 
@@ -187,7 +169,7 @@ void WD1770::posit_event(int new_event_type) {
 		}
 	}
 
-	if(!(interesting_event_mask_ & (int)new_event_type)) return;
+	if(!(interesting_event_mask_ & static_cast<int>(new_event_type))) return;
 	interesting_event_mask_ &= ~new_event_type;
 
 	Status new_status;
@@ -257,7 +239,7 @@ void WD1770::posit_event(int new_event_type) {
 		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:
@@ -280,11 +262,11 @@ void WD1770::posit_event(int 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(step_direction_ ? 1 : -1);
 		unsigned int time_to_wait;
 		switch(command_ & 3) {
 			default:
@@ -310,7 +292,7 @@ void WD1770::posit_event(int new_event_type) {
 		distance_into_section_ = 0;
 
 	verify_read_data:
-		WAIT_FOR_EVENT((int)Event::IndexHole | (int)Event::Token);
+		WAIT_FOR_EVENT(static_cast<int>(Event::IndexHole) | static_cast<int>(Event::Token));
 		READ_ID();
 
 		if(index_hole_count_ == 6) {
@@ -376,7 +358,7 @@ void WD1770::posit_event(int new_event_type) {
 		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();
 
@@ -386,7 +368,7 @@ void WD1770::posit_event(int 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;
 			});
@@ -394,7 +376,7 @@ void WD1770::posit_event(int new_event_type) {
 		}
 
 	type2_get_header:
-		WAIT_FOR_EVENT((int)Event::IndexHole | (int)Event::Token);
+		WAIT_FOR_EVENT(static_cast<int>(Event::IndexHole) | static_cast<int>(Event::Token));
 		READ_ID();
 
 		if(index_hole_count_ == 5) {
@@ -594,7 +576,7 @@ void WD1770::posit_event(int new_event_type) {
 		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:
@@ -611,8 +593,8 @@ void WD1770::posit_event(int new_event_type) {
 		distance_into_section_ = 0;
 
 	read_address_get_header:
-		WAIT_FOR_EVENT((int)Event::IndexHole | (int)Event::Token);
-		if(new_event_type == (int)Event::Token) {
+		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) {
@@ -652,7 +634,7 @@ void WD1770::posit_event(int new_event_type) {
 		index_hole_count_ = 0;
 
 	read_track_read_byte:
-		WAIT_FOR_EVENT((int)Event::Token | (int)Event::IndexHole);
+		WAIT_FOR_EVENT(static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole));
 		if(index_hole_count_) {
 			goto wait_for_command;
 		}
@@ -674,8 +656,7 @@ void WD1770::posit_event(int 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;
 			});
@@ -720,7 +701,7 @@ void WD1770::posit_event(int 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) |
@@ -781,8 +762,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((int)Event1770::HeadLoad);
+	if(head_loaded) posit_event(static_cast<int>(Event1770::HeadLoad));
 }

Components/1770/1770.hpp

@@ -9,7 +9,7 @@
 #ifndef _770_hpp
 #define _770_hpp
 
-#include "../../Storage/Disk/MFMDiskController.hpp"
+#include "../../Storage/Disk/Controller/MFMDiskController.hpp"
 
 namespace WD {
 
@@ -76,6 +76,7 @@ class WD1770: public Storage::Disk::MFMController {
 
 	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:
@@ -84,20 +85,19 @@ class WD1770: public Storage::Disk::MFMController {
 		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_;
@@ -105,7 +105,7 @@ class WD1770: public Storage::Disk::MFMController {
 		uint8_t command_;
 
 		int index_hole_count_;
-		int index_hole_count_target_;
+		int index_hole_count_target_ = -1;
 		int distance_into_section_;
 
 		int step_direction_;
@@ -120,17 +120,17 @@ class WD1770: public Storage::Disk::MFMController {
 		};
 		void posit_event(int type);
 		int interesting_event_mask_;
-		int resume_point_;
-		unsigned int delay_time_;
+		int resume_point_ = 0;
+		unsigned int delay_time_ = 0;
 
 		// ID buffer
 		uint8_t header_[6];
 
 		// 1793 head-loading logic
-		bool head_is_loaded_;
+		bool head_is_loaded_ = false;
 
 		// delegate
-		Delegate *delegate_;
+		Delegate *delegate_ = nullptr;
 };
 
 }

Components/6522/6522.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,27 @@ 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]);
-
-				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) {}
+		uint8_t get_register(int address);
 
 	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,155 @@
+//
+//  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);
+}
+
+// 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

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

@@ -8,13 +8,9 @@
 
 #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;
 
 void Speaker::set_volume(uint8_t volume) {
 	enqueue([=]() {
@@ -98,7 +94,7 @@ static uint8_t noise_pattern[] = {
 
 #define shift(r) shift_registers_[r] = (shift_registers_[r] << 1) | (((shift_registers_[r]^0x80)&control_registers_[r]) >> 7)
 #define increment(r) shift_registers_[r] = (shift_registers_[r]+1)%8191
-#define update(r, m, up) counters_[r]++; if((counters_[r] >> m) == 0x80) { up(r); counters_[r] = (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

Components/6560/6560.hpp

@@ -18,8 +18,6 @@ namespace MOS {
 // audio state
 class Speaker: public ::Outputs::Filter<Speaker> {
 	public:
-		Speaker();
-
 		void set_volume(uint8_t volume);
 		void set_control(int channel, uint8_t value);
 
@@ -27,10 +25,10 @@ class Speaker: public ::Outputs::Filter<Speaker> {
 		void skip_samples(unsigned int number_of_samples);
 
 	private:
-		unsigned int counters_[4];
-		unsigned int shift_registers_[4];
-		uint8_t control_registers_[4];
-		uint8_t volume_;
+		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};
+		uint8_t volume_ = 0;
 };
 
 /*!
@@ -44,13 +42,8 @@ class Speaker: public ::Outputs::Filter<Speaker> {
 template <class T> 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_(new Outputs::CRT::CRT(65*4, 4, Outputs::CRT::DisplayType::NTSC60, 2)),
+				speaker_(new Speaker) {
 			crt_->set_composite_sampling_function(
 				"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
 				"{"
@@ -66,7 +59,7 @@ template <class T> class MOS6560 {
 		}
 
 		void set_clock_rate(double clock_rate) {
-			speaker_->set_input_rate((float)(clock_rate / 4.0));
+			speaker_->set_input_rate(static_cast<float>(clock_rate / 4.0));
 		}
 
 		std::shared_ptr<Outputs::CRT::CRT> get_crt() { return crt_; }
@@ -109,9 +102,9 @@ template <class T> class MOS6560 {
 			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_.lines_per_progressive_field = 312;
@@ -120,7 +113,7 @@ template <class T> class MOS6560 {
 
 				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_.lines_per_progressive_field = 261;
@@ -128,7 +121,7 @@ template <class T> class MOS6560 {
 				break;
 			}
 
-			crt_->set_new_display_type((unsigned int)(timing_.cycles_per_line*4), display_type);
+			crt_->set_new_display_type(static_cast<unsigned int>(timing_.cycles_per_line*4), display_type);
 			crt_->set_visible_area(Outputs::CRT::Rect(0.05f, 0.05f, 0.9f, 0.9f));
 
 //			switch(output_mode) {
@@ -141,7 +134,7 @@ template <class T> class MOS6560 {
 //			}
 
 			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];
 			}
@@ -218,7 +211,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) ||
@@ -270,7 +263,7 @@ template <class T> class MOS6560 {
 
 					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_++;
@@ -345,7 +338,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 +347,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:
@@ -399,7 +392,7 @@ template <class T> class MOS6560 {
 			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 0x03: return static_cast<uint8_t>(current_line << 7) | (registers_.direct_values[3] & 0x7f);
 				case 0x04: return (current_line >> 1) & 0xff;
 			}
 		}
@@ -432,7 +425,7 @@ 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, full_frame_counter_;
 
 		// latches dictating start and length of drawing
 		bool vertical_drawing_latch_, horizontal_drawing_latch_;
@@ -447,14 +440,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);
 		}

Components/6845/CRTC6845.hpp

@@ -18,141 +18,65 @@ namespace Motorola {
 namespace CRTC {
 
 struct BusState {
-	bool display_enable;
-	bool hsync;
-	bool vsync;
-	bool cursor;
-	uint16_t refresh_address;
-	uint16_t row_address;
+	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:
-		void perform_bus_cycle(const BusState &) {}
+		/*!
+			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,	//
-	UM6845R,	//
-	MC6845,		//
-	AMS40226	//
+	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) :
-			personality_(p), bus_handler_(bus_handler) {}
-
-		void run_for(Cycles cycles) {
-			int cyles_remaining = cycles.as_int();
-			while(cyles_remaining--) {
-				// check for end of horizontal sync
-				if(hsync_down_counter_) {
-					hsync_down_counter_--;
-					if(!hsync_down_counter_) {
-						bus_state_.hsync = false;
-					}
-				}
-
-				// check for end of line
-				bool is_end_of_line = character_counter_ == registers_[0];
-
-				// increment counter
-				character_counter_++;
-
-				// check for start of horizontal sync
-				if(character_counter_ == registers_[2]) {
-					hsync_down_counter_ = registers_[3] & 15;
-					if(hsync_down_counter_) bus_state_.hsync = true;
-				}
-
-				// update refresh address
-				if(character_is_visible_) {
-					bus_state_.refresh_address++;
-				}
-
-				// check for end of visible characters
-				if(character_counter_ == registers_[1]) {
-					character_is_visible_ = false;
-				}
-
-				// check for end-of-line
-				if(is_end_of_line) {
-					// check for end of vertical sync
-					if(vsync_down_counter_) {
-						vsync_down_counter_--;
-						if(!vsync_down_counter_) {
-							bus_state_.vsync = false;
-						}
-					}
-
-					if(is_in_adjustment_period_) {
-						line_counter_++;
-						if(line_counter_ == registers_[5]) {
-							line_counter_ = 0;
-							is_in_adjustment_period_ = false;
-							line_is_visible_ = true;
-							line_address_ = (uint16_t)((registers_[12] << 8) | registers_[13]);
-							bus_state_.refresh_address = line_address_;
-						}
-					} else {
-						// advance vertical counter
-						if(bus_state_.row_address == registers_[9]) {
-							if(!character_is_visible_)
-								line_address_ = bus_state_.refresh_address;
-							bus_state_.row_address = 0;
-
-							bool is_at_end_of_frame = line_counter_ == registers_[4];
-							line_counter_ = (line_counter_ + 1) & 0x7f;
-
-							// check for end of visible lines
-							if(line_counter_ == registers_[6]) {
-								line_is_visible_ = false;
-							}
-
-							// check for start of vertical sync
-							if(line_counter_ == registers_[7]) {
-								bus_state_.vsync = true;
-								vsync_down_counter_ = registers_[3] >> 4;
-								if(!vsync_down_counter_) vsync_down_counter_ = 16;
-							}
-
-							// check for entry into the overflow area
-							if(is_at_end_of_frame) {
-								if(registers_[5]) {
-									is_in_adjustment_period_ = true;
-								} else {
-									line_is_visible_ = true;
-									line_address_ = (uint16_t)((registers_[12] << 8) | registers_[13]);
-									bus_state_.refresh_address = line_address_;
-								}
-								bus_state_.row_address = 0;
-								line_counter_ = 0;
-							}
-						} 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);
-				}
-
-				perform_bus_cycle();
-			}
-		}
+		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_];
 		}
@@ -163,38 +87,186 @@ template <class T> class CRTC6845 {
 				0xff, 0x1f, 0x7f, 0x1f, 0x3f, 0xff, 0x3f, 0xff
 			};
 
-			if(selected_register_ < 16)
+			// 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() {
-			bus_state_.display_enable = character_is_visible_ && line_is_visible_;
-			bus_state_.refresh_address &= 0x3fff;
-			bus_handler_.perform_bus_cycle(bus_state_);
+		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];
-		int selected_register_;
+		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_;
-		uint8_t line_counter_;
+		uint8_t character_counter_ = 0;
+		uint8_t line_counter_ = 0;
 
-		bool character_is_visible_, line_is_visible_;
+		bool character_is_visible_ = false, line_is_visible_ = false;
 
-		int hsync_down_counter_;
-		int vsync_down_counter_;
-		bool is_in_adjustment_period_;
-		uint16_t line_address_;
+		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;
 };
 
 }

Components/8272/i8272.cpp

@@ -7,7 +7,7 @@
 //
 
 #include "i8272.hpp"
-#include "../../Storage/Disk/Encodings/MFM.hpp"
+//#include "../../Storage/Disk/Encodings/MFM/Encoder.hpp"
 
 #include <cstdio>
 
@@ -34,6 +34,7 @@ using namespace Intel::i8272;
 #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)
@@ -43,6 +44,7 @@ using namespace Intel::i8272;
 #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)
@@ -75,27 +77,26 @@ namespace {
 	const uint8_t CommandSenseDriveStatus = 0x04;
 }
 
-i8272::i8272(BusHandler &bus_handler, Cycles clock_rate, int clock_rate_multiplier, int revolutions_per_minute) :
-	Storage::Disk::MFMController(clock_rate, clock_rate_multiplier, revolutions_per_minute),
-	bus_handler_(bus_handler),
-	main_status_(0),
-	interesting_event_mask_((int)Event8272::CommandByte),
-	resume_point_(0),
-	delay_time_(0),
-	head_timers_running_(0),
-	expects_input_(false),
-	drives_seeking_(0) {
-	posit_event((int)Event8272::CommandByte);
+i8272::i8272(BusHandler &bus_handler, Cycles clock_rate) :
+	Storage::Disk::MFMController(clock_rate),
+	bus_handler_(bus_handler) {
+	posit_event(static_cast<int>(Event8272::CommandByte));
+}
+
+bool i8272::is_sleeping() {
+	return is_sleeping_ && Storage::Disk::MFMController::is_sleeping();
 }
 
 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((int)Event8272::Timer);
+			posit_event(static_cast<int>(Event8272::Timer));
 		} else {
 			delay_time_ -= cycles.as_int();
 		}
@@ -103,6 +104,7 @@ void i8272::run_for(Cycles cycles) {
 
 	// 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();
@@ -112,37 +114,52 @@ void i8272::run_for(Cycles cycles) {
 					// Perform a step.
 					int direction = (drives_[c].target_head_position < drives_[c].head_position) ? -1 : 1;
 					printf("Target %d versus believed %d\n", drives_[c].target_head_position, drives_[c].head_position);
-					drives_[c].drive->step(direction);
+					select_drive(c);
+					get_drive().step(direction);
 					if(drives_[c].target_head_position >= 0) drives_[c].head_position += direction;
 
 					// Check for completion.
-					if(drives_[c].seek_is_satisfied()) {
+					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_) {
-		for(int c = 0; c < 4; c++) {
-			for(int h = 0; h < 2; h++) {
-				if(drives_[c].head_unload_delay[c] > 0) {
-					if(cycles.as_int() >= drives_[c].head_unload_delay[c]) {
-						drives_[c].head_unload_delay[c] = 0;
-						drives_[c].head_is_loaded[c] = false;
-						head_timers_running_--;
-						if(!head_timers_running_) return;
-					} else {
-						drives_[c].head_unload_delay[c] -= cycles.as_int();
-					}
+		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_sleep_observer();
 }
 
 void i8272::set_register(int address, uint8_t value) {
@@ -159,7 +176,7 @@ void i8272::set_register(int address, uint8_t value) {
 	} else {
 		// accumulate latest byte in the command byte sequence
 		command_.push_back(value);
-		posit_event((int)Event8272::CommandByte);
+		posit_event(static_cast<int>(Event8272::CommandByte));
 	}
 }
 
@@ -168,7 +185,7 @@ uint8_t i8272::get_register(int address) {
 		if(result_stack_.empty()) return 0xff;
 		uint8_t result = result_stack_.back();
 		result_stack_.pop_back();
-		if(result_stack_.empty()) posit_event((int)Event8272::ResultEmpty);
+		if(result_stack_.empty()) posit_event(static_cast<int>(Event8272::ResultEmpty));
 
 		return result;
 	} else {
@@ -176,35 +193,29 @@ uint8_t i8272::get_register(int address) {
 	}
 }
 
-void i8272::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
-	if(drive < 4 && drive >= 0) {
-		drives_[drive].drive->set_disk(disk);
-	}
-}
-
 #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_ = (int)mask; return; case __LINE__:
-#define WAIT_FOR_TIME(ms)		resume_point_ = __LINE__; interesting_event_mask_ = (int)Event8272::Timer; delay_time_ = MS_TO_CYCLES(ms); case __LINE__: if(delay_time_) 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__; interesting_event_mask_ = static_cast<int>(Event8272::Timer); delay_time_ = MS_TO_CYCLES(ms); is_sleeping_ = false; update_sleep_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((int)Event::Token | (int)Event::IndexHole); \
-	if(event_type == (int)Event::IndexHole) { index_hole_limit_--; }	\
+	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__):	0;\
+	CONCAT(header_found, __LINE__):	(void)0;\
 
 #define FIND_DATA()	\
 	set_data_mode(DataMode::Scanning);	\
-	CONCAT(find_data, __LINE__): WAIT_FOR_EVENT((int)Event::Token | (int)Event::IndexHole); \
-	if(event_type == (int)Event::Token) { \
+	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__);	\
 	}
 
@@ -219,10 +230,10 @@ void i8272::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
 #define SET_DRIVE_HEAD_MFM()	\
 	active_drive_ = command_[1]&3;	\
 	active_head_ = (command_[1] >> 2)&1;	\
-	set_drive(drives_[active_drive_].drive);	\
-	drives_[active_drive_].drive->set_head((unsigned int)active_head_);	\
-	set_is_double_density(command_[0] & 0x40);	\
-	invalidate_track();
+	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;	\
@@ -245,12 +256,18 @@ void i8272::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
 	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_sleep_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 == (int)Event::IndexHole) index_hole_count_++;
+	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;
 
@@ -274,7 +291,7 @@ void i8272::posit_event(int event_type) {
 			WAIT_FOR_EVENT(Event8272::CommandByte)
 			SetBusy();
 
-			static const size_t required_lengths[32] = {
+			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,
@@ -320,9 +337,14 @@ void i8272::posit_event(int event_type) {
 				}
 				// 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.
@@ -409,7 +431,8 @@ void i8272::posit_event(int event_type) {
 		// flag doesn't match the sort the command was looking for.
 		read_data_found_header:
 			FIND_DATA();
-			if(event_type == (int)Event::Token) {
+			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();
@@ -440,24 +463,24 @@ void i8272::posit_event(int event_type) {
 		//
 		// TODO: consider DTL.
 		read_data_get_byte:
-			WAIT_FOR_EVENT((int)Event::Token | (int)Event::IndexHole);
-			if(event_type == (int)Event::Token) {
+			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((int)Event8272::ResultEmpty | (int)Event::Token | (int)Event::IndexHole);
+				WAIT_FOR_EVENT(static_cast<int>(Event8272::ResultEmpty) | static_cast<int>(Event::Token) | static_cast<int>(Event::IndexHole));
 			}
 			switch(event_type) {
-				case (int)Event8272::ResultEmpty:	// The caller read the byte in time; proceed as normal.
+				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 (int)Event::Token:				// The caller hasn't read the old byte yet and a new one has arrived
+				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 (int)Event::IndexHole:
+				case static_cast<int>(Event::IndexHole):
 					SetEndOfCylinder();
 					goto abort;
 				break;
@@ -486,7 +509,7 @@ void i8272::posit_event(int event_type) {
 	write_data:
 			printf("Write [deleted] data [%02x %02x %02x %02x ... %02x %02x]\n", command_[2], command_[3], command_[4], command_[5], command_[6], command_[8]);
 
-			if(drives_[active_drive_].drive->get_is_read_only()) {
+			if(get_drive().get_is_read_only()) {
 				SetNotWriteable();
 				goto abort;
 			}
@@ -509,7 +532,6 @@ void i8272::posit_event(int event_type) {
 			WAIT_FOR_EVENT(Event::DataWritten);
 			if(!has_input_) {
 				SetOverrun();
-				end_writing();
 				goto abort;
 			}
 			write_byte(input_);
@@ -541,7 +563,6 @@ void i8272::posit_event(int event_type) {
 		// 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;
-		read_id_find_next_sector:
 			FIND_HEADER();
 			if(!index_hole_limit_) {
 				SetMissingAddressMark();
@@ -589,7 +610,7 @@ void i8272::posit_event(int event_type) {
 			distance_into_section_++;
 			SetDataRequest();
 			// TODO: other possible exit conditions; find a way to merge with the read_data version of this.
-			WAIT_FOR_EVENT((int)Event8272::ResultEmpty);
+			WAIT_FOR_EVENT(static_cast<int>(Event8272::ResultEmpty));
 			ResetDataRequest();
 			if(distance_into_section_ < (128 << header_[2])) goto read_track_get_byte;
 
@@ -601,7 +622,7 @@ void i8272::posit_event(int event_type) {
 	// Performs format [/write] track.
 	format_track:
 			printf("Format track\n");
-			if(drives_[active_drive_].drive->get_is_read_only()) {
+			if(get_drive().get_is_read_only()) {
 				SetNotWriteable();
 				goto abort;
 			}
@@ -626,14 +647,13 @@ void i8272::posit_event(int event_type) {
 			expects_input_ = true;
 			distance_into_section_ = 0;
 		format_track_write_header:
-			WAIT_FOR_EVENT((int)Event::DataWritten | (int)Event::IndexHole);
+			WAIT_FOR_EVENT(static_cast<int>(Event::DataWritten) | static_cast<int>(Event::IndexHole));
 			switch(event_type) {
-				case (int)Event::IndexHole:
+				case static_cast<int>(Event::IndexHole):
 					SetOverrun();
-					end_writing();
 					goto abort;
 				break;
-				case (int)Event::DataWritten:
+				case static_cast<int>(Event::DataWritten):
 					header_[distance_into_section_] = input_;
 					write_byte(input_);
 					has_input_ = false;
@@ -664,8 +684,8 @@ void i8272::posit_event(int event_type) {
 			// Otherwise, pad out to the index hole.
 		format_track_pad:
 			write_byte(get_is_double_density() ? 0x4e : 0xff);
-			WAIT_FOR_EVENT((int)Event::DataWritten | (int)Event::IndexHole);
-			if(event_type != (int)Event::IndexHole) goto format_track_pad;
+			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();
 
@@ -694,10 +714,13 @@ void i8272::posit_event(int event_type) {
 	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_sleep_observer();
 				}
 
 				// Set currently seeking, with a step to occur right now (yes, it sounds like jamming these
@@ -721,7 +744,7 @@ void i8272::posit_event(int event_type) {
 				}
 
 				// Check whether any steps are even needed; if not then mark as completed already.
-				if(drives_[drive].seek_is_satisfied()) {
+				if(seek_is_satisfied(drive)) {
 					drives_[drive].phase = Drive::CompletedSeeking;
 					drives_seeking_--;
 				}
@@ -744,14 +767,13 @@ void i8272::posit_event(int event_type) {
 				// If a drive was found, return its results. Otherwise return a single 0x80.
 				if(found_drive != -1) {
 					drives_[found_drive].phase = Drive::NotSeeking;
-					status_[0] = (uint8_t)found_drive;
+					status_[0] = static_cast<uint8_t>(found_drive);
 					main_status_ &= ~(1 << found_drive);
 					SetSeekEnd();
 
-					result_stack_.push_back(drives_[found_drive].head_position);
-					result_stack_.push_back(status_[0]);
+					result_stack_ = { drives_[found_drive].head_position, status_[0]};
 				} else {
-					result_stack_.push_back(0x80);
+					result_stack_ = { 0x80 };
 				}
 			}
 			goto post_result;
@@ -773,24 +795,28 @@ void i8272::posit_event(int event_type) {
 			printf("Sense drive status\n");
 			{
 				int drive = command_[1] & 3;
-				result_stack_.push_back(
-					(command_[1] & 7) |	// drive and head number
-					0x08 |				// single sided
-					(drives_[drive].drive->get_is_track_zero() ? 0x10 : 0x00)	|
-					(drives_[drive].drive->get_is_ready() ? 0x20 : 0x00)		|
-					(drives_[drive].drive->get_is_read_only() ? 0x40 : 0x00)
-				);
+				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_.push_back(0x80);
+			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;
 
@@ -798,14 +824,7 @@ void i8272::posit_event(int event_type) {
 	post_st012chrn:
 			SCHEDULE_HEAD_UNLOAD();
 
-			result_stack_.push_back(size_);
-			result_stack_.push_back(sector_);
-			result_stack_.push_back(head_);
-			result_stack_.push_back(cylinder_);
-
-			result_stack_.push_back(status_[2]);
-			result_stack_.push_back(status_[1]);
-			result_stack_.push_back(status_[0]);
+			result_stack_ = {size_, sector_, head_, cylinder_, status_[2], status_[1], status_[0]};
 
 			goto post_result;
 
@@ -813,12 +832,13 @@ void i8272::posit_event(int event_type) {
 	// last thing in it will be returned first.
 	post_result:
 			printf("Result to %02x, main %02x: ", command_[0] & 0x1f, main_status_);
-			for(size_t c = 0; c < result_stack_.size(); c++) {
+			for(std::size_t c = 0; c < result_stack_.size(); c++) {
 				printf("%02x ", result_stack_[result_stack_.size() - 1 - c]);
 			}
 			printf("\n");
 
 			// Set ready to send data to the processor, no longer in non-DMA execution phase.
+			is_executing_ = false;
 			ResetNonDMAExecution();
 			SetDataRequest();
 			SetDataDirectionToProcessor();
@@ -833,9 +853,9 @@ void i8272::posit_event(int event_type) {
 	END_SECTION()
 }
 
-bool i8272::Drive::seek_is_satisfied() {
-	return	(target_head_position == head_position) ||
-			(target_head_position == -1 && drive->get_is_track_zero());
+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) {

Components/8272/i8272.hpp

@@ -9,7 +9,7 @@
 #ifndef i8272_hpp
 #define i8272_hpp
 
-#include "../../Storage/Disk/MFMDiskController.hpp"
+#include "../../Storage/Disk/Controller/MFMDiskController.hpp"
 
 #include <cstdint>
 #include <memory>
@@ -26,7 +26,7 @@ class BusHandler {
 
 class i8272: public Storage::Disk::MFMController {
 	public:
-		i8272(BusHandler &bus_handler, Cycles clock_rate, int clock_rate_multiplier, int revolutions_per_minute);
+		i8272(BusHandler &bus_handler, Cycles clock_rate);
 
 		void run_for(Cycles);
 
@@ -39,7 +39,10 @@ class i8272: public Storage::Disk::MFMController {
 		void set_dma_acknowledge(bool dack);
 		void set_terminal_count(bool tc);
 
-		void set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive);
+		bool is_sleeping();
+
+	protected:
+		virtual void select_drive(int number) = 0;
 
 	private:
 		// The bus handler, for interrupt and DMA-driven usage.
@@ -47,86 +50,83 @@ class i8272: public Storage::Disk::MFMController {
 		std::unique_ptr<BusHandler> allocated_bus_handler_;
 
 		// Status registers.
-		uint8_t main_status_;
-		uint8_t status_[3];
+		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_;
-		bool has_input_;
-		bool expects_input_;
+		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);
-		int interesting_event_mask_;
-		int resume_point_;
-		bool is_access_command_;
+		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_;
+		int delay_time_ = 0;
 
 		// The connected drives.
 		struct Drive {
-			uint8_t head_position;
+			uint8_t head_position = 0;
 
 			// Seeking: persistent state.
 			enum Phase {
 				NotSeeking,
 				Seeking,
 				CompletedSeeking
-			} phase;
-			bool did_seek;
-			bool seek_failed;
+			} phase = NotSeeking;
+			bool did_seek = false;
+			bool seek_failed = false;
 
 			// Seeking: transient state.
-			int step_rate_counter;
-			int steps_taken;
-			int target_head_position;	// either an actual number, or -1 to indicate to step until track zero
-
-			/// @returns @c true if the currently queued-up seek or recalibrate has reached where it should be.
-			bool seek_is_satisfied();
+			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];
-			bool head_is_loaded[2];
+			int head_unload_delay[2] = {0, 0};
+			bool head_is_loaded[2] = {false, false};
 
-			// The connected drive.
-			std::shared_ptr<Storage::Disk::Drive> drive;
-
-			Drive() :
-				head_position(0), phase(NotSeeking),
-				drive(new Storage::Disk::Drive),
-				head_is_loaded{false, false} {};
 		} drives_[4];
-		int drives_seeking_;
+		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_;
-		int head_unload_time_;
-		int head_load_time_;
-		bool dma_mode_;
+		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_;
+		int head_timers_running_ = 0;
 
 		// Transient storage and counters used while reading the disk.
-		uint8_t header_[6];
-		int distance_into_section_;
-		int index_hole_count_, index_hole_limit_;
+		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_;
-		int active_head_;
+		int active_drive_ = 0;
+		int active_head_ = 0;
 
 		// Internal registers.
-		uint8_t cylinder_, head_, sector_, size_;
+		uint8_t cylinder_ = 0, head_ = 0, sector_ = 0, size_ = 0;
 
+		// Master switch on not performing any work.
+		bool is_sleeping_ = false;
 };
 
 }

Components/AY38910/AY38910.cpp

@@ -10,16 +10,7 @@
 
 using namespace GI::AY38910;
 
-AY38910::AY38910() :
-		selected_register_(0),
-		tone_counters_{0, 0, 0}, tone_periods_{0, 0, 0}, tone_outputs_{0, 0, 0},
-		noise_shift_register_(0xffff), noise_period_(0), noise_counter_(0), noise_output_(0),
-		envelope_divider_(0), envelope_period_(0), envelope_position_(0),
-		master_divider_(0),
-		output_registers_{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-		port_handler_(nullptr) {
-	output_registers_[8] = output_registers_[9] = output_registers_[10] = 0;
-
+AY38910::AY38910() {
 	// set up envelope lookup tables
 	for(int c = 0; c < 16; c++) {
 		for(int p = 0; p < 32; p++) {
@@ -67,13 +58,13 @@ AY38910::AY38910() :
 	float max_volume = 8192;
 	float root_two = sqrtf(2.0f);
 	for(int v = 0; v < 16; v++) {
-		volumes_[v] = (int)(max_volume / powf(root_two, (float)(v ^ 0xf)));
+		volumes_[v] = static_cast<int>(max_volume / powf(root_two, static_cast<float>(v ^ 0xf)));
 	}
 	volumes_[0] = 0;
 }
 
 void AY38910::set_clock_rate(double clock_rate) {
-	set_input_rate((float)clock_rate);
+	set_input_rate(static_cast<float>(clock_rate));
 }
 
 void AY38910::get_samples(unsigned int number_of_samples, int16_t *target) {
@@ -160,14 +151,14 @@ void AY38910::evaluate_output_volume() {
 #undef channel_volume
 
 	// Mix additively.
-	output_volume_ = (int16_t)(
+	output_volume_ = static_cast<int16_t>(
 		volumes_[volumes[0]] * channel_levels[0] +
 		volumes_[volumes[1]] * channel_levels[1] +
 		volumes_[volumes[2]] * channel_levels[2]
 	);
 }
 
-#pragma mark - Register manipulation
+// MARK: - Register manipulation
 
 void AY38910::select_register(uint8_t r) {
 	selected_register_ = r;
@@ -186,7 +177,7 @@ void AY38910::set_register_value(uint8_t value) {
 					int channel = selected_register >> 1;
 
 					if(selected_register & 1)
-						tone_periods_[channel] = (tone_periods_[channel] & 0xff) | (uint16_t)((value&0xf) << 8);
+						tone_periods_[channel] = (tone_periods_[channel] & 0xff) | static_cast<uint16_t>((value&0xf) << 8);
 					else
 						tone_periods_[channel] = (tone_periods_[channel] & ~0xff) | value;
 				}
@@ -201,7 +192,7 @@ void AY38910::set_register_value(uint8_t value) {
 				break;
 
 				case 12:
-					envelope_period_ = (envelope_period_ & 0xff) | (int)(value << 8);
+					envelope_period_ = (envelope_period_ & 0xff) | static_cast<int>(value << 8);
 				break;
 
 				case 13:
@@ -233,13 +224,13 @@ uint8_t AY38910::get_register_value() {
 	}
 }
 
-#pragma mark - Port handling
+// MARK: - Port handling
 
 uint8_t AY38910::get_port_output(bool port_b) {
 	return registers_[port_b ? 15 : 14];
 }
 
-#pragma mark - Bus handling
+// MARK: - Bus handling
 
 void AY38910::set_port_handler(PortHandler *handler) {
 	port_handler_ = handler;
@@ -262,15 +253,15 @@ uint8_t AY38910::get_data_output() {
 }
 
 void AY38910::set_control_lines(ControlLines control_lines) {
-	switch((int)control_lines) {
+	switch(static_cast<int>(control_lines)) {
 		default:					control_state_ = Inactive;		break;
 
-		case (int)(BDIR | BC2 | BC1):
+		case static_cast<int>(BDIR | BC2 | BC1):
 		case BDIR:
 		case BC1:					control_state_ = LatchAddress;	break;
 
-		case (int)(BC2 | BC1):		control_state_ = Read;			break;
-		case (int)(BDIR | BC2):		control_state_ = Write;			break;
+		case static_cast<int>(BC2 | BC1):		control_state_ = Read;			break;
+		case static_cast<int>(BDIR | BC2):		control_state_ = Write;			break;
 	}
 
 	update_bus();

Components/AY38910/AY38910.hpp

@@ -26,7 +26,7 @@ class PortHandler {
 	public:
 		/*!
 			Requests the current input on an AY port.
-			
+
 			@param port_b @c true if the input being queried is Port B. @c false if it is Port A.
 		*/
 		virtual uint8_t get_port_input(bool port_b) {
@@ -35,7 +35,7 @@ class PortHandler {
 
 		/*!
 			Requests the current input on an AY port.
-			
+
 			@param port_b @c true if the input being queried is Port B. @c false if it is Port A.
 		*/
 		virtual void set_port_output(bool port_b, uint8_t value) {}
@@ -89,24 +89,25 @@ class AY38910: public ::Outputs::Filter<AY38910> {
 		void get_samples(unsigned int number_of_samples, int16_t *target);
 
 	private:
-		int selected_register_;
-		uint8_t registers_[16], output_registers_[16];
+		int selected_register_ = 0;
+		uint8_t registers_[16];
+		uint8_t output_registers_[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 		uint8_t port_inputs_[2];
 
-		int master_divider_;
+		int master_divider_ = 0;
 
-		int tone_periods_[3];
-		int tone_counters_[3];
-		int tone_outputs_[3];
+		int tone_periods_[3] = {0, 0, 0};
+		int tone_counters_[3] = {0, 0, 0};
+		int tone_outputs_[3] = {0, 0, 0};
 
-		int noise_period_;
-		int noise_counter_;
-		int noise_shift_register_;
-		int noise_output_;
+		int noise_period_ = 0;
+		int noise_counter_ = 0;
+		int noise_shift_register_ = 0xffff;
+		int noise_output_ = 0;
 
-		int envelope_period_;
-		int envelope_divider_;
-		int envelope_position_;
+		int envelope_period_ = 0;
+		int envelope_divider_ = 0;
+		int envelope_position_ = 0;
 		int envelope_shapes_[16][32];
 		int envelope_overflow_masks_[16];
 
@@ -129,7 +130,7 @@ class AY38910: public ::Outputs::Filter<AY38910> {
 		inline void evaluate_output_volume();
 
 		inline void update_bus();
-		PortHandler *port_handler_;
+		PortHandler *port_handler_ = nullptr;
 };
 
 }

Concurrency/AsyncTaskQueue.hpp

@@ -9,10 +9,12 @@
 #ifndef AsyncTaskQueue_hpp
 #define AsyncTaskQueue_hpp
 
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <list>
 #include <memory>
 #include <thread>
-#include <list>
-#include <condition_variable>
 
 #ifdef __APPLE__
 #include <dispatch/dispatch.h>

Concurrency/BestEffortUpdater.cpp

@@ -0,0 +1,72 @@
+//
+//  BestEffortUpdater.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "BestEffortUpdater.hpp"
+
+#include <cmath>
+
+using namespace Concurrency;
+
+BestEffortUpdater::BestEffortUpdater() {
+	// ATOMIC_FLAG_INIT isn't necessarily safe to use, so establish default state by other means.
+	update_is_ongoing_.clear();
+}
+
+void BestEffortUpdater::update() {
+	// Perform an update only if one is not currently ongoing.
+	if(!update_is_ongoing_.test_and_set()) {
+		async_task_queue_.enqueue([this]() {
+			// Get time now using the highest-resolution clock provided by the implementation, and determine
+			// the duration since the last time this section was entered.
+			const std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
+			const auto elapsed = now - previous_time_point_;
+			previous_time_point_ = now;
+
+			if(has_previous_time_point_) {
+				// If the duration is valid, convert it to integer cycles, maintaining a rolling error and call the delegate
+				// if there is one. Proceed only if the number of cycles is positive, and cap it to the per-second maximum —
+				// it's possible this is an adjustable clock so be ready to swallow unexpected adjustments.
+				const int64_t duration = std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
+				if(duration > 0) {
+					double cycles = ((static_cast<double>(duration) * clock_rate_) / 1e9) + error_;
+					error_ = fmod(cycles, 1.0);
+
+					if(delegate_) {
+						delegate_->update(this, static_cast<int>(std::min(cycles, clock_rate_)), has_skipped_);
+					}
+					has_skipped_ = false;
+				}
+			} else {
+				has_previous_time_point_ = true;
+			}
+
+			// Allow furthers updates to occur.
+			update_is_ongoing_.clear();
+		});
+	} else {
+		async_task_queue_.enqueue([this]() {
+			has_skipped_ = true;
+		});
+	}
+}
+
+void BestEffortUpdater::flush() {
+	async_task_queue_.flush();
+}
+
+void BestEffortUpdater::set_delegate(Delegate *const delegate) {
+	async_task_queue_.enqueue([this, delegate]() {
+		delegate_ = delegate;
+	});
+}
+
+void BestEffortUpdater::set_clock_rate(const double clock_rate) {
+	async_task_queue_.enqueue([this, clock_rate]() {
+		this->clock_rate_ = clock_rate;
+	});
+}

Concurrency/BestEffortUpdater.hpp

@@ -0,0 +1,65 @@
+//
+//  BestEffortUpdater.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef BestEffortUpdater_hpp
+#define BestEffortUpdater_hpp
+
+#include <atomic>
+#include <chrono>
+
+#include "AsyncTaskQueue.hpp"
+
+namespace Concurrency {
+
+/*!
+	Accepts timing cues from multiple threads and ensures that a delegate receives calls to total
+	a certain number of cycles per second, that those calls are strictly serialised, and that no
+	backlog of calls accrues.
+
+	No guarantees about the thread that the delegate will be called on are made.
+*/
+class BestEffortUpdater {
+	public:
+		BestEffortUpdater();
+
+		/// A delegate receives timing cues.
+		struct Delegate {
+			virtual void update(BestEffortUpdater *updater, int cycles, bool did_skip_previous_update) = 0;
+		};
+
+		/// Sets the current delegate.
+		void set_delegate(Delegate *);
+
+		/// Sets the clock rate of the delegate.
+		void set_clock_rate(double clock_rate);
+
+		/*!
+			If the delegate is not currently in the process of an `update` call, calls it now to catch up to the current time.
+			The call is asynchronous; this method will return immediately.
+		*/
+		void update();
+
+		/// Blocks until any ongoing update is complete.
+		void flush();
+
+	private:
+		std::atomic_flag update_is_ongoing_;
+		AsyncTaskQueue async_task_queue_;
+
+		std::chrono::time_point<std::chrono::high_resolution_clock> previous_time_point_;
+		bool has_previous_time_point_ = false;
+		double error_ = 0.0;
+		bool has_skipped_ = false;
+
+		Delegate *delegate_ = nullptr;
+		double clock_rate_ = 1.0;
+};
+
+}
+
+#endif /* BestEffortUpdater_hpp */

Configurable/Configurable.cpp

@@ -0,0 +1,27 @@
+//
+//  Configurable.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "Configurable.hpp"
+
+using namespace Configurable;
+
+ListSelection *BooleanSelection::list_selection() {
+	return new ListSelection(value ? "yes" : "no");
+}
+
+ListSelection *ListSelection::list_selection() {
+	return new ListSelection(value);
+}
+
+BooleanSelection *ListSelection::boolean_selection() {
+	return new BooleanSelection(value != "no" && value != "n");
+}
+
+BooleanSelection *BooleanSelection::boolean_selection() {
+	return new BooleanSelection(value);
+}

Configurable/Configurable.hpp

@@ -0,0 +1,88 @@
+//
+//  Configurable.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 17/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Configurable_h
+#define Configurable_h
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Configurable {
+
+/*!
+	The Option class hierarchy provides a way for components, machines, etc, to provide a named
+	list of typed options to which they can respond.
+*/
+struct Option {
+	std::string long_name;
+	std::string short_name;
+	virtual ~Option() {}
+
+	Option(const std::string &long_name, const std::string &short_name) : long_name(long_name), short_name(short_name) {}
+};
+
+struct BooleanOption: public Option {
+	BooleanOption(const std::string &long_name, const std::string &short_name) : Option(long_name, short_name) {}
+};
+
+struct ListOption: public Option {
+	std::vector<std::string> options;
+	ListOption(const std::string &long_name, const std::string &short_name, const std::vector<std::string> &options) : Option(long_name, short_name), options(options) {}
+};
+
+struct BooleanSelection;
+struct ListSelection;
+
+/*!
+	Selections are responses to Options.
+*/
+struct Selection {
+	virtual ~Selection() {}
+	virtual ListSelection *list_selection() = 0;
+	virtual BooleanSelection *boolean_selection() = 0;
+};
+
+struct BooleanSelection: public Selection {
+	bool value;
+
+	ListSelection *list_selection();
+	BooleanSelection *boolean_selection();
+	BooleanSelection(bool value) : value(value) {}
+};
+
+struct ListSelection: public Selection {
+	std::string value;
+	
+	ListSelection *list_selection();
+	BooleanSelection *boolean_selection();
+	ListSelection(const std::string value) : value(value) {}
+};
+
+using SelectionSet = std::map<std::string, std::unique_ptr<Selection>>;
+
+/*!
+	A Configuratble provides the options that it responds to and allows selections to be set.
+*/
+struct Device {
+	virtual std::vector<std::unique_ptr<Option>> get_options() = 0;
+	virtual void set_selections(const SelectionSet &selection_by_option) = 0;
+	virtual SelectionSet get_accurate_selections() = 0;
+	virtual SelectionSet get_user_friendly_selections() = 0;
+};
+
+template <typename T> T *selection(const Configurable::SelectionSet &selections_by_option, const std::string &name) {
+	auto selection = selections_by_option.find(name);
+	if(selection == selections_by_option.end()) return nullptr;
+	return dynamic_cast<T *>(selection->second.get());
+}
+
+}
+
+#endif /* Configurable_h */

Configurable/StandardOptions.cpp

@@ -0,0 +1,76 @@
+//
+//  StandardOptions.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "StandardOptions.hpp"
+
+namespace {
+
+/*!
+	Appends a Boolean selection of @c selection for option @c name to @c selection_set.
+*/
+void append_bool(Configurable::SelectionSet &selection_set, const std::string &name, bool selection) {
+	selection_set[name] = std::unique_ptr<Configurable::Selection>(new Configurable::BooleanSelection(selection));
+}
+
+/*!
+	Enquires for a Boolean selection for option @c name from @c selections_by_option, storing it to @c result if found.
+*/
+bool get_bool(const Configurable::SelectionSet &selections_by_option, const std::string &name, bool &result) {
+	auto quickload = Configurable::selection<Configurable::BooleanSelection>(selections_by_option, "quickload");
+	if(!quickload) return false;
+	result = quickload->value;
+	return true;
+}
+
+}
+
+// MARK: - Standard option list builder
+std::vector<std::unique_ptr<Configurable::Option>> Configurable::standard_options(Configurable::StandardOptions mask) {
+	std::vector<std::unique_ptr<Configurable::Option>> options;
+	if(mask & QuickLoadTape)				options.emplace_back(new Configurable::BooleanOption("Load Tapes Quickly", "quickload"));
+	if(mask & DisplayRGBComposite)			options.emplace_back(new Configurable::ListOption("Display", "display", {"composite", "rgb"}));
+	if(mask & AutomaticTapeMotorControl)	options.emplace_back(new Configurable::BooleanOption("Automatic Tape Motor Control", "autotapemotor"));
+	return options;
+}
+
+// MARK: - Selection appenders
+void Configurable::append_quick_load_tape_selection(Configurable::SelectionSet &selection_set, bool selection) {
+	append_bool(selection_set, "quickload", selection);
+}
+
+void Configurable::append_automatic_tape_motor_control_selection(SelectionSet &selection_set, bool selection) {
+	append_bool(selection_set, "autotapemotor", selection);
+}
+
+void Configurable::append_display_selection(Configurable::SelectionSet &selection_set, Display selection) {
+	selection_set["display"] = std::unique_ptr<Configurable::Selection>(new Configurable::ListSelection((selection == Display::RGB) ? "rgb" : "composite"));
+}
+
+// MARK: - Selection parsers
+bool Configurable::get_quick_load_tape(const Configurable::SelectionSet &selections_by_option, bool &result) {
+	return get_bool(selections_by_option, "quickload", result);
+}
+
+bool Configurable::get_automatic_tape_motor_control_selection(const SelectionSet &selections_by_option, bool &result) {
+	return get_bool(selections_by_option, "autotapemotor", result);
+}
+
+bool Configurable::get_display(const Configurable::SelectionSet &selections_by_option, Configurable::Display &result) {
+	auto display = Configurable::selection<Configurable::ListSelection>(selections_by_option, "display");
+	if(display) {
+		if(display->value == "rgb") {
+			result = Configurable::Display::RGB;
+			return true;
+		}
+		if(display->value == "composite") {
+			result = Configurable::Display::Composite;
+			return true;
+		}
+	}
+	return false;
+}

Configurable/StandardOptions.hpp

@@ -0,0 +1,76 @@
+//
+//  StandardOptions.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 20/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef StandardOptions_hpp
+#define StandardOptions_hpp
+
+#include "Configurable.hpp"
+
+namespace Configurable {
+
+enum StandardOptions {
+	DisplayRGBComposite			= (1 << 0),
+	QuickLoadTape				= (1 << 1),
+	AutomaticTapeMotorControl	= (1 << 2)
+};
+
+enum class Display {
+	RGB,
+	Composite
+};
+
+/*!
+	@returns An option list comprised of the standard names for all the options indicated by @c mask.
+*/
+std::vector<std::unique_ptr<Option>> standard_options(StandardOptions mask);
+
+/*!
+	Appends to @c selection_set a selection of @c selection for QuickLoadTape.
+*/
+void append_quick_load_tape_selection(SelectionSet &selection_set, bool selection);
+
+/*!
+	Appends to @c selection_set a selection of @c selection for AutomaticTapeMotorControl.
+*/
+void append_automatic_tape_motor_control_selection(SelectionSet &selection_set, bool selection);
+
+/*!
+	Appends to @c selection_set a selection of @c selection for DisplayRGBComposite.
+*/
+void append_display_selection(SelectionSet &selection_set, Display selection);
+
+/*!
+	Attempts to discern a QuickLoadTape selection from @c selections_by_option.
+ 
+	@param selections_by_option The user selections.
+	@param result The location to which the selection will be stored if found.
+	@returns @c true if a selection is found; @c false otherwise.
+*/
+bool get_quick_load_tape(const SelectionSet &selections_by_option, bool &result);
+
+/*!
+	Attempts to discern an AutomaticTapeMotorControl selection from @c selections_by_option.
+ 
+	@param selections_by_option The user selections.
+	@param result The location to which the selection will be stored if found.
+	@returns @c true if a selection is found; @c false otherwise.
+*/
+bool get_automatic_tape_motor_control_selection(const SelectionSet &selections_by_option, bool &result);
+
+/*!
+	Attempts to discern a display RGB/composite selection from @c selections_by_option.
+ 
+	@param selections_by_option The user selections.
+	@param result The location to which the selection will be stored if found.
+	@returns @c true if a selection is found; @c false otherwise.
+*/
+bool get_display(const SelectionSet &selections_by_option, Display &result);
+
+}
+
+#endif /* StandardOptions_hpp */

Inputs/Joystick.hpp

@@ -0,0 +1,41 @@
+//
+//  Joystick.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Joystick_hpp
+#define Joystick_hpp
+
+#include <vector>
+
+namespace Inputs {
+
+/*!
+	Provides an intermediate idealised model of a simple joystick, allowing a host
+	machine to toggle states, while an interested party either observes or polls.
+*/
+class Joystick {
+	public:
+		virtual ~Joystick() {}
+
+		enum class DigitalInput {
+			Up, Down, Left, Right, Fire
+		};
+
+		// Host interface.
+		virtual void set_digital_input(DigitalInput digital_input, bool is_active) = 0;
+		virtual void reset_all_inputs() {
+			set_digital_input(DigitalInput::Up, false);
+			set_digital_input(DigitalInput::Down, false);
+			set_digital_input(DigitalInput::Left, false);
+			set_digital_input(DigitalInput::Right, false);
+			set_digital_input(DigitalInput::Fire, false);
+		}
+};
+
+}
+
+#endif /* Joystick_hpp */

Inputs/Keyboard.cpp

@@ -0,0 +1,38 @@
+//
+//  Keyboard.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/9/17.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "Keyboard.hpp"
+
+using namespace Inputs;
+
+Keyboard::Keyboard() {}
+
+void Keyboard::set_key_pressed(Key key, bool is_pressed) {
+	std::size_t key_offset = static_cast<std::size_t>(key);
+	if(key_offset >= key_states_.size()) {
+		key_states_.resize(key_offset+1, false);
+	}
+	key_states_[key_offset] = is_pressed;
+
+	if(delegate_) delegate_->keyboard_did_change_key(this, key, is_pressed);
+}
+
+void Keyboard::reset_all_keys() {
+	std::fill(key_states_.begin(), key_states_.end(), false);
+	if(delegate_) delegate_->reset_all_keys(this);
+}
+
+void Keyboard::set_delegate(Delegate *delegate) {
+	delegate_ = delegate;
+}
+
+bool Keyboard::get_key_state(Key key) {
+	std::size_t key_offset = static_cast<std::size_t>(key);
+	if(key_offset >= key_states_.size()) return false;
+	return key_states_[key_offset];
+}

Inputs/Keyboard.hpp

@@ -0,0 +1,61 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/9/17.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Keyboard_hpp
+#define Keyboard_hpp
+
+#include <vector>
+
+namespace Inputs {
+
+/*!
+	Provides an intermediate idealised model of a modern-era computer keyboard
+	(so, heavily indebted to the current Windows and Mac layouts), allowing a host
+	machine to toggle states, while an interested party either observes or polls.
+*/
+class Keyboard {
+	public:
+		Keyboard();
+
+		enum class Key {
+			Escape, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PrintScreen, ScrollLock, Pause,
+			BackTick, k1, k2, k3, k4, k5, k6, k7, k8, k9, k0, Hyphen, Equals, BackSpace,
+			Tab, Q, W, E, R, T, Y, U, I, O, P, OpenSquareBracket, CloseSquareBracket, BackSlash,
+			CapsLock, A, S, D, F, G, H, J, K, L, Semicolon, Quote, Hash, Enter,
+			LeftShift, Z, X, C, V, B, N, M, Comma, FullStop, ForwardSlash, RightShift,
+			LeftControl, LeftOption, LeftMeta, Space, RightMeta, RightOption, RightControl,
+			Left, Right, Up, Down,
+			Insert, Home, PageUp, Delete, End, PageDown,
+			NumLock, KeyPadSlash, KeyPadAsterisk, KeyPadDelete,
+			KeyPad7, KeyPad8, KeyPad9, KeyPadPlus,
+			KeyPad4, KeyPad5, KeyPad6, KeyPadMinus,
+			KeyPad1, KeyPad2, KeyPad3, KeyPadEnter,
+			KeyPad0, KeyPadDecimalPoint, KeyPadEquals,
+			Help
+		};
+
+		// Host interface.
+		virtual void set_key_pressed(Key key, bool is_pressed);
+		virtual void reset_all_keys();
+
+		// Delegate interface.
+		struct Delegate {
+			virtual void keyboard_did_change_key(Keyboard *keyboard, Key key, bool is_pressed) = 0;
+			virtual void reset_all_keys(Keyboard *keyboard) = 0;
+		};
+		void set_delegate(Delegate *delegate);
+		bool get_key_state(Key key);
+
+	private:
+		std::vector<bool> key_states_;
+		Delegate *delegate_ = nullptr;
+};
+
+}
+
+#endif /* Keyboard_hpp */

Machines/AmstradCPC/AmstradCPC.cpp

@@ -8,7 +8,7 @@
 
 #include "AmstradCPC.hpp"
 
-#include "CharacterMapper.hpp"
+#include "Keyboard.hpp"
 
 #include "../../Processors/Z80/Z80.hpp"
 
@@ -17,11 +17,13 @@
 #include "../../Components/8272/i8272.hpp"
 #include "../../Components/AY38910/AY38910.hpp"
 
-#include "../MemoryFuzzer.hpp"
-#include "../Typer.hpp"
+#include "../Utility/MemoryFuzzer.hpp"
+#include "../Utility/Typer.hpp"
 
 #include "../../Storage/Tape/Tape.hpp"
 
+#include "../../ClockReceiver/ForceInline.hpp"
+
 namespace AmstradCPC {
 
 /*!
@@ -33,8 +35,6 @@ namespace AmstradCPC {
 */
 class InterruptTimer {
 	public:
-		InterruptTimer() : timer_(0), interrupt_request_(false) {}
-
 		/*!
 			Indicates that a new hsync pulse has been recognised. This should be
 			supplied on the falling edge of the CRTC HSYNC signal, which is the
@@ -76,7 +76,12 @@ class InterruptTimer {
 
 		/// @returns @c true if an interrupt is currently requested; @c false otherwise.
 		inline bool get_request() {
-			return interrupt_request_;
+			return last_interrupt_request_ = interrupt_request_;
+		}
+
+		/// Asks whether the interrupt status has changed.
+		inline bool request_has_changed() {
+			return last_interrupt_request_ != interrupt_request_;
 		}
 
 		/// Resets the timer.
@@ -86,9 +91,10 @@ class InterruptTimer {
 		}
 
 	private:
-		int reset_counter_;
-		bool interrupt_request_;
-		int timer_;
+		int reset_counter_ = 0;
+		bool interrupt_request_ = false;
+		bool last_interrupt_request_ = false;
+		int timer_ = 0;
 };
 
 /*!
@@ -147,26 +153,17 @@ class AYDeferrer {
 class CRTCBusHandler {
 	public:
 		CRTCBusHandler(uint8_t *ram, InterruptTimer &interrupt_timer) :
-			cycles_(0),
-			was_enabled_(false),
-			was_sync_(false),
-			pixel_data_(nullptr),
-			pixel_pointer_(nullptr),
-			was_hsync_(false),
 			ram_(ram),
-			interrupt_timer_(interrupt_timer),
-			pixel_divider_(1),
-			mode_(2),
-			next_mode_(2),
-			cycles_into_hsync_(0) {
-				build_mode_tables();
+			interrupt_timer_(interrupt_timer) {
+				establish_palette_hits();
+				build_mode_table();
 			}
 
 		/*!
-			The CRTC entry function; takes the current bus state and determines what output 
-			to produce based on the current palette and mode.
+			The CRTC entry function for the main part of each clock cycle; takes the current
+			bus state and determines what output to produce based on the current palette and mode.
 		*/
-		inline void perform_bus_cycle(const Motorola::CRTC::BusState &state) {
+		forceinline void perform_bus_cycle_phase1(const Motorola::CRTC::BusState &state) {
 			// The gate array waits 2µs to react to the CRTC's vsync signal, and then
 			// caps output at 4µs. Since the clock rate is 1Mhz, that's 2 and 4 cycles,
 			// respectively.
@@ -208,14 +205,14 @@ class CRTCBusHandler {
 			// collect some more pixels if output is ongoing
 			if(!is_sync && state.display_enable) {
 				if(!pixel_data_) {
-					pixel_pointer_ = pixel_data_ = crt_->allocate_write_area(320);
+					pixel_pointer_ = pixel_data_ = crt_->allocate_write_area(320, 8);
 				}
 				if(pixel_pointer_) {
 					// the CPC shuffles output lines as:
 					//	MA13 MA12	RA2 RA1 RA0		MA9 MA8 MA7 MA6 MA5 MA4 MA3 MA2 MA1 MA0		CCLK
 					// ... so form the real access address.
 					uint16_t address =
-						(uint16_t)(
+						static_cast<uint16_t>(
 							((state.refresh_address & 0x3ff) << 1) |
 							((state.row_address & 0x7) << 11) |
 							((state.refresh_address & 0x3000) << 2)
@@ -224,26 +221,26 @@ class CRTCBusHandler {
 					// fetch two bytes and translate into pixels
 					switch(mode_) {
 						case 0:
-							((uint16_t *)pixel_pointer_)[0] = mode0_output_[ram_[address]];
-							((uint16_t *)pixel_pointer_)[1] = mode0_output_[ram_[address+1]];
+							reinterpret_cast<uint16_t *>(pixel_pointer_)[0] = mode0_output_[ram_[address]];
+							reinterpret_cast<uint16_t *>(pixel_pointer_)[1] = mode0_output_[ram_[address+1]];
 							pixel_pointer_ += 4;
 						break;
 
 						case 1:
-							((uint32_t *)pixel_pointer_)[0] = mode1_output_[ram_[address]];
-							((uint32_t *)pixel_pointer_)[1] = mode1_output_[ram_[address+1]];
+							reinterpret_cast<uint32_t *>(pixel_pointer_)[0] = mode1_output_[ram_[address]];
+							reinterpret_cast<uint32_t *>(pixel_pointer_)[1] = mode1_output_[ram_[address+1]];
 							pixel_pointer_ += 8;
 						break;
 
 						case 2:
-							((uint64_t *)pixel_pointer_)[0] = mode2_output_[ram_[address]];
-							((uint64_t *)pixel_pointer_)[1] = mode2_output_[ram_[address+1]];
+							reinterpret_cast<uint64_t *>(pixel_pointer_)[0] = mode2_output_[ram_[address]];
+							reinterpret_cast<uint64_t *>(pixel_pointer_)[1] = mode2_output_[ram_[address+1]];
 							pixel_pointer_ += 16;
 						break;
 
 						case 3:
-							((uint16_t *)pixel_pointer_)[0] = mode3_output_[ram_[address]];
-							((uint16_t *)pixel_pointer_)[1] = mode3_output_[ram_[address+1]];
+							reinterpret_cast<uint16_t *>(pixel_pointer_)[0] = mode3_output_[ram_[address]];
+							reinterpret_cast<uint16_t *>(pixel_pointer_)[1] = mode3_output_[ram_[address+1]];
 							pixel_pointer_ += 4;
 						break;
 
@@ -259,7 +256,13 @@ class CRTCBusHandler {
 					}
 				}
 			}
+		}
 
+		/*!
+			The CRTC entry function for phase 2 of each bus cycle — in which the next sync line state becomes
+			visible early. The CPC uses changes in sync to clock the interrupt timer.
+		*/
+		void perform_bus_cycle_phase2(const Motorola::CRTC::BusState &state) {
 			// check for a trailing CRTC hsync; if one occurred then that's the trigger potentially to change
 			// modes, and should also be sent on to the interrupt timer
 			if(was_hsync_ && !state.hsync) {
@@ -271,6 +274,7 @@ class CRTCBusHandler {
 						case 1:		pixel_divider_ = 2;	break;
 						case 2:		pixel_divider_ = 1;	break;
 					}
+					build_mode_table();
 				}
 
 				interrupt_timer_.signal_hsync();
@@ -296,7 +300,7 @@ class CRTCBusHandler {
 					"return vec3(float((sample >> 4) & 3u), float((sample >> 2) & 3u), float(sample & 3u)) / 2.0;"
 				"}");
 			crt_->set_visible_area(Outputs::CRT::Rect(0.075f, 0.05f, 0.9f, 0.9f));
-			crt_->set_output_device(Outputs::CRT::Monitor);
+			crt_->set_output_device(Outputs::CRT::OutputDevice::Monitor);
 		}
 
 		/// Destructs the CRT.
@@ -317,11 +321,6 @@ class CRTCBusHandler {
 			next_mode_ = mode;
 		}
 
-		/// @returns the current value of the CRTC's vertical sync output.
-		bool get_vsync() const {
-			return was_vsync_;
-		}
-
 		/// Palette management: selects a pen to modify.
 		void select_pen(int pen) {
 			pen_ = pen;
@@ -339,50 +338,140 @@ class CRTCBusHandler {
 				border_ = mapped_palette_value(colour);
 			} else {
 				palette_[pen_] = mapped_palette_value(colour);
-				// TODO: no need for a full regeneration, of every mode, every time
-				build_mode_tables();
+				patch_mode_table(pen_);
 			}
 		}
 
 	private:
 		void output_border(unsigned int length) {
-			uint8_t *colour_pointer = (uint8_t *)crt_->allocate_write_area(1);
+			uint8_t *colour_pointer = static_cast<uint8_t *>(crt_->allocate_write_area(1));
 			if(colour_pointer) *colour_pointer = border_;
 			crt_->output_level(length * 16);
 		}
 
-		void build_mode_tables() {
+#define Mode0Colour0(c) ((c & 0x80) >> 7) | ((c & 0x20) >> 3) | ((c & 0x08) >> 2) | ((c & 0x02) << 2)
+#define Mode0Colour1(c) ((c & 0x40) >> 6) | ((c & 0x10) >> 2) | ((c & 0x04) >> 1) | ((c & 0x01) << 3)
+
+#define Mode1Colour0(c) ((c & 0x80) >> 7) | ((c & 0x08) >> 2)
+#define Mode1Colour1(c) ((c & 0x40) >> 6) | ((c & 0x04) >> 1)
+#define Mode1Colour2(c) ((c & 0x20) >> 5) | ((c & 0x02) >> 0)
+#define Mode1Colour3(c) ((c & 0x10) >> 4) | ((c & 0x01) << 1)
+
+#define Mode3Colour0(c)	((c & 0x80) >> 7) | ((c & 0x08) >> 2)
+#define Mode3Colour1(c) ((c & 0x40) >> 6) | ((c & 0x04) >> 1)
+
+		void establish_palette_hits() {
 			for(int c = 0; c < 256; c++) {
-				// prepare mode 0
-				uint8_t *mode0_pixels = (uint8_t *)&mode0_output_[c];
-				mode0_pixels[0] = palette_[((c & 0x80) >> 7) | ((c & 0x20) >> 3) | ((c & 0x08) >> 2) | ((c & 0x02) << 2)];
-				mode0_pixels[1] = palette_[((c & 0x40) >> 6) | ((c & 0x10) >> 2) | ((c & 0x04) >> 1) | ((c & 0x01) << 3)];
+				mode0_palette_hits_[Mode0Colour0(c)].push_back(static_cast<uint8_t>(c));
+				mode0_palette_hits_[Mode0Colour1(c)].push_back(static_cast<uint8_t>(c));
 
-				// prepare mode 1
-				uint8_t *mode1_pixels = (uint8_t *)&mode1_output_[c];
-				mode1_pixels[0] = palette_[((c & 0x80) >> 7) | ((c & 0x08) >> 2)];
-				mode1_pixels[1] = palette_[((c & 0x40) >> 6) | ((c & 0x04) >> 1)];
-				mode1_pixels[2] = palette_[((c & 0x20) >> 5) | ((c & 0x02) >> 0)];
-				mode1_pixels[3] = palette_[((c & 0x10) >> 4) | ((c & 0x01) << 1)];
+				mode1_palette_hits_[Mode1Colour0(c)].push_back(static_cast<uint8_t>(c));
+				mode1_palette_hits_[Mode1Colour1(c)].push_back(static_cast<uint8_t>(c));
+				mode1_palette_hits_[Mode1Colour2(c)].push_back(static_cast<uint8_t>(c));
+				mode1_palette_hits_[Mode1Colour3(c)].push_back(static_cast<uint8_t>(c));
 
-				// prepare mode 2
-				uint8_t *mode2_pixels = (uint8_t *)&mode2_output_[c];
-				mode2_pixels[0] = palette_[((c & 0x80) >> 7)];
-				mode2_pixels[1] = palette_[((c & 0x40) >> 6)];
-				mode2_pixels[2] = palette_[((c & 0x20) >> 5)];
-				mode2_pixels[3] = palette_[((c & 0x10) >> 4)];
-				mode2_pixels[4] = palette_[((c & 0x08) >> 3)];
-				mode2_pixels[5] = palette_[((c & 0x04) >> 2)];
-				mode2_pixels[6] = palette_[((c & 0x03) >> 1)];
-				mode2_pixels[7] = palette_[((c & 0x01) >> 0)];
-
-				// prepare mode 3
-				uint8_t *mode3_pixels = (uint8_t *)&mode3_output_[c];
-				mode3_pixels[0] = palette_[((c & 0x80) >> 7) | ((c & 0x08) >> 2)];
-				mode3_pixels[1] = palette_[((c & 0x40) >> 6) | ((c & 0x04) >> 1)];
+				mode3_palette_hits_[Mode3Colour0(c)].push_back(static_cast<uint8_t>(c));
+				mode3_palette_hits_[Mode3Colour1(c)].push_back(static_cast<uint8_t>(c));
 			}
 		}
 
+		void build_mode_table() {
+			switch(mode_) {
+				case 0:
+					// Mode 0: abcdefgh -> [gcea] [hdfb]
+					for(int c = 0; c < 256; c++) {
+						// prepare mode 0
+						uint8_t *mode0_pixels = reinterpret_cast<uint8_t *>(&mode0_output_[c]);
+						mode0_pixels[0] = palette_[Mode0Colour0(c)];
+						mode0_pixels[1] = palette_[Mode0Colour1(c)];
+					}
+				break;
+
+				case 1:
+					for(int c = 0; c < 256; c++) {
+						// prepare mode 1
+						uint8_t *mode1_pixels = reinterpret_cast<uint8_t *>(&mode1_output_[c]);
+						mode1_pixels[0] = palette_[Mode1Colour0(c)];
+						mode1_pixels[1] = palette_[Mode1Colour1(c)];
+						mode1_pixels[2] = palette_[Mode1Colour2(c)];
+						mode1_pixels[3] = palette_[Mode1Colour3(c)];
+					}
+				break;
+
+				case 2:
+					for(int c = 0; c < 256; c++) {
+						// prepare mode 2
+						uint8_t *mode2_pixels = reinterpret_cast<uint8_t *>(&mode2_output_[c]);
+						mode2_pixels[0] = palette_[((c & 0x80) >> 7)];
+						mode2_pixels[1] = palette_[((c & 0x40) >> 6)];
+						mode2_pixels[2] = palette_[((c & 0x20) >> 5)];
+						mode2_pixels[3] = palette_[((c & 0x10) >> 4)];
+						mode2_pixels[4] = palette_[((c & 0x08) >> 3)];
+						mode2_pixels[5] = palette_[((c & 0x04) >> 2)];
+						mode2_pixels[6] = palette_[((c & 0x03) >> 1)];
+						mode2_pixels[7] = palette_[((c & 0x01) >> 0)];
+					}
+				break;
+
+				case 3:
+					for(int c = 0; c < 256; c++) {
+						// prepare mode 3
+						uint8_t *mode3_pixels = reinterpret_cast<uint8_t *>(&mode3_output_[c]);
+						mode3_pixels[0] = palette_[Mode3Colour0(c)];
+						mode3_pixels[1] = palette_[Mode3Colour1(c)];
+					}
+				break;
+			}
+		}
+
+		void patch_mode_table(int pen) {
+			switch(mode_) {
+				case 0: {
+					for(uint8_t c : mode0_palette_hits_[pen]) {
+						uint8_t *mode0_pixels = reinterpret_cast<uint8_t *>(&mode0_output_[c]);
+						mode0_pixels[0] = palette_[Mode0Colour0(c)];
+						mode0_pixels[1] = palette_[Mode0Colour1(c)];
+					}
+				} break;
+				case 1:
+					if(pen > 3) return;
+					for(uint8_t c : mode1_palette_hits_[pen]) {
+						uint8_t *mode1_pixels = reinterpret_cast<uint8_t *>(&mode1_output_[c]);
+						mode1_pixels[0] = palette_[Mode1Colour0(c)];
+						mode1_pixels[1] = palette_[Mode1Colour1(c)];
+						mode1_pixels[2] = palette_[Mode1Colour2(c)];
+						mode1_pixels[3] = palette_[Mode1Colour3(c)];
+					}
+				break;
+				case 2:
+					if(pen > 1) return;
+					// Whichever pen this is, there's only one table entry it doesn't touch, so just
+					// rebuild the whole thing.
+					build_mode_table();
+				break;
+				case 3:
+					if(pen > 3) return;
+					// Same argument applies here as to case 1, as the unused bits aren't masked out.
+					for(uint8_t c : mode3_palette_hits_[pen]) {
+						uint8_t *mode3_pixels = reinterpret_cast<uint8_t *>(&mode3_output_[c]);
+						mode3_pixels[0] = palette_[Mode3Colour0(c)];
+						mode3_pixels[1] = palette_[Mode3Colour1(c)];
+					}
+				break;
+			}
+		}
+
+#undef Mode0Colour0
+#undef Mode0Colour1
+
+#undef Mode1Colour0
+#undef Mode1Colour1
+#undef Mode1Colour2
+#undef Mode1Colour3
+
+#undef Mode3Colour0
+#undef Mode3Colour1
+
 		uint8_t mapped_palette_value(uint8_t colour) {
 #define COL(r, g, b) (r << 4) | (g << 2) | b
 			static const uint8_t mapping[32] = {
@@ -399,27 +488,31 @@ class CRTCBusHandler {
 			return mapping[colour];
 		}
 
-		unsigned int cycles_;
+		unsigned int cycles_ = 0;
 
-		bool was_enabled_, was_sync_, was_hsync_, was_vsync_;
-		int cycles_into_hsync_;
+		bool was_enabled_ = false, was_sync_ = false, was_hsync_ = false, was_vsync_ = false;
+		int cycles_into_hsync_ = 0;
 
 		std::shared_ptr<Outputs::CRT::CRT> crt_;
-		uint8_t *pixel_data_, *pixel_pointer_;
+		uint8_t *pixel_data_ = nullptr, *pixel_pointer_ = nullptr;
 
-		uint8_t *ram_;
+		uint8_t *ram_ = nullptr;
 
-		int next_mode_, mode_;
+		int next_mode_ = 2, mode_ = 2;
 
-		unsigned int pixel_divider_;
+		unsigned int pixel_divider_ = 1;
 		uint16_t mode0_output_[256];
 		uint32_t mode1_output_[256];
 		uint64_t mode2_output_[256];
 		uint16_t mode3_output_[256];
 
-		int pen_;
+		std::vector<uint8_t> mode0_palette_hits_[16];
+		std::vector<uint8_t> mode1_palette_hits_[4];
+		std::vector<uint8_t> mode3_palette_hits_[4];
+
+		int pen_ = 0;
 		uint8_t palette_[16];
-		uint8_t border_;
+		uint8_t border_ = 0;
 
 		InterruptTimer &interrupt_timer_;
 };
@@ -477,12 +570,25 @@ class KeyboardState: public GI::AY38910::PortHandler {
 class FDC: public Intel::i8272::i8272 {
 	private:
 		Intel::i8272::BusHandler bus_handler_;
+		std::shared_ptr<Storage::Disk::Drive> drive_;
 
 	public:
-		FDC() : i8272(bus_handler_, Cycles(8000000), 16, 300) {}
+		FDC() :
+			i8272(bus_handler_, Cycles(8000000)),
+			drive_(new Storage::Disk::Drive(8000000, 300, 1)) {
+			set_drive(drive_);
+		}
 
 		void set_motor_on(bool on) {
-			Intel::i8272::i8272::set_motor_on(on);
+			drive_->set_motor_on(on);
+		}
+
+		void select_drive(int c) {
+			// TODO: support more than one drive.
+		}
+
+		void set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
+			drive_->set_disk(disk);
 		}
 };
 
@@ -493,12 +599,12 @@ class i8255PortHandler : public Intel::i8255::PortHandler {
 	public:
 		i8255PortHandler(
 			KeyboardState &key_state,
-			const CRTCBusHandler &crtc_bus_handler,
+			const Motorola::CRTC::CRTC6845<CRTCBusHandler> &crtc,
 			AYDeferrer &ay,
 			Storage::Tape::BinaryTapePlayer &tape_player) :
-				key_state_(key_state),
-				crtc_bus_handler_(crtc_bus_handler),
 				ay_(ay),
+				crtc_(crtc),
+				key_state_(key_state),
 				tape_player_(tape_player) {}
 
 		/// The i8255 will call this to set a new output value of @c value for @c port.
@@ -538,7 +644,7 @@ class i8255PortHandler : public Intel::i8255::PortHandler {
 			switch(port) {
 				case 0: return ay_.ay()->get_data_output();	// Port A is wired to the AY
 				case 1:	return
-					(crtc_bus_handler_.get_vsync() ? 0x01 : 0x00) |	// Bit 0 returns CRTC vsync.
+					(crtc_.get_bus_state().vsync ? 0x01 : 0x00) |	// Bit 0 returns CRTC vsync.
 					(tape_player_.get_input() ? 0x80 : 0x00) |		// Bit 7 returns cassette input.
 					0x7e;	// Bits unimplemented:
 							//
@@ -552,8 +658,8 @@ class i8255PortHandler : public Intel::i8255::PortHandler {
 
 	private:
 		AYDeferrer &ay_;
+		const Motorola::CRTC::CRTC6845<CRTCBusHandler> &crtc_;
 		KeyboardState &key_state_;
-		const CRTCBusHandler &crtc_bus_handler_;
 		Storage::Tape::BinaryTapePlayer &tape_player_;
 };
 
@@ -563,25 +669,34 @@ class i8255PortHandler : public Intel::i8255::PortHandler {
 class ConcreteMachine:
 	public Utility::TypeRecipient,
 	public CPU::Z80::BusHandler,
+	public Sleeper::SleepObserver,
 	public Machine {
 	public:
 		ConcreteMachine() :
 			z80_(*this),
-			crtc_counter_(HalfCycles(4)),	// This starts the CRTC exactly out of phase with the CPU's memory accesses
-			crtc_(Motorola::CRTC::HD6845S, crtc_bus_handler_),
 			crtc_bus_handler_(ram_, interrupt_timer_),
+			crtc_(Motorola::CRTC::HD6845S, crtc_bus_handler_),
+			i8255_port_handler_(key_state_, crtc_, ay_, tape_player_),
 			i8255_(i8255_port_handler_),
-			i8255_port_handler_(key_state_, crtc_bus_handler_, ay_, tape_player_),
-			tape_player_(8000000) {
+			tape_player_(8000000),
+			crtc_counter_(HalfCycles(4))	// This starts the CRTC exactly out of phase with the CPU's memory accesses
+		{
 			// primary clock is 4Mhz
 			set_clock_rate(4000000);
 
 			// ensure memory starts in a random state
 			Memory::Fuzz(ram_, sizeof(ram_));
+
+			// register this class as the sleep observer for the FDC and tape
+			fdc_.set_sleep_observer(this);
+			fdc_is_sleeping_ = fdc_.is_sleeping();
+
+			tape_player_.set_sleep_observer(this);
+			tape_player_is_sleeping_ = tape_player_.is_sleeping();
 		}
 
 		/// The entry point for performing a partial Z80 machine cycle.
-		inline HalfCycles perform_machine_cycle(const CPU::Z80::PartialMachineCycle &cycle) {
+		forceinline HalfCycles perform_machine_cycle(const CPU::Z80::PartialMachineCycle &cycle) {
 			// Amstrad CPC timing scheme: assert WAIT for three out of four cycles
 			clock_offset_ = (clock_offset_ + cycle.length) & HalfCycles(7);
 			z80_.set_wait_line(clock_offset_ >= HalfCycles(2));
@@ -593,17 +708,20 @@ class ConcreteMachine:
 			crtc_counter_ += cycle.length;
 			Cycles crtc_cycles = crtc_counter_.divide_cycles(Cycles(4));
 			if(crtc_cycles > Cycles(0)) crtc_.run_for(crtc_cycles);
-			z80_.set_interrupt_line(interrupt_timer_.get_request());
+
+			// Check whether that prompted a change in the interrupt line. If so then date
+			// it to whenever the cycle was triggered.
+			if(interrupt_timer_.request_has_changed()) z80_.set_interrupt_line(interrupt_timer_.get_request(), -crtc_counter_);
 
 			// TODO (in the player, not here): adapt it to accept an input clock rate and
 			// run_for as HalfCycles
-			tape_player_.run_for(cycle.length.as_int());
+			if(!tape_player_is_sleeping_) tape_player_.run_for(cycle.length.as_int());
 
 			// Pump the AY
 			ay_.run_for(cycle.length);
 
 			// Clock the FDC, if connected, using a lazy scale by two
-			if(has_fdc_) fdc_.run_for(Cycles(cycle.length.as_int()));
+			if(has_fdc_ && !fdc_is_sleeping_) fdc_.run_for(Cycles(cycle.length.as_int()));
 
 			// Update typing activity
 			if(typer_) typer_->run_for(cycle.length);
@@ -715,35 +833,35 @@ class ConcreteMachine:
 		}
 
 		/// A CRTMachine function; indicates that outputs should be created now.
-		void setup_output(float aspect_ratio) {
+		void setup_output(float aspect_ratio) override final {
 			crtc_bus_handler_.setup_output(aspect_ratio);
 			ay_.setup_output();
 			ay_.ay()->set_port_handler(&key_state_);
 		}
 
 		/// A CRTMachine function; indicates that outputs should be destroyed now.
-		void close_output() {
+		void close_output() override final {
 			crtc_bus_handler_.close_output();
 			ay_.close_output();
 		}
 
 		/// @returns the CRT in use.
-		std::shared_ptr<Outputs::CRT::CRT> get_crt() {
+		std::shared_ptr<Outputs::CRT::CRT> get_crt() override final {
 			return crtc_bus_handler_.get_crt();
 		}
 
 		/// @returns the speaker in use.
-		std::shared_ptr<Outputs::Speaker> get_speaker() {
+		std::shared_ptr<Outputs::Speaker> get_speaker() override final {
 			return ay_.get_speaker();
 		}
 
 		/// Wires virtual-dispatched CRTMachine run_for requests to the static Z80 method.
-		void run_for(const Cycles cycles) {
+		void run_for(const Cycles cycles) override final {
 			z80_.run_for(cycles);
 		}
 
 		/// The ConfigurationTarget entry point; should configure this meachine as described by @c target.
-		void configure_as_target(const StaticAnalyser::Target &target) {
+		void configure_as_target(const StaticAnalyser::Target &target) override final  {
 			switch(target.amstradcpc.model) {
 				case StaticAnalyser::AmstradCPCModel::CPC464:
 					rom_model_ = ROMType::OS464;
@@ -776,55 +894,90 @@ class ConcreteMachine:
 			read_pointers_[2] = write_pointers_[2];
 			read_pointers_[3] = roms_[upper_rom_].data();
 
+			// Type whatever is required.
+			if(target.loadingCommand.length()) {
+				set_typer_for_string(target.loadingCommand.c_str());
+			}
+
+			insert_media(target.media);
+		}
+
+		bool insert_media(const StaticAnalyser::Media &media) override final {
 			// If there are any tapes supplied, use the first of them.
-			if(!target.tapes.empty()) {
-				tape_player_.set_tape(target.tapes.front());
+			if(!media.tapes.empty()) {
+				tape_player_.set_tape(media.tapes.front());
 			}
 
 			// Insert up to four disks.
 			int c = 0;
-			for(auto &disk : target.disks) {
+			for(auto &disk : media.disks) {
 				fdc_.set_disk(disk, c);
 				c++;
 				if(c == 4) break;
 			}
 
-			// Type whatever is required.
-			if(target.loadingCommand.length()) {
-				set_typer_for_string(target.loadingCommand.c_str());
-			}
+			return !media.tapes.empty() || (!media.disks.empty() && has_fdc_);
 		}
 
 		// See header; provides the system ROMs.
-		void set_rom(ROMType type, std::vector<uint8_t> data) {
-			roms_[(int)type] = data;
+		void set_rom(ROMType type, const std::vector<uint8_t> &data) override final {
+			roms_[static_cast<int>(type)] = data;
 		}
 
-#pragma mark - Keyboard
+		// Obtains the system ROMs.
+		bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) override {
+			auto roms = roms_with_names(
+				"AmstradCPC",
+				{
+					"os464.rom",	"basic464.rom",
+					"os664.rom",	"basic664.rom",
+					"os6128.rom",	"basic6128.rom",
+					"amsdos.rom"
+				});
 
-		void set_typer_for_string(const char *string) {
+			for(std::size_t index = 0; index < roms.size(); ++index) {
+				auto &data = roms[index];
+				if(!data) return false;
+				set_rom(static_cast<ROMType>(index), *data);
+			}
+
+			return true;
+		}
+
+		void set_component_is_sleeping(void *component, bool is_sleeping) override final {
+			fdc_is_sleeping_ = fdc_.is_sleeping();
+			tape_player_is_sleeping_ = tape_player_.is_sleeping();
+		}
+
+// MARK: - Keyboard
+
+		void set_typer_for_string(const char *string) override final {
 			std::unique_ptr<CharacterMapper> mapper(new CharacterMapper());
 			Utility::TypeRecipient::set_typer_for_string(string, std::move(mapper));
 		}
 
-		HalfCycles get_typer_delay() {
+		HalfCycles get_typer_delay() override final {
 			return Cycles(4000000);	// Wait 1 second before typing.
 		}
 
-		HalfCycles get_typer_frequency() {
-			return Cycles(80000);	// Type one character per frame.
+		HalfCycles get_typer_frequency() override final {
+			return Cycles(160000);	// Type one character per frame.
 		}
 
 		// See header; sets a key as either pressed or released.
-		void set_key_state(uint16_t key, bool isPressed) {
+		void set_key_state(uint16_t key, bool isPressed) override final {
 			key_state_.set_is_pressed(isPressed, key >> 4, key & 7);
 		}
 
 		// See header; sets all keys to released.
-		void clear_all_keys() {
+		void clear_all_keys() override final {
 			key_state_.clear_all_keys();
 		}
 
+		KeyboardMapper &get_keyboard_mapper() override {
+			return keyboard_mapper_;
+		}
+
 	private:
 		inline void write_to_gate_array(uint8_t value) {
 			switch(value >> 6) {
@@ -871,7 +1024,7 @@ class ConcreteMachine:
 			}
 		}
 
-		CPU::Z80::Processor<ConcreteMachine> z80_;
+		CPU::Z80::Processor<ConcreteMachine, false, true> z80_;
 
 		CRTCBusHandler crtc_bus_handler_;
 		Motorola::CRTC::CRTC6845<CRTCBusHandler> crtc_;
@@ -893,7 +1046,8 @@ class ConcreteMachine:
 
 		std::vector<uint8_t> roms_[7];
 		int rom_model_;
-		bool has_fdc_;
+		bool has_fdc_, fdc_is_sleeping_;
+		bool tape_player_is_sleeping_;
 		bool has_128k_;
 		bool upper_rom_is_paged_;
 		int upper_rom_;
@@ -903,6 +1057,7 @@ class ConcreteMachine:
 		uint8_t *write_pointers_[4];
 
 		KeyboardState key_state_;
+		AmstradCPC::KeyboardMapper keyboard_mapper_;
 };
 
 }

Machines/AmstradCPC/AmstradCPC.hpp

@@ -25,27 +25,8 @@ enum ROMType: int {
 	AMSDOS
 };
 
-enum Key: uint16_t {
-#define Line(l, k1, k2, k3, k4, k5, k6, k7, k8)	\
-	k1 = (l << 4) | 0x07,	k2 = (l << 4) | 0x06,	k3 = (l << 4) | 0x05,	k4 = (l << 4) | 0x04,\
-	k5 = (l << 4) | 0x03,	k6 = (l << 4) | 0x02,	k7 = (l << 4) | 0x01,	k8 = (l << 4) | 0x00,
-
-	Line(0, KeyFDot,		KeyEnter,			KeyF3,			KeyF6,			KeyF9,					KeyDown,		KeyRight,				KeyUp)
-	Line(1, KeyF0,			KeyF2,				KeyF1,			KeyF5,			KeyF8,					KeyF7,			KeyCopy,				KeyLeft)
-	Line(2, KeyControl,		KeyBackSlash,		KeyShift,		KeyF4,			KeyRightSquareBracket,	KeyReturn,		KeyLeftSquareBracket,	KeyClear)
-	Line(3, KeyFullStop,	KeyForwardSlash,	KeyColon,		KeySemicolon,	KeyP,					KeyAt,			KeyMinus,				KeyCaret)
-	Line(4, KeyComma,		KeyM,				KeyK,			KeyL,			KeyI,					KeyO,			Key9,					Key0)
-	Line(5, KeySpace,		KeyN,				KeyJ,			KeyH,			KeyY,					KeyU,			Key7,					Key8)
-	Line(6, KeyV,			KeyB,				KeyF,			KeyG,			KeyT,					KeyR,			Key5,					Key6)
-	Line(7, KeyX,			KeyC,				KeyD,			KeyS,			KeyW,					KeyE,			Key3,					Key4)
-	Line(8, KeyZ,			KeyCapsLock,		KeyA,			KeyTab,			KeyQ,					KeyEscape,		Key2,					Key1)
-	Line(9, KeyDelete,		KeyJoy1Fire3,		KeyJoy2Fire2,	KeyJoy1Fire1,	KeyJoy1Right,			KeyJoy1Left,	KeyJoy1Down,			KeyJoy1Up)
-
-#undef Line
-};
-
 /*!
-	Models an Amstrad CPC, a CRT-outputting machine with a keyboard that can accept configuration targets.
+	Models an Amstrad CPC.
 */
 class Machine:
 	public CRTMachine::Machine,
@@ -54,11 +35,11 @@ class Machine:
 	public:
 		virtual ~Machine();
 
-		/// Creates an returns an Amstrad CPC on the heap.
+		/// Creates and returns an Amstrad CPC.
 		static Machine *AmstradCPC();
 
 		/// Sets the contents of rom @c type to @c data. Assumed to be a setup step; has no effect once a machine is running.
-		virtual void set_rom(ROMType type, std::vector<uint8_t> data) = 0;
+		virtual void set_rom(ROMType type, const std::vector<uint8_t> &data) = 0;
 };
 
 }

Machines/AmstradCPC/CharacterMapper.hpp

@@ -1,23 +0,0 @@
-//
-//  CharacterMapper.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 11/08/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
-//
-
-#ifndef Machines_AmstradCPC_CharacterMapper_hpp
-#define Machines_AmstradCPC_CharacterMapper_hpp
-
-#include "../Typer.hpp"
-
-namespace AmstradCPC {
-
-class CharacterMapper: public ::Utility::CharacterMapper {
-	public:
-		uint16_t *sequence_for_character(char character);
-};
-
-}
-
-#endif /* CharacterMapper_hpp */

Machines/AmstradCPC/Keyboard.cpp

@@ -1,20 +1,83 @@
 //
-//  CharacterMapper.cpp
+//  Keyboard.cpp
 //  Clock Signal
 //
-//  Created by Thomas Harte on 11/08/2017.
+//  Created by Thomas Harte on 10/10/2017.
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#include "CharacterMapper.hpp"
-#include "AmstradCPC.hpp"
+#include "Keyboard.hpp"
 
 using namespace AmstradCPC;
 
+uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) {
+#define BIND(source, dest)	case Inputs::Keyboard::Key::source:	return dest
+	switch(key) {
+		default: return KeyCopy;
+
+		BIND(k0, Key0);		BIND(k1, Key1);		BIND(k2, Key2);		BIND(k3, Key3);		BIND(k4, Key4);
+		BIND(k5, Key5);		BIND(k6, Key6);		BIND(k7, Key7);		BIND(k8, Key8);		BIND(k9, Key9);
+		BIND(Q, KeyQ);		BIND(W, KeyW);		BIND(E, KeyE);		BIND(R, KeyR);		BIND(T, KeyT);
+		BIND(Y, KeyY);		BIND(U, KeyU);		BIND(I, KeyI);		BIND(O, KeyO);		BIND(P, KeyP);
+		BIND(A, KeyA);		BIND(S, KeyS);		BIND(D, KeyD);		BIND(F, KeyF);		BIND(G, KeyG);
+		BIND(H, KeyH);		BIND(J, KeyJ);		BIND(K, KeyK);		BIND(L, KeyL);
+		BIND(Z, KeyZ);		BIND(X, KeyX);		BIND(C, KeyC);		BIND(V, KeyV);
+		BIND(B, KeyB);		BIND(N, KeyN);		BIND(M, KeyM);
+
+		BIND(Escape, KeyEscape);
+		BIND(F1, KeyF1);	BIND(F2, KeyF2);	BIND(F3, KeyF3);	BIND(F4, KeyF4);	BIND(F5, KeyF5);
+		BIND(F6, KeyF6);	BIND(F7, KeyF7);	BIND(F8, KeyF8);	BIND(F9, KeyF9);	BIND(F10, KeyF0);
+
+		BIND(F11, KeyRightSquareBracket);
+		BIND(F12, KeyClear);
+
+		BIND(Hyphen, KeyMinus);		BIND(Equals, KeyCaret);		BIND(BackSpace, KeyDelete);
+		BIND(Tab, KeyTab);
+
+		BIND(OpenSquareBracket, KeyAt);
+		BIND(CloseSquareBracket, KeyLeftSquareBracket);
+		BIND(BackSlash, KeyBackSlash);
+
+		BIND(CapsLock, KeyCapsLock);
+		BIND(Semicolon, KeyColon);
+		BIND(Quote, KeySemicolon);
+		BIND(Hash, KeyRightSquareBracket);
+		BIND(Enter, KeyReturn);
+
+		BIND(LeftShift, KeyShift);
+		BIND(Comma, KeyComma);
+		BIND(FullStop, KeyFullStop);
+		BIND(ForwardSlash, KeyForwardSlash);
+		BIND(RightShift, KeyShift);
+
+		BIND(LeftControl, KeyControl);	BIND(LeftOption, KeyControl);	BIND(LeftMeta, KeyControl);
+		BIND(Space, KeySpace);
+		BIND(RightMeta, KeyControl);	BIND(RightOption, KeyControl);	BIND(RightControl, KeyControl);
+
+		BIND(Left, KeyLeft);	BIND(Right, KeyRight);
+		BIND(Up, KeyUp);		BIND(Down, KeyDown);
+
+		BIND(KeyPad0, KeyF0);
+		BIND(KeyPad1, KeyF1);		BIND(KeyPad2, KeyF2);		BIND(KeyPad3, KeyF3);
+		BIND(KeyPad4, KeyF4);		BIND(KeyPad5, KeyF5);		BIND(KeyPad6, KeyF6);
+		BIND(KeyPad7, KeyF7);		BIND(KeyPad8, KeyF8);		BIND(KeyPad9, KeyF9);
+		BIND(KeyPadPlus, KeySemicolon);
+		BIND(KeyPadMinus, KeyMinus);
+
+		BIND(KeyPadEnter, KeyEnter);
+		BIND(KeyPadDecimalPoint, KeyFullStop);
+		BIND(KeyPadEquals, KeyMinus);
+		BIND(KeyPadSlash, KeyForwardSlash);
+		BIND(KeyPadAsterisk, KeyColon);
+		BIND(KeyPadDelete, KeyDelete);
+	}
+#undef BIND
+}
+
 uint16_t *CharacterMapper::sequence_for_character(char character) {
-#define KEYS(...)	{__VA_ARGS__, EndSequence}
-#define SHIFT(...)	{KeyShift, __VA_ARGS__, EndSequence}
-#define X			{NotMapped}
+#define KEYS(...)	{__VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define SHIFT(...)	{KeyShift, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define X			{KeyboardMachine::Machine::KeyNotMapped}
 	static KeySequence key_sequences[] = {
 		/* NUL */	X,							/* SOH */	X,
 		/* STX */	X,							/* ETX */	X,

Machines/AmstradCPC/Keyboard.hpp

@@ -0,0 +1,46 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_AmstradCPC_Keyboard_hpp
+#define Machines_AmstradCPC_Keyboard_hpp
+
+#include "../KeyboardMachine.hpp"
+#include "../Utility/Typer.hpp"
+
+namespace AmstradCPC {
+
+enum Key: uint16_t {
+#define Line(l, k1, k2, k3, k4, k5, k6, k7, k8)	\
+	k1 = (l << 4) | 0x07,	k2 = (l << 4) | 0x06,	k3 = (l << 4) | 0x05,	k4 = (l << 4) | 0x04,\
+	k5 = (l << 4) | 0x03,	k6 = (l << 4) | 0x02,	k7 = (l << 4) | 0x01,	k8 = (l << 4) | 0x00,
+
+	Line(0, KeyFDot,		KeyEnter,			KeyF3,			KeyF6,			KeyF9,					KeyDown,		KeyRight,				KeyUp)
+	Line(1, KeyF0,			KeyF2,				KeyF1,			KeyF5,			KeyF8,					KeyF7,			KeyCopy,				KeyLeft)
+	Line(2, KeyControl,		KeyBackSlash,		KeyShift,		KeyF4,			KeyRightSquareBracket,	KeyReturn,		KeyLeftSquareBracket,	KeyClear)
+	Line(3, KeyFullStop,	KeyForwardSlash,	KeyColon,		KeySemicolon,	KeyP,					KeyAt,			KeyMinus,				KeyCaret)
+	Line(4, KeyComma,		KeyM,				KeyK,			KeyL,			KeyI,					KeyO,			Key9,					Key0)
+	Line(5, KeySpace,		KeyN,				KeyJ,			KeyH,			KeyY,					KeyU,			Key7,					Key8)
+	Line(6, KeyV,			KeyB,				KeyF,			KeyG,			KeyT,					KeyR,			Key5,					Key6)
+	Line(7, KeyX,			KeyC,				KeyD,			KeyS,			KeyW,					KeyE,			Key3,					Key4)
+	Line(8, KeyZ,			KeyCapsLock,		KeyA,			KeyTab,			KeyQ,					KeyEscape,		Key2,					Key1)
+	Line(9, KeyDelete,		KeyJoy1Fire3,		KeyJoy2Fire2,	KeyJoy1Fire1,	KeyJoy1Right,			KeyJoy1Left,	KeyJoy1Down,			KeyJoy1Up)
+
+#undef Line
+};
+
+struct KeyboardMapper: public KeyboardMachine::Machine::KeyboardMapper {
+	uint16_t mapped_key_for_key(Inputs::Keyboard::Key key);
+};
+
+struct CharacterMapper: public ::Utility::CharacterMapper {
+	uint16_t *sequence_for_character(char character);
+};
+
+};
+
+#endif /* KeyboardMapper_hpp */

Machines/Atari2600/Atari2600.cpp

@@ -7,151 +7,217 @@
 //
 
 #include "Atari2600.hpp"
+
 #include <algorithm>
-#include <stdio.h>
+#include <cstdio>
 
-#include "Cartridges/CartridgeAtari8k.hpp"
-#include "Cartridges/CartridgeAtari16k.hpp"
-#include "Cartridges/CartridgeAtari32k.hpp"
-#include "Cartridges/CartridgeActivisionStack.hpp"
-#include "Cartridges/CartridgeCBSRAMPlus.hpp"
-#include "Cartridges/CartridgeCommaVid.hpp"
-#include "Cartridges/CartridgeMegaBoy.hpp"
-#include "Cartridges/CartridgeMNetwork.hpp"
-#include "Cartridges/CartridgeParkerBros.hpp"
-#include "Cartridges/CartridgePitfall2.hpp"
-#include "Cartridges/CartridgeTigervision.hpp"
-#include "Cartridges/CartridgeUnpaged.hpp"
+#include "Cartridges/Atari8k.hpp"
+#include "Cartridges/Atari16k.hpp"
+#include "Cartridges/Atari32k.hpp"
+#include "Cartridges/ActivisionStack.hpp"
+#include "Cartridges/CBSRAMPlus.hpp"
+#include "Cartridges/CommaVid.hpp"
+#include "Cartridges/MegaBoy.hpp"
+#include "Cartridges/MNetwork.hpp"
+#include "Cartridges/ParkerBros.hpp"
+#include "Cartridges/Pitfall2.hpp"
+#include "Cartridges/Tigervision.hpp"
+#include "Cartridges/Unpaged.hpp"
 
-using namespace Atari2600;
 namespace {
 	static const double NTSC_clock_rate = 1194720;
 	static const double PAL_clock_rate = 1182298;
 }
 
-Machine::Machine() :
-	frame_record_pointer_(0),
-	is_ntsc_(true) {
-	set_clock_rate(NTSC_clock_rate);
-}
+namespace Atari2600 {
 
-void Machine::setup_output(float aspect_ratio) {
-	bus_->tia_.reset(new TIA);
-	bus_->speaker_.reset(new Speaker);
-	bus_->speaker_->set_input_rate((float)(get_clock_rate() / (double)CPUTicksPerAudioTick));
-	bus_->tia_->get_crt()->set_delegate(this);
-}
+class Joystick: public Inputs::Joystick {
+	public:
+		Joystick(Bus *bus, std::size_t shift, std::size_t fire_tia_input) :
+			bus_(bus), shift_(shift), fire_tia_input_(fire_tia_input) {}
 
-void Machine::close_output() {
-	bus_.reset();
-}
+		void set_digital_input(DigitalInput digital_input, bool is_active) {
+			switch(digital_input) {
+				case DigitalInput::Up:		bus_->mos6532_.update_port_input(0, 0x10 >> shift_, is_active);		break;
+				case DigitalInput::Down:	bus_->mos6532_.update_port_input(0, 0x20 >> shift_, is_active);		break;
+				case DigitalInput::Left:	bus_->mos6532_.update_port_input(0, 0x40 >> shift_, is_active);		break;
+				case DigitalInput::Right:	bus_->mos6532_.update_port_input(0, 0x80 >> shift_, is_active);		break;
 
-Machine::~Machine() {
-	close_output();
-}
-
-void Machine::set_digital_input(Atari2600DigitalInput input, bool state) {
-	switch (input) {
-		case Atari2600DigitalInputJoy1Up:		bus_->mos6532_.update_port_input(0, 0x10, state);	break;
-		case Atari2600DigitalInputJoy1Down:		bus_->mos6532_.update_port_input(0, 0x20, state);	break;
-		case Atari2600DigitalInputJoy1Left:		bus_->mos6532_.update_port_input(0, 0x40, state);	break;
-		case Atari2600DigitalInputJoy1Right:	bus_->mos6532_.update_port_input(0, 0x80, state);	break;
-
-		case Atari2600DigitalInputJoy2Up:		bus_->mos6532_.update_port_input(0, 0x01, state);	break;
-		case Atari2600DigitalInputJoy2Down:		bus_->mos6532_.update_port_input(0, 0x02, state);	break;
-		case Atari2600DigitalInputJoy2Left:		bus_->mos6532_.update_port_input(0, 0x04, state);	break;
-		case Atari2600DigitalInputJoy2Right:	bus_->mos6532_.update_port_input(0, 0x08, state);	break;
-
-		// TODO: latching
-		case Atari2600DigitalInputJoy1Fire:		if(state) bus_->tia_input_value_[0] &= ~0x80; else bus_->tia_input_value_[0] |= 0x80; break;
-		case Atari2600DigitalInputJoy2Fire:		if(state) bus_->tia_input_value_[1] &= ~0x80; else bus_->tia_input_value_[1] |= 0x80; break;
-
-		default: break;
-	}
-}
-
-void Machine::set_switch_is_enabled(Atari2600Switch input, bool state) {
-	switch(input) {
-		case Atari2600SwitchReset:					bus_->mos6532_.update_port_input(1, 0x01, state);	break;
-		case Atari2600SwitchSelect:					bus_->mos6532_.update_port_input(1, 0x02, state);	break;
-		case Atari2600SwitchColour:					bus_->mos6532_.update_port_input(1, 0x08, state);	break;
-		case Atari2600SwitchLeftPlayerDifficulty:	bus_->mos6532_.update_port_input(1, 0x40, state);	break;
-		case Atari2600SwitchRightPlayerDifficulty:	bus_->mos6532_.update_port_input(1, 0x80, state);	break;
-	}
-}
-
-void Machine::configure_as_target(const StaticAnalyser::Target &target) {
-	const std::vector<uint8_t> &rom = target.cartridges.front()->get_segments().front().data;
-	switch(target.atari.paging_model) {
-		case StaticAnalyser::Atari2600PagingModel::ActivisionStack:	bus_.reset(new CartridgeActivisionStack(rom));	break;
-		case StaticAnalyser::Atari2600PagingModel::CBSRamPlus:		bus_.reset(new CartridgeCBSRAMPlus(rom));		break;
-		case StaticAnalyser::Atari2600PagingModel::CommaVid:		bus_.reset(new CartridgeCommaVid(rom));			break;
-		case StaticAnalyser::Atari2600PagingModel::MegaBoy:			bus_.reset(new CartridgeMegaBoy(rom));			break;
-		case StaticAnalyser::Atari2600PagingModel::MNetwork:		bus_.reset(new CartridgeMNetwork(rom));			break;
-		case StaticAnalyser::Atari2600PagingModel::None:			bus_.reset(new CartridgeUnpaged(rom));			break;
-		case StaticAnalyser::Atari2600PagingModel::ParkerBros:		bus_.reset(new CartridgeParkerBros(rom));		break;
-		case StaticAnalyser::Atari2600PagingModel::Pitfall2:		bus_.reset(new CartridgePitfall2(rom));			break;
-		case StaticAnalyser::Atari2600PagingModel::Tigervision:		bus_.reset(new CartridgeTigervision(rom));		break;
-
-		case StaticAnalyser::Atari2600PagingModel::Atari8k:
-			if(target.atari.uses_superchip) {
-				bus_.reset(new CartridgeAtari8kSuperChip(rom));
-			} else {
-				bus_.reset(new CartridgeAtari8k(rom));
+				// TODO: latching
+				case DigitalInput::Fire:
+					if(is_active)
+						bus_->tia_input_value_[fire_tia_input_] &= ~0x80;
+					else
+						bus_->tia_input_value_[fire_tia_input_] |= 0x80;
+				break;
 			}
-		break;
-		case StaticAnalyser::Atari2600PagingModel::Atari16k:
-			if(target.atari.uses_superchip) {
-				bus_.reset(new CartridgeAtari16kSuperChip(rom));
-			} else {
-				bus_.reset(new CartridgeAtari16k(rom));
-			}
-		break;
-		case StaticAnalyser::Atari2600PagingModel::Atari32k:
-			if(target.atari.uses_superchip) {
-				bus_.reset(new CartridgeAtari32kSuperChip(rom));
-			} else {
-				bus_.reset(new CartridgeAtari32k(rom));
-			}
-		break;
-	}
-}
-
-#pragma mark - CRT delegate
-
-void Machine::crt_did_end_batch_of_frames(Outputs::CRT::CRT *crt, unsigned int number_of_frames, unsigned int number_of_unexpected_vertical_syncs) {
-	const size_t number_of_frame_records = sizeof(frame_records_) / sizeof(frame_records_[0]);
-	frame_records_[frame_record_pointer_ % number_of_frame_records].number_of_frames = number_of_frames;
-	frame_records_[frame_record_pointer_ % number_of_frame_records].number_of_unexpected_vertical_syncs = number_of_unexpected_vertical_syncs;
-	frame_record_pointer_ ++;
-
-	if(frame_record_pointer_ >= 6) {
-		unsigned int total_number_of_frames = 0;
-		unsigned int total_number_of_unexpected_vertical_syncs = 0;
-		for(size_t c = 0; c < number_of_frame_records; c++) {
-			total_number_of_frames += frame_records_[c].number_of_frames;
-			total_number_of_unexpected_vertical_syncs += frame_records_[c].number_of_unexpected_vertical_syncs;
 		}
 
-		if(total_number_of_unexpected_vertical_syncs >= total_number_of_frames >> 1) {
-			for(size_t c = 0; c < number_of_frame_records; c++) {
-				frame_records_[c].number_of_frames = 0;
-				frame_records_[c].number_of_unexpected_vertical_syncs = 0;
-			}
-			is_ntsc_ ^= true;
+	private:
+		Bus *bus_;
+		std::size_t shift_, fire_tia_input_;
+};
 
-			double clock_rate;
-			if(is_ntsc_) {
-				clock_rate = NTSC_clock_rate;
-				bus_->tia_->set_output_mode(TIA::OutputMode::NTSC);
-			} else {
-				clock_rate = PAL_clock_rate;
-				bus_->tia_->set_output_mode(TIA::OutputMode::PAL);
-			}
-
-			bus_->speaker_->set_input_rate((float)(clock_rate / (double)CPUTicksPerAudioTick));
-			bus_->speaker_->set_high_frequency_cut_off((float)(clock_rate / ((double)CPUTicksPerAudioTick * 2.0)));
-			set_clock_rate(clock_rate);
+class ConcreteMachine:
+	public Machine,
+	public Outputs::CRT::Delegate {
+	public:
+		ConcreteMachine() :
+			frame_record_pointer_(0),
+			is_ntsc_(true) {
+			set_clock_rate(NTSC_clock_rate);
 		}
-	}
+
+		~ConcreteMachine() {
+			close_output();
+		}
+
+		void configure_as_target(const StaticAnalyser::Target &target) override {
+			const std::vector<uint8_t> &rom = target.media.cartridges.front()->get_segments().front().data;
+			switch(target.atari.paging_model) {
+				case StaticAnalyser::Atari2600PagingModel::ActivisionStack:	bus_.reset(new Cartridge::Cartridge<Cartridge::ActivisionStack>(rom));	break;
+				case StaticAnalyser::Atari2600PagingModel::CBSRamPlus:		bus_.reset(new Cartridge::Cartridge<Cartridge::CBSRAMPlus>(rom));		break;
+				case StaticAnalyser::Atari2600PagingModel::CommaVid:		bus_.reset(new Cartridge::Cartridge<Cartridge::CommaVid>(rom));			break;
+				case StaticAnalyser::Atari2600PagingModel::MegaBoy:			bus_.reset(new Cartridge::Cartridge<Cartridge::MegaBoy>(rom));			break;
+				case StaticAnalyser::Atari2600PagingModel::MNetwork:		bus_.reset(new Cartridge::Cartridge<Cartridge::MNetwork>(rom));			break;
+				case StaticAnalyser::Atari2600PagingModel::None:			bus_.reset(new Cartridge::Cartridge<Cartridge::Unpaged>(rom));			break;
+				case StaticAnalyser::Atari2600PagingModel::ParkerBros:		bus_.reset(new Cartridge::Cartridge<Cartridge::ParkerBros>(rom));		break;
+				case StaticAnalyser::Atari2600PagingModel::Pitfall2:		bus_.reset(new Cartridge::Cartridge<Cartridge::Pitfall2>(rom));			break;
+				case StaticAnalyser::Atari2600PagingModel::Tigervision:		bus_.reset(new Cartridge::Cartridge<Cartridge::Tigervision>(rom));		break;
+
+				case StaticAnalyser::Atari2600PagingModel::Atari8k:
+					if(target.atari.uses_superchip) {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari8kSuperChip>(rom));
+					} else {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari8k>(rom));
+					}
+				break;
+				case StaticAnalyser::Atari2600PagingModel::Atari16k:
+					if(target.atari.uses_superchip) {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari16kSuperChip>(rom));
+					} else {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari16k>(rom));
+					}
+				break;
+				case StaticAnalyser::Atari2600PagingModel::Atari32k:
+					if(target.atari.uses_superchip) {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari32kSuperChip>(rom));
+					} else {
+						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari32k>(rom));
+					}
+				break;
+			}
+
+			joysticks_.emplace_back(new Joystick(bus_.get(), 0, 0));
+			joysticks_.emplace_back(new Joystick(bus_.get(), 4, 1));
+		}
+
+		bool insert_media(const StaticAnalyser::Media &media) override {
+			return false;
+		}
+
+		std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override {
+			return joysticks_;
+		}
+
+		void set_switch_is_enabled(Atari2600Switch input, bool state) override {
+			switch(input) {
+				case Atari2600SwitchReset:					bus_->mos6532_.update_port_input(1, 0x01, state);	break;
+				case Atari2600SwitchSelect:					bus_->mos6532_.update_port_input(1, 0x02, state);	break;
+				case Atari2600SwitchColour:					bus_->mos6532_.update_port_input(1, 0x08, state);	break;
+				case Atari2600SwitchLeftPlayerDifficulty:	bus_->mos6532_.update_port_input(1, 0x40, state);	break;
+				case Atari2600SwitchRightPlayerDifficulty:	bus_->mos6532_.update_port_input(1, 0x80, state);	break;
+			}
+		}
+
+		void set_reset_switch(bool state) override {
+			bus_->set_reset_line(state);
+		}
+
+		// to satisfy CRTMachine::Machine
+		void setup_output(float aspect_ratio) override {
+			bus_->tia_.reset(new TIA);
+			bus_->speaker_.reset(new Speaker);
+			bus_->speaker_->set_input_rate(static_cast<float>(get_clock_rate() / static_cast<double>(CPUTicksPerAudioTick)));
+			bus_->tia_->get_crt()->set_delegate(this);
+		}
+
+		void close_output() override {
+			bus_.reset();
+		}
+
+		std::shared_ptr<Outputs::CRT::CRT> get_crt() override {
+			return bus_->tia_->get_crt();
+		}
+
+		std::shared_ptr<Outputs::Speaker> get_speaker() override {
+			return bus_->speaker_;
+		}
+
+		void run_for(const Cycles cycles) override {
+			bus_->run_for(cycles);
+		}
+
+		// to satisfy Outputs::CRT::Delegate
+		void crt_did_end_batch_of_frames(Outputs::CRT::CRT *crt, unsigned int number_of_frames, unsigned int number_of_unexpected_vertical_syncs) override {
+			const std::size_t number_of_frame_records = sizeof(frame_records_) / sizeof(frame_records_[0]);
+			frame_records_[frame_record_pointer_ % number_of_frame_records].number_of_frames = number_of_frames;
+			frame_records_[frame_record_pointer_ % number_of_frame_records].number_of_unexpected_vertical_syncs = number_of_unexpected_vertical_syncs;
+			frame_record_pointer_ ++;
+
+			if(frame_record_pointer_ >= 6) {
+				unsigned int total_number_of_frames = 0;
+				unsigned int total_number_of_unexpected_vertical_syncs = 0;
+				for(std::size_t c = 0; c < number_of_frame_records; c++) {
+					total_number_of_frames += frame_records_[c].number_of_frames;
+					total_number_of_unexpected_vertical_syncs += frame_records_[c].number_of_unexpected_vertical_syncs;
+				}
+
+				if(total_number_of_unexpected_vertical_syncs >= total_number_of_frames >> 1) {
+					for(std::size_t c = 0; c < number_of_frame_records; c++) {
+						frame_records_[c].number_of_frames = 0;
+						frame_records_[c].number_of_unexpected_vertical_syncs = 0;
+					}
+					is_ntsc_ ^= true;
+
+					double clock_rate;
+					if(is_ntsc_) {
+						clock_rate = NTSC_clock_rate;
+						bus_->tia_->set_output_mode(TIA::OutputMode::NTSC);
+					} else {
+						clock_rate = PAL_clock_rate;
+						bus_->tia_->set_output_mode(TIA::OutputMode::PAL);
+					}
+
+					bus_->speaker_->set_input_rate(static_cast<float>(clock_rate / static_cast<double>(CPUTicksPerAudioTick)));
+					bus_->speaker_->set_high_frequency_cut_off(static_cast<float>(clock_rate / (static_cast<double>(CPUTicksPerAudioTick) * 2.0)));
+					set_clock_rate(clock_rate);
+				}
+			}
+		}
+
+	private:
+		// the bus
+		std::unique_ptr<Bus> bus_;
+
+		// output frame rate tracker
+		struct FrameRecord {
+			unsigned int number_of_frames;
+			unsigned int number_of_unexpected_vertical_syncs;
+
+			FrameRecord() : number_of_frames(0), number_of_unexpected_vertical_syncs(0) {}
+		} frame_records_[4];
+		unsigned int frame_record_pointer_;
+		bool is_ntsc_;
+		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+};
+
 }
+
+using namespace Atari2600;
+
+Machine *Machine::Atari2600() {
+	return new Atari2600::ConcreteMachine;
+}
+
+Machine::~Machine() {}

Machines/Atari2600/Atari2600.hpp

@@ -9,59 +9,32 @@
 #ifndef Atari2600_cpp
 #define Atari2600_cpp
 
-#include <stdint.h>
-
-#include "../../Processors/6502/6502.hpp"
-#include "../CRTMachine.hpp"
-#include "Bus.hpp"
-#include "PIA.hpp"
-#include "Speaker.hpp"
-#include "TIA.hpp"
-
 #include "../ConfigurationTarget.hpp"
+#include "../CRTMachine.hpp"
+#include "../JoystickMachine.hpp"
+
 #include "Atari2600Inputs.h"
 
 namespace Atari2600 {
 
+/*!
+	Models an Atari 2600.
+*/
 class Machine:
 	public CRTMachine::Machine,
 	public ConfigurationTarget::Machine,
-	public Outputs::CRT::Delegate {
-
+	public JoystickMachine::Machine {
 	public:
-		Machine();
-		~Machine();
+		virtual ~Machine();
 
-		void configure_as_target(const StaticAnalyser::Target &target);
-		void switch_region();
+		/// Creates and returns an Atari 2600 on the heap.
+		static Machine *Atari2600();
 
-		void set_digital_input(Atari2600DigitalInput input, bool state);
-		void set_switch_is_enabled(Atari2600Switch input, bool state);
-		void set_reset_line(bool state) { bus_->set_reset_line(state); }
+		/// Sets the switch @c input to @c state.
+		virtual void set_switch_is_enabled(Atari2600Switch input, bool state) = 0;
 
-		// to satisfy CRTMachine::Machine
-		virtual void setup_output(float aspect_ratio);
-		virtual void close_output();
-		virtual std::shared_ptr<Outputs::CRT::CRT> get_crt() { return bus_->tia_->get_crt(); }
-		virtual std::shared_ptr<Outputs::Speaker> get_speaker() { return bus_->speaker_; }
-		virtual void run_for(const Cycles cycles) { bus_->run_for(cycles); }
-
-		// to satisfy Outputs::CRT::Delegate
-		virtual void crt_did_end_batch_of_frames(Outputs::CRT::CRT *crt, unsigned int number_of_frames, unsigned int number_of_unexpected_vertical_syncs);
-
-	private:
-		// the bus
-		std::unique_ptr<Bus> bus_;
-
-		// output frame rate tracker
-		struct FrameRecord {
-			unsigned int number_of_frames;
-			unsigned int number_of_unexpected_vertical_syncs;
-
-			FrameRecord() : number_of_frames(0), number_of_unexpected_vertical_syncs(0) {}
-		} frame_records_[4];
-		unsigned int frame_record_pointer_;
-		bool is_ntsc_;
+		// Presses or releases the reset button.
+		virtual void set_reset_switch(bool state) = 0;
 };
 
 }

Machines/Atari2600/Cartridges/ActivisionStack.hpp

@@ -6,18 +6,18 @@
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#ifndef Atari2600_CartridgeActivisionStack_hpp
-#define Atari2600_CartridgeActivisionStack_hpp
+#ifndef Atari2600_ActivisionStack_hpp
+#define Atari2600_ActivisionStack_hpp
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeActivisionStack: public Cartridge<CartridgeActivisionStack> {
+class ActivisionStack: public BusExtender {
 	public:
-		CartridgeActivisionStack(const std::vector<uint8_t> &rom) :
-			Cartridge(rom),
-			last_opcode_(0x00) {
-			rom_ptr_ = rom_.data();
-		}
+		ActivisionStack(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size),
+			rom_ptr_(rom_base),
+			last_opcode_(0x00) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			if(!(address & 0x1000)) return;
@@ -27,9 +27,9 @@ class CartridgeActivisionStack: public Cartridge<CartridgeActivisionStack> {
 			// RST or JSR.
 			if(operation == CPU::MOS6502::BusOperation::ReadOpcode && (last_opcode_ == 0x20 || last_opcode_ == 0x60)) {
 				if(address & 0x2000) {
-					rom_ptr_ = rom_.data();
+					rom_ptr_ = rom_base_;
 				} else {
-					rom_ptr_ = rom_.data() + 4096;
+					rom_ptr_ = rom_base_ + 4096;
 				}
 			}
 
@@ -45,6 +45,7 @@ class CartridgeActivisionStack: public Cartridge<CartridgeActivisionStack> {
 		uint8_t last_opcode_;
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeActivisionStack_hpp */

Machines/Atari2600/Cartridges/Atari16k.hpp

@@ -12,19 +12,19 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeAtari16k: public Cartridge<CartridgeAtari16k> {
+class Atari16k: public BusExtender {
 	public:
-		CartridgeAtari16k(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari16k(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size),
+			rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address >= 0x1ff6 && address <= 0x1ff9) rom_ptr_ = rom_.data() + (address - 0x1ff6) * 4096;
+			if(address >= 0x1ff6 && address <= 0x1ff9) rom_ptr_ = rom_base_ + (address - 0x1ff6) * 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -35,18 +35,17 @@ class CartridgeAtari16k: public Cartridge<CartridgeAtari16k> {
 		uint8_t *rom_ptr_;
 };
 
-class CartridgeAtari16kSuperChip: public Cartridge<CartridgeAtari16kSuperChip> {
+class Atari16kSuperChip: public BusExtender {
 	public:
-		CartridgeAtari16kSuperChip(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari16kSuperChip(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size),
+			rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address >= 0x1ff6 && address <= 0x1ff9) rom_ptr_ = rom_.data() + (address - 0x1ff6) * 4096;
+			if(address >= 0x1ff6 && address <= 0x1ff9) rom_ptr_ = rom_base_ + (address - 0x1ff6) * 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -61,6 +60,7 @@ class CartridgeAtari16kSuperChip: public Cartridge<CartridgeAtari16kSuperChip> {
 		uint8_t ram_[128];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeAtari16k_hpp */

Machines/Atari2600/Cartridges/Atari32k.hpp

@@ -12,19 +12,17 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeAtari32k: public Cartridge<CartridgeAtari32k> {
+class Atari32k: public BusExtender {
 	public:
-		CartridgeAtari32k(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari32k(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size), rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address >= 0x1ff4 && address <= 0x1ffb) rom_ptr_ = rom_.data() + (address - 0x1ff4) * 4096;
+			if(address >= 0x1ff4 && address <= 0x1ffb) rom_ptr_ = rom_base_ + (address - 0x1ff4) * 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -35,18 +33,15 @@ class CartridgeAtari32k: public Cartridge<CartridgeAtari32k> {
 		uint8_t *rom_ptr_;
 };
 
-class CartridgeAtari32kSuperChip: public Cartridge<CartridgeAtari32kSuperChip> {
+class Atari32kSuperChip: public BusExtender {
 	public:
-		CartridgeAtari32kSuperChip(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari32kSuperChip(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size), rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address >= 0x1ff4 && address <= 0x1ffb) rom_ptr_ = rom_.data() + (address - 0x1ff4) * 4096;
+			if(address >= 0x1ff4 && address <= 0x1ffb) rom_ptr_ = rom_base_ + (address - 0x1ff4) * 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -61,6 +56,7 @@ class CartridgeAtari32kSuperChip: public Cartridge<CartridgeAtari32kSuperChip> {
 		uint8_t ram_[128];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeAtari32k_hpp */

Machines/Atari2600/Cartridges/Atari8k.hpp

@@ -12,20 +12,18 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeAtari8k: public Cartridge<CartridgeAtari8k> {
+class Atari8k: public BusExtender {
 	public:
-		CartridgeAtari8k(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari8k(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size), rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address == 0x1ff8) rom_ptr_ = rom_.data();
-			else if(address == 0x1ff9) rom_ptr_ = rom_.data() + 4096;
+			if(address == 0x1ff8) rom_ptr_ = rom_base_;
+			else if(address == 0x1ff9) rom_ptr_ = rom_base_ + 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -36,19 +34,16 @@ class CartridgeAtari8k: public Cartridge<CartridgeAtari8k> {
 		uint8_t *rom_ptr_;
 };
 
-class CartridgeAtari8kSuperChip: public Cartridge<CartridgeAtari8kSuperChip> {
+class Atari8kSuperChip: public BusExtender {
 	public:
-		CartridgeAtari8kSuperChip(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		Atari8kSuperChip(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size), rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address == 0x1ff8) rom_ptr_ = rom_.data();
-			if(address == 0x1ff9) rom_ptr_ = rom_.data() + 4096;
+			if(address == 0x1ff8) rom_ptr_ = rom_base_;
+			if(address == 0x1ff9) rom_ptr_ = rom_base_ + 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -63,6 +58,7 @@ class CartridgeAtari8kSuperChip: public Cartridge<CartridgeAtari8kSuperChip> {
 		uint8_t ram_[128];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeAtari8k_hpp */

Machines/Atari2600/Cartridges/CBSRAMPlus.hpp

@@ -12,19 +12,17 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeCBSRAMPlus: public Cartridge<CartridgeCBSRAMPlus> {
+class CBSRAMPlus: public BusExtender {
 	public:
-		CartridgeCBSRAMPlus(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_ = rom_.data();
-		}
+		CBSRAMPlus(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size), rom_ptr_(rom_base) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			address &= 0x1fff;
 			if(!(address & 0x1000)) return;
 
-			if(address >= 0x1ff8 && address <= 0x1ffa) rom_ptr_ = rom_.data() + (address - 0x1ff8) * 4096;
+			if(address >= 0x1ff8 && address <= 0x1ffa) rom_ptr_ = rom_base_ + (address - 0x1ff8) * 4096;
 
 			if(isReadOperation(operation)) {
 				*value = rom_ptr_[address & 4095];
@@ -39,6 +37,7 @@ class CartridgeCBSRAMPlus: public Cartridge<CartridgeCBSRAMPlus> {
 		uint8_t ram_[256];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeCBSRAMPlus_hpp */

Machines/Atari2600/Cartridges/Cartridge.hpp

@@ -13,18 +13,34 @@
 #include "../Bus.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
+
+class BusExtender: public CPU::MOS6502::BusHandler {
+	public:
+		BusExtender(uint8_t *rom_base, std::size_t rom_size) : rom_base_(rom_base), rom_size_(rom_size) {}
+
+		void advance_cycles(int cycles) {}
+
+	protected:
+		uint8_t *rom_base_;
+		std::size_t rom_size_;
+};
 
 template<class T> class Cartridge:
-	public CPU::MOS6502::Processor<Cartridge<T>>,
+	public CPU::MOS6502::BusHandler,
 	public Bus {
 
 	public:
 		Cartridge(const std::vector<uint8_t> &rom) :
-			rom_(rom) {}
+			m6502_(*this),
+			rom_(rom),
+			bus_extender_(rom_.data(), rom.size()) {
+			// The above works because bus_extender_ is declared after rom_ in the instance storage list;
+			// consider doing something less fragile.
+		}
 
-		void run_for(const Cycles cycles) { CPU::MOS6502::Processor<Cartridge<T>>::run_for(cycles); }
-		void set_reset_line(bool state) { CPU::MOS6502::Processor<Cartridge<T>>::set_reset_line(state); }
-		void advance_cycles(int cycles) {}
+		void run_for(const Cycles cycles)	{ m6502_.run_for(cycles);		}
+		void set_reset_line(bool state)		{ m6502_.set_reset_line(state);	}
 
 		// to satisfy CPU::MOS6502::Processor
 		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
@@ -41,11 +57,11 @@ template<class T> class Cartridge:
 			cycles_since_speaker_update_ += Cycles(cycles_run_for);
 			cycles_since_video_update_ += Cycles(cycles_run_for);
 			cycles_since_6532_update_ += Cycles(cycles_run_for / 3);
-			static_cast<T *>(this)->advance_cycles(cycles_run_for / 3);
+			bus_extender_.advance_cycles(cycles_run_for / 3);
 
 			if(operation != CPU::MOS6502::BusOperation::Ready) {
 				// give the cartridge a chance to respond to the bus access
-				static_cast<T *>(this)->perform_bus_operation(operation, address, value);
+				bus_extender_.perform_bus_operation(operation, address, value);
 
 				// check for a RIOT RAM access
 				if((address&0x1280) == 0x80) {
@@ -91,7 +107,7 @@ template<class T> class Cartridge:
 							case 0x00:	update_video(); tia_->set_sync(*value & 0x02);		break;
 							case 0x01:	update_video();	tia_->set_blank(*value & 0x02);		break;
 
-							case 0x02:	CPU::MOS6502::Processor<Cartridge<T>>::set_ready_line(true);								break;
+							case 0x02:	m6502_.set_ready_line(true);						break;
 							case 0x03:	update_video();	tia_->reset_horizontal_counter();	break;
 								// TODO: audio will now be out of synchronisation — fix
 
@@ -156,7 +172,7 @@ template<class T> class Cartridge:
 				}
 			}
 
-			if(!tia_->get_cycles_until_horizontal_blank(cycles_since_video_update_)) CPU::MOS6502::Processor<Cartridge<T>>::set_ready_line(false);
+			if(!tia_->get_cycles_until_horizontal_blank(cycles_since_video_update_)) m6502_.set_ready_line(false);
 
 			return Cycles(cycles_run_for / 3);
 		}
@@ -168,9 +184,14 @@ template<class T> class Cartridge:
 		}
 
 	protected:
+		CPU::MOS6502::Processor<Cartridge<T>, true> m6502_;
 		std::vector<uint8_t> rom_;
+
+	private:
+		T bus_extender_;
 };
 
+}
 }
 
 #endif /* Atari2600_Cartridge_hpp */

Machines/Atari2600/Cartridges/CommaVid.hpp

@@ -9,12 +9,14 @@
 #ifndef Atari2600_CartridgeCommaVid_hpp
 #define Atari2600_CartridgeCommaVid_hpp
 
-namespace Atari2600 {
+#include "Cartridge.hpp"
 
-class CartridgeCommaVid: public Cartridge<CartridgeCommaVid> {
+namespace Atari2600 {
+namespace Cartridge {
+
+class CommaVid: public BusExtender {
 	public:
-		CartridgeCommaVid(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {}
+		CommaVid(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			if(!(address & 0x1000)) return;
@@ -30,13 +32,14 @@ class CartridgeCommaVid: public Cartridge<CartridgeCommaVid> {
 				return;
 			}
 
-			if(isReadOperation(operation)) *value = rom_[address & 2047];
+			if(isReadOperation(operation)) *value = rom_base_[address & 2047];
 		}
 
 	private:
 		uint8_t ram_[1024];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeCommaVid_hpp */

Machines/Atari2600/Cartridges/MNetwork.hpp

@@ -12,12 +12,13 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeMNetwork: public Cartridge<CartridgeMNetwork> {
+class MNetwork: public BusExtender {
 	public:
-		CartridgeMNetwork(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_[0] = rom_.data() + rom_.size() - 4096;
+		MNetwork(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size) {
+			rom_ptr_[0] = rom_base + rom_size_ - 4096;
 			rom_ptr_[1] = rom_ptr_[0] + 2048;
 			high_ram_ptr_ = high_ram_;
 		}
@@ -27,7 +28,7 @@ class CartridgeMNetwork: public Cartridge<CartridgeMNetwork> {
 			if(!(address & 0x1000)) return;
 
 			if(address >= 0x1fe0 && address <= 0x1fe6) {
-				rom_ptr_[0] = rom_.data() + (address - 0x1fe0) * 2048;
+				rom_ptr_[0] = rom_base_ + (address - 0x1fe0) * 2048;
 			} else if(address == 0x1fe7) {
 				rom_ptr_[0] = nullptr;
 			} else if(address >= 0x1ff8 && address <= 0x1ffb) {
@@ -54,7 +55,6 @@ class CartridgeMNetwork: public Cartridge<CartridgeMNetwork> {
 					}
 				}
 			}
-
 		}
 
 	private:
@@ -63,6 +63,7 @@ class CartridgeMNetwork: public Cartridge<CartridgeMNetwork> {
 		uint8_t low_ram_[1024], high_ram_[1024];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeMNetwork_hpp */

Machines/Atari2600/Cartridges/MegaBoy.hpp

@@ -12,13 +12,14 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeMegaBoy: public Cartridge<CartridgeMegaBoy> {
+class MegaBoy: public BusExtender {
 	public:
-		CartridgeMegaBoy(const std::vector<uint8_t> &rom) :
-			Cartridge(rom),
+		MegaBoy(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size),
+			rom_ptr_(rom_base),
 			current_page_(0) {
-			rom_ptr_ = rom_.data();
 		}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
@@ -27,7 +28,7 @@ class CartridgeMegaBoy: public Cartridge<CartridgeMegaBoy> {
 
 			if(address == 0x1ff0) {
 				current_page_ = (current_page_ + 1) & 15;
-				rom_ptr_ = rom_.data() + current_page_ * 4096;
+				rom_ptr_ = rom_base_ + current_page_ * 4096;
 			}
 
 			if(isReadOperation(operation)) {
@@ -40,6 +41,7 @@ class CartridgeMegaBoy: public Cartridge<CartridgeMegaBoy> {
 		uint8_t current_page_;
 };
 
+}
 }
 
 #endif /* CartridgeMegaBoy_h */

Machines/Atari2600/Cartridges/ParkerBros.hpp

@@ -12,12 +12,13 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeParkerBros: public Cartridge<CartridgeParkerBros> {
+class ParkerBros: public BusExtender {
 	public:
-		CartridgeParkerBros(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_[0] = rom_.data() + 4096;
+		ParkerBros(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size) {
+			rom_ptr_[0] = rom_base + 4096;
 			rom_ptr_[1] = rom_ptr_[0] + 1024;
 			rom_ptr_[2] = rom_ptr_[1] + 1024;
 			rom_ptr_[3] = rom_ptr_[2] + 1024;
@@ -29,7 +30,7 @@ class CartridgeParkerBros: public Cartridge<CartridgeParkerBros> {
 
 			if(address >= 0x1fe0 && address < 0x1ff8) {
 				int slot = (address >> 3)&3;
-				rom_ptr_[slot] = rom_.data() + ((address & 7) * 1024);
+				rom_ptr_[slot] = rom_base_ + ((address & 7) * 1024);
 			}
 
 			if(isReadOperation(operation)) {
@@ -41,6 +42,7 @@ class CartridgeParkerBros: public Cartridge<CartridgeParkerBros> {
 		uint8_t *rom_ptr_[4];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeParkerBros_hpp */

Machines/Atari2600/Cartridges/Pitfall2.hpp

@@ -10,17 +10,13 @@
 #define Atari2600_CartridgePitfall2_hpp
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgePitfall2: public Cartridge<CartridgePitfall2> {
+class Pitfall2: public BusExtender {
 	public:
-		CartridgePitfall2(const std::vector<uint8_t> &rom) :
-			Cartridge(rom),
-			random_number_generator_(0),
-			featcher_address_{0, 0, 0, 0, 0, 0, 0, 0},
-			mask_{0, 0, 0, 0, 0, 0, 0, 0},
-			cycles_since_audio_update_(0) {
-			rom_ptr_ = rom_.data();
-		}
+		Pitfall2(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size),
+			rom_ptr_(rom_base) {}
 
 		void advance_cycles(int cycles) {
 			cycles_since_audio_update_ += cycles;
@@ -32,14 +28,14 @@ class CartridgePitfall2: public Cartridge<CartridgePitfall2> {
 
 			switch(address) {
 
-#pragma mark - Reads
+// MARK: - Reads
 
 				// The random number generator
 				case 0x1000: case 0x1001: case 0x1002: case 0x1003: case 0x1004:
 					if(isReadOperation(operation)) {
 						*value = random_number_generator_;
 					}
-					random_number_generator_ = (uint8_t)(
+					random_number_generator_ = static_cast<uint8_t>(
 						(random_number_generator_ << 1) |
 						(~(	(random_number_generator_ >> 7) ^
 							(random_number_generator_ >> 5) ^
@@ -53,14 +49,14 @@ class CartridgePitfall2: public Cartridge<CartridgePitfall2> {
 				break;
 
 				case 0x1008: case 0x1009: case 0x100a: case 0x100b: case 0x100c: case 0x100d: case 0x100e: case 0x100f:
-					*value = rom_[8192 + address_for_counter(address & 7)];
+					*value = rom_base_[8192 + address_for_counter(address & 7)];
 				break;
 
 				case 0x1010: case 0x1011: case 0x1012: case 0x1013: case 0x1014: case 0x1015: case 0x1016: case 0x1017:
-					*value = rom_[8192 + address_for_counter(address & 7)] & mask_[address & 7];
+					*value = rom_base_[8192 + address_for_counter(address & 7)] & mask_[address & 7];
 				break;
 
-#pragma mark - Writes
+// MARK: - Writes
 
 				case 0x1040: case 0x1041: case 0x1042: case 0x1043: case 0x1044: case 0x1045: case 0x1046: case 0x1047:
 					top_[address & 7] = *value;
@@ -73,18 +69,18 @@ class CartridgePitfall2: public Cartridge<CartridgePitfall2> {
 					mask_[address & 7] = 0x00;
 				break;
 				case 0x1058: case 0x1059: case 0x105a: case 0x105b: case 0x105c: case 0x105d: case 0x105e: case 0x105f:
-					featcher_address_[address & 7] = (featcher_address_[address & 7] & 0x00ff) | (uint16_t)(*value << 8);
+					featcher_address_[address & 7] = (featcher_address_[address & 7] & 0x00ff) | static_cast<uint16_t>(*value << 8);
 				break;
 				case 0x1070: case 0x1071: case 0x1072: case 0x1073: case 0x1074: case 0x1075: case 0x1076: case 0x1077:
 					random_number_generator_ = 0;
 				break;
 
-#pragma mark - Paging
+// MARK: - Paging
 
-				case 0x1ff8: rom_ptr_ = rom_.data();		break;
-				case 0x1ff9: rom_ptr_ = rom_.data() + 4096;	break;
+				case 0x1ff8: rom_ptr_ = rom_base_;			break;
+				case 0x1ff9: rom_ptr_ = rom_base_ + 4096;	break;
 
-#pragma mark - Business as usual
+// MARK: - Business as usual
 
 				default:
 					if(isReadOperation(operation)) {
@@ -119,15 +115,16 @@ class CartridgePitfall2: public Cartridge<CartridgePitfall2> {
 			return level_table[table_position];
 		}
 
-		uint16_t featcher_address_[8];
-		uint8_t top_[8], bottom_[8], mask_[8];
+		uint16_t featcher_address_[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+		uint8_t top_[8], bottom_[8], mask_[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 		uint8_t music_mode_[3];
-		uint8_t random_number_generator_;
+		uint8_t random_number_generator_ = 0;
 		uint8_t *rom_ptr_;
 		uint8_t audio_channel_[3];
-		Cycles cycles_since_audio_update_;
+		Cycles cycles_since_audio_update_ = 0;
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgePitfall2_hpp */

Machines/Atari2600/Cartridges/Tigervision.hpp

@@ -12,19 +12,20 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeTigervision: public Cartridge<CartridgeTigervision> {
+class Tigervision: public BusExtender {
 	public:
-		CartridgeTigervision(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {
-			rom_ptr_[0] = rom_.data() + rom_.size() - 4096;
+		Tigervision(uint8_t *rom_base, std::size_t rom_size) :
+			BusExtender(rom_base, rom_size) {
+			rom_ptr_[0] = rom_base + rom_size - 4096;
 			rom_ptr_[1] = rom_ptr_[0] + 2048;
 		}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			if((address&0x1fff) == 0x3f) {
-				int offset = ((*value) * 2048) & (rom_.size() - 1);
-				rom_ptr_[0] = rom_.data() + offset;
+				int offset = ((*value) * 2048) & (rom_size_ - 1);
+				rom_ptr_[0] = rom_base_ + offset;
 				return;
 			} else if((address&0x1000) && isReadOperation(operation)) {
 				*value = rom_ptr_[(address >> 11)&1][address & 2047];
@@ -35,6 +36,7 @@ class CartridgeTigervision: public Cartridge<CartridgeTigervision> {
 		uint8_t *rom_ptr_[2];
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeTigervision_hpp */

Machines/Atari2600/Cartridges/Unpaged.hpp

@@ -12,19 +12,20 @@
 #include "Cartridge.hpp"
 
 namespace Atari2600 {
+namespace Cartridge {
 
-class CartridgeUnpaged: public Cartridge<CartridgeUnpaged> {
+class Unpaged: public BusExtender {
 	public:
-		CartridgeUnpaged(const std::vector<uint8_t> &rom) :
-			Cartridge(rom) {}
+		Unpaged(uint8_t *rom_base, std::size_t rom_size) : BusExtender(rom_base, rom_size) {}
 
 		void perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 			if(isReadOperation(operation) && (address & 0x1000)) {
-				*value = rom_[address & (rom_.size() - 1)];
+				*value = rom_base_[address & (rom_size_ - 1)];
 			}
 		}
 };
 
+}
 }
 
 #endif /* Atari2600_CartridgeUnpaged_hpp */

Machines/Atari2600/PIA.hpp

@@ -9,6 +9,8 @@
 #ifndef Atari2600_PIA_h
 #define Atari2600_PIA_h
 
+#include <cstdint>
+
 #include "../../Components/6532/6532.hpp"
 
 namespace Atari2600 {

Machines/Atari2600/TIA.cpp

@@ -20,36 +20,27 @@ namespace {
 	uint8_t reverse_table[256];
 }
 
-TIA::TIA(bool create_crt) :
-	horizontal_counter_(0),
-	pixels_start_location_(0),
-	output_mode_(0),
-	pixel_target_(nullptr),
-	background_{0, 0},
-	background_half_mask_(0),
-	horizontal_blank_extend_(false),
-	collision_flags_(0)
-{
+TIA::TIA(bool create_crt) {
 	if(create_crt) {
 		crt_.reset(new Outputs::CRT::CRT(cycles_per_line * 2 - 1, 1, Outputs::CRT::DisplayType::NTSC60, 1));
-		crt_->set_output_device(Outputs::CRT::Television);
+		crt_->set_output_device(Outputs::CRT::OutputDevice::Television);
 		set_output_mode(OutputMode::NTSC);
 	}
 
 	for(int c = 0; c < 256; c++) {
-		reverse_table[c] = (uint8_t)(
+		reverse_table[c] = static_cast<uint8_t>(
 			((c & 0x01) << 7) | ((c & 0x02) << 5) | ((c & 0x04) << 3) | ((c & 0x08) << 1) |
 			((c & 0x10) >> 1) | ((c & 0x20) >> 3) | ((c & 0x40) >> 5) | ((c & 0x80) >> 7)
 		);
 	}
 
 	for(int c = 0; c < 64; c++) {
-		bool has_playfield = c & (int)(CollisionType::Playfield);
-		bool has_ball = c & (int)(CollisionType::Ball);
-		bool has_player0 = c & (int)(CollisionType::Player0);
-		bool has_player1 = c & (int)(CollisionType::Player1);
-		bool has_missile0 = c & (int)(CollisionType::Missile0);
-		bool has_missile1 = c & (int)(CollisionType::Missile1);
+		bool has_playfield = c & static_cast<int>(CollisionType::Playfield);
+		bool has_ball = c & static_cast<int>(CollisionType::Ball);
+		bool has_player0 = c & static_cast<int>(CollisionType::Player0);
+		bool has_player1 = c & static_cast<int>(CollisionType::Player1);
+		bool has_missile0 = c & static_cast<int>(CollisionType::Missile0);
+		bool has_missile1 = c & static_cast<int>(CollisionType::Missile1);
 
 		uint8_t collision_registers[8];
 		collision_registers[0] = ((has_missile0 && has_player1) ? 0x80 : 0x00)		|	((has_missile0 && has_player0) ? 0x40 : 0x00);
@@ -71,51 +62,51 @@ TIA::TIA(bool create_crt) :
 			(collision_registers[7] << 8);
 
 		// all priority modes show the background if nothing else is present
-		colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] =
-		colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] =
-		colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] =
-		colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::Background;
+		colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::Standard)][c] =
+		colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][c] =
+		colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][c] =
+		colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::OnTop)][c] = static_cast<uint8_t>(ColourIndex::Background);
 
 		// test 1 for standard priority: if there is a playfield or ball pixel, plot that colour
 		if(has_playfield || has_ball) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] = (uint8_t)ColourIndex::PlayfieldBall;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::Standard)][c] = static_cast<uint8_t>(ColourIndex::PlayfieldBall);
 		}
 
 		// test 1 for score mode: if there is a ball pixel, plot that colour
 		if(has_ball) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = (uint8_t)ColourIndex::PlayfieldBall;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][c] = static_cast<uint8_t>(ColourIndex::PlayfieldBall);
 		}
 
 		// test 1 for on-top mode, test 2 for everbody else: if there is a player 1 or missile 1 pixel, plot that colour
 		if(has_player1 || has_missile1) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::PlayerMissile1;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::Standard)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::OnTop)][c] = static_cast<uint8_t>(ColourIndex::PlayerMissile1);
 		}
 
 		// in the right-hand side of score mode, the playfield has the same priority as player 1
 		if(has_playfield) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] = (uint8_t)ColourIndex::PlayerMissile1;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][c] = static_cast<uint8_t>(ColourIndex::PlayerMissile1);
 		}
 
 		// next test for everybody: if there is a player 0 or missile 0 pixel, plot that colour instead
 		if(has_player0 || has_missile0) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::Standard][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][c] =
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::PlayerMissile0;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::Standard)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][c] =
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::OnTop)][c] = static_cast<uint8_t>(ColourIndex::PlayerMissile0);
 		}
 
 		// if this is the left-hand side of score mode, the playfield has the same priority as player 0
 		if(has_playfield) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][c] = (uint8_t)ColourIndex::PlayerMissile0;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][c] = static_cast<uint8_t>(ColourIndex::PlayerMissile0);
 		}
 
 		// a final test for 'on top' priority mode: if the playfield or ball are visible, prefer that colour to all others
 		if(has_playfield || has_ball) {
-			colour_mask_by_mode_collision_flags_[(int)ColourMode::OnTop][c] = (uint8_t)ColourIndex::PlayfieldBall;
+			colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::OnTop)][c] = static_cast<uint8_t>(ColourIndex::PlayfieldBall);
 		}
 	}
 }
@@ -162,7 +153,7 @@ void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) {
 	// cycles_per_line * 2 cycles of information from one sync edge to the next
 	crt_->set_new_display_type(cycles_per_line * 2 - 1, display_type);
 
-/*	speaker_->set_input_rate((float)(get_clock_rate() / 38.0));*/
+/*	speaker_->set_input_rate(static_cast<float>(get_clock_rate() / 38.0));*/
 }
 
 void TIA::run_for(const Cycles cycles) {
@@ -203,23 +194,23 @@ int TIA::get_cycles_until_horizontal_blank(const Cycles from_offset) {
 }
 
 void TIA::set_background_colour(uint8_t colour) {
-	colour_palette_[(int)ColourIndex::Background] = colour;
+	colour_palette_[static_cast<int>(ColourIndex::Background)] = colour;
 }
 
 void TIA::set_playfield(uint16_t offset, uint8_t value) {
 	assert(offset >= 0 && offset < 3);
 	switch(offset) {
 		case 0:
-			background_[1] = (background_[1] & 0x0ffff) | ((uint32_t)reverse_table[value & 0xf0] << 16);
-			background_[0] = (background_[0] & 0xffff0) | (uint32_t)(value >> 4);
+			background_[1] = (background_[1] & 0x0ffff) | (static_cast<uint32_t>(reverse_table[value & 0xf0]) << 16);
+			background_[0] = (background_[0] & 0xffff0) | static_cast<uint32_t>(value >> 4);
 		break;
 		case 1:
-			background_[1] = (background_[1] & 0xf00ff) | ((uint32_t)value << 8);
-			background_[0] = (background_[0] & 0xff00f) | ((uint32_t)reverse_table[value] << 4);
+			background_[1] = (background_[1] & 0xf00ff) | (static_cast<uint32_t>(value) << 8);
+			background_[0] = (background_[0] & 0xff00f) | (static_cast<uint32_t>(reverse_table[value]) << 4);
 		break;
 		case 2:
 			background_[1] = (background_[1] & 0xfff00) | reverse_table[value];
-			background_[0] = (background_[0] & 0x00fff) | ((uint32_t)value << 12);
+			background_[0] = (background_[0] & 0x00fff) | (static_cast<uint32_t>(value) << 12);
 		break;
 	}
 }
@@ -243,7 +234,7 @@ void TIA::set_playfield_control_and_ball_size(uint8_t value) {
 }
 
 void TIA::set_playfield_ball_colour(uint8_t colour) {
-	colour_palette_[(int)ColourIndex::PlayfieldBall] = colour;
+	colour_palette_[static_cast<int>(ColourIndex::PlayfieldBall)] = colour;
 }
 
 void TIA::set_player_number_and_size(int player, uint8_t value) {
@@ -305,7 +296,7 @@ void TIA::set_player_motion(int player, uint8_t motion) {
 
 void TIA::set_player_missile_colour(int player, uint8_t colour) {
 	assert(player >= 0 && player < 2);
-	colour_palette_[(int)ColourIndex::PlayerMissile0 + player] = colour;
+	colour_palette_[static_cast<int>(ColourIndex::PlayerMissile0) + player] = colour;
 }
 
 void TIA::set_missile_enable(int missile, bool enabled) {
@@ -360,7 +351,7 @@ void TIA::clear_motion() {
 }
 
 uint8_t TIA::get_collision_flags(int offset) {
-	return (uint8_t)((collision_flags_ >> (offset << 1)) << 6) & 0xc0;
+	return static_cast<uint8_t>((collision_flags_ >> (offset << 1)) << 6) & 0xc0;
 }
 
 void TIA::clear_collision_flags() {
@@ -401,22 +392,22 @@ void TIA::output_for_cycles(int number_of_cycles) {
 	int latent_start = output_cursor + 4;
 	int latent_end = horizontal_counter_ + 4;
 	draw_playfield(latent_start, latent_end);
-	draw_object<Player>(player_[0], (uint8_t)CollisionType::Player0, output_cursor, horizontal_counter_);
-	draw_object<Player>(player_[1], (uint8_t)CollisionType::Player1, output_cursor, horizontal_counter_);
-	draw_missile(missile_[0], player_[0], (uint8_t)CollisionType::Missile0, output_cursor, horizontal_counter_);
-	draw_missile(missile_[1], player_[1], (uint8_t)CollisionType::Missile1, output_cursor, horizontal_counter_);
-	draw_object<Ball>(ball_, (uint8_t)CollisionType::Ball, output_cursor, horizontal_counter_);
+	draw_object<Player>(player_[0], static_cast<uint8_t>(CollisionType::Player0), output_cursor, horizontal_counter_);
+	draw_object<Player>(player_[1], static_cast<uint8_t>(CollisionType::Player1), output_cursor, horizontal_counter_);
+	draw_missile(missile_[0], player_[0], static_cast<uint8_t>(CollisionType::Missile0), output_cursor, horizontal_counter_);
+	draw_missile(missile_[1], player_[1], static_cast<uint8_t>(CollisionType::Missile1), output_cursor, horizontal_counter_);
+	draw_object<Ball>(ball_, static_cast<uint8_t>(CollisionType::Ball), output_cursor, horizontal_counter_);
 
 	// convert to television signals
 
 #define Period(function, target)	\
 	if(output_cursor < target) { \
 		if(horizontal_counter_ <= target) { \
-			if(crt_) crt_->function((unsigned int)((horizontal_counter_ - output_cursor) * 2)); \
+			if(crt_) crt_->function(static_cast<unsigned int>((horizontal_counter_ - output_cursor) * 2)); \
 			horizontal_counter_ %= cycles_per_line; \
 			return; \
 		} else { \
-			if(crt_) crt_->function((unsigned int)((target - output_cursor) * 2)); \
+			if(crt_) crt_->function(static_cast<unsigned int>((target - output_cursor) * 2)); \
 			output_cursor = target; \
 		} \
 	}
@@ -442,12 +433,12 @@ void TIA::output_for_cycles(int number_of_cycles) {
 	if(output_mode_ & blank_flag) {
 		if(pixel_target_) {
 			output_pixels(pixels_start_location_, output_cursor);
-			if(crt_) crt_->output_data((unsigned int)(output_cursor - pixels_start_location_) * 2, 2);
+			if(crt_) crt_->output_data(static_cast<unsigned int>(output_cursor - pixels_start_location_) * 2, 2);
 			pixel_target_ = nullptr;
 			pixels_start_location_ = 0;
 		}
 		int duration = std::min(228, horizontal_counter_) - output_cursor;
-		if(crt_) crt_->output_blank((unsigned int)(duration * 2));
+		if(crt_) crt_->output_blank(static_cast<unsigned int>(duration * 2));
 	} else {
 		if(!pixels_start_location_ && crt_) {
 			pixels_start_location_ = output_cursor;
@@ -464,7 +455,7 @@ void TIA::output_for_cycles(int number_of_cycles) {
 		}
 
 		if(horizontal_counter_ == cycles_per_line && crt_) {
-			crt_->output_data((unsigned int)(output_cursor - pixels_start_location_) * 2, 2);
+			crt_->output_data(static_cast<unsigned int>(output_cursor - pixels_start_location_) * 2, 2);
 			pixel_target_ = nullptr;
 			pixels_start_location_ = 0;
 		}
@@ -490,18 +481,18 @@ void TIA::output_pixels(int start, int end) {
 	if(playfield_priority_ == PlayfieldPriority::Score) {
 		while(start < end && start < first_pixel_cycle + 80) {
 			uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle];
-			pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreLeft][buffer_value]];
+			pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreLeft)][buffer_value]];
 			start++;
 			target_position++;
 		}
 		while(start < end) {
 			uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle];
-			pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[(int)ColourMode::ScoreRight][buffer_value]];
+			pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[static_cast<int>(ColourMode::ScoreRight)][buffer_value]];
 			start++;
 			target_position++;
 		}
 	} else {
-		int table_index = (int)((playfield_priority_ == PlayfieldPriority::Standard) ? ColourMode::Standard : ColourMode::OnTop);
+		int table_index = static_cast<int>((playfield_priority_ == PlayfieldPriority::Standard) ? ColourMode::Standard : ColourMode::OnTop);
 		while(start < end) {
 			uint8_t buffer_value = collision_buffer_[start - first_pixel_cycle];
 			pixel_target_[target_position] = colour_palette_[colour_mask_by_mode_collision_flags_[table_index][buffer_value]];
@@ -538,7 +529,7 @@ void TIA::output_line() {
 	}
 }
 
-#pragma mark - Playfield output
+// MARK: - Playfield output
 
 void TIA::draw_playfield(int start, int end) {
 	// don't do anything if this window ends too early
@@ -553,12 +544,12 @@ void TIA::draw_playfield(int start, int end) {
 	while(aligned_position < end) {
 		int offset = (aligned_position - first_pixel_cycle) >> 2;
 		uint32_t value = ((background_[(offset/20)&background_half_mask_] >> (offset%20))&1) * 0x01010101;
-		*(uint32_t *)&collision_buffer_[aligned_position - first_pixel_cycle] |= value;
+		*reinterpret_cast<uint32_t *>(&collision_buffer_[aligned_position - first_pixel_cycle]) |= value;
 		aligned_position += 4;
 	}
 }
 
-#pragma mark - Motion
+// MARK: - Motion
 
 template<class T> void TIA::perform_motion_step(T &object) {
 	if((object.motion_step ^ (object.motion ^ 8)) == 0xf) {
@@ -666,7 +657,7 @@ template<class T> void TIA::draw_object_visible(T &object, const uint8_t collisi
 	}
 }
 
-#pragma mark - Missile drawing
+// MARK: - Missile drawing
 
 void TIA::draw_missile(Missile &missile, Player &player, const uint8_t collision_identity, int start, int end) {
 	if(!missile.locked_to_player || player.latched_pixel4_time < 0) {

Machines/Atari2600/TIA.hpp

@@ -81,10 +81,10 @@ class TIA {
 		std::function<void(uint8_t *output_buffer)> line_end_function_;
 
 		// the master counter; counts from 0 to 228 with all visible pixels being in the final 160
-		int horizontal_counter_;
+		int horizontal_counter_ = 0;
 
 		// contains flags to indicate whether sync or blank are currently active
-		int output_mode_;
+		int output_mode_ = 0;
 
 		// keeps track of the target pixel buffer for this line and when it was acquired, and a corresponding collision buffer
 		alignas(alignof(uint32_t)) uint8_t collision_buffer_[160];
@@ -97,7 +97,7 @@ class TIA {
 			Missile1	= (1 << 5)
 		};
 
-		int collision_flags_;
+		int collision_flags_ = 0;
 		int collision_flags_by_buffer_vaules_[64];
 
 		// colour mapping tables
@@ -118,59 +118,45 @@ class TIA {
 		uint8_t colour_palette_[4];
 
 		// playfield state
-		int background_half_mask_;
+		int background_half_mask_ = 0;
 		enum class PlayfieldPriority {
 			Standard,
 			Score,
 			OnTop
 		} playfield_priority_;
-		uint32_t background_[2];	// contains two 20-bit bitfields representing the background state;
-									// at index 0 is the left-hand side of the playfield with bit 0 being
-									// the first bit to display, bit 1 the second, etc. Index 1 contains
-									// a mirror image of index 0. If the playfield is being displayed in
-									// mirroring mode, background_[0] will be output on the left and
-									// background_[1] on the right; otherwise background_[0] will be
-									// output twice.
+		uint32_t background_[2] = {0, 0};
+				// contains two 20-bit bitfields representing the background state;
+				// at index 0 is the left-hand side of the playfield with bit 0 being
+				// the first bit to display, bit 1 the second, etc. Index 1 contains
+				// a mirror image of index 0. If the playfield is being displayed in
+				// mirroring mode, background_[0] will be output on the left and
+				// background_[1] on the right; otherwise background_[0] will be
+				// output twice.
 
 		// objects
 		template<class T> struct Object {
 			// the two programmer-set values
-			int position;
-			int motion;
+			int position = 0;
+			int motion = 0;
 
 			// motion_step_ is the current motion counter value; motion_time_ is the next time it will fire
-			int motion_step;
-			int motion_time;
+			int motion_step = 0;
+			int motion_time = 0;
 
 			// indicates whether this object is currently undergoing motion
-			bool is_moving;
-
-			Object() : position(0), motion(0), motion_step(0), motion_time(0), is_moving(false) {};
+			bool is_moving = false;
 		};
 
 		// player state
 		struct Player: public Object<Player> {
-			Player() :
-				adder(4),
-				copy_flags(0),
-				graphic{0, 0},
-				reverse_mask(false),
-				graphic_index(0),
-				pixel_position(32),
-				pixel_counter(0),
-				latched_pixel4_time(-1),
-				copy_index_(0),
-				queue_read_pointer_(0),
-				queue_write_pointer_(0) {}
+			int adder = 4;
+			int copy_flags = 0;				// a bit field, corresponding to the first few values of NUSIZ
+			uint8_t graphic[2] = {0, 0};	// the player graphic; 1 = new, 0 = current
+			int reverse_mask = false;		// 7 for a reflected player, 0 for normal
+			int graphic_index = 0;
 
-			int adder;
-			int copy_flags;		// a bit field, corresponding to the first few values of NUSIZ
-			uint8_t graphic[2];	// the player graphic; 1 = new, 0 = current
-			int reverse_mask;	// 7 for a reflected player, 0 for normal
-			int graphic_index;
-
-			int pixel_position, pixel_counter;
-			int latched_pixel4_time;
+			int pixel_position = 32, pixel_counter = 0;
+			int latched_pixel4_time = -1;
 			const bool enqueues = true;
 
 			inline void skip_pixels(const int count, int from_horizontal_counter) {
@@ -219,15 +205,14 @@ class TIA {
 			}
 
 			private:
-				int copy_index_;
+				int copy_index_ = 0;
 				struct QueuedPixels {
-					int start, end;
-					int pixel_position;
-					int adder;
-					int reverse_mask;
-					QueuedPixels() : start(0), end(0), pixel_position(0), adder(0), reverse_mask(false) {}
+					int start = 0, end = 0;
+					int pixel_position = 0;
+					int adder = 0;
+					int reverse_mask = false;
 				} queue_[4];
-				int queue_read_pointer_, queue_write_pointer_;
+				int queue_read_pointer_ = 0, queue_write_pointer_ = 0;
 
 				inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int output_pixel_position, int output_adder, int output_reverse_mask) {
 					if(output_pixel_position == 32 || !graphic[graphic_index]) return;
@@ -244,8 +229,8 @@ class TIA {
 
 		// common actor for things that appear as a horizontal run of pixels
 		struct HorizontalRun: public Object<HorizontalRun> {
-			int pixel_position;
-			int size;
+			int pixel_position = 0;
+			int size = 1;
 			const bool enqueues = false;
 
 			inline void skip_pixels(const int count, int from_horizontal_counter) {
@@ -268,16 +253,13 @@ class TIA {
 
 			void dequeue_pixels(uint8_t *const target, const uint8_t collision_identity, const int time_now) {}
 			void enqueue_pixels(const int start, const int end, int from_horizontal_counter) {}
-
-			HorizontalRun() : pixel_position(0), size(1) {}
 		};
 
-
 		// missile state
 		struct Missile: public HorizontalRun {
-			bool enabled;
-			bool locked_to_player;
-			int copy_flags;
+			bool enabled = false;
+			bool locked_to_player = false;
+			int copy_flags = 0;
 
 			inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) {
 				if(!pixel_position) return;
@@ -287,14 +269,12 @@ class TIA {
 					skip_pixels(count, from_horizontal_counter);
 				}
 			}
-
-			Missile() : enabled(false), copy_flags(0) {}
 		} missile_[2];
 
 		// ball state
 		struct Ball: public HorizontalRun {
-			bool enabled[2];
-			int enabled_index;
+			bool enabled[2] = {false, false};
+			int enabled_index = 0;
 			const int copy_flags = 0;
 
 			inline void output_pixels(uint8_t *const target, const int count, const uint8_t collision_identity, int from_horizontal_counter) {
@@ -305,12 +285,10 @@ class TIA {
 					skip_pixels(count, from_horizontal_counter);
 				}
 			}
-
-			Ball() : enabled{false, false}, enabled_index(0) {}
 		} ball_;
 
 		// motion
-		bool horizontal_blank_extend_;
+		bool horizontal_blank_extend_ = false;
 		template<class T> void perform_border_motion(T &object, int start, int end);
 		template<class T> void perform_motion_step(T &object);
 
@@ -323,8 +301,8 @@ class TIA {
 		inline void output_for_cycles(int number_of_cycles);
 		inline void output_line();
 
-		int pixels_start_location_;
-		uint8_t *pixel_target_;
+		int pixels_start_location_ = 0;
+		uint8_t *pixel_target_ = nullptr;
 		inline void output_pixels(int start, int end);
 };
 

Machines/CRTMachine.hpp

@@ -12,6 +12,7 @@
 #include "../Outputs/CRT/CRT.hpp"
 #include "../Outputs/Speaker.hpp"
 #include "../ClockReceiver/ClockReceiver.hpp"
+#include "ROMMachine.hpp"
 
 namespace CRTMachine {
 
@@ -20,10 +21,8 @@ namespace CRTMachine {
 	that optionally provide a speaker, and that nominate a clock rate and can announce to a delegate
 	should that clock rate change.
 */
-class Machine {
+class Machine: public ROMMachine::Machine {
 	public:
-		Machine() : clock_is_unlimited_(false), delegate_(nullptr) {}
-
 		/*!
 			Causes the machine to set up its CRT and, if it has one, speaker. The caller guarantees
 			that an OpenGL context is bound.
@@ -74,9 +73,9 @@ class Machine {
 		}
 
 	private:
-		Delegate *delegate_;
-		double clock_rate_;
-		bool clock_is_unlimited_;
+		Delegate *delegate_ = nullptr;
+		double clock_rate_ = 1.0;
+		bool clock_is_unlimited_ = false;
 };
 
 }

Machines/Commodore/1540/C1540.hpp

@@ -9,159 +9,43 @@
 #ifndef Commodore1540_hpp
 #define Commodore1540_hpp
 
-#include "../../../Processors/6502/6502.hpp"
-#include "../../../Components/6522/6522.hpp"
-
 #include "../SerialBus.hpp"
-
+#include "../../ROMMachine.hpp"
 #include "../../../Storage/Disk/Disk.hpp"
-#include "../../../Storage/Disk/DiskController.hpp"
+#include "Implementation/C1540Base.hpp"
 
 namespace Commodore {
 namespace C1540 {
 
-/*!
-	An implementation of the serial-port VIA in a Commodore 1540 — the VIA that facilitates all
-	IEC bus communications.
-
-	It is wired up such that Port B contains:
-		Bit 0:		data input; 1 if the line is low, 0 if it is high;
-		Bit 1:		data output; 1 if the line should be low, 0 if it should be high;
-		Bit 2:		clock input; 1 if the line is low, 0 if it is high;
-		Bit 3:		clock output; 1 if the line is low, 0 if it is high;
-		Bit 4:		attention acknowledge output; exclusive ORd with the attention input and ORd onto the data output;
-		Bits 5/6:	device select input; the 1540 will act as device 8 + [value of bits]
-		Bit 7:		attention input; 1 if the line is low, 0 if it is high
-
-	The attention input is also connected to CA1, similarly inverted — the CA1 wire will be high when the bus is low and vice versa.
-*/
-class SerialPortVIA: public MOS::MOS6522<SerialPortVIA>, public MOS::MOS6522IRQDelegate {
-	public:
-		using MOS6522IRQDelegate::set_interrupt_status;
-
-		SerialPortVIA();
-
-		uint8_t get_port_input(Port);
-
-		void set_port_output(Port, uint8_t value, uint8_t mask);
-		void set_serial_line_state(::Commodore::Serial::Line, bool);
-
-		void set_serial_port(const std::shared_ptr<::Commodore::Serial::Port> &);
-
-	private:
-		uint8_t port_b_;
-		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
-		bool attention_acknowledge_level_, attention_level_input_, data_level_output_;
-
-		void update_data_line();
-};
-
-/*!
-	An implementation of the drive VIA in a Commodore 1540 — the VIA that is used to interface with the disk.
-
-	It is wired up such that Port B contains:
-		Bits 0/1:	head step direction
-		Bit 2:		motor control
-		Bit 3:		LED control (TODO)
-		Bit 4:		write protect photocell status (TODO)
-		Bits 5/6:	read/write density
-		Bit 7:		0 if sync marks are currently being detected, 1 otherwise.
-
-	... and Port A contains the byte most recently read from the disk or the byte next to write to the disk, depending on data direction.
-
-	It is implied that CA2 might be used to set processor overflow, CA1 a strobe for data input, and one of the CBs being definitive on
-	whether the disk head is being told to read or write, but it's unclear and I've yet to investigate. So, TODO.
-*/
-class DriveVIA: public MOS::MOS6522<DriveVIA>, public MOS::MOS6522IRQDelegate {
-	public:
-		class Delegate {
-			public:
-				virtual void drive_via_did_step_head(void *driveVIA, int direction) = 0;
-				virtual void drive_via_did_set_data_density(void *driveVIA, int density) = 0;
-		};
-		void set_delegate(Delegate *);
-
-		using MOS6522IRQDelegate::set_interrupt_status;
-
-		DriveVIA();
-
-		uint8_t get_port_input(Port port);
-
-		void set_sync_detected(bool);
-		void set_data_input(uint8_t);
-		bool get_should_set_overflow();
-		bool get_motor_enabled();
-
-		void set_control_line_output(Port, Line, bool value);
-
-		void set_port_output(Port, uint8_t value, uint8_t direction_mask);
-
-	private:
-		uint8_t port_b_, port_a_;
-		bool should_set_overflow_;
-		bool drive_motor_;
-		uint8_t previous_port_b_output_;
-		Delegate *delegate_;
-};
-
-/*!
-	An implementation of the C1540's serial port; this connects incoming line levels to the serial-port VIA.
-*/
-class SerialPort : public ::Commodore::Serial::Port {
-	public:
-		void set_input(::Commodore::Serial::Line, ::Commodore::Serial::LineLevel);
-		void set_serial_port_via(const std::shared_ptr<SerialPortVIA> &);
-
-	private:
-		std::weak_ptr<SerialPortVIA> serial_port_VIA_;
-};
-
 /*!
 	Provides an emulation of the C1540.
 */
-class Machine:
-	public CPU::MOS6502::Processor<Machine>,
-	public MOS::MOS6522IRQDelegate::Delegate,
-	public DriveVIA::Delegate,
-	public Storage::Disk::Controller {
-
+class Machine: public MachineBase, public ROMMachine::Machine {
 	public:
-		Machine();
+		enum Personality {
+			C1540,
+			C1541
+		};
+		Machine(Personality p);
 
 		/*!
-			Sets the ROM image to use for this drive; it is assumed that the buffer provided will be at least 16 kb in size.
+			Sets the source for this drive's ROM image.
 		*/
-		void set_rom(const std::vector<uint8_t> &rom);
+		bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names);
 
 		/*!
 			Sets the serial bus to which this drive should attach itself.
 		*/
 		void set_serial_bus(std::shared_ptr<::Commodore::Serial::Bus> serial_bus);
 
+		/// Advances time.
 		void run_for(const Cycles cycles);
+
+		/// Inserts @c disk into the drive.
 		void set_disk(std::shared_ptr<Storage::Disk::Disk> disk);
 
-		// to satisfy CPU::MOS6502::Processor
-		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value);
-
-		// to satisfy MOS::MOS6522::Delegate
-		virtual void mos6522_did_change_interrupt_status(void *mos6522);
-
-		// to satisfy DriveVIA::Delegate
-		void drive_via_did_step_head(void *driveVIA, int direction);
-		void drive_via_did_set_data_density(void *driveVIA, int density);
-
 	private:
-		uint8_t ram_[0x800];
-		uint8_t rom_[0x4000];
-
-		std::shared_ptr<SerialPortVIA> serial_port_VIA_;
-		std::shared_ptr<SerialPort> serial_port_;
-		DriveVIA drive_VIA_;
-
-		int shift_register_, bit_window_offset_;
-		virtual void process_input_bit(int value, unsigned int cycles_since_index_hole);
-		virtual void process_index_hole();
+		Personality personality_;
 };
 
 }

Machines/Commodore/1540/Implementation/C1540.cpp

@@ -6,35 +6,47 @@
 //  Copyright © 2016 Thomas Harte. All rights reserved.
 //
 
-#include "C1540.hpp"
+#include "../C1540.hpp"
+
+#include <cassert>
+#include <cstring>
 #include <string>
-#include "../../../Storage/Disk/Encodings/CommodoreGCR.hpp"
+
+#include "../../../../Storage/Disk/Encodings/CommodoreGCR.hpp"
 
 using namespace Commodore::C1540;
 
-Machine::Machine() :
-		shift_register_(0),
-		Storage::Disk::Controller(1000000, 4, 300),
+MachineBase::MachineBase() :
+		Storage::Disk::Controller(1000000),
+		m6502_(*this),
+		drive_(new Storage::Disk::Drive(1000000, 300, 2)),
+		serial_port_VIA_port_handler_(new SerialPortVIA(serial_port_VIA_)),
 		serial_port_(new SerialPort),
-		serial_port_VIA_(new SerialPortVIA) {
+		drive_VIA_(drive_VIA_port_handler_),
+		serial_port_VIA_(*serial_port_VIA_port_handler_) {
 	// attach the serial port to its VIA and vice versa
-	serial_port_->set_serial_port_via(serial_port_VIA_);
-	serial_port_VIA_->set_serial_port(serial_port_);
+	serial_port_->set_serial_port_via(serial_port_VIA_port_handler_);
+	serial_port_VIA_port_handler_->set_serial_port(serial_port_);
 
 	// set this instance as the delegate to receive interrupt requests from both VIAs
-	serial_port_VIA_->set_interrupt_delegate(this);
-	drive_VIA_.set_interrupt_delegate(this);
-	drive_VIA_.set_delegate(this);
+	serial_port_VIA_port_handler_->set_interrupt_delegate(this);
+	drive_VIA_port_handler_.set_interrupt_delegate(this);
+	drive_VIA_port_handler_.set_delegate(this);
 
 	// set a bit rate
 	set_expected_bit_length(Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(3));
+
+	// attach the only drive there is
+	set_drive(drive_);
 }
 
+Machine::Machine(Commodore::C1540::Machine::Personality personality) : personality_(personality) {}
+
 void Machine::set_serial_bus(std::shared_ptr<::Commodore::Serial::Bus> serial_bus) {
 	Commodore::Serial::AttachPortAndBus(serial_port_, serial_bus);
 }
 
-Cycles Machine::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
+Cycles MachineBase::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
 	/*
 		Memory map (given that I'm unsure yet on any potential mirroring):
 
@@ -49,13 +61,14 @@ Cycles Machine::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint
 		else
 			ram_[address] = *value;
 	} else if(address >= 0xc000) {
-		if(isReadOperation(operation))
+		if(isReadOperation(operation)) {
 			*value = rom_[address & 0x3fff];
+		}
 	} else if(address >= 0x1800 && address <= 0x180f) {
 		if(isReadOperation(operation))
-			*value = serial_port_VIA_->get_register(address);
+			*value = serial_port_VIA_.get_register(address);
 		else
-			serial_port_VIA_->set_register(address, *value);
+			serial_port_VIA_.set_register(address, *value);
 	} else if(address >= 0x1c00 && address <= 0x1c0f) {
 		if(isReadOperation(operation))
 			*value = drive_VIA_.get_register(address);
@@ -63,81 +76,89 @@ Cycles Machine::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint
 			drive_VIA_.set_register(address, *value);
 	}
 
-	serial_port_VIA_->run_for(Cycles(1));
+	serial_port_VIA_.run_for(Cycles(1));
 	drive_VIA_.run_for(Cycles(1));
 
 	return Cycles(1);
 }
 
-void Machine::set_rom(const std::vector<uint8_t> &rom) {
-	memcpy(rom_, rom.data(), std::min(sizeof(rom_), rom.size()));
+bool Machine::set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) {
+	std::string rom_name;
+	switch(personality_) {
+		case Personality::C1540:	rom_name = "1540.bin";	break;
+		case Personality::C1541:	rom_name = "1541.bin";	break;
+	}
+
+	auto roms = roms_with_names("Commodore1540", {rom_name});
+	if(!roms[0]) return false;
+	std::memcpy(rom_, roms[0]->data(), std::min(sizeof(rom_), roms[0]->size()));
+	return true;
 }
 
 void Machine::set_disk(std::shared_ptr<Storage::Disk::Disk> disk) {
-	std::shared_ptr<Storage::Disk::Drive> drive(new Storage::Disk::Drive);
-	drive->set_disk(disk);
-	set_drive(drive);
+	drive_->set_disk(disk);
 }
 
 void Machine::run_for(const Cycles cycles) {
-	CPU::MOS6502::Processor<Machine>::run_for(cycles);
-	set_motor_on(drive_VIA_.get_motor_enabled());
-	if(drive_VIA_.get_motor_enabled()) // TODO: motor speed up/down
+	m6502_.run_for(cycles);
+
+	bool drive_motor = drive_VIA_port_handler_.get_motor_enabled();
+	drive_->set_motor_on(drive_motor);
+	if(drive_motor)
 		Storage::Disk::Controller::run_for(cycles);
 }
 
-#pragma mark - 6522 delegate
+// MARK: - 6522 delegate
 
-void Machine::mos6522_did_change_interrupt_status(void *mos6522) {
+void MachineBase::mos6522_did_change_interrupt_status(void *mos6522) {
 	// both VIAs are connected to the IRQ line
-	set_irq_line(serial_port_VIA_->get_interrupt_line() || drive_VIA_.get_interrupt_line());
+	m6502_.set_irq_line(serial_port_VIA_.get_interrupt_line() || drive_VIA_.get_interrupt_line());
 }
 
-#pragma mark - Disk drive
+// MARK: - Disk drive
 
-void Machine::process_input_bit(int value, unsigned int cycles_since_index_hole) {
+void MachineBase::process_input_bit(int value) {
 	shift_register_ = (shift_register_ << 1) | value;
 	if((shift_register_ & 0x3ff) == 0x3ff) {
-		drive_VIA_.set_sync_detected(true);
+		drive_VIA_port_handler_.set_sync_detected(true);
 		bit_window_offset_ = -1; // i.e. this bit isn't the first within a data window, but the next might be
 	} else {
-		drive_VIA_.set_sync_detected(false);
+		drive_VIA_port_handler_.set_sync_detected(false);
 	}
 	bit_window_offset_++;
 	if(bit_window_offset_ == 8) {
-		drive_VIA_.set_data_input((uint8_t)shift_register_);
+		drive_VIA_port_handler_.set_data_input(static_cast<uint8_t>(shift_register_));
 		bit_window_offset_ = 0;
-		if(drive_VIA_.get_should_set_overflow()) {
-			set_overflow_line(true);
+		if(drive_VIA_port_handler_.get_should_set_overflow()) {
+			m6502_.set_overflow_line(true);
 		}
 	}
-	else set_overflow_line(false);
+	else m6502_.set_overflow_line(false);
 }
 
 // the 1540 does not recognise index holes
-void Machine::process_index_hole()	{}
+void MachineBase::process_index_hole()	{}
 
-#pragma mak - Drive VIA delegate
+// MARK: - Drive VIA delegate
 
-void Machine::drive_via_did_step_head(void *driveVIA, int direction) {
-	step(direction);
+void MachineBase::drive_via_did_step_head(void *driveVIA, int direction) {
+	drive_->step(direction);
 }
 
-void Machine::drive_via_did_set_data_density(void *driveVIA, int density) {
-	set_expected_bit_length(Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone((unsigned int)density));
+void MachineBase::drive_via_did_set_data_density(void *driveVIA, int density) {
+	set_expected_bit_length(Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(static_cast<unsigned int>(density)));
 }
 
-#pragma mark - SerialPortVIA
+// MARK: - SerialPortVIA
 
-SerialPortVIA::SerialPortVIA() :
-	port_b_(0x00), attention_acknowledge_level_(false), attention_level_input_(true), data_level_output_(false) {}
+SerialPortVIA::SerialPortVIA(MOS::MOS6522::MOS6522<SerialPortVIA> &via) : via_(via) {}
 
-uint8_t SerialPortVIA::get_port_input(Port port) {
+uint8_t SerialPortVIA::get_port_input(MOS::MOS6522::Port port) {
 	if(port) return port_b_;
 	return 0xff;
 }
 
-void SerialPortVIA::set_port_output(Port port, uint8_t value, uint8_t mask) {
+void SerialPortVIA::set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t mask) {
 	if(port) {
 		std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
 		if(serialPort) {
@@ -151,6 +172,8 @@ void SerialPortVIA::set_port_output(Port port, uint8_t value, uint8_t mask) {
 }
 
 void SerialPortVIA::set_serial_line_state(::Commodore::Serial::Line line, bool value) {
+//	printf("[C1540] %s is %s\n", StringForLine(line), value ? "high" : "low");
+
 	switch(line) {
 		default: break;
 		case ::Commodore::Serial::Line::Data:		port_b_ = (port_b_ & ~0x01) | (value ? 0x00 : 0x01);		break;
@@ -158,7 +181,7 @@ void SerialPortVIA::set_serial_line_state(::Commodore::Serial::Line line, bool v
 		case ::Commodore::Serial::Line::Attention:
 			attention_level_input_ = !value;
 			port_b_ = (port_b_ & ~0x80) | (value ? 0x00 : 0x80);
-			set_control_line_input(Port::A, Line::One, !value);
+			via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !value);
 			update_data_line();
 		break;
 	}
@@ -177,7 +200,7 @@ void SerialPortVIA::update_data_line() {
 	}
 }
 
-#pragma mark - DriveVIA
+// MARK: - DriveVIA
 
 void DriveVIA::set_delegate(Delegate *delegate) {
 	delegate_ = delegate;
@@ -186,7 +209,7 @@ void DriveVIA::set_delegate(Delegate *delegate) {
 // write protect tab uncovered
 DriveVIA::DriveVIA() : port_b_(0xff), port_a_(0xff), delegate_(nullptr) {}
 
-uint8_t DriveVIA::get_port_input(Port port) {
+uint8_t DriveVIA::get_port_input(MOS::MOS6522::Port port) {
 	return port ? port_b_ : port_a_;
 }
 
@@ -206,37 +229,39 @@ bool DriveVIA::get_motor_enabled() {
 	return drive_motor_;
 }
 
-void DriveVIA::set_control_line_output(Port port, Line line, bool value) {
-	if(port == Port::A && line == Line::Two) {
+void DriveVIA::set_control_line_output(MOS::MOS6522::Port port, MOS::MOS6522::Line line, bool value) {
+	if(port == MOS::MOS6522::Port::A && line == MOS::MOS6522::Line::Two) {
 		should_set_overflow_ = value;
 	}
 }
 
-void DriveVIA::set_port_output(Port port, uint8_t value, uint8_t direction_mask) {
+void DriveVIA::set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t direction_mask) {
 	if(port) {
-		// record drive motor state
-		drive_motor_ = !!(value&4);
+		if(previous_port_b_output_ != value) {
+			// record drive motor state
+			drive_motor_ = !!(value&4);
 
-		// check for a head step
-		int step_difference = ((value&3) - (previous_port_b_output_&3))&3;
-		if(step_difference) {
-			if(delegate_) delegate_->drive_via_did_step_head(this, (step_difference == 1) ? 1 : -1);
+			// check for a head step
+			int step_difference = ((value&3) - (previous_port_b_output_&3))&3;
+			if(step_difference) {
+				if(delegate_) delegate_->drive_via_did_step_head(this, (step_difference == 1) ? 1 : -1);
+			}
+
+			// check for a change in density
+			int density_difference = (previous_port_b_output_^value) & (3 << 5);
+			if(density_difference && delegate_) {
+				delegate_->drive_via_did_set_data_density(this, (value >> 5)&3);
+			}
+
+			// TODO: something with the drive LED
+//			printf("LED: %s\n", value&8 ? "On" : "Off");
+
+			previous_port_b_output_ = value;
 		}
-
-		// check for a change in density
-		int density_difference = (previous_port_b_output_^value) & (3 << 5);
-		if(density_difference && delegate_) {
-			delegate_->drive_via_did_set_data_density(this, (value >> 5)&3);
-		}
-
-		// TODO: something with the drive LED
-//		printf("LED: %s\n", value&8 ? "On" : "Off");
-
-		previous_port_b_output_ = value;
 	}
 }
 
-#pragma mark - SerialPort
+// MARK: - SerialPort
 
 void SerialPort::set_input(::Commodore::Serial::Line line, ::Commodore::Serial::LineLevel level) {
 	std::shared_ptr<SerialPortVIA> serialPortVIA = serial_port_VIA_.lock();

Machines/Commodore/1540/Implementation/C1540Base.hpp

@@ -0,0 +1,160 @@
+//
+//  C1540Base.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/09/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef C1540Base_hpp
+#define C1540Base_hpp
+
+#include "../../../../Processors/6502/6502.hpp"
+#include "../../../../Components/6522/6522.hpp"
+
+#include "../../SerialBus.hpp"
+
+#include "../../../../Storage/Disk/Disk.hpp"
+
+#include "../../../../Storage/Disk/Controller/DiskController.hpp"
+
+namespace Commodore {
+namespace C1540 {
+
+/*!
+	An implementation of the serial-port VIA in a Commodore 1540 — the VIA that facilitates all
+	IEC bus communications.
+
+	It is wired up such that Port B contains:
+		Bit 0:		data input; 1 if the line is low, 0 if it is high;
+		Bit 1:		data output; 1 if the line should be low, 0 if it should be high;
+		Bit 2:		clock input; 1 if the line is low, 0 if it is high;
+		Bit 3:		clock output; 1 if the line is low, 0 if it is high;
+		Bit 4:		attention acknowledge output; exclusive ORd with the attention input and ORd onto the data output;
+		Bits 5/6:	device select input; the 1540 will act as device 8 + [value of bits]
+		Bit 7:		attention input; 1 if the line is low, 0 if it is high
+
+	The attention input is also connected to CA1, similarly inverted — the CA1 wire will be high when the bus is low and vice versa.
+*/
+class SerialPortVIA: public MOS::MOS6522::IRQDelegatePortHandler {
+	public:
+		SerialPortVIA(MOS::MOS6522::MOS6522<SerialPortVIA> &via);
+
+		uint8_t get_port_input(MOS::MOS6522::Port);
+
+		void set_port_output(MOS::MOS6522::Port, uint8_t value, uint8_t mask);
+		void set_serial_line_state(::Commodore::Serial::Line, bool);
+
+		void set_serial_port(const std::shared_ptr<::Commodore::Serial::Port> &);
+
+	private:
+		MOS::MOS6522::MOS6522<SerialPortVIA> &via_;
+		uint8_t port_b_ = 0x0;
+		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
+		bool attention_acknowledge_level_ = false;
+		bool attention_level_input_ = true;
+		bool data_level_output_ = false;
+
+		void update_data_line();
+};
+
+/*!
+	An implementation of the drive VIA in a Commodore 1540 — the VIA that is used to interface with the disk.
+
+	It is wired up such that Port B contains:
+		Bits 0/1:	head step direction
+		Bit 2:		motor control
+		Bit 3:		LED control (TODO)
+		Bit 4:		write protect photocell status (TODO)
+		Bits 5/6:	read/write density
+		Bit 7:		0 if sync marks are currently being detected, 1 otherwise.
+
+	... and Port A contains the byte most recently read from the disk or the byte next to write to the disk, depending on data direction.
+
+	It is implied that CA2 might be used to set processor overflow, CA1 a strobe for data input, and one of the CBs being definitive on
+	whether the disk head is being told to read or write, but it's unclear and I've yet to investigate. So, TODO.
+*/
+class DriveVIA: public MOS::MOS6522::IRQDelegatePortHandler {
+	public:
+		class Delegate {
+			public:
+				virtual void drive_via_did_step_head(void *driveVIA, int direction) = 0;
+				virtual void drive_via_did_set_data_density(void *driveVIA, int density) = 0;
+		};
+		void set_delegate(Delegate *);
+
+		DriveVIA();
+
+		uint8_t get_port_input(MOS::MOS6522::Port port);
+
+		void set_sync_detected(bool);
+		void set_data_input(uint8_t);
+		bool get_should_set_overflow();
+		bool get_motor_enabled();
+
+		void set_control_line_output(MOS::MOS6522::Port, MOS::MOS6522::Line, bool value);
+
+		void set_port_output(MOS::MOS6522::Port, uint8_t value, uint8_t direction_mask);
+
+	private:
+		uint8_t port_b_, port_a_;
+		bool should_set_overflow_;
+		bool drive_motor_;
+		uint8_t previous_port_b_output_;
+		Delegate *delegate_;
+};
+
+/*!
+	An implementation of the C1540's serial port; this connects incoming line levels to the serial-port VIA.
+*/
+class SerialPort : public ::Commodore::Serial::Port {
+	public:
+		void set_input(::Commodore::Serial::Line, ::Commodore::Serial::LineLevel);
+		void set_serial_port_via(const std::shared_ptr<SerialPortVIA> &);
+
+	private:
+		std::weak_ptr<SerialPortVIA> serial_port_VIA_;
+};
+
+class MachineBase:
+	public CPU::MOS6502::BusHandler,
+	public MOS::MOS6522::IRQDelegatePortHandler::Delegate,
+	public DriveVIA::Delegate,
+	public Storage::Disk::Controller {
+
+	public:
+		MachineBase();
+
+		// to satisfy CPU::MOS6502::Processor
+		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value);
+
+		// to satisfy MOS::MOS6522::Delegate
+		virtual void mos6522_did_change_interrupt_status(void *mos6522);
+
+		// to satisfy DriveVIA::Delegate
+		void drive_via_did_step_head(void *driveVIA, int direction);
+		void drive_via_did_set_data_density(void *driveVIA, int density);
+
+	protected:
+		CPU::MOS6502::Processor<MachineBase, false> m6502_;
+		std::shared_ptr<Storage::Disk::Drive> drive_;
+
+		uint8_t ram_[0x800];
+		uint8_t rom_[0x4000];
+
+		std::shared_ptr<SerialPortVIA> serial_port_VIA_port_handler_;
+		std::shared_ptr<SerialPort> serial_port_;
+		DriveVIA drive_VIA_port_handler_;
+
+		MOS::MOS6522::MOS6522<DriveVIA> drive_VIA_;
+		MOS::MOS6522::MOS6522<SerialPortVIA> serial_port_VIA_;
+
+		int shift_register_ = 0, bit_window_offset_;
+		virtual void process_input_bit(int value);
+		virtual void process_index_hole();
+};
+
+}
+}
+
+#endif /* C1540Base_hpp */

Machines/Commodore/SerialBus.cpp

@@ -8,6 +8,8 @@
 
 #include "SerialBus.hpp"
 
+#include <cstdio>
+
 using namespace Commodore::Serial;
 
 const char *::Commodore::Serial::StringForLine(Line line) {
@@ -17,6 +19,7 @@ const char *::Commodore::Serial::StringForLine(Line line) {
 		case Clock: return "Clock";
 		case Data: return "Data";
 		case Reset: return "Reset";
+		default: return nullptr;
 	}
 }
 
@@ -27,12 +30,12 @@ void ::Commodore::Serial::AttachPortAndBus(std::shared_ptr<Port> port, std::shar
 
 void Bus::add_port(std::shared_ptr<Port> port) {
 	ports_.push_back(port);
-	for(int line = (int)ServiceRequest; line <= (int)Reset; line++) {
+	for(int line = static_cast<int>(ServiceRequest); line <= static_cast<int>(Reset); line++) {
 		// the addition of a new device may change the line output...
-		set_line_output_did_change((Line)line);
+		set_line_output_did_change(static_cast<Line>(line));
 
 		// ... but the new device will need to be told the current state regardless
-		port->set_input((Line)line, line_levels_[line]);
+		port->set_input(static_cast<Line>(line), line_levels_[line]);
 	}
 }
 
@@ -46,6 +49,8 @@ void Bus::set_line_output_did_change(Line line) {
 		}
 	}
 
+//	printf("[Bus] %s is %s\n", StringForLine(line), new_line_level ? "high" : "low");
+
 	// post an update only if one occurred
 	if(new_line_level != line_levels_[line]) {
 		line_levels_[line] = new_line_level;
@@ -59,7 +64,7 @@ void Bus::set_line_output_did_change(Line line) {
 	}
 }
 
-#pragma mark - The debug port
+// MARK: - The debug port
 
 void DebugPort::set_input(Line line, LineLevel value) {
 	input_levels_[line] = value;

Machines/Commodore/SerialBus.hpp

@@ -9,6 +9,8 @@
 #ifndef SerialBus_hpp
 #define SerialBus_hpp
 
+#include <cstdint>
+#include <memory>
 #include <vector>
 
 namespace Commodore {

Machines/Commodore/Vic-20/CharacterMapper.hpp

@@ -1,25 +0,0 @@
-//
-//  CharacterMapper.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 03/08/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
-//
-
-#ifndef Machines_Commodore_Vic20_CharacterMapper_hpp
-#define Machines_Commodore_Vic20_CharacterMapper_hpp
-
-#include "../../Typer.hpp"
-
-namespace Commodore {
-namespace Vic20 {
-
-class CharacterMapper: public ::Utility::CharacterMapper {
-	public:
-		uint16_t *sequence_for_character(char character);
-};
-
-}
-}
-
-#endif /* CharacterMapper_hpp */

Machines/Commodore/Vic-20/Keyboard.cpp

@@ -1,20 +1,80 @@
 //
-//  CharacterMapper.cpp
+//  Keyboard.cpp
 //  Clock Signal
 //
-//  Created by Thomas Harte on 03/08/2017.
+//  Created by Thomas Harte on 10/10/2017.
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#include "CharacterMapper.hpp"
-#include "Vic20.hpp"
+#include "Keyboard.hpp"
 
 using namespace Commodore::Vic20;
 
+uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) {
+#define BIND(source, dest)	case Inputs::Keyboard::Key::source:	return Commodore::Vic20::dest
+	switch(key) {
+		default: break;
+
+		BIND(k0, Key0);		BIND(k1, Key1);		BIND(k2, Key2);		BIND(k3, Key3);		BIND(k4, Key4);
+		BIND(k5, Key5);		BIND(k6, Key6);		BIND(k7, Key7);		BIND(k8, Key8);		BIND(k9, Key9);
+		BIND(Q, KeyQ);		BIND(W, KeyW);		BIND(E, KeyE);		BIND(R, KeyR);		BIND(T, KeyT);
+		BIND(Y, KeyY);		BIND(U, KeyU);		BIND(I, KeyI);		BIND(O, KeyO);		BIND(P, KeyP);
+		BIND(A, KeyA);		BIND(S, KeyS);		BIND(D, KeyD);		BIND(F, KeyF);		BIND(G, KeyG);
+		BIND(H, KeyH);		BIND(J, KeyJ);		BIND(K, KeyK);		BIND(L, KeyL);
+		BIND(Z, KeyZ);		BIND(X, KeyX);		BIND(C, KeyC);		BIND(V, KeyV);
+		BIND(B, KeyB);		BIND(N, KeyN);		BIND(M, KeyM);
+
+		BIND(BackTick, KeyLeft);
+		BIND(Hyphen, KeyPlus);
+		BIND(Equals, KeyDash);
+		BIND(F11, KeyGBP);
+		BIND(F12, KeyHome);
+
+		BIND(Tab, KeyControl);
+		BIND(OpenSquareBracket, KeyAt);
+		BIND(CloseSquareBracket, KeyAsterisk);
+
+		BIND(BackSlash, KeyRestore);
+		BIND(Hash, KeyUp);
+		BIND(F10, KeyUp);
+
+		BIND(Semicolon, KeyColon);
+		BIND(Quote, KeySemicolon);
+		BIND(F9, KeyEquals);
+
+		BIND(LeftMeta, KeyCBM);
+		BIND(LeftOption, KeyCBM);
+		BIND(RightOption, KeyCBM);
+		BIND(RightMeta, KeyCBM);
+
+		BIND(LeftShift, KeyLShift);
+		BIND(RightShift, KeyRShift);
+
+		BIND(Comma, KeyComma);
+		BIND(FullStop, KeyFullStop);
+		BIND(ForwardSlash, KeySlash);
+
+		BIND(Right, KeyRight);
+		BIND(Down, KeyDown);
+
+		BIND(Enter, KeyReturn);
+		BIND(Space, KeySpace);
+		BIND(BackSpace, KeyDelete);
+
+		BIND(Escape, KeyRunStop);
+		BIND(F1, KeyF1);
+		BIND(F3, KeyF3);
+		BIND(F5, KeyF5);
+		BIND(F7, KeyF7);
+	}
+#undef BIND
+	return KeyboardMachine::Machine::KeyNotMapped;
+}
+
 uint16_t *CharacterMapper::sequence_for_character(char character) {
-#define KEYS(...)	{__VA_ARGS__, EndSequence}
-#define SHIFT(...)	{KeyLShift, __VA_ARGS__, EndSequence}
-#define X			{NotMapped}
+#define KEYS(...)	{__VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define SHIFT(...)	{KeyLShift, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define X			{KeyboardMachine::Machine::KeyNotMapped}
 	static KeySequence key_sequences[] = {
 		/* NUL */	X,							/* SOH */	X,
 		/* STX */	X,							/* ETX */	X,

Machines/Commodore/Vic-20/Keyboard.hpp

@@ -0,0 +1,52 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_Commodore_Vic20_Keyboard_hpp
+#define Machines_Commodore_Vic20_Keyboard_hpp
+
+#include "../../KeyboardMachine.hpp"
+#include "../../Utility/Typer.hpp"
+
+namespace Commodore {
+namespace Vic20 {
+
+enum Key: uint16_t {
+#define key(line, mask) (((mask) << 3) | (line))
+	Key2		= key(7, 0x01),		Key4		= key(7, 0x02),		Key6			= key(7, 0x04),		Key8		= key(7, 0x08),
+	Key0		= key(7, 0x10),		KeyDash		= key(7, 0x20),		KeyHome			= key(7, 0x40),		KeyF7		= key(7, 0x80),
+	KeyQ		= key(6, 0x01),		KeyE		= key(6, 0x02),		KeyT			= key(6, 0x04),		KeyU		= key(6, 0x08),
+	KeyO		= key(6, 0x10),		KeyAt		= key(6, 0x20),		KeyUp			= key(6, 0x40),		KeyF5		= key(6, 0x80),
+	KeyCBM		= key(5, 0x01),		KeyS		= key(5, 0x02),		KeyF			= key(5, 0x04),		KeyH		= key(5, 0x08),
+	KeyK		= key(5, 0x10),		KeyColon	= key(5, 0x20),		KeyEquals		= key(5, 0x40),		KeyF3		= key(5, 0x80),
+	KeySpace	= key(4, 0x01),		KeyZ		= key(4, 0x02),		KeyC			= key(4, 0x04),		KeyB		= key(4, 0x08),
+	KeyM		= key(4, 0x10),		KeyFullStop	= key(4, 0x20),		KeyRShift		= key(4, 0x40),		KeyF1		= key(4, 0x80),
+	KeyRunStop	= key(3, 0x01),		KeyLShift	= key(3, 0x02),		KeyX			= key(3, 0x04),		KeyV		= key(3, 0x08),
+	KeyN		= key(3, 0x10),		KeyComma	= key(3, 0x20),		KeySlash		= key(3, 0x40),		KeyDown		= key(3, 0x80),
+	KeyControl	= key(2, 0x01),		KeyA		= key(2, 0x02),		KeyD			= key(2, 0x04),		KeyG		= key(2, 0x08),
+	KeyJ		= key(2, 0x10),		KeyL		= key(2, 0x20),		KeySemicolon	= key(2, 0x40),		KeyRight	= key(2, 0x80),
+	KeyLeft		= key(1, 0x01),		KeyW		= key(1, 0x02),		KeyR			= key(1, 0x04),		KeyY		= key(1, 0x08),
+	KeyI		= key(1, 0x10),		KeyP		= key(1, 0x20),		KeyAsterisk		= key(1, 0x40),		KeyReturn	= key(1, 0x80),
+	Key1		= key(0, 0x01),		Key3		= key(0, 0x02),		Key5			= key(0, 0x04),		Key7		= key(0, 0x08),
+	Key9		= key(0, 0x10),		KeyPlus		= key(0, 0x20),		KeyGBP			= key(0, 0x40),		KeyDelete	= key(0, 0x80),
+
+	KeyRestore 	= 0xfffd
+#undef key
+};
+
+struct KeyboardMapper: public KeyboardMachine::Machine::KeyboardMapper {
+	uint16_t mapped_key_for_key(Inputs::Keyboard::Key key);
+};
+
+struct CharacterMapper: public ::Utility::CharacterMapper {
+	uint16_t *sequence_for_character(char character);
+};
+
+}
+}
+
+#endif /* Keyboard_hpp */

Machines/Commodore/Vic-20/Vic20.hpp

@@ -9,25 +9,19 @@
 #ifndef Vic20_hpp
 #define Vic20_hpp
 
+#include "../../../Configurable/Configurable.hpp"
 #include "../../ConfigurationTarget.hpp"
 #include "../../CRTMachine.hpp"
-#include "../../Typer.hpp"
+#include "../../KeyboardMachine.hpp"
+#include "../../JoystickMachine.hpp"
 
-#include "../../../Processors/6502/6502.hpp"
-#include "../../../Components/6560/6560.hpp"
-#include "../../../Components/6522/6522.hpp"
-
-#include "../SerialBus.hpp"
-#include "../1540/C1540.hpp"
-
-#include "../../../Storage/Tape/Tape.hpp"
-#include "../../../Storage/Disk/Disk.hpp"
+#include <cstdint>
 
 namespace Commodore {
 namespace Vic20 {
 
 enum ROMSlot {
-	Kernel,
+	Kernel = 0,
 	BASIC,
 	Characters,
 	Drive
@@ -40,186 +34,39 @@ enum MemorySize {
 };
 
 enum Region {
-	NTSC,
-	PAL
+	American,
+	Danish,
+	Japanese,
+	European,
+	Swedish
 };
 
-#define key(line, mask) (((mask) << 3) | (line))
-
-enum Key: uint16_t {
-	Key2		= key(7, 0x01),		Key4		= key(7, 0x02),		Key6			= key(7, 0x04),		Key8		= key(7, 0x08),
-	Key0		= key(7, 0x10),		KeyDash		= key(7, 0x20),		KeyHome			= key(7, 0x40),		KeyF7		= key(7, 0x80),
-	KeyQ		= key(6, 0x01),		KeyE		= key(6, 0x02),		KeyT			= key(6, 0x04),		KeyU		= key(6, 0x08),
-	KeyO		= key(6, 0x10),		KeyAt		= key(6, 0x20),		KeyUp			= key(6, 0x40),		KeyF5		= key(6, 0x80),
-	KeyCBM		= key(5, 0x01),		KeyS		= key(5, 0x02),		KeyF			= key(5, 0x04),		KeyH		= key(5, 0x08),
-	KeyK		= key(5, 0x10),		KeyColon	= key(5, 0x20),		KeyEquals		= key(5, 0x40),		KeyF3		= key(5, 0x80),
-	KeySpace	= key(4, 0x01),		KeyZ		= key(4, 0x02),		KeyC			= key(4, 0x04),		KeyB		= key(4, 0x08),
-	KeyM		= key(4, 0x10),		KeyFullStop	= key(4, 0x20),		KeyRShift		= key(4, 0x40),		KeyF1		= key(4, 0x80),
-	KeyRunStop	= key(3, 0x01),		KeyLShift	= key(3, 0x02),		KeyX			= key(3, 0x04),		KeyV		= key(3, 0x08),
-	KeyN		= key(3, 0x10),		KeyComma	= key(3, 0x20),		KeySlash		= key(3, 0x40),		KeyDown		= key(3, 0x80),
-	KeyControl	= key(2, 0x01),		KeyA		= key(2, 0x02),		KeyD			= key(2, 0x04),		KeyG		= key(2, 0x08),
-	KeyJ		= key(2, 0x10),		KeyL		= key(2, 0x20),		KeySemicolon	= key(2, 0x40),		KeyRight	= key(2, 0x80),
-	KeyLeft		= key(1, 0x01),		KeyW		= key(1, 0x02),		KeyR			= key(1, 0x04),		KeyY		= key(1, 0x08),
-	KeyI		= key(1, 0x10),		KeyP		= key(1, 0x20),		KeyAsterisk		= key(1, 0x40),		KeyReturn	= key(1, 0x80),
-	Key1		= key(0, 0x01),		Key3		= key(0, 0x02),		Key5			= key(0, 0x04),		Key7		= key(0, 0x08),
-	Key9		= key(0, 0x10),		KeyPlus		= key(0, 0x20),		KeyGBP			= key(0, 0x40),		KeyDelete	= key(0, 0x80),
-};
-
-enum JoystickInput {
-	Up = 0x04,
-	Down = 0x08,
-	Left = 0x10,
-	Right = 0x80,
-	Fire = 0x20
-};
-
-class UserPortVIA: public MOS::MOS6522<UserPortVIA>, public MOS::MOS6522IRQDelegate {
-	public:
-		UserPortVIA();
-		using MOS6522IRQDelegate::set_interrupt_status;
-
-		uint8_t get_port_input(Port port);
-		void set_control_line_output(Port port, Line line, bool value);
-		void set_serial_line_state(::Commodore::Serial::Line line, bool value);
-		void set_joystick_state(JoystickInput input, bool value);
-		void set_port_output(Port port, uint8_t value, uint8_t mask);
-
-		void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serialPort);
-		void set_tape(std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape);
-
-	private:
-		uint8_t port_a_;
-		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
-		std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
-};
-
-class KeyboardVIA: public MOS::MOS6522<KeyboardVIA>, public MOS::MOS6522IRQDelegate {
-	public:
-		KeyboardVIA();
-		using MOS6522IRQDelegate::set_interrupt_status;
-
-		void set_key_state(uint16_t key, bool isPressed);
-		void clear_all_keys();
-
-		// to satisfy MOS::MOS6522
-		uint8_t get_port_input(Port port);
-
-		void set_port_output(Port port, uint8_t value, uint8_t mask);
-		void set_control_line_output(Port port, Line line, bool value);
-
-		void set_joystick_state(JoystickInput input, bool value);
-
-		void set_serial_port(std::shared_ptr<::Commodore::Serial::Port> serialPort);
-
-	private:
-		uint8_t port_b_;
-		uint8_t columns_[8];
-		uint8_t activation_mask_;
-		std::weak_ptr<::Commodore::Serial::Port> serial_port_;
-};
-
-class SerialPort : public ::Commodore::Serial::Port {
-	public:
-		void set_input(::Commodore::Serial::Line line, ::Commodore::Serial::LineLevel level);
-		void set_user_port_via(std::shared_ptr<UserPortVIA> userPortVIA);
-
-	private:
-		std::weak_ptr<UserPortVIA> user_port_via_;
-};
-
-class Vic6560: public MOS::MOS6560<Vic6560> {
-	public:
-		inline void perform_read(uint16_t address, uint8_t *pixel_data, uint8_t *colour_data) {
-			*pixel_data = video_memory_map[address >> 10] ? video_memory_map[address >> 10][address & 0x3ff] : 0xff; // TODO
-			*colour_data = colour_memory[address & 0x03ff];
-		}
-
-		uint8_t *video_memory_map[16];
-		uint8_t *colour_memory;
-};
+/// @returns The options available for a Vic-20.
+std::vector<std::unique_ptr<Configurable::Option>> get_options();
 
 class Machine:
-	public CPU::MOS6502::Processor<Machine>,
 	public CRTMachine::Machine,
-	public MOS::MOS6522IRQDelegate::Delegate,
-	public Utility::TypeRecipient,
-	public Storage::Tape::BinaryTapePlayer::Delegate,
-	public ConfigurationTarget::Machine {
-
+	public ConfigurationTarget::Machine,
+	public KeyboardMachine::Machine,
+	public JoystickMachine::Machine,
+	public Configurable::Device {
 	public:
-		Machine();
-		~Machine();
+		virtual ~Machine();
 
-		void set_rom(ROMSlot slot, size_t length, const uint8_t *data);
-		void configure_as_target(const StaticAnalyser::Target &target);
+		/// Creates and returns a Vic-20.
+		static Machine *Vic20();
 
-		void set_key_state(uint16_t key, bool isPressed) { keyboard_via_->set_key_state(key, isPressed); }
-		void clear_all_keys() { keyboard_via_->clear_all_keys(); }
-		void set_joystick_state(JoystickInput input, bool isPressed) {
-			user_port_via_->set_joystick_state(input, isPressed);
-			keyboard_via_->set_joystick_state(input, isPressed);
-		}
+		/// Sets the contents of the rom in @c slot to the buffer @c data of length @c length.
+		virtual void set_rom(ROMSlot slot, const std::vector<uint8_t> &data) = 0;
 
-		void set_memory_size(MemorySize size);
-		void set_region(Region region);
+		/// Sets the memory size of this Vic-20.
+		virtual void set_memory_size(MemorySize size) = 0;
 
-		inline void set_use_fast_tape_hack(bool activate) { use_fast_tape_hack_ = activate; }
+		/// Sets the region of this Vic-20.
+		virtual void set_region(Region region) = 0;
 
-		// to satisfy CPU::MOS6502::Processor
-		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value);
-		void flush() { mos6560_->flush(); }
-
-		// to satisfy CRTMachine::Machine
-		virtual void setup_output(float aspect_ratio);
-		virtual void close_output();
-		virtual std::shared_ptr<Outputs::CRT::CRT> get_crt() { return mos6560_->get_crt(); }
-		virtual std::shared_ptr<Outputs::Speaker> get_speaker() { return mos6560_->get_speaker(); }
-		virtual void run_for(const Cycles cycles) { CPU::MOS6502::Processor<Machine>::run_for(cycles); }
-
-		// to satisfy MOS::MOS6522::Delegate
-		virtual void mos6522_did_change_interrupt_status(void *mos6522);
-
-		// for Utility::TypeRecipient
-		uint16_t *sequence_for_character(Utility::Typer *typer, char character);
-		void set_typer_for_string(const char *string);
-
-		// for Tape::Delegate
-		virtual void tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape);
-
-	private:
-		uint8_t character_rom_[0x1000];
-		uint8_t basic_rom_[0x2000];
-		uint8_t kernel_rom_[0x2000];
-		uint8_t expansion_ram_[0x8000];
-
-		uint8_t *rom_;
-		uint16_t rom_address_, rom_length_;
-
-		uint8_t user_basic_memory_[0x0400];
-		uint8_t screen_memory_[0x1000];
-		uint8_t colour_memory_[0x0400];
-		std::vector<uint8_t> drive_rom_;
-
-		uint8_t *processor_read_memory_map_[64];
-		uint8_t *processor_write_memory_map_[64];
-		void write_to_map(uint8_t **map, uint8_t *area, uint16_t address, uint16_t length);
-
-		Region region_;
-
-		std::unique_ptr<Vic6560> mos6560_;
-		std::shared_ptr<UserPortVIA> user_port_via_;
-		std::shared_ptr<KeyboardVIA> keyboard_via_;
-		std::shared_ptr<SerialPort> serial_port_;
-		std::shared_ptr<::Commodore::Serial::Bus> serial_bus_;
-
-		// Tape
-		std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
-		bool use_fast_tape_hack_;
-		bool is_running_at_zero_cost_;
-
-		// Disk
-		std::shared_ptr<::Commodore::C1540::Machine> c1540_;
-		void install_disk_rom();
+		/// Enables or disables turbo-speed tape loading.
+		virtual void set_use_fast_tape_hack(bool activate) = 0;
 };
 
 }

Machines/ConfigurationTarget.hpp

@@ -10,16 +10,27 @@
 #define ConfigurationTarget_hpp
 
 #include "../StaticAnalyser/StaticAnalyser.hpp"
+#include "../Configurable/Configurable.hpp"
+
+#include <string>
 
 namespace ConfigurationTarget {
 
 /*!
 	A ConfigurationTarget::Machine is anything that can accept a StaticAnalyser::Target
-	and configure itself appropriately.
+	and configure itself appropriately, or accept a list of media subsequently to insert.
 */
 class Machine {
 	public:
+		/// Instructs the machine to configure itself as described by @c target and insert the included media.
 		virtual void configure_as_target(const StaticAnalyser::Target &target) = 0;
+
+		/*!
+			Requests that the machine insert @c media as a modification to current state
+
+			@returns @c true if any media was inserted; @c false otherwise.
+		*/
+		virtual bool insert_media(const StaticAnalyser::Media &media) = 0;
 };
 
 }

Machines/Electron/CharacterMapper.hpp

@@ -1,23 +0,0 @@
-//
-//  CharacterMapper.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 03/08/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
-//
-
-#ifndef Machines_Electron_CharacterMapper_hpp
-#define Machines_Electron_CharacterMapper_hpp
-
-#include "../Typer.hpp"
-
-namespace Electron {
-
-class CharacterMapper: public ::Utility::CharacterMapper {
-	public:
-		uint16_t *sequence_for_character(char character);
-};
-
-}
-
-#endif /* Machines_Electron_CharacterMapper_hpp */

Machines/Electron/Electron.cpp

@@ -8,407 +8,539 @@
 
 #include "Electron.hpp"
 
-#include "CharacterMapper.hpp"
+#include "../../Configurable/StandardOptions.hpp"
+#include "../../Processors/6502/6502.hpp"
+#include "../../Storage/Tape/Tape.hpp"
+#include "../../ClockReceiver/ClockReceiver.hpp"
+#include "../../ClockReceiver/ForceInline.hpp"
+
+#include "../Utility/Typer.hpp"
+
+#include "Interrupts.hpp"
+#include "Keyboard.hpp"
+#include "Plus3.hpp"
+#include "Speaker.hpp"
+#include "Tape.hpp"
+#include "Video.hpp"
+
+namespace Electron {
+
+std::vector<std::unique_ptr<Configurable::Option>> get_options() {
+	return Configurable::standard_options(
+		static_cast<Configurable::StandardOptions>(Configurable::DisplayRGBComposite | Configurable::QuickLoadTape)
+	);
+}
+
+class ConcreteMachine:
+	public Machine,
+	public CPU::MOS6502::BusHandler,
+	public Tape::Delegate,
+	public Utility::TypeRecipient {
+	public:
+		ConcreteMachine() : m6502_(*this) {
+			memset(key_states_, 0, sizeof(key_states_));
+			for(int c = 0; c < 16; c++)
+				memset(roms_[c], 0xff, 16384);
+
+			tape_.set_delegate(this);
+			set_clock_rate(2000000);
+		}
+
+		void set_rom(ROMSlot slot, const std::vector<uint8_t> &data, bool is_writeable) override final {
+			uint8_t *target = nullptr;
+			switch(slot) {
+				case ROMSlotDFS:	dfs_ = data;			return;
+				case ROMSlotADFS1:	adfs1_ = data;			return;
+				case ROMSlotADFS2:	adfs2_ = data;			return;
+
+				case ROMSlotOS:		target = os_;			break;
+				default:
+					target = roms_[slot];
+					rom_write_masks_[slot] = is_writeable;
+				break;
+			}
+
+			std::memcpy(target, &data[0], std::min(static_cast<std::size_t>(16384), data.size()));
+		}
+
+		// Obtains the system ROMs.
+		bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) override {
+			auto roms = roms_with_names(
+				"Electron",
+				{
+					"DFS-1770-2.20.rom",
+					"ADFS-E00_1.rom",	"ADFS-E00_2.rom",
+					"basic.rom",		"os.rom"
+				});
+			ROMSlot slots[] = {
+				ROMSlotDFS,
+				ROMSlotADFS1, ROMSlotADFS2,
+				ROMSlotBASIC, ROMSlotOS
+			};
+
+			for(std::size_t index = 0; index < roms.size(); ++index) {
+				auto &data = roms[index];
+				if(!data) return false;
+				set_rom(slots[index], *data, false);
+			}
+
+			return true;
+		}
+
+		void set_key_state(uint16_t key, bool isPressed) override final {
+			if(key == KeyBreak) {
+				m6502_.set_reset_line(isPressed);
+			} else {
+				if(isPressed)
+					key_states_[key >> 4] |= key&0xf;
+				else
+					key_states_[key >> 4] &= ~(key&0xf);
+			}
+		}
+
+		void clear_all_keys() override final {
+			memset(key_states_, 0, sizeof(key_states_));
+			if(is_holding_shift_) set_key_state(KeyShift, true);
+		}
+
+		void set_use_fast_tape_hack(bool activate) override final {
+			use_fast_tape_hack_ = activate;
+		}
+
+		void configure_as_target(const StaticAnalyser::Target &target) override final {
+			if(target.loadingCommand.length()) {
+				set_typer_for_string(target.loadingCommand.c_str());
+			}
+
+			if(target.acorn.should_shift_restart) {
+				shift_restart_counter_ = 1000000;
+			}
+
+			if(target.acorn.has_dfs || target.acorn.has_adfs) {
+				plus3_.reset(new Plus3);
+
+				if(target.acorn.has_dfs) {
+					set_rom(ROMSlot0, dfs_, true);
+				}
+				if(target.acorn.has_adfs) {
+					set_rom(ROMSlot4, adfs1_, true);
+					set_rom(ROMSlot5, adfs2_, true);
+				}
+			}
+
+			insert_media(target.media);
+		}
+
+		bool insert_media(const StaticAnalyser::Media &media) override final {
+			if(!media.tapes.empty()) {
+				tape_.set_tape(media.tapes.front());
+			}
+
+			if(!media.disks.empty() && plus3_) {
+				plus3_->set_disk(media.disks.front(), 0);
+			}
+
+			ROMSlot slot = ROMSlot12;
+			for(std::shared_ptr<Storage::Cartridge::Cartridge> cartridge : media.cartridges) {
+				set_rom(slot, cartridge->get_segments().front().data, false);
+				slot = static_cast<ROMSlot>((static_cast<int>(slot) + 1)&15);
+			}
+
+			return !media.tapes.empty() || !media.disks.empty() || !media.cartridges.empty();
+		}
+
+		forceinline Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
+			unsigned int cycles = 1;
+
+			if(address < 0x8000) {
+				if(isReadOperation(operation)) {
+					*value = ram_[address];
+				} else {
+					if(address >= video_access_range_.low_address && address <= video_access_range_.high_address) update_display();
+					ram_[address] = *value;
+				}
+
+				// for the entire frame, RAM is accessible only on odd cycles; in modes below 4
+				// it's also accessible only outside of the pixel regions
+				cycles += video_output_->get_cycles_until_next_ram_availability(cycles_since_display_update_.as_int() + 1);
+			} else {
+				switch(address & 0xff0f) {
+					case 0xfe00:
+						if(isReadOperation(operation)) {
+							*value = interrupt_status_;
+							interrupt_status_ &= ~PowerOnReset;
+						} else {
+							interrupt_control_ = (*value) & ~1;
+							evaluate_interrupts();
+						}
+					break;
+					case 0xfe07:
+						if(!isReadOperation(operation)) {
+							// update speaker mode
+							bool new_speaker_is_enabled = (*value & 6) == 2;
+							if(new_speaker_is_enabled != speaker_is_enabled_) {
+								update_audio();
+								speaker_->set_is_enabled(new_speaker_is_enabled);
+								speaker_is_enabled_ = new_speaker_is_enabled;
+							}
+
+							tape_.set_is_enabled((*value & 6) != 6);
+							tape_.set_is_in_input_mode((*value & 6) == 0);
+							tape_.set_is_running(((*value)&0x40) ? true : false);
+
+							// TODO: caps lock LED
+						}
+
+					// deliberate fallthrough
+					case 0xfe02: case 0xfe03:
+					case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b:
+					case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
+						if(!isReadOperation(operation)) {
+							update_display();
+							video_output_->set_register(address, *value);
+							video_access_range_ = video_output_->get_memory_access_range();
+							queue_next_display_interrupt();
+						}
+					break;
+					case 0xfe04:
+						if(isReadOperation(operation)) {
+							*value = tape_.get_data_register();
+							tape_.clear_interrupts(Interrupt::ReceiveDataFull);
+						} else {
+							tape_.set_data_register(*value);
+							tape_.clear_interrupts(Interrupt::TransmitDataEmpty);
+						}
+					break;
+					case 0xfe05:
+						if(!isReadOperation(operation)) {
+							const uint8_t interruptDisable = (*value)&0xf0;
+							if( interruptDisable ) {
+								if( interruptDisable&0x10 ) interrupt_status_ &= ~Interrupt::DisplayEnd;
+								if( interruptDisable&0x20 ) interrupt_status_ &= ~Interrupt::RealTimeClock;
+								if( interruptDisable&0x40 ) interrupt_status_ &= ~Interrupt::HighToneDetect;
+								evaluate_interrupts();
+
+								// TODO: NMI
+							}
+
+							// latch the paged ROM in case external hardware is being emulated
+							active_rom_ = (Electron::ROMSlot)(*value & 0xf);
+
+							// apply the ULA's test
+							if(*value & 0x08) {
+								if(*value & 0x04) {
+									keyboard_is_active_ = false;
+									basic_is_active_ = false;
+								} else {
+									keyboard_is_active_ = !(*value & 0x02);
+									basic_is_active_ = !keyboard_is_active_;
+								}
+							}
+						}
+					break;
+					case 0xfe06:
+						if(!isReadOperation(operation)) {
+							update_audio();
+							speaker_->set_divider(*value);
+							tape_.set_counter(*value);
+						}
+					break;
+
+					case 0xfc04: case 0xfc05: case 0xfc06: case 0xfc07:
+						if(plus3_ && (address&0x00f0) == 0x00c0) {
+							if(is_holding_shift_ && address == 0xfcc4) {
+								is_holding_shift_ = false;
+								set_key_state(KeyShift, false);
+							}
+							if(isReadOperation(operation))
+								*value = plus3_->get_register(address);
+							else
+								plus3_->set_register(address, *value);
+						}
+					break;
+					case 0xfc00:
+						if(plus3_ && (address&0x00f0) == 0x00c0) {
+							if(!isReadOperation(operation)) {
+								plus3_->set_control_register(*value);
+							} else *value = 1;
+						}
+					break;
+
+					default:
+						if(address >= 0xc000) {
+							if(isReadOperation(operation)) {
+								if(
+									use_fast_tape_hack_ &&
+									tape_.has_tape() &&
+									(operation == CPU::MOS6502::BusOperation::ReadOpcode) &&
+									(
+										(address == 0xf4e5) || (address == 0xf4e6) ||	// double NOPs at 0xf4e5, 0xf6de, 0xf6fa and 0xfa51
+										(address == 0xf6de) || (address == 0xf6df) ||	// act to disable the normal branch into tape-handling
+										(address == 0xf6fa) || (address == 0xf6fb) ||	// code, forcing the OS along the serially-accessed ROM
+										(address == 0xfa51) || (address == 0xfa52) ||	// pathway.
+
+										(address == 0xf0a8)								// 0xf0a8 is from where a service call would normally be
+																						// dispatched; we can check whether it would be call 14
+																						// (i.e. read byte) and, if so, whether the OS was about to
+																						// issue a read byte call to a ROM despite being the tape
+																						// FS being selected. If so then this is a get byte that
+																						// we should service synthetically. Put the byte into Y
+																						// and set A to zero to report that action was taken, then
+																						// allow the PC read to return an RTS.
+									)
+								) {
+									uint8_t service_call = static_cast<uint8_t>(m6502_.get_value_of_register(CPU::MOS6502::Register::X));
+									if(address == 0xf0a8) {
+										if(!ram_[0x247] && service_call == 14) {
+											tape_.set_delegate(nullptr);
+
+											// TODO: handle tape wrap around.
+
+											int cycles_left_while_plausibly_in_data = 50;
+											tape_.clear_interrupts(Interrupt::ReceiveDataFull);
+											while(!tape_.get_tape()->is_at_end()) {
+												tape_.run_for_input_pulse();
+												cycles_left_while_plausibly_in_data--;
+												if(!cycles_left_while_plausibly_in_data) fast_load_is_in_data_ = false;
+												if(	(tape_.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
+													(fast_load_is_in_data_ || tape_.get_data_register() == 0x2a)
+												) break;
+											}
+											tape_.set_delegate(this);
+											tape_.clear_interrupts(Interrupt::ReceiveDataFull);
+											interrupt_status_ |= tape_.get_interrupt_status();
+
+											fast_load_is_in_data_ = true;
+											m6502_.set_value_of_register(CPU::MOS6502::Register::A, 0);
+											m6502_.set_value_of_register(CPU::MOS6502::Register::Y, tape_.get_data_register());
+											*value = 0x60; // 0x60 is RTS
+										}
+										else *value = os_[address & 16383];
+									}
+									else *value = 0xea;
+								} else {
+									*value = os_[address & 16383];
+								}
+							}
+						} else {
+							if(isReadOperation(operation)) {
+								*value = roms_[active_rom_][address & 16383];
+								if(keyboard_is_active_) {
+									*value &= 0xf0;
+									for(int address_line = 0; address_line < 14; address_line++) {
+										if(!(address&(1 << address_line))) *value |= key_states_[address_line];
+									}
+								}
+								if(basic_is_active_) {
+									*value &= roms_[ROMSlotBASIC][address & 16383];
+								}
+							} else if(rom_write_masks_[active_rom_]) {
+								roms_[active_rom_][address & 16383] = *value;
+							}
+						}
+					break;
+				}
+			}
+
+			cycles_since_display_update_ += Cycles(static_cast<int>(cycles));
+			cycles_since_audio_update_ += Cycles(static_cast<int>(cycles));
+			if(cycles_since_audio_update_ > Cycles(16384)) update_audio();
+			tape_.run_for(Cycles(static_cast<int>(cycles)));
+
+			cycles_until_display_interrupt_ -= cycles;
+			if(cycles_until_display_interrupt_ < 0) {
+				signal_interrupt(next_display_interrupt_);
+				update_display();
+				queue_next_display_interrupt();
+			}
+
+			if(typer_) typer_->run_for(Cycles(static_cast<int>(cycles)));
+			if(plus3_) plus3_->run_for(Cycles(4*static_cast<int>(cycles)));
+			if(shift_restart_counter_) {
+				shift_restart_counter_ -= cycles;
+				if(shift_restart_counter_ <= 0) {
+					shift_restart_counter_ = 0;
+					m6502_.set_power_on(true);
+					set_key_state(KeyShift, true);
+					is_holding_shift_ = true;
+				}
+			}
+
+			return Cycles(static_cast<int>(cycles));
+		}
+
+		forceinline void flush() {
+			update_display();
+			update_audio();
+			speaker_->flush();
+		}
+
+		void setup_output(float aspect_ratio) override final {
+			video_output_.reset(new VideoOutput(ram_));
+
+			// The maximum output frequency is 62500Hz and all other permitted output frequencies are integral divisions of that;
+			// however setting the speaker on or off can happen on any 2Mhz cycle, and probably (?) takes effect immediately. So
+			// run the speaker at a 2000000Hz input rate, at least for the time being.
+			speaker_.reset(new Speaker);
+			speaker_->set_input_rate(2000000 / Speaker::clock_rate_divider);
+		}
+
+		void close_output() override final {
+			video_output_.reset();
+		}
+
+		std::shared_ptr<Outputs::CRT::CRT> get_crt() override final {
+			return video_output_->get_crt();
+		}
+
+		std::shared_ptr<Outputs::Speaker> get_speaker() override final {
+			return speaker_;
+		}
+
+		void run_for(const Cycles cycles) override final {
+			m6502_.run_for(cycles);
+		}
+
+		void tape_did_change_interrupt_status(Tape *tape) override final {
+			interrupt_status_ = (interrupt_status_ & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | tape_.get_interrupt_status();
+			evaluate_interrupts();
+		}
+
+		HalfCycles get_typer_delay() override final {
+			return m6502_.get_is_resetting() ? Cycles(625*25*128) : Cycles(0);	// wait one second if resetting
+		}
+
+		HalfCycles get_typer_frequency() override final {
+			return Cycles(625*128*2);	// accept a new character every two frames
+		}
+
+		void set_typer_for_string(const char *string) override final {
+			std::unique_ptr<CharacterMapper> mapper(new CharacterMapper());
+			Utility::TypeRecipient::set_typer_for_string(string, std::move(mapper));
+		}
+
+		KeyboardMapper &get_keyboard_mapper() override {
+			return keyboard_mapper_;
+		}
+
+		// MARK: - Configuration options.
+		std::vector<std::unique_ptr<Configurable::Option>> get_options() override {
+			return Electron::get_options();
+		}
+
+		void set_selections(const Configurable::SelectionSet &selections_by_option) override {
+			bool quickload;
+			if(Configurable::get_quick_load_tape(selections_by_option, quickload)) {
+				set_use_fast_tape_hack(quickload);
+			}
+
+			Configurable::Display display;
+			if(Configurable::get_display(selections_by_option, display)) {
+				get_crt()->set_output_device((display == Configurable::Display::RGB) ? Outputs::CRT::OutputDevice::Monitor : Outputs::CRT::OutputDevice::Television);
+			}
+		}
+
+		Configurable::SelectionSet get_accurate_selections() override {
+			Configurable::SelectionSet selection_set;
+			Configurable::append_quick_load_tape_selection(selection_set, false);
+			Configurable::append_display_selection(selection_set, Configurable::Display::Composite);
+			return selection_set;
+		}
+
+		Configurable::SelectionSet get_user_friendly_selections() override {
+			Configurable::SelectionSet selection_set;
+			Configurable::append_quick_load_tape_selection(selection_set, true);
+			Configurable::append_display_selection(selection_set, Configurable::Display::RGB);
+			return selection_set;
+		}
+
+	private:
+		// MARK: - Work deferral updates.
+		inline void update_display() {
+			if(cycles_since_display_update_ > 0) {
+				video_output_->run_for(cycles_since_display_update_.flush());
+			}
+		}
+
+		inline void queue_next_display_interrupt() {
+			VideoOutput::Interrupt next_interrupt = video_output_->get_next_interrupt();
+			cycles_until_display_interrupt_ = next_interrupt.cycles;
+			next_display_interrupt_ = next_interrupt.interrupt;
+		}
+
+		inline void update_audio() {
+			if(cycles_since_audio_update_ > 0) {
+				speaker_->run_for(cycles_since_audio_update_.divide(Cycles(Speaker::clock_rate_divider)));
+			}
+		}
+
+		inline void signal_interrupt(Interrupt interrupt) {
+			interrupt_status_ |= interrupt;
+			evaluate_interrupts();
+		}
+
+		inline void clear_interrupt(Interrupt interrupt) {
+			interrupt_status_ &= ~interrupt;
+			evaluate_interrupts();
+		}
+
+		inline void evaluate_interrupts() {
+			if(interrupt_status_ & interrupt_control_) {
+				interrupt_status_ |= 1;
+			} else {
+				interrupt_status_ &= ~1;
+			}
+			m6502_.set_irq_line(interrupt_status_ & 1);
+		}
+
+		CPU::MOS6502::Processor<ConcreteMachine, false> m6502_;
+
+		// Things that directly constitute the memory map.
+		uint8_t roms_[16][16384];
+		bool rom_write_masks_[16] = {false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false};
+		uint8_t os_[16384], ram_[32768];
+		std::vector<uint8_t> dfs_, adfs1_, adfs2_;
+
+		// Paging
+		ROMSlot active_rom_ = ROMSlot::ROMSlot0;
+		bool keyboard_is_active_ = false;
+		bool basic_is_active_ = false;
+
+		// Interrupt and keyboard state
+		uint8_t interrupt_status_ = Interrupt::PowerOnReset | Interrupt::TransmitDataEmpty | 0x80;
+		uint8_t interrupt_control_ = 0;
+		uint8_t key_states_[14];
+		Electron::KeyboardMapper keyboard_mapper_;
+
+		// Counters related to simultaneous subsystems
+		Cycles cycles_since_display_update_ = 0;
+		Cycles cycles_since_audio_update_ = 0;
+		int cycles_until_display_interrupt_ = 0;
+		Interrupt next_display_interrupt_ = Interrupt::RealTimeClock;
+		VideoOutput::Range video_access_range_ = {0, 0xffff};
+
+		// Tape
+		Tape tape_;
+		bool use_fast_tape_hack_ = false;
+		bool fast_load_is_in_data_ = false;
+
+		// Disk
+		std::unique_ptr<Plus3> plus3_;
+		bool is_holding_shift_ = false;
+		int shift_restart_counter_ = 0;
+
+		// Outputs
+		std::unique_ptr<VideoOutput> video_output_;
+		std::shared_ptr<Speaker> speaker_;
+		bool speaker_is_enabled_ = false;
+};
+
+}
 
 using namespace Electron;
 
-#pragma mark - Lifecycle
-
-Machine::Machine() :
-		interrupt_control_(0),
-		interrupt_status_(Interrupt::PowerOnReset | Interrupt::TransmitDataEmpty | 0x80),
-		cycles_since_audio_update_(0),
-		use_fast_tape_hack_(false),
-		cycles_until_display_interrupt_(0) {
-	memset(key_states_, 0, sizeof(key_states_));
-	for(int c = 0; c < 16; c++)
-		memset(roms_[c], 0xff, 16384);
-
-	tape_.set_delegate(this);
-	set_clock_rate(2000000);
+Machine *Machine::Electron() {
+	return new Electron::ConcreteMachine;
 }
 
-#pragma mark - Output
-
-void Machine::setup_output(float aspect_ratio) {
-	video_output_.reset(new VideoOutput(ram_));
-
-	// The maximum output frequency is 62500Hz and all other permitted output frequencies are integral divisions of that;
-	// however setting the speaker on or off can happen on any 2Mhz cycle, and probably (?) takes effect immediately. So
-	// run the speaker at a 2000000Hz input rate, at least for the time being.
-	speaker_.reset(new Speaker);
-	speaker_->set_input_rate(2000000 / Speaker::clock_rate_divider);
-}
-
-void Machine::close_output() {
-	video_output_.reset();
-}
-
-std::shared_ptr<Outputs::CRT::CRT> Machine::get_crt() {
-	return video_output_->get_crt();
-}
-
-std::shared_ptr<Outputs::Speaker> Machine::get_speaker() {
-	return speaker_;
-}
-
-#pragma mark - The keyboard
-
-void Machine::clear_all_keys() {
-	memset(key_states_, 0, sizeof(key_states_));
-	if(is_holding_shift_) set_key_state(KeyShift, true);
-}
-
-void Machine::set_key_state(uint16_t key, bool isPressed) {
-	if(key == KeyBreak) {
-		set_reset_line(isPressed);
-	} else {
-		if(isPressed)
-			key_states_[key >> 4] |= key&0xf;
-		else
-			key_states_[key >> 4] &= ~(key&0xf);
-	}
-}
-
-#pragma mark - Machine configuration
-
-void Machine::configure_as_target(const StaticAnalyser::Target &target) {
-	if(target.tapes.size()) {
-		tape_.set_tape(target.tapes.front());
-	}
-
-	if(target.disks.size()) {
-		plus3_.reset(new Plus3);
-
-		if(target.acorn.has_dfs) {
-			set_rom(ROMSlot0, dfs_, true);
-		}
-		if(target.acorn.has_adfs) {
-			set_rom(ROMSlot4, adfs_, true);
-			set_rom(ROMSlot5, std::vector<uint8_t>(adfs_.begin() + 16384, adfs_.end()), true);
-		}
-
-		plus3_->set_disk(target.disks.front(), 0);
-	}
-
-	ROMSlot slot = ROMSlot12;
-	for(std::shared_ptr<Storage::Cartridge::Cartridge> cartridge : target.cartridges) {
-		set_rom(slot, cartridge->get_segments().front().data, false);
-		slot = (ROMSlot)(((int)slot + 1)&15);
-	}
-
-	if(target.loadingCommand.length()) {
-		set_typer_for_string(target.loadingCommand.c_str());
-	}
-
-	if(target.acorn.should_shift_restart) {
-		shift_restart_counter_ = 1000000;
-	}
-}
-
-void Machine::set_typer_for_string(const char *string) {
-	std::unique_ptr<CharacterMapper> mapper(new CharacterMapper());
-	Utility::TypeRecipient::set_typer_for_string(string, std::move(mapper));
-}
-
-void Machine::set_rom(ROMSlot slot, std::vector<uint8_t> data, bool is_writeable) {
-	uint8_t *target = nullptr;
-	switch(slot) {
-		case ROMSlotDFS:	dfs_ = data;			return;
-		case ROMSlotADFS:	adfs_ = data;			return;
-
-		case ROMSlotOS:		target = os_;			break;
-		default:
-			target = roms_[slot];
-			rom_write_masks_[slot] = is_writeable;
-		break;
-	}
-
-	memcpy(target, &data[0], std::min((size_t)16384, data.size()));
-}
-
-#pragma mark - The bus
-
-Cycles Machine::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
-	unsigned int cycles = 1;
-
-	if(address < 0x8000) {
-		if(isReadOperation(operation)) {
-			*value = ram_[address];
-		} else {
-			if(address >= video_access_range_.low_address && address <= video_access_range_.high_address) update_display();
-			ram_[address] = *value;
-		}
-
-		// for the entire frame, RAM is accessible only on odd cycles; in modes below 4
-		// it's also accessible only outside of the pixel regions
-		cycles += video_output_->get_cycles_until_next_ram_availability(cycles_since_display_update_.as_int() + 1);
-	} else {
-		switch(address & 0xff0f) {
-			case 0xfe00:
-				if(isReadOperation(operation)) {
-					*value = interrupt_status_;
-					interrupt_status_ &= ~PowerOnReset;
-				} else {
-					interrupt_control_ = (*value) & ~1;
-					evaluate_interrupts();
-				}
-			break;
-			case 0xfe07:
-				if(!isReadOperation(operation)) {
-					// update speaker mode
-					bool new_speaker_is_enabled = (*value & 6) == 2;
-					if(new_speaker_is_enabled != speaker_is_enabled_) {
-						update_audio();
-						speaker_->set_is_enabled(new_speaker_is_enabled);
-						speaker_is_enabled_ = new_speaker_is_enabled;
-					}
-
-					tape_.set_is_enabled((*value & 6) != 6);
-					tape_.set_is_in_input_mode((*value & 6) == 0);
-					tape_.set_is_running(((*value)&0x40) ? true : false);
-
-					// TODO: caps lock LED
-				}
-
-			// deliberate fallthrough
-			case 0xfe02: case 0xfe03:
-			case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b:
-			case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
-				if(!isReadOperation(operation)) {
-					update_display();
-					video_output_->set_register(address, *value);
-					video_access_range_ = video_output_->get_memory_access_range();
-					queue_next_display_interrupt();
-				}
-			break;
-			case 0xfe04:
-				if(isReadOperation(operation)) {
-					*value = tape_.get_data_register();
-					tape_.clear_interrupts(Interrupt::ReceiveDataFull);
-				} else {
-					tape_.set_data_register(*value);
-					tape_.clear_interrupts(Interrupt::TransmitDataEmpty);
-				}
-			break;
-			case 0xfe05:
-				if(!isReadOperation(operation)) {
-					const uint8_t interruptDisable = (*value)&0xf0;
-					if( interruptDisable ) {
-						if( interruptDisable&0x10 ) interrupt_status_ &= ~Interrupt::DisplayEnd;
-						if( interruptDisable&0x20 ) interrupt_status_ &= ~Interrupt::RealTimeClock;
-						if( interruptDisable&0x40 ) interrupt_status_ &= ~Interrupt::HighToneDetect;
-						evaluate_interrupts();
-
-						// TODO: NMI
-					}
-
-					// latch the paged ROM in case external hardware is being emulated
-					active_rom_ = (Electron::ROMSlot)(*value & 0xf);
-
-					// apply the ULA's test
-					if(*value & 0x08) {
-						if(*value & 0x04) {
-							keyboard_is_active_ = false;
-							basic_is_active_ = false;
-						} else {
-							keyboard_is_active_ = !(*value & 0x02);
-							basic_is_active_ = !keyboard_is_active_;
-						}
-					}
-				}
-			break;
-			case 0xfe06:
-				if(!isReadOperation(operation)) {
-					update_audio();
-					speaker_->set_divider(*value);
-					tape_.set_counter(*value);
-				}
-			break;
-
-			case 0xfc04: case 0xfc05: case 0xfc06: case 0xfc07:
-				if(plus3_ && (address&0x00f0) == 0x00c0) {
-					if(is_holding_shift_ && address == 0xfcc4) {
-						is_holding_shift_ = false;
-						set_key_state(KeyShift, false);
-					}
-					if(isReadOperation(operation))
-						*value = plus3_->get_register(address);
-					else
-						plus3_->set_register(address, *value);
-				}
-			break;
-			case 0xfc00:
-				if(plus3_ && (address&0x00f0) == 0x00c0) {
-					if(!isReadOperation(operation)) {
-						plus3_->set_control_register(*value);
-					} else *value = 1;
-				}
-			break;
-
-			default:
-				if(address >= 0xc000) {
-					if(isReadOperation(operation)) {
-						if(
-							use_fast_tape_hack_ &&
-							tape_.has_tape() &&
-							(operation == CPU::MOS6502::BusOperation::ReadOpcode) &&
-							(
-								(address == 0xf4e5) || (address == 0xf4e6) ||	// double NOPs at 0xf4e5, 0xf6de, 0xf6fa and 0xfa51
-								(address == 0xf6de) || (address == 0xf6df) ||	// act to disable the normal branch into tape-handling
-								(address == 0xf6fa) || (address == 0xf6fb) ||	// code, forcing the OS along the serially-accessed ROM
-								(address == 0xfa51) || (address == 0xfa52) ||	// pathway.
-
-								(address == 0xf0a8)								// 0xf0a8 is from where a service call would normally be
-																				// dispatched; we can check whether it would be call 14
-																				// (i.e. read byte) and, if so, whether the OS was about to
-																				// issue a read byte call to a ROM despite being the tape
-																				// FS being selected. If so then this is a get byte that
-																				// we should service synthetically. Put the byte into Y
-																				// and set A to zero to report that action was taken, then
-																				// allow the PC read to return an RTS.
-							)
-						) {
-							uint8_t service_call = (uint8_t)get_value_of_register(CPU::MOS6502::Register::X);
-							if(address == 0xf0a8) {
-								if(!ram_[0x247] && service_call == 14) {
-									tape_.set_delegate(nullptr);
-
-									// TODO: handle tape wrap around.
-
-									int cycles_left_while_plausibly_in_data = 50;
-									tape_.clear_interrupts(Interrupt::ReceiveDataFull);
-									while(!tape_.get_tape()->is_at_end()) {
-										tape_.run_for_input_pulse();
-										cycles_left_while_plausibly_in_data--;
-										if(!cycles_left_while_plausibly_in_data) fast_load_is_in_data_ = false;
-										if(	(tape_.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
-											(fast_load_is_in_data_ || tape_.get_data_register() == 0x2a)
-										) break;
-									}
-									tape_.set_delegate(this);
-									tape_.clear_interrupts(Interrupt::ReceiveDataFull);
-									interrupt_status_ |= tape_.get_interrupt_status();
-
-									fast_load_is_in_data_ = true;
-									set_value_of_register(CPU::MOS6502::Register::A, 0);
-									set_value_of_register(CPU::MOS6502::Register::Y, tape_.get_data_register());
-									*value = 0x60; // 0x60 is RTS
-								}
-								else *value = os_[address & 16383];
-							}
-							else *value = 0xea;
-						} else {
-							*value = os_[address & 16383];
-						}
-					}
-				} else {
-					if(isReadOperation(operation)) {
-						*value = roms_[active_rom_][address & 16383];
-						if(keyboard_is_active_) {
-							*value &= 0xf0;
-							for(int address_line = 0; address_line < 14; address_line++) {
-								if(!(address&(1 << address_line))) *value |= key_states_[address_line];
-							}
-						}
-						if(basic_is_active_) {
-							*value &= roms_[ROMSlotBASIC][address & 16383];
-						}
-					} else if(rom_write_masks_[active_rom_]) {
-						roms_[active_rom_][address & 16383] = *value;
-					}
-				}
-			break;
-		}
-	}
-
-	cycles_since_display_update_ += Cycles((int)cycles);
-	cycles_since_audio_update_ += Cycles((int)cycles);
-	if(cycles_since_audio_update_ > Cycles(16384)) update_audio();
-	tape_.run_for(Cycles((int)cycles));
-
-	cycles_until_display_interrupt_ -= cycles;
-	if(cycles_until_display_interrupt_ < 0) {
-		signal_interrupt(next_display_interrupt_);
-		update_display();
-		queue_next_display_interrupt();
-	}
-
-	if(typer_) typer_->run_for(Cycles((int)cycles));
-	if(plus3_) plus3_->run_for(Cycles(4*(int)cycles));
-	if(shift_restart_counter_) {
-		shift_restart_counter_ -= cycles;
-		if(shift_restart_counter_ <= 0) {
-			shift_restart_counter_ = 0;
-			set_power_on(true);
-			set_key_state(KeyShift, true);
-			is_holding_shift_ = true;
-		}
-	}
-
-	return Cycles((int)cycles);
-}
-
-void Machine::flush() {
-	update_display();
-	update_audio();
-	speaker_->flush();
-}
-
-#pragma mark - Deferred scheduling
-
-inline void Machine::update_display() {
-	if(cycles_since_display_update_ > 0) {
-		video_output_->run_for(cycles_since_display_update_.flush());
-	}
-}
-
-inline void Machine::queue_next_display_interrupt() {
-	VideoOutput::Interrupt next_interrupt = video_output_->get_next_interrupt();
-	cycles_until_display_interrupt_ = next_interrupt.cycles;
-	next_display_interrupt_ = next_interrupt.interrupt;
-}
-
-inline void Machine::update_audio() {
-	if(cycles_since_audio_update_ > 0) {
-		speaker_->run_for(cycles_since_audio_update_.divide(Cycles(Speaker::clock_rate_divider)));
-	}
-}
-
-#pragma mark - Interrupts
-
-inline void Machine::signal_interrupt(Electron::Interrupt interrupt) {
-	interrupt_status_ |= interrupt;
-	evaluate_interrupts();
-}
-
-inline void Machine::clear_interrupt(Electron::Interrupt interrupt) {
-	interrupt_status_ &= ~interrupt;
-	evaluate_interrupts();
-}
-
-inline void Machine::evaluate_interrupts() {
-	if(interrupt_status_ & interrupt_control_) {
-		interrupt_status_ |= 1;
-	} else {
-		interrupt_status_ &= ~1;
-	}
-	set_irq_line(interrupt_status_ & 1);
-}
-
-#pragma mark - Tape::Delegate
-
-void Machine::tape_did_change_interrupt_status(Tape *tape) {
-	interrupt_status_ = (interrupt_status_ & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | tape_.get_interrupt_status();
-	evaluate_interrupts();
-}
-
-#pragma mark - Typer timing
-
-HalfCycles Electron::Machine::get_typer_delay() {
-	return get_is_resetting() ? Cycles(625*25*128) : Cycles(0);	// wait one second if resetting
-}
-
-HalfCycles Electron::Machine::get_typer_frequency() {
-	return Cycles(625*128*2);	// accept a new character every two frames
-}
+Machine::~Machine() {}

Machines/Electron/Electron.hpp

@@ -9,19 +9,10 @@
 #ifndef Electron_hpp
 #define Electron_hpp
 
-#include "../../Processors/6502/6502.hpp"
-#include "../../Storage/Tape/Tape.hpp"
-#include "../../ClockReceiver/ClockReceiver.hpp"
-
+#include "../../Configurable/Configurable.hpp"
 #include "../ConfigurationTarget.hpp"
 #include "../CRTMachine.hpp"
-#include "../Typer.hpp"
-
-#include "Interrupts.hpp"
-#include "Plus3.hpp"
-#include "Speaker.hpp"
-#include "Tape.hpp"
-#include "Video.hpp"
+#include "../KeyboardMachine.hpp"
 
 #include <cstdint>
 #include <vector>
@@ -38,117 +29,38 @@ enum ROMSlot: uint8_t {
 
 	ROMSlot12,	ROMSlot13,	ROMSlot14,	ROMSlot15,
 
-	ROMSlotOS,	ROMSlotDFS,	ROMSlotADFS
+	ROMSlotOS,		ROMSlotDFS,
+	ROMSlotADFS1,	ROMSlotADFS2
 };
 
-enum Key: uint16_t {
-	KeySpace		= 0x0000 | 0x08,										KeyCopy			= 0x0000 | 0x02,	KeyRight		= 0x0000 | 0x01,
-	KeyDelete		= 0x0010 | 0x08,	KeyReturn		= 0x0010 | 0x04,	KeyDown			= 0x0010 | 0x02,	KeyLeft			= 0x0010 | 0x01,
-										KeyColon		= 0x0020 | 0x04,	KeyUp			= 0x0020 | 0x02,	KeyMinus		= 0x0020 | 0x01,
-	KeySlash		= 0x0030 | 0x08,	KeySemiColon	= 0x0030 | 0x04,	KeyP			= 0x0030 | 0x02,	Key0			= 0x0030 | 0x01,
-	KeyFullStop		= 0x0040 | 0x08,	KeyL			= 0x0040 | 0x04,	KeyO			= 0x0040 | 0x02,	Key9			= 0x0040 | 0x01,
-	KeyComma		= 0x0050 | 0x08,	KeyK			= 0x0050 | 0x04,	KeyI			= 0x0050 | 0x02,	Key8			= 0x0050 | 0x01,
-	KeyM			= 0x0060 | 0x08,	KeyJ			= 0x0060 | 0x04,	KeyU			= 0x0060 | 0x02,	Key7			= 0x0060 | 0x01,
-	KeyN			= 0x0070 | 0x08,	KeyH			= 0x0070 | 0x04,	KeyY			= 0x0070 | 0x02,	Key6			= 0x0070 | 0x01,
-	KeyB			= 0x0080 | 0x08,	KeyG			= 0x0080 | 0x04,	KeyT			= 0x0080 | 0x02,	Key5			= 0x0080 | 0x01,
-	KeyV			= 0x0090 | 0x08,	KeyF			= 0x0090 | 0x04,	KeyR			= 0x0090 | 0x02,	Key4			= 0x0090 | 0x01,
-	KeyC			= 0x00a0 | 0x08,	KeyD			= 0x00a0 | 0x04,	KeyE			= 0x00a0 | 0x02,	Key3			= 0x00a0 | 0x01,
-	KeyX			= 0x00b0 | 0x08,	KeyS			= 0x00b0 | 0x04,	KeyW			= 0x00b0 | 0x02,	Key2			= 0x00b0 | 0x01,
-	KeyZ			= 0x00c0 | 0x08,	KeyA			= 0x00c0 | 0x04,	KeyQ			= 0x00c0 | 0x02,	Key1			= 0x00c0 | 0x01,
-	KeyShift		= 0x00d0 | 0x08,	KeyControl		= 0x00d0 | 0x04,	KeyFunc			= 0x00d0 | 0x02,	KeyEscape		= 0x00d0 | 0x01,
-
-	KeyBreak		= 0xfffd,
-};
+/// @returns The options available for an Electron.
+std::vector<std::unique_ptr<Configurable::Option>> get_options();
 
 /*!
 	@abstract Represents an Acorn Electron.
-	
+
 	@discussion An instance of Electron::Machine represents the current state of an
 	Acorn Electron.
 */
 class Machine:
-	public CPU::MOS6502::Processor<Machine>,
 	public CRTMachine::Machine,
-	public Tape::Delegate,
-	public Utility::TypeRecipient,
-	public ConfigurationTarget::Machine {
-
+	public ConfigurationTarget::Machine,
+	public KeyboardMachine::Machine,
+	public Configurable::Device {
 	public:
-		Machine();
+		virtual ~Machine();
 
-		void set_rom(ROMSlot slot, std::vector<uint8_t> data, bool is_writeable);
+		/// Creates and returns an Electron.
+		static Machine *Electron();
 
-		void set_key_state(uint16_t key, bool isPressed);
-		void clear_all_keys();
+		/*!
+			Sets the contents of @c slot to @c data. If @c is_writeable is @c true then writing to the slot
+			is enabled — it acts as if it were sideways RAM. Otherwise the slot is modelled as containing ROM.
+		*/
+		virtual void set_rom(ROMSlot slot, const std::vector<uint8_t> &data, bool is_writeable) = 0;
 
-		inline void set_use_fast_tape_hack(bool activate) { use_fast_tape_hack_ = activate; }
-
-		// to satisfy ConfigurationTarget::Machine
-		void configure_as_target(const StaticAnalyser::Target &target);
-
-		// to satisfy CPU::MOS6502::Processor
-		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value);
-		void flush();
-
-		// to satisfy CRTMachine::Machine
-		virtual void setup_output(float aspect_ratio);
-		virtual void close_output();
-		virtual std::shared_ptr<Outputs::CRT::CRT> get_crt();
-		virtual std::shared_ptr<Outputs::Speaker> get_speaker();
-		virtual void run_for(const Cycles cycles) { CPU::MOS6502::Processor<Machine>::run_for(cycles); }
-
-		// to satisfy Tape::Delegate
-		virtual void tape_did_change_interrupt_status(Tape *tape);
-
-		// for Utility::TypeRecipient
-		virtual HalfCycles get_typer_delay();
-		virtual HalfCycles get_typer_frequency();
-		virtual void set_typer_for_string(const char *string);
-
-	private:
-		inline void update_display();
-		inline void queue_next_display_interrupt();
-		inline void update_audio();
-
-		inline void signal_interrupt(Interrupt interrupt);
-		inline void clear_interrupt(Interrupt interrupt);
-		inline void evaluate_interrupts();
-
-		// Things that directly constitute the memory map.
-		uint8_t roms_[16][16384];
-		bool rom_write_masks_[16];
-		uint8_t os_[16384], ram_[32768];
-		std::vector<uint8_t> dfs_, adfs_;
-
-		// Paging
-		ROMSlot active_rom_;
-		bool keyboard_is_active_, basic_is_active_;
-
-		// Interrupt and keyboard state
-		uint8_t interrupt_status_, interrupt_control_;
-		uint8_t key_states_[14];
-
-		// Counters related to simultaneous subsystems
-		Cycles cycles_since_display_update_;
-		Cycles cycles_since_audio_update_;
-		int cycles_until_display_interrupt_;
-		Interrupt next_display_interrupt_;
-		VideoOutput::Range video_access_range_;
-
-		// Tape
-		Tape tape_;
-		bool use_fast_tape_hack_;
-		bool fast_load_is_in_data_;
-
-		// Disk
-		std::unique_ptr<Plus3> plus3_;
-		bool is_holding_shift_;
-		int shift_restart_counter_;
-
-		// Outputs
-		std::unique_ptr<VideoOutput> video_output_;
-		std::shared_ptr<Speaker> speaker_;
-		bool speaker_is_enabled_;
+		/// Enables or disables turbo-speed tape loading.
+		virtual void set_use_fast_tape_hack(bool activate) = 0;
 };
 
 }

Machines/Electron/Keyboard.cpp

@@ -1,21 +1,65 @@
 //
-//  CharacterMapper.cpp
+//  Keyboard.cpp
 //  Clock Signal
 //
-//  Created by Thomas Harte on 03/08/2017.
+//  Created by Thomas Harte on 10/10/2017.
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#include "CharacterMapper.hpp"
-#include "Electron.hpp"
+#include "Keyboard.hpp"
 
 using namespace Electron;
 
+uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) {
+#define BIND(source, dest)	case Inputs::Keyboard::Key::source:	return Electron::Key::dest
+	switch(key) {
+		default: return KeyCopy;
+
+		BIND(k0, Key0);		BIND(k1, Key1);		BIND(k2, Key2);		BIND(k3, Key3);		BIND(k4, Key4);
+		BIND(k5, Key5);		BIND(k6, Key6);		BIND(k7, Key7);		BIND(k8, Key8);		BIND(k9, Key9);
+		BIND(Q, KeyQ);		BIND(W, KeyW);		BIND(E, KeyE);		BIND(R, KeyR);		BIND(T, KeyT);
+		BIND(Y, KeyY);		BIND(U, KeyU);		BIND(I, KeyI);		BIND(O, KeyO);		BIND(P, KeyP);
+		BIND(A, KeyA);		BIND(S, KeyS);		BIND(D, KeyD);		BIND(F, KeyF);		BIND(G, KeyG);
+		BIND(H, KeyH);		BIND(J, KeyJ);		BIND(K, KeyK);		BIND(L, KeyL);
+		BIND(Z, KeyZ);		BIND(X, KeyX);		BIND(C, KeyC);		BIND(V, KeyV);
+		BIND(B, KeyB);		BIND(N, KeyN);		BIND(M, KeyM);
+
+		BIND(Comma, KeyComma);
+		BIND(FullStop, KeyFullStop);
+		BIND(ForwardSlash, KeySlash);
+		BIND(Semicolon, KeySemiColon);
+		BIND(Quote, KeyColon);
+
+		BIND(Escape, KeyEscape);
+		BIND(Equals, KeyBreak);
+		BIND(F12, KeyBreak);
+
+		BIND(Left, KeyLeft);	BIND(Right, KeyRight);		BIND(Up, KeyUp);		BIND(Down, KeyDown);
+
+		BIND(Tab, KeyFunc);				BIND(LeftOption, KeyFunc);		BIND(RightOption, KeyFunc);
+		BIND(LeftMeta, KeyFunc);		BIND(RightMeta, KeyFunc);
+		BIND(CapsLock, KeyControl);		BIND(LeftControl, KeyControl);	BIND(RightControl, KeyControl);
+		BIND(LeftShift, KeyShift);		BIND(RightShift, KeyShift);
+
+		BIND(Hyphen, KeyMinus);
+		BIND(Delete, KeyDelete);		BIND(BackSpace, KeyDelete);
+		BIND(Enter, KeyReturn);			BIND(KeyPadEnter, KeyReturn);
+
+		BIND(KeyPad0, Key0);		BIND(KeyPad1, Key1);		BIND(KeyPad2, Key2);		BIND(KeyPad3, Key3);		BIND(KeyPad4, Key4);
+		BIND(KeyPad5, Key5);		BIND(KeyPad6, Key6);		BIND(KeyPad7, Key7);		BIND(KeyPad8, Key8);		BIND(KeyPad9, Key9);
+
+		BIND(KeyPadMinus, KeyMinus);			BIND(KeyPadPlus, KeyColon);
+
+		BIND(Space, KeySpace);
+	}
+#undef BIND
+}
+
 uint16_t *CharacterMapper::sequence_for_character(char character) {
-#define KEYS(...)	{__VA_ARGS__, EndSequence}
-#define SHIFT(...)	{KeyShift, __VA_ARGS__, EndSequence}
-#define CTRL(...)	{KeyControl, __VA_ARGS__, EndSequence}
-#define X			{NotMapped}
+#define KEYS(...)	{__VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define SHIFT(...)	{KeyShift, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define CTRL(...)	{KeyControl, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define X			{KeyboardMachine::Machine::KeyNotMapped}
 	static KeySequence key_sequences[] = {
 		/* NUL */	X,							/* SOH */	X,
 		/* STX */	X,							/* ETX */	X,

Machines/Electron/Keyboard.hpp

@@ -0,0 +1,46 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_Electron_Keyboard_hpp
+#define Machines_Electron_Keyboard_hpp
+
+#include "../KeyboardMachine.hpp"
+#include "../Utility/Typer.hpp"
+
+namespace Electron {
+
+enum Key: uint16_t {
+	KeySpace		= 0x0000 | 0x08,										KeyCopy			= 0x0000 | 0x02,	KeyRight		= 0x0000 | 0x01,
+	KeyDelete		= 0x0010 | 0x08,	KeyReturn		= 0x0010 | 0x04,	KeyDown			= 0x0010 | 0x02,	KeyLeft			= 0x0010 | 0x01,
+										KeyColon		= 0x0020 | 0x04,	KeyUp			= 0x0020 | 0x02,	KeyMinus		= 0x0020 | 0x01,
+	KeySlash		= 0x0030 | 0x08,	KeySemiColon	= 0x0030 | 0x04,	KeyP			= 0x0030 | 0x02,	Key0			= 0x0030 | 0x01,
+	KeyFullStop		= 0x0040 | 0x08,	KeyL			= 0x0040 | 0x04,	KeyO			= 0x0040 | 0x02,	Key9			= 0x0040 | 0x01,
+	KeyComma		= 0x0050 | 0x08,	KeyK			= 0x0050 | 0x04,	KeyI			= 0x0050 | 0x02,	Key8			= 0x0050 | 0x01,
+	KeyM			= 0x0060 | 0x08,	KeyJ			= 0x0060 | 0x04,	KeyU			= 0x0060 | 0x02,	Key7			= 0x0060 | 0x01,
+	KeyN			= 0x0070 | 0x08,	KeyH			= 0x0070 | 0x04,	KeyY			= 0x0070 | 0x02,	Key6			= 0x0070 | 0x01,
+	KeyB			= 0x0080 | 0x08,	KeyG			= 0x0080 | 0x04,	KeyT			= 0x0080 | 0x02,	Key5			= 0x0080 | 0x01,
+	KeyV			= 0x0090 | 0x08,	KeyF			= 0x0090 | 0x04,	KeyR			= 0x0090 | 0x02,	Key4			= 0x0090 | 0x01,
+	KeyC			= 0x00a0 | 0x08,	KeyD			= 0x00a0 | 0x04,	KeyE			= 0x00a0 | 0x02,	Key3			= 0x00a0 | 0x01,
+	KeyX			= 0x00b0 | 0x08,	KeyS			= 0x00b0 | 0x04,	KeyW			= 0x00b0 | 0x02,	Key2			= 0x00b0 | 0x01,
+	KeyZ			= 0x00c0 | 0x08,	KeyA			= 0x00c0 | 0x04,	KeyQ			= 0x00c0 | 0x02,	Key1			= 0x00c0 | 0x01,
+	KeyShift		= 0x00d0 | 0x08,	KeyControl		= 0x00d0 | 0x04,	KeyFunc			= 0x00d0 | 0x02,	KeyEscape		= 0x00d0 | 0x01,
+
+	KeyBreak		= 0xfffd,
+};
+
+struct KeyboardMapper: public KeyboardMachine::Machine::KeyboardMapper {
+	uint16_t mapped_key_for_key(Inputs::Keyboard::Key key);
+};
+
+struct CharacterMapper: public ::Utility::CharacterMapper {
+	uint16_t *sequence_for_character(char character);
+};
+
+};
+
+#endif /* KeyboardMapper_hpp */

Machines/Electron/Plus3.cpp

@@ -10,13 +10,13 @@
 
 using namespace Electron;
 
-Plus3::Plus3() : WD1770(P1770), last_control_(0) {
+Plus3::Plus3() : WD1770(P1770) {
 	set_control_register(last_control_, 0xff);
 }
 
 void Plus3::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
 	if(!drives_[drive]) {
-		drives_[drive].reset(new Storage::Disk::Drive);
+		drives_[drive].reset(new Storage::Disk::Drive(8000000, 300, 2));
 		if(drive == selected_drive_) set_drive(drives_[drive]);
 	}
 	drives_[drive]->set_disk(disk);
@@ -42,9 +42,14 @@ void Plus3::set_control_register(uint8_t control, uint8_t changes) {
 		}
 	}
 	if(changes & 0x04) {
-		invalidate_track();
 		if(drives_[0]) drives_[0]->set_head((control & 0x04) ? 1 : 0);
 		if(drives_[1]) drives_[1]->set_head((control & 0x04) ? 1 : 0);
 	}
 	if(changes & 0x08) set_is_double_density(!(control & 0x08));
 }
+
+void Plus3::set_motor_on(bool on) {
+	// TODO: this status should transfer if the selected drive changes. But the same goes for
+	// writing state, so plenty of work to do in general here.
+	get_drive().set_motor_on(on);
+}

Machines/Electron/Plus3.hpp

@@ -23,8 +23,10 @@ class Plus3 : public WD::WD1770 {
 	private:
 		void set_control_register(uint8_t control, uint8_t changes);
 		std::shared_ptr<Storage::Disk::Drive> drives_[2];
-		int selected_drive_;
-		uint8_t last_control_;
+		int selected_drive_ = 0;
+		uint8_t last_control_ = 0;
+
+		void set_motor_on(bool on);
 };
 
 }

Machines/Electron/Speaker.cpp

@@ -13,7 +13,7 @@ using namespace Electron;
 void Speaker::get_samples(unsigned int number_of_samples, int16_t *target) {
 	if(is_enabled_) {
 		while(number_of_samples--) {
-			*target = (int16_t)((counter_ / (divider_+1)) * 8192);
+			*target = static_cast<int16_t>((counter_ / (divider_+1)) * 8192);
 			target++;
 			counter_ = (counter_ + 1) % ((divider_+1) * 2);
 		}

Machines/Electron/Speaker.hpp

@@ -25,9 +25,9 @@ class Speaker: public ::Outputs::Filter<Speaker> {
 		static const unsigned int clock_rate_divider = 8;
 
 	private:
-		unsigned int counter_;
-		unsigned int divider_;
-		bool is_enabled_;
+		unsigned int counter_ = 0;
+		unsigned int divider_ = 0;
+		bool is_enabled_ = false;
 };
 
 }

Machines/Electron/Tape.cpp

@@ -10,19 +10,12 @@
 
 using namespace Electron;
 
-Tape::Tape() :
-		TapePlayer(2000000),
-		is_running_(false),
-		data_register_(0),
-		delegate_(nullptr),
-		output_({.bits_remaining_until_empty = 0, .cycles_into_pulse = 0}),
-		last_posted_interrupt_status_(0),
-		interrupt_status_(0) {
+Tape::Tape() : TapePlayer(2000000) {
 	shifter_.set_delegate(this);
 }
 
 void Tape::push_tape_bit(uint16_t bit) {
-	data_register_ = (uint16_t)((data_register_ >> 1) | (bit << 10));
+	data_register_ = static_cast<uint16_t>((data_register_ >> 1) | (bit << 10));
 
 	if(input_.minimum_bits_until_full) input_.minimum_bits_until_full--;
 	if(input_.minimum_bits_until_full == 8) interrupt_status_ &= ~Interrupt::ReceiveDataFull;
@@ -64,12 +57,12 @@ void Tape::set_counter(uint8_t value) {
 }
 
 void Tape::set_data_register(uint8_t value) {
-	data_register_ = (uint16_t)((value << 2) | 1);
+	data_register_ = static_cast<uint16_t>((value << 2) | 1);
 	output_.bits_remaining_until_empty = 9;
 }
 
 uint8_t Tape::get_data_register() {
-	return (uint8_t)(data_register_ >> 2);
+	return static_cast<uint8_t>(data_register_ >> 2);
 }
 
 void Tape::process_input_pulse(const Storage::Tape::Tape::Pulse &pulse) {
@@ -77,7 +70,7 @@ void Tape::process_input_pulse(const Storage::Tape::Tape::Pulse &pulse) {
 }
 
 void Tape::acorn_shifter_output_bit(int value) {
-	push_tape_bit((uint16_t)value);
+	push_tape_bit(static_cast<uint16_t>(value));
 }
 
 void Tape::run_for(const Cycles cycles) {
@@ -87,7 +80,7 @@ void Tape::run_for(const Cycles cycles) {
 				TapePlayer::run_for(cycles);
 			}
 		} else {
-			output_.cycles_into_pulse += (unsigned int)cycles.as_int();
+			output_.cycles_into_pulse += static_cast<unsigned int>(cycles.as_int());
 			while(output_.cycles_into_pulse > 1664) {	// 1664 = the closest you can get to 1200 baud if you're looking for something
 				output_.cycles_into_pulse -= 1664;		// that divides the 125,000Hz clock that the sound divider runs off.
 				push_tape_bit(1);

Machines/Electron/Tape.hpp

@@ -52,22 +52,23 @@ class Tape:
 		inline void get_next_tape_pulse();
 
 		struct {
-			int minimum_bits_until_full;
+			int minimum_bits_until_full = 0;
 		} input_;
 		struct {
-			unsigned int cycles_into_pulse;
-			unsigned int bits_remaining_until_empty;
+			unsigned int cycles_into_pulse = 0;
+			unsigned int bits_remaining_until_empty = 0;
 		} output_;
 
-		bool is_running_;
-		bool is_enabled_;
-		bool is_in_input_mode_;
+		bool is_running_ = false;
+		bool is_enabled_ = false;
+		bool is_in_input_mode_ = false;
 
 		inline void evaluate_interrupts();
-		uint16_t data_register_;
+		uint16_t data_register_ = 0;
 
-		uint8_t interrupt_status_, last_posted_interrupt_status_;
-		Delegate *delegate_;
+		uint8_t interrupt_status_ = 0;
+		uint8_t last_posted_interrupt_status_ = 0;
+		Delegate *delegate_ = nullptr;
 
 		::Storage::Tape::Acorn::Shifter shifter_;
 };

Machines/Electron/Video.cpp

@@ -8,6 +8,8 @@
 
 #include "Video.hpp"
 
+#include <cstring>
+
 using namespace Electron;
 
 #define graphics_line(v)	((((v) >> 7) - first_graphics_line + field_divider_line) % field_divider_line)
@@ -32,17 +34,18 @@ namespace {
 	static const int real_time_clock_interrupt_2 = 56704;
 	static const int display_end_interrupt_1 = (first_graphics_line + display_end_interrupt_line)*cycles_per_line;
 	static const int display_end_interrupt_2 = (first_graphics_line + field_divider_line + display_end_interrupt_line)*cycles_per_line;
+
+	struct FourBPPBookender: public Outputs::CRT::TextureBuilder::Bookender {
+		void add_bookends(uint8_t *const left_value, uint8_t *const right_value, uint8_t *left_bookend, uint8_t *right_bookend) {
+			*left_bookend = static_cast<uint8_t>(((*left_value) & 0x0f) | (((*left_value) & 0x0f) << 4));
+			*right_bookend = static_cast<uint8_t>(((*right_value) & 0xf0) | (((*right_value) & 0xf0) >> 4));
+		}
+	};
 }
 
-#pragma mark - Lifecycle
+// MARK: - Lifecycle
 
-VideoOutput::VideoOutput(uint8_t *memory) :
-		ram_(memory),
-		current_pixel_line_(-1),
-		output_position_(0),
-		screen_mode_(6),
-		screen_map_pointer_(0),
-		cycles_into_draw_action_(0) {
+VideoOutput::VideoOutput(uint8_t *memory) : ram_(memory) {
 	memset(palette_, 0xf, sizeof(palette_));
 	setup_screen_map();
 	setup_base_address();
@@ -55,17 +58,19 @@ VideoOutput::VideoOutput(uint8_t *memory) :
 			"texValue >>= 4 - (int(icoordinate.x * 8) & 4);"
 			"return vec3( uvec3(texValue) & uvec3(4u, 2u, 1u));"
 		"}");
+	std::unique_ptr<Outputs::CRT::TextureBuilder::Bookender> bookender(new FourBPPBookender);
+	crt_->set_bookender(std::move(bookender));
 	// TODO: as implied below, I've introduced a clock's latency into the graphics pipeline somehow. Investigate.
 	crt_->set_visible_area(crt_->get_rect_for_area(first_graphics_line - 3, 256, (first_graphics_cycle+1) * crt_cycles_multiplier, 80 * crt_cycles_multiplier, 4.0f / 3.0f));
 }
 
-#pragma mark - CRT getter
+// MARK: - CRT getter
 
 std::shared_ptr<Outputs::CRT::CRT> VideoOutput::get_crt() {
 	return crt_;
 }
 
-#pragma mark - Display update methods
+// MARK: - Display update methods
 
 void VideoOutput::start_pixel_line() {
 	current_pixel_line_ = (current_pixel_line_+1)&255;
@@ -92,7 +97,7 @@ void VideoOutput::start_pixel_line() {
 }
 
 void VideoOutput::end_pixel_line() {
-	if(current_output_target_) crt_->output_data((unsigned int)((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
+	if(current_output_target_) crt_->output_data(static_cast<unsigned int>((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
 	current_character_row_++;
 }
 
@@ -110,9 +115,9 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 		}
 
 		if(!initial_output_target_ || divider != current_output_divider_) {
-			if(current_output_target_) crt_->output_data((unsigned int)((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
+			if(current_output_target_) crt_->output_data(static_cast<unsigned int>((current_output_target_ - initial_output_target_) * current_output_divider_), current_output_divider_);
 			current_output_divider_ = divider;
-			initial_output_target_ = current_output_target_ = crt_->allocate_write_area(640 / current_output_divider_);
+			initial_output_target_ = current_output_target_ = crt_->allocate_write_area(640 / current_output_divider_, 4);
 		}
 
 #define get_pixel()	\
@@ -127,7 +132,7 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 				if(initial_output_target_) {
 					while(number_of_cycles--) {
 						get_pixel();
-						*(uint32_t *)current_output_target_ = palette_tables_.eighty1bpp[last_pixel_byte_];
+						*reinterpret_cast<uint32_t *>(current_output_target_) = palette_tables_.eighty1bpp[last_pixel_byte_];
 						current_output_target_ += 4;
 						current_pixel_column_++;
 					}
@@ -138,7 +143,7 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 				if(initial_output_target_) {
 					while(number_of_cycles--) {
 						get_pixel();
-						*(uint16_t *)current_output_target_ = palette_tables_.eighty2bpp[last_pixel_byte_];
+						*reinterpret_cast<uint16_t *>(current_output_target_) = palette_tables_.eighty2bpp[last_pixel_byte_];
 						current_output_target_ += 2;
 						current_pixel_column_++;
 					}
@@ -160,7 +165,7 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 				if(initial_output_target_) {
 					if(current_pixel_column_&1) {
 						last_pixel_byte_ <<= 4;
-						*(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
+						*reinterpret_cast<uint16_t *>(current_output_target_) = palette_tables_.forty1bpp[last_pixel_byte_];
 						current_output_target_ += 2;
 
 						number_of_cycles--;
@@ -168,11 +173,11 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 					}
 					while(number_of_cycles > 1) {
 						get_pixel();
-						*(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
+						*reinterpret_cast<uint16_t *>(current_output_target_) = palette_tables_.forty1bpp[last_pixel_byte_];
 						current_output_target_ += 2;
 
 						last_pixel_byte_ <<= 4;
-						*(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
+						*reinterpret_cast<uint16_t *>(current_output_target_) = palette_tables_.forty1bpp[last_pixel_byte_];
 						current_output_target_ += 2;
 
 						number_of_cycles -= 2;
@@ -180,7 +185,7 @@ void VideoOutput::output_pixels(unsigned int number_of_cycles) {
 					}
 					if(number_of_cycles) {
 						get_pixel();
-						*(uint16_t *)current_output_target_ = palette_tables_.forty1bpp[last_pixel_byte_];
+						*reinterpret_cast<uint16_t *>(current_output_target_) = palette_tables_.forty1bpp[last_pixel_byte_];
 						current_output_target_ += 2;
 						current_pixel_column_++;
 					}
@@ -229,16 +234,16 @@ void VideoOutput::run_for(const Cycles cycles) {
 	while(number_of_cycles) {
 		int draw_action_length = screen_map_[screen_map_pointer_].length;
 		int time_left_in_action = std::min(number_of_cycles, draw_action_length - cycles_into_draw_action_);
-		if(screen_map_[screen_map_pointer_].type == DrawAction::Pixels) output_pixels((unsigned int)time_left_in_action);
+		if(screen_map_[screen_map_pointer_].type == DrawAction::Pixels) output_pixels(static_cast<unsigned int>(time_left_in_action));
 
 		number_of_cycles -= time_left_in_action;
 		cycles_into_draw_action_ += time_left_in_action;
 		if(cycles_into_draw_action_ == draw_action_length) {
 			switch(screen_map_[screen_map_pointer_].type) {
-				case DrawAction::Sync:			crt_->output_sync((unsigned int)(draw_action_length * crt_cycles_multiplier));					break;
-				case DrawAction::ColourBurst:	crt_->output_default_colour_burst((unsigned int)(draw_action_length * crt_cycles_multiplier));	break;
-				case DrawAction::Blank:			crt_->output_blank((unsigned int)(draw_action_length * crt_cycles_multiplier));					break;
-				case DrawAction::Pixels:		end_pixel_line();																				break;
+				case DrawAction::Sync:			crt_->output_sync(static_cast<unsigned int>(draw_action_length * crt_cycles_multiplier));					break;
+				case DrawAction::ColourBurst:	crt_->output_default_colour_burst(static_cast<unsigned int>(draw_action_length * crt_cycles_multiplier));	break;
+				case DrawAction::Blank:			crt_->output_blank(static_cast<unsigned int>(draw_action_length * crt_cycles_multiplier));					break;
+				case DrawAction::Pixels:		end_pixel_line();																							break;
 			}
 			screen_map_pointer_ = (screen_map_pointer_ + 1) % screen_map_.size();
 			cycles_into_draw_action_ = 0;
@@ -247,16 +252,16 @@ void VideoOutput::run_for(const Cycles cycles) {
 	}
 }
 
-#pragma mark - Register hub
+// MARK: - Register hub
 
 void VideoOutput::set_register(int address, uint8_t value) {
 	switch(address & 0xf) {
 		case 0x02:
-			start_screen_address_ = (start_screen_address_ & 0xfe00) | (uint16_t)((value & 0xe0) << 1);
+			start_screen_address_ = (start_screen_address_ & 0xfe00) | static_cast<uint16_t>((value & 0xe0) << 1);
 			if(!start_screen_address_) start_screen_address_ |= 0x8000;
 		break;
 		case 0x03:
-			start_screen_address_ = (start_screen_address_ & 0x01ff) | (uint16_t)((value & 0x3f) << 9);
+			start_screen_address_ = (start_screen_address_ & 0x01ff) | static_cast<uint16_t>((value & 0x3f) << 9);
 			if(!start_screen_address_) start_screen_address_ |= 0x8000;
 		break;
 		case 0x07: {
@@ -298,17 +303,17 @@ void VideoOutput::set_register(int address, uint8_t value) {
 			}
 
 			// regenerate all palette tables for now
-#define pack(a, b) (uint8_t)((a << 4) | (b))
+#define pack(a, b) static_cast<uint8_t>((a << 4) | (b))
 			for(int byte = 0; byte < 256; byte++) {
-				uint8_t *target = (uint8_t *)&palette_tables_.forty1bpp[byte];
+				uint8_t *target = reinterpret_cast<uint8_t *>(&palette_tables_.forty1bpp[byte]);
 				target[0] = pack(palette_[(byte&0x80) >> 4], palette_[(byte&0x40) >> 3]);
 				target[1] = pack(palette_[(byte&0x20) >> 2], palette_[(byte&0x10) >> 1]);
 
-				target = (uint8_t *)&palette_tables_.eighty2bpp[byte];
+				target = reinterpret_cast<uint8_t *>(&palette_tables_.eighty2bpp[byte]);
 				target[0] = pack(palette_[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], palette_[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]);
 				target[1] = pack(palette_[((byte&0x20) >> 2) | ((byte&0x02) >> 0)], palette_[((byte&0x10) >> 1) | ((byte&0x01) << 1)]);
 
-				target = (uint8_t *)&palette_tables_.eighty1bpp[byte];
+				target = reinterpret_cast<uint8_t *>(&palette_tables_.eighty1bpp[byte]);
 				target[0] = pack(palette_[(byte&0x80) >> 4], palette_[(byte&0x40) >> 3]);
 				target[1] = pack(palette_[(byte&0x20) >> 2], palette_[(byte&0x10) >> 1]);
 				target[2] = pack(palette_[(byte&0x08) >> 0], palette_[(byte&0x04) << 1]);
@@ -333,7 +338,7 @@ void VideoOutput::setup_base_address() {
 	}
 }
 
-#pragma mark - Interrupts
+// MARK: - Interrupts
 
 VideoOutput::Interrupt VideoOutput::get_next_interrupt() {
 	VideoOutput::Interrupt interrupt;
@@ -367,7 +372,7 @@ VideoOutput::Interrupt VideoOutput::get_next_interrupt() {
 	return interrupt;
 }
 
-#pragma mark - RAM timing and access information
+// MARK: - RAM timing and access information
 
 unsigned int VideoOutput::get_cycles_until_next_ram_availability(int from_time) {
 	unsigned int result = 0;
@@ -382,9 +387,9 @@ unsigned int VideoOutput::get_cycles_until_next_ram_availability(int from_time)
 				int output_position_line = graphics_line(output_position_);
 				int implied_row = current_character_row_ + (current_line - output_position_line) % 10;
 				if(implied_row < 8)
-					result += (unsigned int)(80 - current_column);
+					result += static_cast<unsigned int>(80 - current_column);
 			}
-			else result += (unsigned int)(80 - current_column);
+			else result += static_cast<unsigned int>(80 - current_column);
 		}
 	}
 	return result;
@@ -402,7 +407,7 @@ VideoOutput::Range VideoOutput::get_memory_access_range() {
 	return range;
 }
 
-#pragma mark - The screen map
+// MARK: - The screen map
 
 void VideoOutput::setup_screen_map() {
 	/*

Machines/Electron/Video.hpp

@@ -80,12 +80,13 @@ class VideoOutput {
 		inline void output_pixels(unsigned int number_of_cycles);
 		inline void setup_base_address();
 
-		int output_position_, unused_cycles_;
+		int output_position_ = 0;
+		int unused_cycles_ = 0;
 
 		uint8_t palette_[16];
-		uint8_t screen_mode_;
-		uint16_t screen_mode_base_address_;
-		uint16_t start_screen_address_;
+		uint8_t screen_mode_ = 6;
+		uint16_t screen_mode_base_address_ = 0;
+		uint16_t start_screen_address_ = 0;
 
 		uint8_t *ram_;
 		struct {
@@ -97,14 +98,18 @@ class VideoOutput {
 		} palette_tables_;
 
 		// Display generation.
-		uint16_t start_line_address_, current_screen_address_;
-		int current_pixel_line_, current_pixel_column_, current_character_row_;
-		uint8_t last_pixel_byte_;
-		bool is_blank_line_;
+		uint16_t start_line_address_ = 0;
+		uint16_t current_screen_address_ = 0;
+		int current_pixel_line_ = -1;
+		int current_pixel_column_ = 0;
+		int current_character_row_ = 0;
+		uint8_t last_pixel_byte_ = 0;
+		bool is_blank_line_ = false;
 
 		// CRT output
-		uint8_t *current_output_target_, *initial_output_target_;
-		unsigned int current_output_divider_;
+		uint8_t *current_output_target_ = nullptr;
+		uint8_t *initial_output_target_ = nullptr;
+		unsigned int current_output_divider_ = 1;
 
 		std::shared_ptr<Outputs::CRT::CRT> crt_;
 
@@ -119,8 +124,8 @@ class VideoOutput {
 		void setup_screen_map();
 		void emplace_blank_line();
 		void emplace_pixel_line();
-		size_t screen_map_pointer_;
-		int cycles_into_draw_action_;
+		std::size_t screen_map_pointer_ = 0;
+		int cycles_into_draw_action_ = 0;
 };
 
 }

Machines/JoystickMachine.hpp

@@ -0,0 +1,24 @@
+//
+//  JoystickMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 14/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef JoystickMachine_hpp
+#define JoystickMachine_hpp
+
+#include "../Inputs/Joystick.hpp"
+#include <vector>
+
+namespace JoystickMachine {
+
+class Machine {
+	public:
+		virtual std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() = 0;
+};
+
+}
+
+#endif /* JoystickMachine_hpp */

Machines/KeyboardMachine.cpp

@@ -0,0 +1,29 @@
+//
+//  KeyboardMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "KeyboardMachine.hpp"
+
+using namespace KeyboardMachine;
+
+Machine::Machine() {
+	keyboard_.set_delegate(this);
+}
+
+void Machine::keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) {
+	uint16_t mapped_key = get_keyboard_mapper().mapped_key_for_key(key);
+	if(mapped_key != KeyNotMapped) set_key_state(mapped_key, is_pressed);
+}
+
+void Machine::reset_all_keys(Inputs::Keyboard *keyboard) {
+	// TODO: unify naming.
+	clear_all_keys();
+}
+
+Inputs::Keyboard &Machine::get_keyboard() {
+	return keyboard_;
+}

Machines/KeyboardMachine.hpp

@@ -9,20 +9,61 @@
 #ifndef KeyboardMachine_h
 #define KeyboardMachine_h
 
+#include <cstdint>
+
+#include "../Inputs/Keyboard.hpp"
+
 namespace KeyboardMachine {
 
-class Machine {
+class Machine: public Inputs::Keyboard::Delegate {
 	public:
+		Machine();
+
 		/*!
 			Indicates that the key @c key has been either pressed or released, according to
 			the state of @c isPressed.
 		*/
-		virtual void set_key_state(uint16_t key, bool isPressed) = 0;
+		virtual void set_key_state(uint16_t key, bool is_pressed) = 0;
 
 		/*!
 			Instructs that all keys should now be treated as released.
 		*/
 		virtual void clear_all_keys() = 0;
+
+		/*!
+			Provides a destination for keyboard input.
+		*/
+		virtual Inputs::Keyboard &get_keyboard();
+
+		/*!
+			A keyboard mapper attempts to provide a physical mapping between host keys and emulated keys.
+			See the character mapper for logical mapping.
+		*/
+		class KeyboardMapper {
+			public:
+				virtual uint16_t mapped_key_for_key(Inputs::Keyboard::Key key) = 0;
+		};
+
+		/// Terminates a key sequence from the character mapper.
+		static const uint16_t KeyEndSequence = 0xffff;
+
+		/*!
+			Indicates that a key is not mapped (for the keyboard mapper) or that a
+			character cannot be typed (for the character mapper).
+		*/
+		static const uint16_t KeyNotMapped = 0xfffe;
+
+	protected:
+		/*!
+			Allows individual machines to provide the mapping between host keys
+			as per Inputs::Keyboard and their native scheme.
+		*/
+		virtual KeyboardMapper &get_keyboard_mapper() = 0;
+
+	private:
+		void keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) override;
+		void reset_all_keys(Inputs::Keyboard *keyboard) override;
+		Inputs::Keyboard keyboard_;
 };
 
 }

Machines/Oric/CharacterMapper.hpp

@@ -1,23 +0,0 @@
-//
-//  CharacterMapper.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 03/08/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
-//
-
-#ifndef Machines_Oric_CharacterMapper_hpp
-#define Machines_Oric_CharacterMapper_hpp
-
-#include "../Typer.hpp"
-
-namespace Oric {
-
-class CharacterMapper: public ::Utility::CharacterMapper {
-	public:
-		uint16_t *sequence_for_character(char character);
-};
-
-}
-
-#endif /* Machines_Oric_CharacterMapper_hpp */

Machines/Oric/Keyboard.cpp

@@ -1,20 +1,60 @@
 //
-//  CharacterMapper.cpp
+//  Keyboard.cpp
 //  Clock Signal
 //
-//  Created by Thomas Harte on 03/08/2017.
+//  Created by Thomas Harte on 10/10/2017.
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#include "CharacterMapper.hpp"
-#include "Oric.hpp"
+#include "Keyboard.hpp"
 
 using namespace Oric;
 
+uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) {
+#define BIND(source, dest)	case Inputs::Keyboard::Key::source:	return Oric::dest
+	switch(key) {
+		default: break;
+
+		BIND(k0, Key0);		BIND(k1, Key1);		BIND(k2, Key2);		BIND(k3, Key3);		BIND(k4, Key4);
+		BIND(k5, Key5);		BIND(k6, Key6);		BIND(k7, Key7);		BIND(k8, Key8);		BIND(k9, Key9);
+		BIND(Q, KeyQ);		BIND(W, KeyW);		BIND(E, KeyE);		BIND(R, KeyR);		BIND(T, KeyT);
+		BIND(Y, KeyY);		BIND(U, KeyU);		BIND(I, KeyI);		BIND(O, KeyO);		BIND(P, KeyP);
+		BIND(A, KeyA);		BIND(S, KeyS);		BIND(D, KeyD);		BIND(F, KeyF);		BIND(G, KeyG);
+		BIND(H, KeyH);		BIND(J, KeyJ);		BIND(K, KeyK);		BIND(L, KeyL);
+		BIND(Z, KeyZ);		BIND(X, KeyX);		BIND(C, KeyC);		BIND(V, KeyV);
+		BIND(B, KeyB);		BIND(N, KeyN);		BIND(M, KeyM);
+
+		BIND(Left, KeyLeft);	BIND(Right, KeyRight);		BIND(Up, KeyUp);		BIND(Down, KeyDown);
+
+		BIND(Hyphen, KeyMinus);		BIND(Equals, KeyEquals);		BIND(BackSlash, KeyBackSlash);
+		BIND(OpenSquareBracket, KeyOpenSquare);	BIND(CloseSquareBracket, KeyCloseSquare);
+
+		BIND(BackSpace, KeyDelete); 	BIND(Delete, KeyDelete);
+
+		BIND(Semicolon, KeySemiColon);	BIND(Quote, KeyQuote);
+		BIND(Comma, KeyComma); 		BIND(FullStop, KeyFullStop); 	BIND(ForwardSlash, KeyForwardSlash);
+
+		BIND(Escape, KeyEscape);	BIND(Tab, KeyEscape);
+		BIND(CapsLock, KeyControl);	BIND(LeftControl, KeyControl);	BIND(RightControl, KeyControl);
+		BIND(LeftOption, KeyFunction);
+		BIND(RightOption, KeyFunction);
+		BIND(LeftMeta, KeyFunction);
+		BIND(RightMeta, KeyFunction);
+		BIND(LeftShift, KeyLeftShift);
+		BIND(RightShift, KeyRightShift);
+
+		BIND(Space, KeySpace);
+		BIND(Enter, KeyReturn);
+	}
+#undef BIND
+
+	return KeyboardMachine::Machine::KeyNotMapped;
+}
+
 uint16_t *CharacterMapper::sequence_for_character(char character) {
-#define KEYS(...)	{__VA_ARGS__, EndSequence}
-#define SHIFT(...)	{KeyLeftShift, __VA_ARGS__, EndSequence}
-#define X			{NotMapped}
+#define KEYS(...)	{__VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define SHIFT(...)	{KeyLeftShift, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define X			{KeyboardMachine::Machine::KeyNotMapped}
 	static KeySequence key_sequences[] = {
 		/* NUL */	X,							/* SOH */	X,
 		/* STX */	X,							/* ETX */	X,

Machines/Oric/Keyboard.hpp

@@ -0,0 +1,48 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_Oric_Keyboard_hpp
+#define Machines_Oric_Keyboard_hpp
+
+#include "../KeyboardMachine.hpp"
+#include "../Utility/Typer.hpp"
+
+namespace Oric {
+
+enum Key: uint16_t {
+	Key3			= 0x0000 | 0x80,	KeyX			= 0x0000 | 0x40,	Key1			= 0x0000 | 0x20,
+	KeyV			= 0x0000 | 0x08,	Key5			= 0x0000 | 0x04,	KeyN			= 0x0000 | 0x02,	Key7			= 0x0000 | 0x01,
+	KeyD			= 0x0100 | 0x80,	KeyQ			= 0x0100 | 0x40,	KeyEscape		= 0x0100 | 0x20,
+	KeyF			= 0x0100 | 0x08,	KeyR			= 0x0100 | 0x04,	KeyT			= 0x0100 | 0x02,	KeyJ			= 0x0100 | 0x01,
+	KeyC			= 0x0200 | 0x80,	Key2			= 0x0200 | 0x40,	KeyZ			= 0x0200 | 0x20,	KeyControl		= 0x0200 | 0x10,
+	Key4			= 0x0200 | 0x08,	KeyB			= 0x0200 | 0x04,	Key6			= 0x0200 | 0x02,	KeyM			= 0x0200 | 0x01,
+	KeyQuote		= 0x0300 | 0x80,	KeyBackSlash	= 0x0300 | 0x40,
+	KeyMinus		= 0x0300 | 0x08,	KeySemiColon	= 0x0300 | 0x04,	Key9			= 0x0300 | 0x02,	KeyK			= 0x0300 | 0x01,
+	KeyRight		= 0x0400 | 0x80,	KeyDown			= 0x0400 | 0x40,	KeyLeft			= 0x0400 | 0x20,	KeyLeftShift	= 0x0400 | 0x10,
+	KeyUp			= 0x0400 | 0x08,	KeyFullStop		= 0x0400 | 0x04,	KeyComma		= 0x0400 | 0x02,	KeySpace		= 0x0400 | 0x01,
+	KeyOpenSquare	= 0x0500 | 0x80,	KeyCloseSquare	= 0x0500 | 0x40,	KeyDelete		= 0x0500 | 0x20,	KeyFunction		= 0x0500 | 0x10,
+	KeyP			= 0x0500 | 0x08,	KeyO			= 0x0500 | 0x04,	KeyI			= 0x0500 | 0x02,	KeyU			= 0x0500 | 0x01,
+	KeyW			= 0x0600 | 0x80,	KeyS			= 0x0600 | 0x40,	KeyA			= 0x0600 | 0x20,
+	KeyE			= 0x0600 | 0x08,	KeyG			= 0x0600 | 0x04,	KeyH			= 0x0600 | 0x02,	KeyY			= 0x0600 | 0x01,
+	KeyEquals		= 0x0700 | 0x80,										KeyReturn		= 0x0700 | 0x20,	KeyRightShift	= 0x0700 | 0x10,
+	KeyForwardSlash	= 0x0700 | 0x08,	Key0			= 0x0700 | 0x04,	KeyL			= 0x0700 | 0x02,	Key8			= 0x0700 | 0x01,
+
+	KeyNMI			= 0xfffd,
+};
+
+struct KeyboardMapper: public KeyboardMachine::Machine::KeyboardMapper {
+	uint16_t mapped_key_for_key(Inputs::Keyboard::Key key);
+};
+
+struct CharacterMapper: public ::Utility::CharacterMapper {
+	uint16_t *sequence_for_character(char character);
+};
+
+};
+
+#endif /* KeyboardMapper_hpp */

Machines/Oric/Microdisc.cpp

@@ -18,19 +18,13 @@ namespace {
 	const int head_load_request_counter_target = 7653333;
 }
 
-Microdisc::Microdisc() :
-		irq_enable_(false),
-		delegate_(nullptr),
-		paging_flags_(BASICDisable),
-		head_load_request_counter_(-1),
-		WD1770(P1793),
-		last_control_(0) {
+Microdisc::Microdisc() : WD1770(P1793) {
 	set_control_register(last_control_, 0xff);
 }
 
 void Microdisc::set_disk(std::shared_ptr<Storage::Disk::Disk> disk, int drive) {
 	if(!drives_[drive]) {
-		drives_[drive].reset(new Storage::Disk::Drive);
+		drives_[drive].reset(new Storage::Disk::Drive(8000000, 300, 2));
 		if(drive == selected_drive_) set_drive(drives_[drive]);
 	}
 	drives_[drive]->set_disk(disk);
@@ -53,7 +47,7 @@ void Microdisc::set_control_register(uint8_t control, uint8_t changes) {
 
 	// b4: side select
 	if(changes & 0x10) {
-		unsigned int head = (control & 0x10) ? 1 : 0;
+		int head = (control & 0x10) ? 1 : 0;
 		for(int c = 0; c < 4; c++) {
 			if(drives_[c]) drives_[c]->set_head(head);
 		}
@@ -95,7 +89,14 @@ uint8_t Microdisc::get_data_request_register() {
 }
 
 void Microdisc::set_head_load_request(bool head_load) {
-	set_motor_on(head_load);
+	// The drive motors (at present: I believe **all drive motors** regardless of the selected drive) receive
+	// the current head load request state.
+	for(int c = 0; c < 4; c++) {
+		if(drives_[c]) drives_[c]->set_motor_on(head_load);
+	}
+
+	// A request to load the head results in a delay until the head is confirmed loaded. This delay is handled
+	// in ::run_for. A request to unload the head results in an instant answer that the head is unloaded.
 	if(head_load) {
 		head_load_request_counter_ = 0;
 	} else {

Machines/Oric/Microdisc.hpp

@@ -45,11 +45,11 @@ class Microdisc: public WD::WD1770 {
 		bool get_drive_is_ready();
 		std::shared_ptr<Storage::Disk::Drive> drives_[4];
 		int selected_drive_;
-		bool irq_enable_;
-		int paging_flags_;
-		int head_load_request_counter_;
-		Delegate *delegate_;
-		uint8_t last_control_;
+		bool irq_enable_ = false;
+		int paging_flags_ = BASICDisable;
+		int head_load_request_counter_ = -1;
+		Delegate *delegate_ = nullptr;
+		uint8_t last_control_ = 0;
 };
 
 }

Machines/Oric/Oric.cpp

@@ -8,286 +8,513 @@
 
 #include "Oric.hpp"
 
-#include "CharacterMapper.hpp"
-#include "../MemoryFuzzer.hpp"
+#include "Keyboard.hpp"
+#include "Microdisc.hpp"
+#include "Video.hpp"
+
+#include "../Utility/MemoryFuzzer.hpp"
+#include "../Utility/Typer.hpp"
+
+#include "../../Processors/6502/6502.hpp"
+#include "../../Components/6522/6522.hpp"
+#include "../../Components/AY38910/AY38910.hpp"
+
+#include "../../Storage/Tape/Tape.hpp"
+#include "../../Storage/Tape/Parsers/Oric.hpp"
+
+#include "../../ClockReceiver/ForceInline.hpp"
+#include "../../Configurable/StandardOptions.hpp"
 
 #include <memory>
 
-using namespace Oric;
+namespace Oric {
 
-Machine::Machine() :
-		use_fast_tape_hack_(false),
-		typer_delay_(2500000),
-		keyboard_read_count_(0),
-		keyboard_(new Keyboard),
-		ram_top_(0xbfff),
-		paged_rom_(rom_),
-		microdisc_is_enabled_(false) {
-	set_clock_rate(1000000);
-	via_.set_interrupt_delegate(this);
-	via_.keyboard = keyboard_;
-	clear_all_keys();
-	via_.tape->set_delegate(this);
-	Memory::Fuzz(ram_, sizeof(ram_));
+std::vector<std::unique_ptr<Configurable::Option>> get_options() {
+	return Configurable::standard_options(
+		static_cast<Configurable::StandardOptions>(Configurable::DisplayRGBComposite | Configurable::QuickLoadTape)
+	);
 }
 
-void Machine::configure_as_target(const StaticAnalyser::Target &target) {
-	if(target.tapes.size()) {
-		via_.tape->set_tape(target.tapes.front());
-	}
+/*!
+	Models the Oric's keyboard: eight key rows, containing a bitfield of keys set.
 
-	if(target.loadingCommand.length()) {
-		set_typer_for_string(target.loadingCommand.c_str());
-	}
-
-	if(target.oric.has_microdisc) {
-		microdisc_is_enabled_ = true;
-		microdisc_did_change_paging_flags(&microdisc_);
-		microdisc_.set_delegate(this);
-	}
-
-	int drive_index = 0;
-	for(auto disk : target.disks) {
-		if(drive_index < 4) microdisc_.set_disk(disk, drive_index);
-		drive_index++;
-	}
-
-	if(target.oric.use_atmos_rom) {
-		memcpy(rom_, basic11_rom_.data(), std::min(basic11_rom_.size(), sizeof(rom_)));
-
-		is_using_basic11_ = true;
-		tape_get_byte_address_ = 0xe6c9;
-		scan_keyboard_address_ = 0xf495;
-		tape_speed_address_ = 0x024d;
-	} else {
-		memcpy(rom_, basic10_rom_.data(), std::min(basic10_rom_.size(), sizeof(rom_)));
-
-		is_using_basic11_ = false;
-		tape_get_byte_address_ = 0xe630;
-		scan_keyboard_address_ = 0xf43c;
-		tape_speed_address_ = 0x67;
-	}
-}
-
-void Machine::set_typer_for_string(const char *string) {
-	std::unique_ptr<CharacterMapper> mapper(new CharacterMapper);
-	Utility::TypeRecipient::set_typer_for_string(string, std::move(mapper));
-}
-
-void Machine::set_rom(ROM rom, const std::vector<uint8_t> &data) {
-	switch(rom) {
-		case BASIC11:	basic11_rom_ = std::move(data);		break;
-		case BASIC10:	basic10_rom_ = std::move(data);		break;
-		case Microdisc:	microdisc_rom_ = std::move(data);	break;
-		case Colour:
-			colour_rom_ = std::move(data);
-			if(video_output_) video_output_->set_colour_rom(colour_rom_);
-		break;
-	}
-}
-
-Cycles Machine::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
-	if(address > ram_top_) {
-		if(isReadOperation(operation)) *value = paged_rom_[address - ram_top_ - 1];
-
-		// 024D = 0 => fast; otherwise slow
-		// E6C9 = read byte: return byte in A
-		if(address == tape_get_byte_address_ && paged_rom_ == rom_ && use_fast_tape_hack_ && operation == CPU::MOS6502::BusOperation::ReadOpcode && via_.tape->has_tape() && !via_.tape->get_tape()->is_at_end()) {
-			uint8_t next_byte = via_.tape->get_next_byte(!ram_[tape_speed_address_]);
-			set_value_of_register(CPU::MOS6502::A, next_byte);
-			set_value_of_register(CPU::MOS6502::Flags, next_byte ? 0 : CPU::MOS6502::Flag::Zero);
-			*value = 0x60; // i.e. RTS
+	Active line is selected through a port on the Oric's VIA, and a column mask is
+	selected via a port on the AY, returning a single Boolean representation of the
+	logical OR of every key selected by the column mask on the active row.
+*/
+class Keyboard {
+	public:
+		Keyboard() {
+			clear_all_keys();
 		}
-	} else {
-		if((address & 0xff00) == 0x0300) {
-			if(microdisc_is_enabled_ && address >= 0x0310) {
-				switch(address) {
-					case 0x0310: case 0x0311: case 0x0312: case 0x0313:
-						if(isReadOperation(operation)) *value = microdisc_.get_register(address);
-						else microdisc_.set_register(address, *value);
-					break;
-					case 0x314: case 0x315: case 0x316: case 0x317:
-						if(isReadOperation(operation)) *value = microdisc_.get_interrupt_request_register();
-						else microdisc_.set_control_register(*value);
-					break;
-					case 0x318: case 0x319: case 0x31a: case 0x31b:
-						if(isReadOperation(operation)) *value = microdisc_.get_data_request_register();
-					break;
+
+		/// Sets whether @c key is or is not pressed, per @c is_pressed.
+		void set_key_state(uint16_t key, bool is_pressed) {
+			uint8_t mask = key & 0xff;
+			int line = key >> 8;
+
+			if(is_pressed)	rows_[line] |= mask;
+			else			rows_[line] &= ~mask;
+		}
+
+		/// Sets all keys as unpressed.
+		void clear_all_keys() {
+			memset(rows_, 0, sizeof(rows_));
+		}
+
+		/// Selects the active row.
+		void set_active_row(uint8_t row) {
+			row_ = row & 7;
+		}
+
+		/// Queries the keys on the active row specified by @c mask.
+		bool query_column(uint8_t column_mask) {
+			return !!(rows_[row_] & column_mask);
+		}
+
+	private:
+		uint8_t row_ = 0;
+		uint8_t rows_[8];
+};
+
+/*!
+	Provide's the Oric's tape player: a standard binary-sampled tape which also holds
+	an instance of the Oric tape parser, to provide fast-tape loading.
+*/
+class TapePlayer: public Storage::Tape::BinaryTapePlayer {
+	public:
+		TapePlayer() : Storage::Tape::BinaryTapePlayer(1000000) {}
+
+		/*!
+			Parses the incoming tape event stream to obtain the next stored byte.
+
+			@param use_fast_encoding If set to @c true , inspects the tape as though it
+			is encoded in the Oric's fast-loading scheme. Otherwise looks for a slow-encoded byte.
+
+			@returns The next byte from the tape.
+		*/
+		uint8_t get_next_byte(bool use_fast_encoding) {
+			return static_cast<uint8_t>(parser_.get_next_byte(get_tape(), use_fast_encoding));
+		}
+
+	private:
+		Storage::Tape::Oric::Parser parser_;
+};
+
+/*!
+	Implements the Oric's VIA's port handler. On the Oric the VIA's ports connect
+	to the AY, the tape's motor control signal and the keyboard.
+*/
+class VIAPortHandler: public MOS::MOS6522::IRQDelegatePortHandler {
+	public:
+		VIAPortHandler(TapePlayer &tape_player, Keyboard &keyboard) : tape_player_(tape_player), keyboard_(keyboard) {}
+
+		/*!
+			Reponds to the 6522's control line output change signal; on an Oric A2 is connected to
+			the AY's BDIR, and B2 is connected to the AY's A2.
+		*/
+		void set_control_line_output(MOS::MOS6522::Port port, MOS::MOS6522::Line line, bool value) {
+			if(line) {
+				if(port) ay_bdir_ = value; else ay_bc1_ = value;
+				update_ay();
+				ay8910_->set_control_lines( (GI::AY38910::ControlLines)((ay_bdir_ ? GI::AY38910::BDIR : 0) | (ay_bc1_ ? GI::AY38910::BC1 : 0) | GI::AY38910::BC2));
+			}
+		}
+
+		/*!
+			Reponds to changes in the 6522's port output. On an Oric port B sets the tape motor control
+			and the keyboard's active row. Port A is connected to the AY's data bus.
+		*/
+		void set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t direction_mask)  {
+			if(port) {
+				keyboard_.set_active_row(value);
+				tape_player_.set_motor_control(value & 0x40);
+			} else {
+				update_ay();
+				ay8910_->set_data_input(value);
+			}
+		}
+
+		/*!
+			Provides input data for the 6522. Port B reads the keyboard, and port A reads from the AY.
+		*/
+		uint8_t get_port_input(MOS::MOS6522::Port port) {
+			if(port) {
+				uint8_t column = ay8910_->get_port_output(false) ^ 0xff;
+				return keyboard_.query_column(column) ? 0x08 : 0x00;
+			} else {
+				return ay8910_->get_data_output();
+			}
+		}
+
+		/*!
+			Advances time. This class manages the AY's concept of time to permit updating-on-demand.
+		*/
+		inline void run_for(const Cycles cycles) {
+			cycles_since_ay_update_ += cycles;
+		}
+
+		/// Flushes any queued behaviour (which, specifically, means on the AY).
+		void flush() {
+			ay8910_->run_for(cycles_since_ay_update_.flush());
+			ay8910_->flush();
+		}
+
+		/// Sets the AY in use by the machine the VIA that uses this port handler sits within.
+		void set_ay(GI::AY38910::AY38910 *ay) {
+			ay8910_ = ay;
+		}
+
+	private:
+		void update_ay() {
+			ay8910_->run_for(cycles_since_ay_update_.flush());
+		}
+		bool ay_bdir_ = false;
+		bool ay_bc1_ = false;
+		Cycles cycles_since_ay_update_;
+
+		GI::AY38910::AY38910 *ay8910_ = nullptr;
+		TapePlayer &tape_player_;
+		Keyboard &keyboard_;
+};
+
+class ConcreteMachine:
+	public CPU::MOS6502::BusHandler,
+	public MOS::MOS6522::IRQDelegatePortHandler::Delegate,
+	public Utility::TypeRecipient,
+	public Storage::Tape::BinaryTapePlayer::Delegate,
+	public Microdisc::Delegate,
+	public Machine {
+
+	public:
+		ConcreteMachine() :
+				m6502_(*this),
+				via_port_handler_(tape_player_, keyboard_),
+				via_(via_port_handler_),
+				paged_rom_(rom_) {
+			set_clock_rate(1000000);
+			via_port_handler_.set_interrupt_delegate(this);
+			tape_player_.set_delegate(this);
+			Memory::Fuzz(ram_, sizeof(ram_));
+		}
+
+		void set_rom(ROM rom, const std::vector<uint8_t> &data) override final {
+			switch(rom) {
+				case BASIC11:	basic11_rom_ = std::move(data);		break;
+				case BASIC10:	basic10_rom_ = std::move(data);		break;
+				case Microdisc:	microdisc_rom_ = std::move(data);	break;
+				case Colour:
+					colour_rom_ = std::move(data);
+					if(video_output_) video_output_->set_colour_rom(colour_rom_);
+				break;
+			}
+		}
+
+		// Obtains the system ROMs.
+		bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) override {
+			auto roms = roms_with_names(
+				"Oric",
+				{
+					"basic10.rom",	"basic11.rom",
+					"microdisc.rom", "colour.rom"
+				});
+
+			for(std::size_t index = 0; index < roms.size(); ++index) {
+				auto &data = roms[index];
+				if(!data) return false;
+				set_rom(static_cast<ROM>(index), *data);
+			}
+
+			return true;
+		}
+
+		void set_key_state(uint16_t key, bool is_pressed) override final {
+			if(key == KeyNMI) {
+				m6502_.set_nmi_line(is_pressed);
+			} else {
+				keyboard_.set_key_state(key, is_pressed);
+			}
+		}
+
+		void clear_all_keys() override final {
+			keyboard_.clear_all_keys();
+		}
+
+		void set_use_fast_tape_hack(bool activate) override final {
+			use_fast_tape_hack_ = activate;
+		}
+
+		void set_output_device(Outputs::CRT::OutputDevice output_device) override final {
+			video_output_->set_output_device(output_device);
+		}
+
+		// to satisfy ConfigurationTarget::Machine
+		void configure_as_target(const StaticAnalyser::Target &target) override final {
+			if(target.oric.has_microdisc) {
+				microdisc_is_enabled_ = true;
+				microdisc_did_change_paging_flags(&microdisc_);
+				microdisc_.set_delegate(this);
+			}
+
+			if(target.loadingCommand.length()) {
+				set_typer_for_string(target.loadingCommand.c_str());
+			}
+
+			if(target.oric.use_atmos_rom) {
+				std::memcpy(rom_, basic11_rom_.data(), std::min(basic11_rom_.size(), sizeof(rom_)));
+
+				is_using_basic11_ = true;
+				tape_get_byte_address_ = 0xe6c9;
+				scan_keyboard_address_ = 0xf495;
+				tape_speed_address_ = 0x024d;
+			} else {
+				std::memcpy(rom_, basic10_rom_.data(), std::min(basic10_rom_.size(), sizeof(rom_)));
+
+				is_using_basic11_ = false;
+				tape_get_byte_address_ = 0xe630;
+				scan_keyboard_address_ = 0xf43c;
+				tape_speed_address_ = 0x67;
+			}
+
+			insert_media(target.media);
+		}
+
+		bool insert_media(const StaticAnalyser::Media &media) override final {
+			if(media.tapes.size()) {
+				tape_player_.set_tape(media.tapes.front());
+			}
+
+			int drive_index = 0;
+			for(auto disk : media.disks) {
+				if(drive_index < 4) microdisc_.set_disk(disk, drive_index);
+				drive_index++;
+			}
+
+			return !media.tapes.empty() || (!media.disks.empty() && microdisc_is_enabled_);
+		}
+
+		// to satisfy CPU::MOS6502::BusHandler
+		forceinline Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
+			if(address > ram_top_) {
+				if(isReadOperation(operation)) *value = paged_rom_[address - ram_top_ - 1];
+
+				// 024D = 0 => fast; otherwise slow
+				// E6C9 = read byte: return byte in A
+				if(	address == tape_get_byte_address_ &&
+					paged_rom_ == rom_ &&
+					use_fast_tape_hack_ &&
+					operation == CPU::MOS6502::BusOperation::ReadOpcode &&
+					tape_player_.has_tape() &&
+					!tape_player_.get_tape()->is_at_end()) {
+
+					uint8_t next_byte = tape_player_.get_next_byte(!ram_[tape_speed_address_]);
+					m6502_.set_value_of_register(CPU::MOS6502::A, next_byte);
+					m6502_.set_value_of_register(CPU::MOS6502::Flags, next_byte ? 0 : CPU::MOS6502::Flag::Zero);
+					*value = 0x60; // i.e. RTS
 				}
 			} else {
-				if(isReadOperation(operation)) *value = via_.get_register(address);
-				else via_.set_register(address, *value);
+				if((address & 0xff00) == 0x0300) {
+					if(microdisc_is_enabled_ && address >= 0x0310) {
+						switch(address) {
+							case 0x0310: case 0x0311: case 0x0312: case 0x0313:
+								if(isReadOperation(operation)) *value = microdisc_.get_register(address);
+								else microdisc_.set_register(address, *value);
+							break;
+							case 0x314: case 0x315: case 0x316: case 0x317:
+								if(isReadOperation(operation)) *value = microdisc_.get_interrupt_request_register();
+								else microdisc_.set_control_register(*value);
+							break;
+							case 0x318: case 0x319: case 0x31a: case 0x31b:
+								if(isReadOperation(operation)) *value = microdisc_.get_data_request_register();
+							break;
+						}
+					} else {
+						if(isReadOperation(operation)) *value = via_.get_register(address);
+						else via_.set_register(address, *value);
+					}
+				} else {
+					if(isReadOperation(operation))
+						*value = ram_[address];
+					else {
+						if(address >= 0x9800 && address <= 0xc000) update_video();
+						ram_[address] = *value;
+					}
+				}
 			}
-		} else {
-			if(isReadOperation(operation))
-				*value = ram_[address];
-			else {
-				if(address >= 0x9800 && address <= 0xc000) { update_video(); typer_delay_ = 0; }
-				ram_[address] = *value;
+
+			if(typer_ && address == scan_keyboard_address_ && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
+				// the Oric 1 misses any key pressed on the very first entry into the read keyboard routine, so don't
+				// do anything until at least the second, regardless of machine
+				if(!keyboard_read_count_) keyboard_read_count_++;
+				else if(!typer_->type_next_character()) {
+					clear_all_keys();
+					typer_.reset();
+				}
+			}
+
+			via_.run_for(Cycles(1));
+			via_port_handler_.run_for(Cycles(1));
+			tape_player_.run_for(Cycles(1));
+			if(microdisc_is_enabled_) microdisc_.run_for(Cycles(8));
+			cycles_since_video_update_++;
+			return Cycles(1);
+		}
+
+		forceinline void flush() {
+			update_video();
+			via_port_handler_.flush();
+		}
+
+		// to satisfy CRTMachine::Machine
+		void setup_output(float aspect_ratio) override final {
+			ay8910_.reset(new GI::AY38910::AY38910());
+			ay8910_->set_clock_rate(1000000);
+			via_port_handler_.set_ay(ay8910_.get());
+
+			video_output_.reset(new VideoOutput(ram_));
+			if(!colour_rom_.empty()) video_output_->set_colour_rom(colour_rom_);
+		}
+
+		void close_output() override final {
+			video_output_.reset();
+			ay8910_.reset();
+			via_port_handler_.set_ay(nullptr);
+		}
+
+		std::shared_ptr<Outputs::CRT::CRT> get_crt() override final {
+			return video_output_->get_crt();
+		}
+
+		std::shared_ptr<Outputs::Speaker> get_speaker() override final {
+			return ay8910_;
+		}
+
+		void run_for(const Cycles cycles) override final {
+			m6502_.run_for(cycles);
+		}
+
+		// to satisfy MOS::MOS6522IRQDelegate::Delegate
+		void mos6522_did_change_interrupt_status(void *mos6522) override final {
+			set_interrupt_line();
+		}
+
+		// to satisfy Storage::Tape::BinaryTapePlayer::Delegate
+		void tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape_player) override final {
+			// set CB1
+			via_.set_control_line_input(MOS::MOS6522::Port::B, MOS::MOS6522::Line::One, !tape_player->get_input());
+		}
+
+		// for Utility::TypeRecipient::Delegate
+		void set_typer_for_string(const char *string) override final {
+			std::unique_ptr<CharacterMapper> mapper(new CharacterMapper);
+			Utility::TypeRecipient::set_typer_for_string(string, std::move(mapper));
+		}
+
+		// for Microdisc::Delegate
+		void microdisc_did_change_paging_flags(class Microdisc *microdisc) override final {
+			int flags = microdisc->get_paging_flags();
+			if(!(flags&Microdisc::PagingFlags::BASICDisable)) {
+				ram_top_ = 0xbfff;
+				paged_rom_ = rom_;
+			} else {
+				if(flags&Microdisc::PagingFlags::MicrodscDisable) {
+					ram_top_ = 0xffff;
+				} else {
+					ram_top_ = 0xdfff;
+					paged_rom_ = microdisc_rom_.data();
+				}
 			}
 		}
-	}
 
-	if(typer_ && address == scan_keyboard_address_ && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
-		// the Oric 1 misses any key pressed on the very first entry into the read keyboard routine, so don't
-		// do anything until at least the second, regardless of machine
-		if(!keyboard_read_count_) keyboard_read_count_++;
-		else if(!typer_->type_next_character()) {
-			clear_all_keys();
-			typer_.reset();
+		void wd1770_did_change_output(WD::WD1770 *wd1770) override final {
+			set_interrupt_line();
 		}
-	}
 
-	via_.run_for(Cycles(1));
-	if(microdisc_is_enabled_) microdisc_.run_for(Cycles(8));
-	cycles_since_video_update_++;
-	return Cycles(1);
-}
-
-void Machine::flush() {
-	update_video();
-	via_.flush();
-}
-
-void Machine::update_video() {
-	video_output_->run_for(cycles_since_video_update_.flush());
-}
-
-void Machine::setup_output(float aspect_ratio) {
-	via_.ay8910.reset(new GI::AY38910::AY38910());
-	via_.ay8910->set_clock_rate(1000000);
-	video_output_.reset(new VideoOutput(ram_));
-	if(!colour_rom_.empty()) video_output_->set_colour_rom(colour_rom_);
-}
-
-void Machine::close_output() {
-	video_output_.reset();
-	via_.ay8910.reset();
-}
-
-void Machine::mos6522_did_change_interrupt_status(void *mos6522) {
-	set_interrupt_line();
-}
-
-void Machine::set_key_state(uint16_t key, bool isPressed) {
-	if(key == KeyNMI) {
-		set_nmi_line(isPressed);
-	} else {
-		if(isPressed)
-			keyboard_->rows[key >> 8] |= (key & 0xff);
-		else
-			keyboard_->rows[key >> 8] &= ~(key & 0xff);
-	}
-}
-
-void Machine::clear_all_keys() {
-	memset(keyboard_->rows, 0, sizeof(keyboard_->rows));
-}
-
-void Machine::set_use_fast_tape_hack(bool activate) {
-	use_fast_tape_hack_ = activate;
-}
-
-void Machine::set_output_device(Outputs::CRT::OutputDevice output_device) {
-	video_output_->set_output_device(output_device);
-}
-
-void Machine::tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape_player) {
-	// set CB1
-	via_.set_control_line_input(VIA::Port::B, VIA::Line::One, !tape_player->get_input());
-}
-
-std::shared_ptr<Outputs::CRT::CRT> Machine::get_crt() {
-	return video_output_->get_crt();
-}
-
-std::shared_ptr<Outputs::Speaker> Machine::get_speaker() {
-	return via_.ay8910;
-}
-
-void Machine::run_for(const Cycles cycles) {
-	CPU::MOS6502::Processor<Machine>::run_for(cycles);
-}
-
-#pragma mark - The 6522
-
-Machine::VIA::VIA() :
-		MOS::MOS6522<Machine::VIA>(),
-		tape(new TapePlayer) {}
-
-void Machine::VIA::set_control_line_output(Port port, Line line, bool value) {
-	if(line) {
-		if(port) ay_bdir_ = value; else ay_bc1_ = value;
-		update_ay();
-	}
-}
-
-void Machine::VIA::set_port_output(Port port, uint8_t value, uint8_t direction_mask) {
-	if(port) {
-		keyboard->row = value;
-		tape->set_motor_control(value & 0x40);
-	} else {
-		ay8910->set_data_input(value);
-	}
-}
-
-uint8_t Machine::VIA::get_port_input(Port port) {
-	if(port) {
-		uint8_t column = ay8910->get_port_output(false) ^ 0xff;
-		return (keyboard->rows[keyboard->row & 7] & column) ? 0x08 : 0x00;
-	} else {
-		return ay8910->get_data_output();
-	}
-}
-
-void Machine::VIA::flush() {
-	ay8910->run_for(cycles_since_ay_update_.flush());
-	ay8910->flush();
-}
-
-void Machine::VIA::run_for(const Cycles cycles) {
-	cycles_since_ay_update_ += cycles;
-	MOS::MOS6522<VIA>::run_for(cycles);
-	tape->run_for(cycles);
-}
-
-void Machine::VIA::update_ay() {
-	ay8910->run_for(cycles_since_ay_update_.flush());
-	ay8910->set_control_lines( (GI::AY38910::ControlLines)((ay_bdir_ ? GI::AY38910::BDIR : 0) | (ay_bc1_ ? GI::AY38910::BC1 : 0) | GI::AY38910::BC2));
-}
-
-#pragma mark - TapePlayer
-
-Machine::TapePlayer::TapePlayer() :
-		Storage::Tape::BinaryTapePlayer(1000000) {}
-
-uint8_t Machine::TapePlayer::get_next_byte(bool fast) {
-	return (uint8_t)parser_.get_next_byte(get_tape(), fast);
-}
-
-#pragma mark - Microdisc
-
-void Machine::microdisc_did_change_paging_flags(class Microdisc *microdisc) {
-	int flags = microdisc->get_paging_flags();
-	if(!(flags&Microdisc::PagingFlags::BASICDisable)) {
-		ram_top_ = 0xbfff;
-		paged_rom_ = rom_;
-	} else {
-		if(flags&Microdisc::PagingFlags::MicrodscDisable) {
-			ram_top_ = 0xffff;
-		} else {
-			ram_top_ = 0xdfff;
-			paged_rom_ = microdisc_rom_.data();
+		KeyboardMapper &get_keyboard_mapper() override {
+			return keyboard_mapper_;
 		}
-	}
+
+		// MARK: - Configuration options.
+		std::vector<std::unique_ptr<Configurable::Option>> get_options() override {
+			return Oric::get_options();
+		}
+
+		void set_selections(const Configurable::SelectionSet &selections_by_option) override {
+			bool quickload;
+			if(Configurable::get_quick_load_tape(selections_by_option, quickload)) {
+				set_use_fast_tape_hack(quickload);
+			}
+
+			Configurable::Display display;
+			if(Configurable::get_display(selections_by_option, display)) {
+				get_crt()->set_output_device((display == Configurable::Display::RGB) ? Outputs::CRT::OutputDevice::Monitor : Outputs::CRT::OutputDevice::Television);
+			}
+		}
+
+		Configurable::SelectionSet get_accurate_selections() override {
+			Configurable::SelectionSet selection_set;
+			Configurable::append_quick_load_tape_selection(selection_set, false);
+			Configurable::append_display_selection(selection_set, Configurable::Display::Composite);
+			return selection_set;
+		}
+
+		Configurable::SelectionSet get_user_friendly_selections() override {
+			Configurable::SelectionSet selection_set;
+			Configurable::append_quick_load_tape_selection(selection_set, true);
+			Configurable::append_display_selection(selection_set, Configurable::Display::RGB);
+			return selection_set;
+		}
+
+	private:
+		CPU::MOS6502::Processor<ConcreteMachine, false> m6502_;
+
+		// RAM and ROM
+		std::vector<uint8_t> basic11_rom_, basic10_rom_, microdisc_rom_, colour_rom_;
+		uint8_t ram_[65536], rom_[16384];
+		Cycles cycles_since_video_update_;
+		inline void update_video() {
+			video_output_->run_for(cycles_since_video_update_.flush());
+		}
+
+		// ROM bookkeeping
+		bool is_using_basic11_ = false;
+		uint16_t tape_get_byte_address_ = 0, scan_keyboard_address_ = 0, tape_speed_address_ = 0;
+		int keyboard_read_count_ = 0;
+
+		// Outputs
+		std::unique_ptr<VideoOutput> video_output_;
+		std::shared_ptr<GI::AY38910::AY38910> ay8910_;
+
+		// Inputs
+		Oric::KeyboardMapper keyboard_mapper_;
+
+		// The tape
+		TapePlayer tape_player_;
+		bool use_fast_tape_hack_ = false;
+
+		VIAPortHandler via_port_handler_;
+		MOS::MOS6522::MOS6522<VIAPortHandler> via_;
+		Keyboard keyboard_;
+
+		// the Microdisc, if in use
+		class Microdisc microdisc_;
+		bool microdisc_is_enabled_ = false;
+		uint16_t ram_top_ = 0xbfff;
+		uint8_t *paged_rom_;
+
+		inline void set_interrupt_line() {
+			m6502_.set_irq_line(
+				via_.get_interrupt_line() ||
+				(microdisc_is_enabled_ && microdisc_.get_interrupt_request_line()));
+		}
+};
+
 }
 
-void Machine::wd1770_did_change_output(WD::WD1770 *wd1770) {
-	set_interrupt_line();
+using namespace Oric;
+
+Machine *Machine::Oric() {
+	return new ConcreteMachine;
 }
 
-void Machine::set_interrupt_line() {
-	set_irq_line(
-		via_.get_interrupt_line() ||
-		(microdisc_is_enabled_ && microdisc_.get_interrupt_request_line()));
-}
+Machine::~Machine() {}

Machines/Oric/Oric.hpp

@@ -9,163 +9,45 @@
 #ifndef Oric_hpp
 #define Oric_hpp
 
+#include "../../Configurable/Configurable.hpp"
 #include "../ConfigurationTarget.hpp"
 #include "../CRTMachine.hpp"
-#include "../Typer.hpp"
-
-#include "../../Processors/6502/6502.hpp"
-#include "../../Components/6522/6522.hpp"
-#include "../../Components/AY38910/AY38910.hpp"
-#include "../../Storage/Tape/Parsers/Oric.hpp"
-
-#include "Video.hpp"
-#include "Microdisc.hpp"
-
-#include "../../Storage/Tape/Tape.hpp"
+#include "../KeyboardMachine.hpp"
 
 #include <cstdint>
 #include <vector>
-#include <memory>
 
 namespace Oric {
 
-enum Key: uint16_t {
-	Key3			= 0x0000 | 0x80,	KeyX			= 0x0000 | 0x40,	Key1			= 0x0000 | 0x20,
-	KeyV			= 0x0000 | 0x08,	Key5			= 0x0000 | 0x04,	KeyN			= 0x0000 | 0x02,	Key7			= 0x0000 | 0x01,
-	KeyD			= 0x0100 | 0x80,	KeyQ			= 0x0100 | 0x40,	KeyEscape		= 0x0100 | 0x20,
-	KeyF			= 0x0100 | 0x08,	KeyR			= 0x0100 | 0x04,	KeyT			= 0x0100 | 0x02,	KeyJ			= 0x0100 | 0x01,
-	KeyC			= 0x0200 | 0x80,	Key2			= 0x0200 | 0x40,	KeyZ			= 0x0200 | 0x20,	KeyControl		= 0x0200 | 0x10,
-	Key4			= 0x0200 | 0x08,	KeyB			= 0x0200 | 0x04,	Key6			= 0x0200 | 0x02,	KeyM			= 0x0200 | 0x01,
-	KeyQuote		= 0x0300 | 0x80,	KeyBackSlash	= 0x0300 | 0x40,
-	KeyMinus		= 0x0300 | 0x08,	KeySemiColon	= 0x0300 | 0x04,	Key9			= 0x0300 | 0x02,	KeyK			= 0x0300 | 0x01,
-	KeyRight		= 0x0400 | 0x80,	KeyDown			= 0x0400 | 0x40,	KeyLeft			= 0x0400 | 0x20,	KeyLeftShift	= 0x0400 | 0x10,
-	KeyUp			= 0x0400 | 0x08,	KeyFullStop		= 0x0400 | 0x04,	KeyComma		= 0x0400 | 0x02,	KeySpace		= 0x0400 | 0x01,
-	KeyOpenSquare	= 0x0500 | 0x80,	KeyCloseSquare	= 0x0500 | 0x40,	KeyDelete		= 0x0500 | 0x20,	KeyFunction		= 0x0500 | 0x10,
-	KeyP			= 0x0500 | 0x08,	KeyO			= 0x0500 | 0x04,	KeyI			= 0x0500 | 0x02,	KeyU			= 0x0500 | 0x01,
-	KeyW			= 0x0600 | 0x80,	KeyS			= 0x0600 | 0x40,	KeyA			= 0x0600 | 0x20,
-	KeyE			= 0x0600 | 0x08,	KeyG			= 0x0600 | 0x04,	KeyH			= 0x0600 | 0x02,	KeyY			= 0x0600 | 0x01,
-	KeyEquals		= 0x0700 | 0x80,										KeyReturn		= 0x0700 | 0x20,	KeyRightShift	= 0x0700 | 0x10,
-	KeyForwardSlash	= 0x0700 | 0x08,	Key0			= 0x0700 | 0x04,	KeyL			= 0x0700 | 0x02,	Key8			= 0x0700 | 0x01,
-
-	KeyNMI			= 0xfffd,
-};
-
 enum ROM {
-	BASIC10, BASIC11, Microdisc, Colour
+	BASIC10 = 0, BASIC11, Microdisc, Colour
 };
 
+/// @returns The options available for an Oric.
+std::vector<std::unique_ptr<Configurable::Option>> get_options();
+
+/*!
+	Models an Oric 1/Atmos with or without a Microdisc.
+*/
 class Machine:
-	public CPU::MOS6502::Processor<Machine>,
 	public CRTMachine::Machine,
 	public ConfigurationTarget::Machine,
-	public MOS::MOS6522IRQDelegate::Delegate,
-	public Utility::TypeRecipient,
-	public Storage::Tape::BinaryTapePlayer::Delegate,
-	public Microdisc::Delegate {
-
+	public KeyboardMachine::Machine,
+	public Configurable::Device {
 	public:
-		Machine();
+		virtual ~Machine();
 
-		void set_rom(ROM rom, const std::vector<uint8_t> &data);
-		void set_key_state(uint16_t key, bool isPressed);
-		void clear_all_keys();
+		/// Creates and returns an Oric.
+		static Machine *Oric();
 
-		void set_use_fast_tape_hack(bool activate);
-		void set_output_device(Outputs::CRT::OutputDevice output_device);
+		/// Sets the contents of @c rom to @c data. Assumed to be a setup step; has no effect once a machine is running.
+		virtual void set_rom(ROM rom, const std::vector<uint8_t> &data) = 0;
 
-		// to satisfy ConfigurationTarget::Machine
-		void configure_as_target(const StaticAnalyser::Target &target);
+		/// Enables or disables turbo-speed tape loading.
+		virtual void set_use_fast_tape_hack(bool activate) = 0;
 
-		// to satisfy CPU::MOS6502::Processor
-		Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value);
-		void flush();
-
-		// to satisfy CRTMachine::Machine
-		virtual void setup_output(float aspect_ratio);
-		virtual void close_output();
-		virtual std::shared_ptr<Outputs::CRT::CRT> get_crt();
-		virtual std::shared_ptr<Outputs::Speaker> get_speaker();
-		virtual void run_for(const Cycles cycles);
-
-		// to satisfy MOS::MOS6522IRQDelegate::Delegate
-		void mos6522_did_change_interrupt_status(void *mos6522);
-
-		// to satisfy Storage::Tape::BinaryTapePlayer::Delegate
-		void tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape_player);
-
-		// for Utility::TypeRecipient::Delegate
-		void set_typer_for_string(const char *string);
-
-		// for Microdisc::Delegate
-		void microdisc_did_change_paging_flags(class Microdisc *microdisc);
-		void wd1770_did_change_output(WD::WD1770 *wd1770);
-
-	private:
-		// RAM and ROM
-		std::vector<uint8_t> basic11_rom_, basic10_rom_, microdisc_rom_, colour_rom_;
-		uint8_t ram_[65536], rom_[16384];
-		Cycles cycles_since_video_update_;
-		inline void update_video();
-
-		// ROM bookkeeping
-		bool is_using_basic11_;
-		uint16_t tape_get_byte_address_, scan_keyboard_address_, tape_speed_address_;
-		int keyboard_read_count_;
-
-		// Outputs
-		std::unique_ptr<VideoOutput> video_output_;
-
-		// Keyboard
-		class Keyboard {
-			public:
-				uint8_t row;
-				uint8_t rows[8];
-		};
-		int typer_delay_;
-
-		// The tape
-		class TapePlayer: public Storage::Tape::BinaryTapePlayer {
-			public:
-				TapePlayer();
-				uint8_t get_next_byte(bool fast);
-
-			private:
-				Storage::Tape::Oric::Parser parser_;
-		};
-		bool use_fast_tape_hack_;
-
-		// VIA (which owns the tape and the AY)
-		class VIA: public MOS::MOS6522<VIA>, public MOS::MOS6522IRQDelegate {
-			public:
-				VIA();
-				using MOS6522IRQDelegate::set_interrupt_status;
-
-				void set_control_line_output(Port port, Line line, bool value);
-				void set_port_output(Port port, uint8_t value, uint8_t direction_mask);
-				uint8_t get_port_input(Port port);
-				inline void run_for(const Cycles cycles);
-
-				std::shared_ptr<GI::AY38910::AY38910> ay8910;
-				std::unique_ptr<TapePlayer> tape;
-				std::shared_ptr<Keyboard> keyboard;
-
-				void flush();
-
-			private:
-				void update_ay();
-				bool ay_bdir_, ay_bc1_;
-				Cycles cycles_since_ay_update_;
-		};
-		VIA via_;
-		std::shared_ptr<Keyboard> keyboard_;
-
-		// the Microdisc, if in use
-		class Microdisc microdisc_;
-		bool microdisc_is_enabled_;
-		uint16_t ram_top_;
-		uint8_t *paged_rom_;
-
-		inline void set_interrupt_line();
+		/// Sets the type of display the Oric is connected to.
+		virtual void set_output_device(Outputs::CRT::OutputDevice output_device) = 0;
 };
 
 }

Machines/Oric/Video.cpp

@@ -21,12 +21,9 @@ namespace {
 
 VideoOutput::VideoOutput(uint8_t *memory) :
 		ram_(memory),
-		frame_counter_(0), counter_(0),
-		is_graphics_mode_(false),
-		character_set_base_address_(0xb400),
+		crt_(new Outputs::CRT::CRT(64*6, 6, Outputs::CRT::DisplayType::PAL50, 2)),
 		v_sync_start_position_(PAL50VSyncStartPosition), v_sync_end_position_(PAL50VSyncEndPosition),
-		counter_period_(PAL50Period), next_frame_is_sixty_hertz_(false),
-		crt_(new Outputs::CRT::CRT(64*6, 6, Outputs::CRT::DisplayType::PAL50, 2)) {
+		counter_period_(PAL50Period) {
 	crt_->set_rgb_sampling_function(
 		"vec3 rgb_sample(usampler2D sampler, vec2 coordinate, vec2 icoordinate)"
 		"{"
@@ -44,8 +41,8 @@ VideoOutput::VideoOutput(uint8_t *memory) :
 	);
 	crt_->set_composite_function_type(Outputs::CRT::CRT::CompositeSourceType::DiscreteFourSamplesPerCycle, 0.0f);
 
-	set_output_device(Outputs::CRT::Television);
-	crt_->set_visible_area(crt_->get_rect_for_area(50, 224, 16 * 6, 40 * 6, 4.0f / 3.0f));
+	set_output_device(Outputs::CRT::OutputDevice::Television);
+	crt_->set_visible_area(crt_->get_rect_for_area(53, 224, 16 * 6, 40 * 6, 4.0f / 3.0f));
 }
 
 void VideoOutput::set_output_device(Outputs::CRT::OutputDevice output_device) {
@@ -54,18 +51,18 @@ void VideoOutput::set_output_device(Outputs::CRT::OutputDevice output_device) {
 }
 
 void VideoOutput::set_colour_rom(const std::vector<uint8_t> &rom) {
-	for(size_t c = 0; c < 8; c++) {
-		size_t index = (c << 2);
-		uint16_t rom_value = (uint16_t)(((uint16_t)rom[index] << 8) | (uint16_t)rom[index+1]);
+	for(std::size_t c = 0; c < 8; c++) {
+		std::size_t index = (c << 2);
+		uint16_t rom_value = static_cast<uint16_t>((static_cast<uint16_t>(rom[index]) << 8) | static_cast<uint16_t>(rom[index+1]));
 		rom_value = (rom_value & 0xff00) | ((rom_value >> 4)&0x000f) | ((rom_value << 4)&0x00f0);
 		colour_forms_[c] = rom_value;
 	}
 
 	// check for big endianness and byte swap if required
 	uint16_t test_value = 0x0001;
-	if(*(uint8_t *)&test_value != 0x01) {
-		for(size_t c = 0; c < 8; c++) {
-			colour_forms_[c] = (uint16_t)((colour_forms_[c] >> 8) | (colour_forms_[c] << 8));
+	if(*reinterpret_cast<uint8_t *>(&test_value) != 0x01) {
+		for(std::size_t c = 0; c < 8; c++) {
+			colour_forms_[c] = static_cast<uint16_t>((colour_forms_[c] >> 8) | (colour_forms_[c] << 8));
 		}
 	}
 }
@@ -89,7 +86,7 @@ void VideoOutput::run_for(const Cycles cycles) {
 		if(counter_ >= v_sync_start_position_ && counter_ < v_sync_end_position_) {
 			// this is a sync line
 			cycles_run_for = v_sync_end_position_ - counter_;
-			clamp(crt_->output_sync((unsigned int)(v_sync_end_position_ - v_sync_start_position_) * 6));
+			clamp(crt_->output_sync(static_cast<unsigned int>(v_sync_end_position_ - v_sync_start_position_) * 6));
 		} else if(counter_ < 224*64 && h_counter < 40) {
 			// this is a pixel line
 			if(!h_counter) {
@@ -97,7 +94,7 @@ void VideoOutput::run_for(const Cycles cycles) {
 				paper_ = 0x0;
 				use_alternative_character_set_ = use_double_height_characters_ = blink_text_ = false;
 				set_character_set_base_address();
-				pixel_target_ = (uint16_t *)crt_->allocate_write_area(240);
+				pixel_target_ = reinterpret_cast<uint16_t *>(crt_->allocate_write_area(240));
 
 				if(!counter_) {
 					frame_counter_++;
@@ -132,9 +129,9 @@ void VideoOutput::run_for(const Cycles cycles) {
 				if(control_byte & 0x60) {
 					if(pixel_target_) {
 						uint16_t colours[2];
-						if(output_device_ == Outputs::CRT::Monitor) {
-							colours[0] = (uint8_t)(paper_ ^ inverse_mask);
-							colours[1] = (uint8_t)(ink_ ^ inverse_mask);
+						if(output_device_ == Outputs::CRT::OutputDevice::Monitor) {
+							colours[0] = static_cast<uint8_t>(paper_ ^ inverse_mask);
+							colours[1] = static_cast<uint8_t>(ink_ ^ inverse_mask);
 						} else {
 							colours[0] = colour_forms_[paper_ ^ inverse_mask];
 							colours[1] = colour_forms_[ink_ ^ inverse_mask];
@@ -186,7 +183,7 @@ void VideoOutput::run_for(const Cycles cycles) {
 						pixel_target_[0] = pixel_target_[1] =
 						pixel_target_[2] = pixel_target_[3] =
 						pixel_target_[4] = pixel_target_[5] =
-							(output_device_ == Outputs::CRT::Monitor) ? paper_ ^ inverse_mask : colour_forms_[paper_ ^ inverse_mask];
+							(output_device_ == Outputs::CRT::OutputDevice::Monitor) ? paper_ ^ inverse_mask : colour_forms_[paper_ ^ inverse_mask];
 					}
 				}
 				if(pixel_target_) pixel_target_ += 6;
@@ -202,7 +199,7 @@ void VideoOutput::run_for(const Cycles cycles) {
 				cycles_run_for = 48 - h_counter;
 				clamp(
 					int period = (counter_ < 224*64) ? 8 : 48;
-					crt_->output_blank((unsigned int)period * 6);
+					crt_->output_blank(static_cast<unsigned int>(period) * 6);
 				);
 			} else if(h_counter < 54) {
 				cycles_run_for = 54 - h_counter;

Machines/Oric/Video.hpp

@@ -27,7 +27,7 @@ class VideoOutput {
 		std::shared_ptr<Outputs::CRT::CRT> crt_;
 
 		// Counters and limits
-		int counter_, frame_counter_;
+		int counter_ = 0, frame_counter_ = 0;
 		int v_sync_start_position_, v_sync_end_position_, counter_period_;
 
 		// Output target and device
@@ -38,11 +38,11 @@ class VideoOutput {
 		// Registers
 		uint8_t ink_, paper_;
 
-		int character_set_base_address_;
+		int character_set_base_address_ = 0xb400;
 		inline void set_character_set_base_address();
 
-		bool is_graphics_mode_;
-		bool next_frame_is_sixty_hertz_;
+		bool is_graphics_mode_ = false;
+		bool next_frame_is_sixty_hertz_ = false;
 		bool use_alternative_character_set_;
 		bool use_double_height_characters_;
 		bool blink_text_;

Machines/ROMMachine.hpp

@@ -0,0 +1,27 @@
+//
+//  ROMMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 07/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef ROMMachine_hpp
+#define ROMMachine_hpp
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace ROMMachine {
+
+struct Machine {
+	/*!
+		Provides the machine with a way to obtain such ROMs as it needs.
+	*/
+	virtual bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &rom_with_name) { return true; }
+};
+
+}
+
+#endif /* ROMMachine_h */

Machines/Utility/MachineForTarget.cpp

@@ -0,0 +1,105 @@
+//
+//  MachineForTarget.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "MachineForTarget.hpp"
+
+#include "../AmstradCPC/AmstradCPC.hpp"
+#include "../Atari2600/Atari2600.hpp"
+#include "../Commodore/Vic-20/Vic20.hpp"
+#include "../Electron/Electron.hpp"
+#include "../Oric/Oric.hpp"
+#include "../ZX8081/ZX8081.hpp"
+
+namespace {
+
+template<typename T> class TypedDynamicMachine: public ::Machine::DynamicMachine {
+	public:
+		TypedDynamicMachine(T *machine) : machine_(machine) {}
+
+		ConfigurationTarget::Machine *configuration_target() override {
+			return get<ConfigurationTarget::Machine>();
+		}
+
+		CRTMachine::Machine *crt_machine() override {
+			return get<CRTMachine::Machine>();
+		}
+
+		JoystickMachine::Machine *joystick_machine() override {
+			return get<JoystickMachine::Machine>();
+		}
+
+		KeyboardMachine::Machine *keyboard_machine() override {
+			return get<KeyboardMachine::Machine>();
+		}
+
+		Configurable::Device *configurable_device() override {
+			return get<Configurable::Device>();
+		}
+
+		Utility::TypeRecipient *type_recipient() override {
+			return get<Utility::TypeRecipient>();
+		}
+
+	private:
+		template <typename Class> Class *get() {
+			return dynamic_cast<Class *>(machine_.get());
+		}
+		std::unique_ptr<T> machine_;
+};
+
+}
+
+::Machine::DynamicMachine *::Machine::MachineForTarget(const StaticAnalyser::Target &target) {
+	switch(target.machine) {
+		case StaticAnalyser::Target::AmstradCPC:	return new TypedDynamicMachine<AmstradCPC::Machine>(AmstradCPC::Machine::AmstradCPC());
+		case StaticAnalyser::Target::Atari2600:		return new TypedDynamicMachine<Atari2600::Machine>(Atari2600::Machine::Atari2600());
+		case StaticAnalyser::Target::Electron:		return new TypedDynamicMachine<Electron::Machine>(Electron::Machine::Electron());
+		case StaticAnalyser::Target::Oric:			return new TypedDynamicMachine<Oric::Machine>(Oric::Machine::Oric());
+		case StaticAnalyser::Target::Vic20:			return new TypedDynamicMachine<Commodore::Vic20::Machine>(Commodore::Vic20::Machine::Vic20());
+		case StaticAnalyser::Target::ZX8081:		return new TypedDynamicMachine<ZX8081::Machine>(ZX8081::Machine::ZX8081(target));
+
+		default:	return nullptr;
+	}
+}
+
+std::string Machine::ShortNameForTargetMachine(const StaticAnalyser::Target::Machine machine) {
+	switch(machine) {
+		case StaticAnalyser::Target::AmstradCPC:	return "AmstradCPC";
+		case StaticAnalyser::Target::Atari2600:		return "Atari2600";
+		case StaticAnalyser::Target::Electron:		return "Electron";
+		case StaticAnalyser::Target::Oric:			return "Oric";
+		case StaticAnalyser::Target::Vic20:			return "Vic20";
+		case StaticAnalyser::Target::ZX8081:		return "ZX8081";
+
+		default:	return "";
+	}
+}
+
+std::string Machine::LongNameForTargetMachine(StaticAnalyser::Target::Machine machine) {
+	switch(machine) {
+		case StaticAnalyser::Target::AmstradCPC:	return "Amstrad CPC";
+		case StaticAnalyser::Target::Atari2600:		return "Atari 2600";
+		case StaticAnalyser::Target::Electron:		return "Acorn Electron";
+		case StaticAnalyser::Target::Oric:			return "Oric";
+		case StaticAnalyser::Target::Vic20:			return "Vic 20";
+		case StaticAnalyser::Target::ZX8081:		return "ZX80/81";
+
+		default:	return "";
+	}
+}
+
+std::map<std::string, std::vector<std::unique_ptr<Configurable::Option>>> Machine::AllOptionsByMachineName() {
+	std::map<std::string, std::vector<std::unique_ptr<Configurable::Option>>> options;
+
+	options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Electron), Electron::get_options()));
+	options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Oric), Oric::get_options()));
+	options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Vic20), Commodore::Vic20::get_options()));
+	options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::ZX8081), ZX8081::get_options()));
+
+	return options;
+}

Machines/Utility/MachineForTarget.hpp

@@ -0,0 +1,67 @@
+//
+//  MachineForTarget.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef MachineForTarget_hpp
+#define MachineForTarget_hpp
+
+#include "../../StaticAnalyser/StaticAnalyser.hpp"
+
+#include "../../Configurable/Configurable.hpp"
+#include "../ConfigurationTarget.hpp"
+#include "../CRTMachine.hpp"
+#include "../JoystickMachine.hpp"
+#include "../KeyboardMachine.hpp"
+#include "Typer.hpp"
+
+#include <map>
+#include <string>
+
+namespace Machine {
+
+/*!
+	Provides the structure for owning a machine and dynamically casting it as desired without knowledge of
+	the machine's parent class or, therefore, the need to establish a common one.
+*/
+struct DynamicMachine {
+	virtual ConfigurationTarget::Machine *configuration_target() = 0;
+	virtual CRTMachine::Machine *crt_machine() = 0;
+	virtual JoystickMachine::Machine *joystick_machine() = 0;
+	virtual KeyboardMachine::Machine *keyboard_machine() = 0;
+	virtual Configurable::Device *configurable_device() = 0;
+	virtual Utility::TypeRecipient *type_recipient() = 0;
+};
+
+/*!
+	Allocates an instance of DynamicMachine holding a machine that can
+	receive the supplied target. The machine has been allocated on the heap.
+	It is the caller's responsibility to delete the class when finished.
+*/
+DynamicMachine *MachineForTarget(const StaticAnalyser::Target &target);
+
+/*!
+	Returns a short string name for the machine identified by the target,
+	which is guaranteed not to have any spaces or other potentially
+	filesystem-bothering contents.
+*/
+std::string ShortNameForTargetMachine(const StaticAnalyser::Target::Machine target);
+
+/*!
+	Returns a long string name for the machine identified by the target,
+	usable for presentation to a human.
+*/
+std::string LongNameForTargetMachine(const StaticAnalyser::Target::Machine target);
+
+/*!
+	Returns a map from machine name to the list of options that machine
+	exposes, for all machines.
+*/
+std::map<std::string, std::vector<std::unique_ptr<Configurable::Option>>> AllOptionsByMachineName();
+
+}
+
+#endif /* MachineForTarget_hpp */

Machines/Utility/MemoryFuzzer.cpp

@@ -10,16 +10,16 @@
 
 #include <cstdlib>
 
-void Memory::Fuzz(uint8_t *buffer, size_t size) {
-	unsigned int divider = ((unsigned int)RAND_MAX + 1) / 256;
+void Memory::Fuzz(uint8_t *buffer, std::size_t size) {
+	unsigned int divider = (static_cast<unsigned int>(RAND_MAX) + 1) / 256;
 	unsigned int shift = 1, value = 1;
 	while(value < divider) {
 		value <<= 1;
 		shift++;
 	}
 
-	for(size_t c = 0; c < size; c++) {
-		buffer[c] = (uint8_t)(std::rand() >> shift);
+	for(std::size_t c = 0; c < size; c++) {
+		buffer[c] = static_cast<uint8_t>(std::rand() >> shift);
 	}
 }
 

Machines/Utility/MemoryFuzzer.hpp

@@ -16,7 +16,7 @@
 namespace Memory {
 
 /// Stores @c size random bytes from @c buffer onwards.
-void Fuzz(uint8_t *buffer, size_t size);
+void Fuzz(uint8_t *buffer, std::size_t size);
 
 // Replaces all existing vector contents with random bytes.
 void Fuzz(std::vector<uint8_t> &buffer);

Machines/Utility/Typer.cpp

@@ -7,19 +7,19 @@
 //
 
 #include "Typer.hpp"
-#include <stdlib.h>
+
+#include <cstdlib>
+#include <cstring>
 
 using namespace Utility;
 
 Typer::Typer(const char *string, HalfCycles delay, HalfCycles frequency, std::unique_ptr<CharacterMapper> character_mapper, Delegate *delegate) :
-		counter_(-delay),
 		frequency_(frequency),
-		string_pointer_(0),
+		counter_(-delay),
 		delegate_(delegate),
-		phase_(0),
 		character_mapper_(std::move(character_mapper)) {
-	size_t string_size = strlen(string) + 3;
-	string_ = (char *)malloc(string_size);
+	std::size_t string_size = std::strlen(string) + 3;
+	string_ = (char *)std::malloc(string_size);
 	snprintf(string_, string_size, "%c%s%c", Typer::BeginString, string, Typer::EndString);
 }
 
@@ -44,14 +44,14 @@ void Typer::run_for(const HalfCycles duration) {
 bool Typer::try_type_next_character() {
 	uint16_t *sequence = character_mapper_->sequence_for_character(string_[string_pointer_]);
 
-	if(!sequence || sequence[0] == CharacterMapper::NotMapped) {
+	if(!sequence || sequence[0] == KeyboardMachine::Machine::KeyNotMapped) {
 		return false;
 	}
 
 	if(!phase_) delegate_->clear_all_keys();
 	else {
 		delegate_->set_key_state(sequence[phase_ - 1], true);
-		return sequence[phase_] != CharacterMapper::EndSequence;
+		return sequence[phase_] != KeyboardMachine::Machine::KeyEndSequence;
 	}
 
 	return true;
@@ -63,7 +63,7 @@ bool Typer::type_next_character() {
 	if(!try_type_next_character()) {
 		phase_ = 0;
 		if(!string_[string_pointer_]) {
-			free(string_);
+			std::free(string_);
 			string_ = nullptr;
 			return false;
 		}
@@ -77,14 +77,14 @@ bool Typer::type_next_character() {
 }
 
 Typer::~Typer() {
-	free(string_);
+	std::free(string_);
 }
 
-#pragma mark - Character mapper
+// MARK: - Character mapper
 
-uint16_t *CharacterMapper::table_lookup_sequence_for_character(KeySequence *sequences, size_t length, char character) {
-	size_t ucharacter = (size_t)((unsigned char)character);
+uint16_t *CharacterMapper::table_lookup_sequence_for_character(KeySequence *sequences, std::size_t length, char character) {
+	std::size_t ucharacter = static_cast<std::size_t>((unsigned char)character);
 	if(ucharacter > (length / sizeof(KeySequence))) return nullptr;
-	if(sequences[ucharacter][0] == NotMapped) return nullptr;
+	if(sequences[ucharacter][0] == KeyboardMachine::Machine::KeyNotMapped) return nullptr;
 	return sequences[ucharacter];
 }

Machines/Utility/Typer.hpp

@@ -10,8 +10,8 @@
 #define Typer_hpp
 
 #include <memory>
-#include "KeyboardMachine.hpp"
-#include "../ClockReceiver/ClockReceiver.hpp"
+#include "../KeyboardMachine.hpp"
+#include "../../ClockReceiver/ClockReceiver.hpp"
 
 namespace Utility {
 
@@ -24,15 +24,6 @@ class CharacterMapper {
 		/// @returns The EndSequence-terminated sequence of keys that would cause @c character to be typed.
 		virtual uint16_t *sequence_for_character(char character) = 0;
 
-		/// Terminates a key sequence.
-		static const uint16_t EndSequence = 0xffff;
-
-		/*!
-			If returned as the first entry in a key sequence, indicates that the requested character
-			cannot be mapped.
-		*/
-		static const uint16_t NotMapped = 0xfffe;
-
 	protected:
 		typedef uint16_t KeySequence[16];
 
@@ -41,7 +32,7 @@ class CharacterMapper {
 			with @c length entries, returns the sequence for character @c character if it exists; otherwise
 			returns @c nullptr.
 		*/
-		uint16_t *table_lookup_sequence_for_character(KeySequence *sequences, size_t length, char character);
+		uint16_t *table_lookup_sequence_for_character(KeySequence *sequences, std::size_t length, char character);
 };
 
 /*!
@@ -72,11 +63,11 @@ class Typer {
 
 	private:
 		char *string_;
-		size_t string_pointer_;
+		std::size_t string_pointer_ = 0;
 
 		HalfCycles frequency_;
 		HalfCycles counter_;
-		int phase_;
+		int phase_ = 0;
 
 		Delegate *delegate_;
 		std::unique_ptr<CharacterMapper> character_mapper_;
@@ -107,12 +98,21 @@ class TypeRecipient: public Typer::Delegate {
 		*/
 		void typer_reset(Typer *typer) {
 			clear_all_keys();
+
+			// It's unsafe to deallocate typer right now, since it is the caller, but also it has a small
+			// memory footprint and it's desireable not to imply that the subclass need call it any more.
+			// So shuffle it off into a siding.
+			previous_typer_ = std::move(typer_);
+			typer_ = nullptr;
 		}
 
 	protected:
 		virtual HalfCycles get_typer_delay() { return HalfCycles(0); }
 		virtual HalfCycles get_typer_frequency() { return HalfCycles(0); }
 		std::unique_ptr<Typer> typer_;
+
+	private:
+		std::unique_ptr<Typer> previous_typer_;
 };
 
 }

Machines/ZX8081/CharacterMapper.hpp

@@ -1,27 +0,0 @@
-//
-//  CharacterMapper.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 03/08/2017.
-//  Copyright © 2017 Thomas Harte. All rights reserved.
-//
-
-#ifndef Machines_ZX8081_CharacterMapper_hpp
-#define Machines_ZX8081_CharacterMapper_hpp
-
-#include "../Typer.hpp"
-
-namespace ZX8081 {
-
-class CharacterMapper: public ::Utility::CharacterMapper {
-	public:
-		CharacterMapper(bool is_zx81);
-		uint16_t *sequence_for_character(char character);
-
-	private:
-		bool is_zx81_;
-};
-
-}
-
-#endif /* CharacterMapper_hpp */

Machines/ZX8081/Keyboard.cpp

@@ -1,22 +1,44 @@
 //
-//  CharacterMapper.cpp
+//  Keyboard.cpp
 //  Clock Signal
 //
-//  Created by Thomas Harte on 03/08/2017.
+//  Created by Thomas Harte on 10/10/2017.
 //  Copyright © 2017 Thomas Harte. All rights reserved.
 //
 
-#include "CharacterMapper.hpp"
-#include "ZX8081.hpp"
+#include "Keyboard.hpp"
 
 using namespace ZX8081;
 
+uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) {
+#define BIND(source, dest)	case Inputs::Keyboard::Key::source:	return ZX8081::dest
+	switch(key) {
+		default: break;
+
+		BIND(k0, Key0);		BIND(k1, Key1);		BIND(k2, Key2);		BIND(k3, Key3);		BIND(k4, Key4);
+		BIND(k5, Key5);		BIND(k6, Key6);		BIND(k7, Key7);		BIND(k8, Key8);		BIND(k9, Key9);
+		BIND(Q, KeyQ);		BIND(W, KeyW);		BIND(E, KeyE);		BIND(R, KeyR);		BIND(T, KeyT);
+		BIND(Y, KeyY);		BIND(U, KeyU);		BIND(I, KeyI);		BIND(O, KeyO);		BIND(P, KeyP);
+		BIND(A, KeyA);		BIND(S, KeyS);		BIND(D, KeyD);		BIND(F, KeyF);		BIND(G, KeyG);
+		BIND(H, KeyH);		BIND(J, KeyJ);		BIND(K, KeyK);		BIND(L, KeyL);
+		BIND(Z, KeyZ);		BIND(X, KeyX);		BIND(C, KeyC);		BIND(V, KeyV);
+		BIND(B, KeyB);		BIND(N, KeyN);		BIND(M, KeyM);
+
+		BIND(LeftShift, KeyShift);	BIND(RightShift, KeyShift);
+		BIND(FullStop, KeyDot);
+		BIND(Enter, KeyEnter);
+		BIND(Space, KeySpace);
+	}
+#undef BIND
+	return KeyboardMachine::Machine::KeyNotMapped;
+}
+
 CharacterMapper::CharacterMapper(bool is_zx81) : is_zx81_(is_zx81) {}
 
 uint16_t *CharacterMapper::sequence_for_character(char character) {
-#define KEYS(...)	{__VA_ARGS__, EndSequence}
-#define SHIFT(...)	{KeyShift, __VA_ARGS__, EndSequence}
-#define X			{NotMapped}
+#define KEYS(...)	{__VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define SHIFT(...)	{KeyShift, __VA_ARGS__, KeyboardMachine::Machine::KeyEndSequence}
+#define X			{KeyboardMachine::Machine::KeyNotMapped}
 	static KeySequence zx81_key_sequences[] = {
 		/* NUL */	X,							/* SOH */	X,
 		/* STX */	X,							/* ETX */	X,

Machines/ZX8081/Keyboard.hpp

@@ -0,0 +1,43 @@
+//
+//  Keyboard.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 10/10/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_ZX8081_Keyboard_hpp
+#define Machines_ZX8081_Keyboard_hpp
+
+#include "../KeyboardMachine.hpp"
+#include "../Utility/Typer.hpp"
+
+namespace ZX8081 {
+
+enum Key: uint16_t {
+	KeyShift	= 0x0000 | 0x01,	KeyZ	= 0x0000 | 0x02,	KeyX = 0x0000 | 0x04,	KeyC = 0x0000 | 0x08,	KeyV = 0x0000 | 0x10,
+	KeyA		= 0x0100 | 0x01,	KeyS	= 0x0100 | 0x02,	KeyD = 0x0100 | 0x04,	KeyF = 0x0100 | 0x08,	KeyG = 0x0100 | 0x10,
+	KeyQ		= 0x0200 | 0x01,	KeyW	= 0x0200 | 0x02,	KeyE = 0x0200 | 0x04,	KeyR = 0x0200 | 0x08,	KeyT = 0x0200 | 0x10,
+	Key1		= 0x0300 | 0x01,	Key2	= 0x0300 | 0x02,	Key3 = 0x0300 | 0x04,	Key4 = 0x0300 | 0x08,	Key5 = 0x0300 | 0x10,
+	Key0		= 0x0400 | 0x01,	Key9	= 0x0400 | 0x02,	Key8 = 0x0400 | 0x04,	Key7 = 0x0400 | 0x08,	Key6 = 0x0400 | 0x10,
+	KeyP		= 0x0500 | 0x01,	KeyO	= 0x0500 | 0x02,	KeyI = 0x0500 | 0x04,	KeyU = 0x0500 | 0x08,	KeyY = 0x0500 | 0x10,
+	KeyEnter	= 0x0600 | 0x01,	KeyL	= 0x0600 | 0x02,	KeyK = 0x0600 | 0x04,	KeyJ = 0x0600 | 0x08,	KeyH = 0x0600 | 0x10,
+	KeySpace	= 0x0700 | 0x01,	KeyDot	= 0x0700 | 0x02,	KeyM = 0x0700 | 0x04,	KeyN = 0x0700 | 0x08,	KeyB = 0x0700 | 0x10,
+};
+
+struct KeyboardMapper: public KeyboardMachine::Machine::KeyboardMapper {
+	uint16_t mapped_key_for_key(Inputs::Keyboard::Key key);
+};
+
+class CharacterMapper: public ::Utility::CharacterMapper {
+	public:
+		CharacterMapper(bool is_zx81);
+		uint16_t *sequence_for_character(char character);
+
+	private:
+		bool is_zx81_;
+};
+
+};
+
+#endif /* KeyboardMapper_hpp */