Merge branch 'master' into SeparateFetchClock

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

.github/workflows/ccpp.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Install dependencies
       run: sudo apt-get --allow-releaseinfo-change update && sudo apt-get --fix-missing install libsdl2-dev scons
     - name: Make

Activity/Observer.hpp

@@ -9,6 +9,7 @@
 #ifndef ActivityObserver_h
 #define ActivityObserver_h
 
+#include <cstdint>
 #include <string>
 
 namespace Activity {
@@ -23,10 +24,19 @@ namespace Activity {
 */
 class Observer {
 	public:
+		/// Provides hints as to the sort of information presented on an LED.
+		enum LEDPresentation: uint8_t {
+			/// This LED informs the user of some sort of persistent state, e.g. scroll lock.
+			/// If this flag is absent then the LED describes an ephemeral state, such as media access.
+			Persistent = (1 << 0),
+		};
+
 		/// Announces to the receiver that there is an LED of name @c name.
-		virtual void register_led([[maybe_unused]] const std::string &name) {}
+		virtual void register_led([[maybe_unused]] const std::string &name, [[maybe_unused]] uint8_t presentation = 0) {}
 
 		/// Announces to the receiver that there is a drive of name @c name.
+		///
+		/// If a drive has the same name as an LED, that LED goes with this drive.
 		virtual void register_drive([[maybe_unused]] const std::string &name) {}
 
 		/// Informs the receiver of the new state of the LED with name @c name.

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -11,8 +11,7 @@
 
 #include "ConfidenceSource.hpp"
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a confidence source that calculates its probability by virtual of a history of events.
@@ -41,7 +40,6 @@ class ConfidenceCounter: public ConfidenceSource {
 		int misses_ = 1;
 };
 
-}
 }
 
 #endif /* ConfidenceCounter_hpp */

Analyser/Dynamic/ConfidenceSource.hpp

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

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -13,8 +13,7 @@
 
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Summaries a collection of confidence sources by calculating their weighted sum.
@@ -40,7 +39,6 @@ class ConfidenceSummary: public ConfidenceSource {
 		float weight_sum_;
 };
 
-}
 }
 
 #endif /* ConfidenceSummary_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -15,8 +15,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the configurable interface to multiple machines.
@@ -36,7 +35,6 @@ class MultiConfigurable: public Configurable::Device {
 		std::vector<Configurable::Device *> devices_;
 };
 
-}
 }
 
 #endif /* MultiConfigurable_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -14,8 +14,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the joystick machine interface to multiple machines.
@@ -34,7 +33,6 @@ class MultiJoystickMachine: public MachineTypes::JoystickMachine {
 		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
 };
 
-}
 }
 
 #endif /* MultiJoystickMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -15,8 +15,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the keyboard machine interface to multiple machines.
@@ -55,7 +54,6 @@ class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
 		Inputs::Keyboard &get_keyboard() final;
 };
 
-}
 }
 
 #endif /* MultiKeyboardMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -15,8 +15,7 @@
 #include <memory>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes the media target interface to multiple machines.
@@ -35,7 +34,6 @@ struct MultiMediaTarget: public MachineTypes::MediaTarget {
 		std::vector<MachineTypes::MediaTarget *> targets_;
 };
 
-}
 }
 
 #endif /* MultiMediaTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

@@ -19,8 +19,7 @@
 #include <mutex>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 template <typename MachineType> class MultiInterface {
 	public:
@@ -47,7 +46,7 @@ template <typename MachineType> class MultiInterface {
 		std::recursive_mutex &machines_mutex_;
 
 	private:
-		std::vector<Concurrency::AsyncTaskQueue> queues_;
+		std::vector<Concurrency::AsyncTaskQueue<true>> queues_;
 };
 
 class MultiTimedMachine: public MultiInterface<MachineTypes::TimedMachine>, public MachineTypes::TimedMachine {
@@ -116,7 +115,5 @@ class MultiAudioProducer: public MultiInterface<MachineTypes::AudioProducer>, pu
 */
 
 }
-}
-
 
 #endif /* MultiProducer_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -16,8 +16,7 @@
 #include <mutex>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides a class that multiplexes calls to and from Outputs::Speaker::Speaker in order
@@ -55,7 +54,6 @@ class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker:
 		bool stereo_output_ = false;
 };
 
-}
 }
 
 #endif /* MultiSpeaker_hpp */

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -22,8 +22,7 @@
 #include <mutex>
 #include <vector>
 
-namespace Analyser {
-namespace Dynamic {
+namespace Analyser::Dynamic {
 
 /*!
 	Provides the same interface as to a single machine, while multiplexing all
@@ -80,7 +79,6 @@ class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::
 		bool has_picked_ = false;
 };
 
-}
 }
 
 #endif /* MultiMachine_hpp */

Analyser/Machines.hpp

@@ -17,6 +17,7 @@ enum class Machine {
 	AppleIIgs,
 	Atari2600,
 	AtariST,
+	Amiga,
 	ColecoVision,
 	Electron,
 	Enterprise,

Analyser/Static/Acorn/Disk.hpp

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

Analyser/Static/Acorn/File.hpp

@@ -13,9 +13,7 @@
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 struct File {
 	std::string name;
@@ -60,8 +58,6 @@ struct File {
 	std::vector<Chunk> chunks;
 };
 
-}
-}
 }
 
 #endif /* File_hpp */

Analyser/Static/Acorn/StaticAnalyser.hpp

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

Analyser/Static/Acorn/Tape.cpp

@@ -20,7 +20,7 @@ static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::
 	int shift_register = 0;
 
 // TODO: move this into the parser
-#define shift()	shift_register = (shift_register >> 1) |  (parser.get_next_bit(tape) << 9)
+#define shift()	shift_register = (shift_register >> 1) | (parser.get_next_bit(tape) << 9)
 
 	// find next area of high tone
 	while(!tape->is_at_end() && (shift_register != 0x3ff)) {

Analyser/Static/Acorn/Tape.hpp

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

Analyser/Static/Acorn/Target.hpp

@@ -13,9 +13,7 @@
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Acorn {
+namespace Analyser::Static::Acorn {
 
 struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	bool has_acorn_adfs = false;
@@ -37,8 +35,6 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Acorn_Target_h */

Analyser/Static/Amiga/StaticAnalyser.cpp

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

Analyser/Static/Amiga/StaticAnalyser.hpp

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

Analyser/Static/Amiga/Target.hpp

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

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

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

Analyser/Static/AmstradCPC/Target.hpp

@@ -14,9 +14,7 @@
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace AmstradCPC {
+namespace Analyser::Static::AmstradCPC {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model, CPC464, CPC664, CPC6128);
@@ -32,8 +30,5 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 };
 
 }
-}
-}
-
 
 #endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/AppleII/StaticAnalyser.cpp

@@ -13,8 +13,17 @@ Analyser::Static::TargetList Analyser::Static::AppleII::GetTargets(const Media &
 	auto target = std::make_unique<Target>();
 	target->media = media;
 
-	if(!target->media.disks.empty())
+	// If any disks are present, attach a Disk II.
+	if(!target->media.disks.empty()) {
 		target->disk_controller = Target::DiskController::SixteenSector;
+	}
+
+	// The emulated SCSI card requires a IIe, so upgrade to that if
+	// any mass storage is present.
+	if(!target->media.mass_storage_devices.empty()) {
+		target->model = Target::Model::EnhancedIIe;
+		target->scsi_controller = Target::SCSIController::AppleSCSI;
+	}
 
 	TargetList targets;
 	targets.push_back(std::move(target));

Analyser/Static/AppleII/StaticAnalyser.hpp

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

Analyser/Static/AppleII/Target.hpp

@@ -13,9 +13,7 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace AppleII {
+namespace Analyser::Static::AppleII {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model,
@@ -29,22 +27,28 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 		SixteenSector,
 		ThirteenSector
 	);
+	ReflectableEnum(SCSIController,
+		None,
+		AppleSCSI
+	);
 
 	Model model = Model::IIe;
 	DiskController disk_controller = DiskController::None;
+	SCSIController scsi_controller = SCSIController::None;
 
 	Target() : Analyser::Static::Target(Machine::AppleII) {
 		if(needs_declare()) {
 			DeclareField(model);
 			DeclareField(disk_controller);
+			DeclareField(scsi_controller);
+
 			AnnounceEnum(Model);
 			AnnounceEnum(DiskController);
+			AnnounceEnum(SCSIController);
 		}
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_AppleII_Target_h */

Analyser/Static/AppleIIgs/StaticAnalyser.hpp

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

Analyser/Static/AppleIIgs/Target.hpp

@@ -13,9 +13,7 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace AppleIIgs {
+namespace Analyser::Static::AppleIIgs {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model,
@@ -29,7 +27,7 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 		EightMB
 	);
 
-	Model model = Model::ROM03;
+	Model model = Model::ROM01;
 	MemoryModel memory_model = MemoryModel::EightMB;
 
 	Target() : Analyser::Static::Target(Machine::AppleIIgs) {
@@ -42,8 +40,6 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_AppleIIgs_Target_h */

Analyser/Static/Atari2600/StaticAnalyser.hpp

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

Analyser/Static/Atari2600/Target.hpp

@@ -11,9 +11,7 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Atari2600 {
+namespace Analyser::Static::Atari2600 {
 
 struct Target: public ::Analyser::Static::Target {
 	enum class PagingModel {
@@ -38,8 +36,6 @@ struct Target: public ::Analyser::Static::Target {
 	Target() : Analyser::Static::Target(Machine::Atari2600) {}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/AtariST/StaticAnalyser.hpp

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

Analyser/Static/AtariST/Target.hpp

@@ -12,16 +12,23 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace AtariST {
+namespace Analyser::Static::AtariST {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
-	Target() : Analyser::Static::Target(Machine::AtariST) {}
+	ReflectableEnum(MemorySize,
+		FiveHundredAndTwelveKilobytes,
+		OneMegabyte,
+		FourMegabytes);
+	MemorySize memory_size = MemorySize::OneMegabyte;
+
+	Target() : Analyser::Static::Target(Machine::AtariST) {
+		if(needs_declare()) {
+			DeclareField(memory_size);
+			AnnounceEnum(MemorySize);
+		}
+	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_AtariST_Target_h */

Analyser/Static/Coleco/StaticAnalyser.hpp

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

Analyser/Static/Commodore/Disk.hpp

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

Analyser/Static/Commodore/File.hpp

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

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -93,7 +93,7 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 		// make a first guess based on loading address
 		switch(files.front().starting_address) {
 			default:
-				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) <<  files.front().starting_address);
+				LOG("Unrecognised loading address for Commodore program: " << PADHEX(4) << files.front().starting_address);
 				[[fallthrough]];
 			case 0x1001:
 				memory_model = Target::MemoryModel::Unexpanded;
@@ -188,8 +188,8 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(const Media
 
 				// Unhandled:
 				//
-				//	M6: 	this is a C64 file.
-				//	MV: 	this is a Vic-20 file.
+				//	M6:		this is a C64 file.
+				//	MV:		this is a Vic-20 file.
 				//	J1/J2:	this C64 file should have the primary joystick in slot 1/2.
 				//	RO:		this disk image should be treated as read-only.
 			}

Analyser/Static/Commodore/StaticAnalyser.hpp

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

Analyser/Static/Commodore/Tape.hpp

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

Analyser/Static/Commodore/Target.hpp

@@ -14,9 +14,7 @@
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Commodore {
+namespace Analyser::Static::Commodore {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	enum class MemoryModel {
@@ -71,8 +69,6 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.cpp

@@ -11,7 +11,7 @@
 #include "Kernel.hpp"
 
 using namespace Analyser::Static::MOS6502;
-namespace  {
+namespace {
 
 using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 

Analyser/Static/Disassembler/6502.hpp

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

Analyser/Static/Disassembler/AddressMapper.hpp

@@ -11,9 +11,7 @@
 
 #include <functional>
 
-namespace Analyser {
-namespace Static {
-namespace Disassembler {
+namespace Analyser::Static::Disassembler {
 
 /*!
 	Provides an address mapper that relocates a chunk of memory so that it starts at
@@ -25,8 +23,6 @@ template <typename T> std::function<std::size_t(T)> OffsetMapper(T start_address
 	};
 }
 
-}
-}
 }
 
 #endif /* AddressMapper_hpp */

Analyser/Static/Disassembler/Kernel.hpp

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

Analyser/Static/Disassembler/Z80.cpp

@@ -11,7 +11,7 @@
 #include "Kernel.hpp"
 
 using namespace Analyser::Static::Z80;
-namespace  {
+namespace {
 
 using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 

Analyser/Static/Disassembler/Z80.hpp

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

Analyser/Static/DiskII/StaticAnalyser.hpp

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

Analyser/Static/Enterprise/StaticAnalyser.cpp

@@ -48,9 +48,10 @@ Analyser::Static::TargetList Analyser::Static::Enterprise::GetTargets(const Medi
 		auto volume = Storage::Disk::FAT::GetVolume(media.disks.front());
 		if(volume) {
 			// If there's an EXDOS.INI then this disk should be able to boot itself.
-			// If not but if there's only one .COM or .BAS, automatically load that.
-			// Failing that, issue a :DIR and give the user a clue as to how to load.
-			const Storage::Disk::FAT::File *selected_file = nullptr;
+			// If not but if there's only one visible .COM or .BAS, automatically load
+			// that. Otherwise, issue a :DIR.
+			using File = Storage::Disk::FAT::File;
+			const File *selected_file = nullptr;
 			bool has_exdos_ini = false;
 			bool did_pick_file = false;
 			for(const auto &file: (*volume).root_directory) {
@@ -59,7 +60,9 @@ Analyser::Static::TargetList Analyser::Static::Enterprise::GetTargets(const Medi
 					break;
 				}
 
-				if(insensitive_equal(file.extension, "com") || insensitive_equal(file.extension, "bas")) {
+				if(!(file.attributes & File::Attribute::Hidden) &&
+					(insensitive_equal(file.extension, "com") || insensitive_equal(file.extension, "bas"))
+				) {
 					did_pick_file = !selected_file;
 					selected_file = &file;
 				}

Analyser/Static/Enterprise/StaticAnalyser.hpp

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

Analyser/Static/Enterprise/Target.hpp

@@ -15,9 +15,7 @@
 
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Enterprise {
+namespace Analyser::Static::Enterprise {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model, Enterprise64, Enterprise128, Enterprise256);
@@ -50,8 +48,6 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Enterprise_Target_h */

Analyser/Static/MSX/Cartridge.hpp

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

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -37,6 +37,11 @@ static std::unique_ptr<Analyser::Static::Target> CartridgeTarget(
 	auto target = std::make_unique<Analyser::Static::MSX::Target>();
 	target->confidence = confidence;
 
+	// Observation: all ROMs of 48kb or less are from the MSX 1 era.
+	if(segment.data.size() < 48*1024) {
+		target->model = Analyser::Static::MSX::Target::Model::MSX1;
+	}
+
 	if(type == Analyser::Static::MSX::Cartridge::Type::None) {
 		target->media.cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
 	} else {
@@ -100,6 +105,7 @@ static Analyser::Static::TargetList CartridgeTargetsFrom(
 		// TODO: check for a rational init address?
 
 		// If this ROM is less than 48kb in size then it's an ordinary ROM. Just emplace it and move on.
+		// Bonus observation: all such ROMs are from the MSX 1 era.
 		if(data_size <= 0xc000) {
 			targets.emplace_back(CartridgeTarget(segment, start_address, Analyser::Static::MSX::Cartridge::Type::None, 1.0));
 			continue;

Analyser/Static/MSX/StaticAnalyser.hpp

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

Analyser/Static/MSX/Tape.hpp

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

Analyser/Static/MSX/Target.hpp

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

Analyser/Static/Macintosh/StaticAnalyser.hpp

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

Analyser/Static/Macintosh/Target.hpp

@@ -13,9 +13,7 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Macintosh {
+namespace Analyser::Static::Macintosh {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model, Mac128k, Mac512k, Mac512ke, MacPlus);
@@ -30,8 +28,6 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Macintosh_Target_h */

Analyser/Static/Oric/StaticAnalyser.hpp

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

Analyser/Static/Oric/Tape.hpp

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

Analyser/Static/Oric/Target.hpp

@@ -14,9 +14,7 @@
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace Oric {
+namespace Analyser::Static::Oric {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(ROM,
@@ -56,8 +54,6 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_Oric_Target_h */

Analyser/Static/Sega/StaticAnalyser.hpp

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

Analyser/Static/Sega/Target.hpp

@@ -13,9 +13,7 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace Sega {
+namespace Analyser::Static::Sega {
 
 struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	enum class Model {
@@ -48,10 +46,10 @@ struct Target: public Analyser::Static::Target, public Reflection::StructImpl<Ta
 	}
 };
 
-#define is_master_system(v) v >= Analyser::Static::Sega::Target::Model::MasterSystem
+constexpr bool is_master_system(Analyser::Static::Sega::Target::Model model) {
+	return model >= Analyser::Static::Sega::Target::Model::MasterSystem;
+}
 
-}
-}
 }
 
 #endif /* Analyser_Static_Sega_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -15,6 +15,7 @@
 
 // Analysers
 #include "Acorn/StaticAnalyser.hpp"
+#include "Amiga/StaticAnalyser.hpp"
 #include "AmstradCPC/StaticAnalyser.hpp"
 #include "AppleII/StaticAnalyser.hpp"
 #include "AppleIIgs/StaticAnalyser.hpp"
@@ -38,25 +39,27 @@
 // Disks
 #include "../../Storage/Disk/DiskImage/Formats/2MG.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/AmigaADF.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/AppleDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/D64.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/MacintoshIMG.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/G64.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/DMK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/FAT12.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/IPF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/MacintoshIMG.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/MSA.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/NIB.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
-#include "../../Storage/Disk/DiskImage/Formats/ST.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/STX.hpp"
 #include "../../Storage/Disk/DiskImage/Formats/WOZ.hpp"
 
 // Mass Storage Devices (i.e. usually, hard disks)
 #include "../../Storage/MassStorage/Formats/DAT.hpp"
 #include "../../Storage/MassStorage/Formats/DSK.hpp"
+#include "../../Storage/MassStorage/Formats/HDV.hpp"
 #include "../../Storage/MassStorage/Formats/HFV.hpp"
 
 // State Snapshots
@@ -78,6 +81,8 @@
 // Target Platform Types
 #include "../../Storage/TargetPlatforms.hpp"
 
+template<class> inline constexpr bool always_false_v = false;
+
 using namespace Analyser::Static;
 
 namespace {
@@ -101,8 +106,8 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 #define InsertInstance(list, instance, platforms) \
 	list.emplace_back(instance);\
 	potential_platforms |= platforms;\
-	TargetPlatform::TypeDistinguisher *distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
-	if(distinguisher) potential_platforms &= distinguisher->target_platform_type(); \
+	TargetPlatform::TypeDistinguisher *const distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
+	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
 
 #define Insert(list, class, platforms, ...) \
 	InsertInstance(list, new Storage::class(__VA_ARGS__), platforms);
@@ -121,14 +126,29 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	if(extension == "2mg") {
 		// 2MG uses a factory method; defer to it.
 		try {
-			InsertInstance(result.disks, Storage::Disk::Disk2MG::open(file_name), TargetPlatform::DiskII)
+			const auto media = Storage::Disk::Disk2MG::open(file_name);
+			std::visit([&result, &potential_platforms](auto &&arg) {
+				using Type = typename std::decay<decltype(arg)>::type;
+
+				if constexpr (std::is_same<Type, nullptr_t>::value) {
+					// It's valid for no media to be returned.
+				} else if constexpr (std::is_same<Type, Storage::Disk::DiskImageHolderBase *>::value) {
+					InsertInstance(result.disks, arg, TargetPlatform::DiskII);
+				} else if constexpr (std::is_same<Type, Storage::MassStorage::MassStorageDevice *>::value) {
+					// TODO: or is it Apple IIgs?
+					InsertInstance(result.mass_storage_devices, arg, TargetPlatform::AppleII);
+				} else {
+					static_assert(always_false_v<Type>, "Unexpected type encountered.");
+				}
+			}, media);
 		} catch(...) {}
 	}
 
 	Format("80", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 80
 	Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// 81
 	Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600)							// A26
-	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADF
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADF (Acorn)
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AmigaADF>, TargetPlatform::Amiga)			// ADF (Amiga)
 	Format("adl", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)			// ADL
 	Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge)						// BIN (cartridge dump)
 	Format("cas", result.tapes, Tape::CAS, TargetPlatform::MSX)													// CAS
@@ -151,6 +171,7 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::MSX)				// DSK (MSX)
 	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::OricMFMDSK>, TargetPlatform::Oric)			// DSK (Oric)
 	Format("g64", result.disks, Disk::DiskImageHolder<Storage::Disk::G64>, TargetPlatform::Commodore)			// G64
+	Format("hdv", result.mass_storage_devices, MassStorage::HDV, TargetPlatform::AppleII)						// HDV (Apple II, hard disk, single volume image)
 	Format(	"hfe",
 			result.disks,
 			Disk::DiskImageHolder<Storage::Disk::HFE>,
@@ -158,8 +179,13 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 			// HFE (TODO: switch to AllDisk once the MSX stops being so greedy)
 	Format("img", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)		// IMG (DiskCopy 4.2)
 	Format("image", result.disks, Disk::DiskImageHolder<Storage::Disk::MacintoshIMG>, TargetPlatform::Macintosh)	// IMG (DiskCopy 4.2)
-	Format("img", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::Enterprise)		// IMG (Enterprise/MS-DOS style)
+	Format("img", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::Enterprise)			// IMG (Enterprise/MS-DOS style)
+	Format(	"ipf",
+			result.disks,
+			Disk::DiskImageHolder<Storage::Disk::IPF>,
+			TargetPlatform::Amiga | TargetPlatform::AtariST | TargetPlatform::AmstradCPC | TargetPlatform::ZXSpectrum)		// IPF
 	Format("msa", result.disks, Disk::DiskImageHolder<Storage::Disk::MSA>, TargetPlatform::AtariST)				// MSA
+	Format("mx2", result.cartridges, Cartridge::BinaryDump, TargetPlatform::MSX)								// MX2
 	Format("nib", result.disks, Disk::DiskImageHolder<Storage::Disk::NIB>, TargetPlatform::DiskII)				// NIB
 	Format("o", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// O
 	Format("p", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)											// P
@@ -191,7 +217,7 @@ static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::
 	Format("sg", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Sega)								// SG
 	Format("sms", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Sega)								// SMS
 	Format("ssd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)				// SSD
-	Format("st", result.disks, Disk::DiskImageHolder<Storage::Disk::ST>, TargetPlatform::AtariST)				// ST
+	Format("st", result.disks, Disk::DiskImageHolder<Storage::Disk::FAT12>, TargetPlatform::AtariST)			// ST
 	Format("stx", result.disks, Disk::DiskImageHolder<Storage::Disk::STX>, TargetPlatform::AtariST)				// STX
 	Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore)									// TAP (Commodore)
 	Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric)											// TAP (Oric)
@@ -219,7 +245,7 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 	const std::string extension = get_extension(file_name);
 
 	// Check whether the file directly identifies a target; if so then just return that.
-#define Format(ext, class) 											\
+#define Format(ext, class)											\
 	if(extension == ext)	{										\
 		try {														\
 			auto target = Storage::State::class::load(file_name);	\
@@ -253,6 +279,7 @@ TargetList Analyser::Static::GetTargets(const std::string &file_name) {
 	Append(AmstradCPC);
 	Append(AppleII);
 	Append(AppleIIgs);
+	Append(Amiga);
 	Append(Atari2600);
 	Append(AtariST);
 	Append(Coleco);

Analyser/Static/StaticAnalyser.hpp

@@ -21,8 +21,7 @@
 #include <string>
 #include <vector>
 
-namespace Analyser {
-namespace Static {
+namespace Analyser::Static {
 
 struct State;
 
@@ -79,7 +78,6 @@ TargetList GetTargets(const std::string &file_name);
 */
 Media GetMedia(const std::string &file_name);
 
-}
 }
 
 #endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.hpp

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

Analyser/Static/ZX8081/Target.hpp

@@ -14,9 +14,7 @@
 #include "../StaticAnalyser.hpp"
 #include <string>
 
-namespace Analyser {
-namespace Static {
-namespace ZX8081 {
+namespace Analyser::Static::ZX8081 {
 
 struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(MemoryModel,
@@ -40,8 +38,6 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	}
 };
 
-}
-}
 }
 
 #endif /* Analyser_Static_ZX8081_Target_h */

Analyser/Static/ZXSpectrum/StaticAnalyser.hpp

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

Analyser/Static/ZXSpectrum/Target.hpp

@@ -13,9 +13,7 @@
 #include "../../../Reflection/Struct.hpp"
 #include "../StaticAnalyser.hpp"
 
-namespace Analyser {
-namespace Static {
-namespace ZXSpectrum {
+namespace Analyser::Static::ZXSpectrum {
 
 struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<Target> {
 	ReflectableEnum(Model,
@@ -38,8 +36,6 @@ struct Target: public ::Analyser::Static::Target, public Reflection::StructImpl<
 	}
 };
 
-}
-}
 }
 
 #endif /* Target_h */

ClockReceiver/ClockReceiver.hpp

@@ -11,6 +11,7 @@
 
 #include "ForceInline.hpp"
 
+#include <algorithm>
 #include <cstdint>
 #include <limits>
 
@@ -138,8 +139,11 @@ template <class T> class WrappedInt {
 		forceinline constexpr bool operator !() const					{	return !length_;					}
 		// bool operator () is not supported because it offers an implicit cast to int, which is prone silently to permit misuse
 
-		/// @returns The underlying int, cast to an integral type of your choosing.
-		template<typename Type = IntType> forceinline constexpr Type as() const { return Type(length_); }
+		/// @returns The underlying int, converted to an integral type of your choosing, clamped to that int's range.
+		template<typename Type = IntType> forceinline constexpr Type as() const {
+			const auto clamped = std::clamp(length_, IntType(std::numeric_limits<Type>::min()), IntType(std::numeric_limits<Type>::max()));
+			return Type(clamped);
+		}
 
 		/// @returns The underlying int, in its native form.
 		forceinline constexpr IntType as_integral() const { return length_; }
@@ -222,6 +226,15 @@ class HalfCycles: public WrappedInt<HalfCycles> {
 			return result;
 		}
 
+		/*!
+			Equivalent to @c divide_cycles(Cycles(1)) but faster.
+		*/
+		forceinline Cycles divide_cycles() {
+			const Cycles result(length_ >> 1);
+			length_ &= 1;
+			return result;
+		}
+
 	private:
 		friend WrappedInt;
 		void fill(Cycles &result) {

ClockReceiver/DeferredValue.hpp

@@ -0,0 +1,48 @@
+//
+//  DeferredValue.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 07/08/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef DeferredValue_h
+#define DeferredValue_h
+
+/*!
+	Provides storage for a single deferred value: one with a current value and a certain number
+	of future values.
+*/
+template <int DeferredDepth, typename ValueT> class DeferredValue {
+	private:
+		static_assert(sizeof(ValueT) <= 4);
+
+		constexpr int elements_per_uint32 = sizeof(uint32_t) / sizeof(ValueT);
+		constexpr int unit_shift = sizeof(ValueT) * 8;
+		constexpr int insert_shift = (DeferredDepth & (elements_per_uint32 - 1)) * unit_shift;
+		constexpr uint32_t insert_mask = ~(0xffff'ffff << insert_shift);
+
+		std::array<uint32_t, (DeferredDepth + elements_per_uint32 - 1) / elements_per_uint32> backlog;
+
+	public:
+		/// @returns the current value.
+		ValueT value() const {
+			return uint8_t(backlog[0]);
+		}
+
+		/// Advances to the next enqueued value.
+		void advance() {
+			for(size_t c = 0; c < backlog.size() - 1; c--) {
+				backlog[c] = (backlog[c] >> unit_shift) | (backlog[c+1] << (32 - unit_shift));
+			}
+			backlog[backlog.size() - 1] >>= unit_shift;
+		}
+
+		/// Inserts a new value, replacing whatever is currently at the end of the queue.
+		void insert(ValueT value) {
+			backlog[DeferredDepth / elements_per_uint32] =
+				(backlog[DeferredDepth / elements_per_uint32] & insert_mask) | (value << insert_shift);
+		}
+};
+
+#endif /* DeferredValue_h */

ClockReceiver/JustInTime.hpp

@@ -9,10 +9,13 @@
 #ifndef JustInTime_h
 #define JustInTime_h
 
+#include "ClockReceiver.hpp"
 #include "../Concurrency/AsyncTaskQueue.hpp"
 #include "ClockingHintSource.hpp"
 #include "ForceInline.hpp"
 
+#include <atomic>
+
 /*!
 	A JustInTimeActor holds (i) an embedded object with a run_for method; and (ii) an amount
 	of time since run_for was last called.
@@ -120,7 +123,13 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 		/// If this object provides sequence points, checks for changes to the next
 		/// sequence point upon deletion of the pointer.
 		[[nodiscard]] forceinline auto operator->() {
+#ifndef NDEBUG
+			assert(!flush_concurrency_check_.test_and_set());
+#endif
 			flush();
+#ifndef NDEBUG
+			flush_concurrency_check_.clear();
+#endif
 			return std::unique_ptr<T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(this));
 		}
 
@@ -129,7 +138,13 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 		/// Despite being const, this will flush the object and, if relevant, update the next sequence point.
 		[[nodiscard]] forceinline auto operator -> () const {
 			auto non_const_this = const_cast<JustInTimeActor<T, LocalTimeScale, multiplier, divider> *>(this);
+#ifndef NDEBUG
+			assert(!non_const_this->flush_concurrency_check_.test_and_set());
+#endif
 			non_const_this->flush();
+#ifndef NDEBUG
+			non_const_this->flush_concurrency_check_.clear();
+#endif
 			return std::unique_ptr<const T, SequencePointAwareDeleter>(&object_, SequencePointAwareDeleter(non_const_this));
 		}
 
@@ -263,6 +278,10 @@ template <class T, class LocalTimeScale = HalfCycles, int multiplier = 1, int di
 		void set_component_prefers_clocking(ClockingHint::Source *, ClockingHint::Preference clocking) {
 			clocking_preference_ = clocking;
 		}
+
+#ifndef NDEBUG
+		std::atomic_flag flush_concurrency_check_{};
+#endif
 };
 
 /*!
@@ -275,7 +294,7 @@ template <class T, class LocalTimeScale = HalfCycles, class TargetTimeScale = Lo
 		/// Constructs a new AsyncJustInTimeActor using the same construction arguments as the included object.
 		template<typename... Args> AsyncJustInTimeActor(TargetTimeScale threshold, Args&&... args) :
 			object_(std::forward<Args>(args)...),
-		 	threshold_(threshold) {}
+			threshold_(threshold) {}
 
 		/// Adds time to the actor.
 		inline void operator += (const LocalTimeScale &rhs) {
@@ -314,7 +333,7 @@ template <class T, class LocalTimeScale = HalfCycles, class TargetTimeScale = Lo
 		LocalTimeScale time_since_update_;
 		TargetTimeScale threshold_;
 		bool is_flushed_ = true;
-		Concurrency::AsyncTaskQueue task_queue_;
+		Concurrency::AsyncTaskQueue<true> task_queue_;
 };
 
 #endif /* JustInTime_h */

ClockReceiver/TimeTypes.hpp

@@ -20,6 +20,11 @@ inline Nanos nanos_now() {
 	return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 }
 
+inline Seconds seconds(Nanos nanos) {
+	return double(nanos) / 1e9;
+}
+
 }
 
 #endif /* TimeTypes_h */
+

Components/1770/1770.cpp

@@ -66,7 +66,7 @@ uint8_t WD1770::read(int address) {
 
 			// Per Jean Louis-Guérin's documentation:
 			//
-			//	* 	the write-protect bit is locked into place by a type 2 or type 3 command, but is
+			//	*	the write-protect bit is locked into place by a type 2 or type 3 command, but is
 			//		read live after a type 1.
 			//	*	the track 0 bit is captured during a type 1 instruction and lost upon any other type,
 			//		it is not live sampled.

Components/5380/ncr5380.cpp

@@ -8,8 +8,18 @@
 
 #include "ncr5380.hpp"
 
+#ifndef NDEBUG
+#define NDEBUG
+#endif
+#define LOG_PREFIX "[5380] "
+
 #include "../../Outputs/Log.hpp"
 
+// TODO:
+//
+//	end_of_dma_ should be set if: /EOP && /DACK && (/RD || /WR); for at least 100ns.
+
+
 using namespace NCR::NCR5380;
 using SCSI::Line;
 
@@ -28,20 +38,16 @@ NCR5380::NCR5380(SCSI::Bus &bus, int clock_rate) :
 void NCR5380::write(int address, uint8_t value, bool) {
 	switch(address & 7) {
 		case 0:
-//			LOG("[SCSI 0] Set current SCSI bus state to " << PADHEX(2) << int(value));
-			data_bus_ = value;
+			LOG("[0] Set current SCSI bus state to " << PADHEX(2) << int(value));
 
+			data_bus_ = value;
 			if(dma_request_ && dma_operation_ == DMAOperation::Send) {
-//				printf("w %02x\n", value);
-				dma_acknowledge_ = true;
-				dma_request_ = false;
-				update_control_output();
-				bus_.set_device_output(device_id_, bus_output_);
+				dma_acknowledge(value);
 			}
 		break;
 
 		case 1: {
-//			LOG("[SCSI 1] Initiator command register set: " << PADHEX(2) << int(value));
+			LOG("[1] Initiator command register set: " << PADHEX(2) << int(value));
 			initiator_command_ = value;
 
 			bus_output_ &= ~(Line::Reset | Line::Acknowledge | Line::Busy | Line::SelectTarget | Line::Attention);
@@ -57,7 +63,7 @@ void NCR5380::write(int address, uint8_t value, bool) {
 		} break;
 
 		case 2:
-//			LOG("[SCSI 2] Set mode: " << PADHEX(2) << int(value));
+			LOG("[2] Set mode: " << PADHEX(2) << int(value));
 			mode_ = value;
 
 			// bit 7: 1 = use block mode DMA mode (if DMA mode is also enabled)
@@ -69,6 +75,7 @@ void NCR5380::write(int address, uint8_t value, bool) {
 			// bit 1: 1 = use DMA mode
 			// bit 0: 1 = begin arbitration mode (device ID should be in register 0)
 			arbitration_in_progress_ = false;
+			phase_mismatch_ = false;
 			switch(mode_ & 0x3) {
 				case 0x0:
 					bus_output_ &= ~SCSI::Line::Busy;
@@ -88,31 +95,36 @@ void NCR5380::write(int address, uint8_t value, bool) {
 					bus_.update_observers();
 				break;
 			}
+
+			// "[The End of DMA Transfer] bit is reset when the DMA MODE bit
+			// is reset (0) in the Mode Register".
+			end_of_dma_ &= bool(value & 0x2);
+
 			update_control_output();
 		break;
 
 		case 3: {
-//			LOG("[SCSI 3] Set target command: " << PADHEX(2) << int(value));
+			LOG("[3] Set target command: " << PADHEX(2) << int(value));
 			target_command_ = value;
 			update_control_output();
 		} break;
 
 		case 4:
-//			LOG("[SCSI 4] Set select enabled: " << PADHEX(2) << int(value));
+			LOG("[4] Set select enabled: " << PADHEX(2) << int(value));
 		break;
 
 		case 5:
-//			LOG("[SCSI 5] Start DMA send: " << PADHEX(2) << int(value));
+			LOG("[5] Start DMA send: " << PADHEX(2) << int(value));
 			dma_operation_ = DMAOperation::Send;
 		break;
 
 		case 6:
-//			LOG("[SCSI 6] Start DMA target receive: " << PADHEX(2) << int(value));
+			LOG("[6] Start DMA target receive: " << PADHEX(2) << int(value));
 			dma_operation_ = DMAOperation::TargetReceive;
 		break;
 
 		case 7:
-//			LOG("[SCSI 7] Start DMA initiator receive: " << PADHEX(2) << int(value));
+			LOG("[7] Start DMA initiator receive: " << PADHEX(2) << int(value));
 			dma_operation_ = DMAOperation::InitiatorReceive;
 		break;
 	}
@@ -136,18 +148,15 @@ void NCR5380::write(int address, uint8_t value, bool) {
 uint8_t NCR5380::read(int address, bool) {
 	switch(address & 7) {
 		case 0:
-//			LOG("[SCSI 0] Get current SCSI bus state: " << PADHEX(2) << (bus_.get_state() & 0xff));
+			LOG("[0] Get current SCSI bus state: " << PADHEX(2) << (bus_.get_state() & 0xff));
 
 			if(dma_request_ && dma_operation_ == DMAOperation::InitiatorReceive) {
-				dma_acknowledge_ = true;
-				dma_request_ = false;
-				update_control_output();
-				bus_.set_device_output(device_id_, bus_output_);
+				return dma_acknowledge();
 			}
 		return uint8_t(bus_.get_state());
 
 		case 1:
-//			LOG("[SCSI 1] Initiator command register get: " << (arbitration_in_progress_ ? 'p' : '-') <<  (lost_arbitration_ ? 'l' : '-'));
+			LOG("[1] Initiator command register get: " << (arbitration_in_progress_ ? 'p' : '-') << (lost_arbitration_ ? 'l' : '-'));
 		return
 			// Bits repeated as they were set.
 			(initiator_command_ & ~0x60) |
@@ -159,11 +168,11 @@ uint8_t NCR5380::read(int address, bool) {
 			(lost_arbitration_ ? 0x20 : 0x00);
 
 		case 2:
-//			LOG("[SCSI 2] Get mode");
+			LOG("[2] Get mode");
 		return mode_;
 
 		case 3:
-//			LOG("[SCSI 3] Get target command");
+			LOG("[3] Get target command");
 		return target_command_;
 
 		case 4: {
@@ -177,41 +186,38 @@ uint8_t NCR5380::read(int address, bool) {
 				((bus_state & Line::Input)			? 0x04 : 0x00) |
 				((bus_state & Line::SelectTarget)	? 0x02 : 0x00) |
 				((bus_state & Line::Parity)			? 0x01 : 0x00);
-//			LOG("[SCSI 4] Get current bus state: " << PADHEX(2) << int(result));
+			LOG("[4] Get current bus state: " << PADHEX(2) << int(result));
 			return result;
 		}
 
 		case 5: {
 			const auto bus_state = bus_.get_state();
-			const bool phase_matches =
-				(target_output() & (Line::Message | Line::Control | Line::Input)) ==
-				(bus_state & (Line::Message | Line::Control | Line::Input));
-
 			const uint8_t result =
-				/* b7 = end of DMA */
+				(end_of_dma_ ? 0x80 : 0x00) |
 				((dma_request_ && state_ == ExecutionState::PerformingDMA) ? 0x40 : 0x00)	|
 				/* b5 = parity error */
-				/* b4 = IRQ active */
-				(phase_matches ? 0x08 : 0x00)	|
+				(irq_ ? 0x10 : 0x00) |
+				(phase_matches() ? 0x08 : 0x00)	|
 				/* b2 = busy error */
 				((bus_state & Line::Attention) ? 0x02 : 0x00) |
 				((bus_state & Line::Acknowledge) ? 0x01 : 0x00);
-//			LOG("[SCSI 5] Get bus and status: " << PADHEX(2) << int(result));
+			LOG("[5] Get bus and status: " << PADHEX(2) << int(result));
 			return result;
 		}
 
 		case 6:
-//			LOG("[SCSI 6] Get input data");
+			LOG("[6] Get input data");
 		return 0xff;
 
 		case 7:
-//			LOG("[SCSI 7] Reset parity/interrupt");
+			LOG("[7] Reset parity/interrupt");
+			irq_ = false;
 		return 0xff;
 	}
 	return 0;
 }
 
-SCSI::BusState NCR5380::target_output() {
+SCSI::BusState NCR5380::target_output() const {
 	SCSI::BusState output = SCSI::DefaultBusState;
 	if(target_command_ & 0x08) output |= Line::Request;
 	if(target_command_ & 0x04) output |= Line::Message;
@@ -236,6 +242,17 @@ void NCR5380::update_control_output() {
 }
 
 void NCR5380::scsi_bus_did_change(SCSI::Bus *, SCSI::BusState new_state, double time_since_change) {
+	/*
+		When connected as an Initiator with DMA Mode True,
+		if the phase lines I//O, C//D, and /MSG do not match the
+		phase bits in the Target Command Register, a phase mismatch
+		interrupt is generated when /REQ goes active.
+	*/
+	if((mode_ & 0x42) == 0x02 && new_state & SCSI::Line::Request && !phase_matches()) {
+		irq_ = true;
+		phase_mismatch_ = true;
+	}
+
 	switch(state_) {
 		default: break;
 
@@ -296,7 +313,13 @@ void NCR5380::scsi_bus_did_change(SCSI::Bus *, SCSI::BusState new_state, double
 					dma_request_ = false;
 				break;
 				case SCSI::Line::Request:
-					dma_request_ = true;
+					// Don't issue a new DMA request if a phase mismatch has
+					// been detected and this is an intiator receiving.
+					// This is a bit of reading between the lines.
+					// (i.e. guesswork, partly)
+					dma_request_ =
+						!phase_mismatch_ ||
+						(dma_operation_ != DMAOperation::InitiatorReceive);
 				break;
 				case SCSI::Line::Request | SCSI::Line::Acknowledge:
 					dma_request_ = false;
@@ -316,3 +339,38 @@ void NCR5380::set_execution_state(ExecutionState state) {
 	state_ = state;
 	if(state != ExecutionState::PerformingDMA) dma_operation_ = DMAOperation::Ready;
 }
+
+size_t NCR5380::scsi_id() {
+	return device_id_;
+}
+
+bool NCR5380::dma_request() {
+	return dma_request_;
+}
+
+uint8_t NCR5380::dma_acknowledge() {
+	const uint8_t bus_state = uint8_t(bus_.get_state());
+
+	dma_acknowledge_ = true;
+	dma_request_ = false;
+	update_control_output();
+	bus_.set_device_output(device_id_, bus_output_);
+
+	return bus_state;
+}
+
+void NCR5380::dma_acknowledge(uint8_t value) {
+	data_bus_ = value;
+
+	dma_acknowledge_ = true;
+	dma_request_ = false;
+	update_control_output();
+	bus_.set_device_output(device_id_, bus_output_);
+}
+
+bool NCR5380::phase_matches() const {
+	const auto bus_state = bus_.get_state();
+	return
+		(target_output() & (Line::Message | Line::Control | Line::Input)) ==
+		(bus_state & (Line::Message | Line::Control | Line::Input));
+}

Components/5380/ncr5380.hpp

@@ -14,8 +14,7 @@
 #include "../../Storage/MassStorage/SCSI/SCSI.hpp"
 
 
-namespace NCR {
-namespace NCR5380 {
+namespace NCR::NCR5380 {
 
 /*!
 	Models the NCR 5380, a SCSI interface chip.
@@ -24,12 +23,24 @@ class NCR5380 final: public SCSI::Bus::Observer {
 	public:
 		NCR5380(SCSI::Bus &bus, int clock_rate);
 
-		/*! Writes @c value to @c address.  */
+		/*! Writes @c value to @c address. */
 		void write(int address, uint8_t value, bool dma_acknowledge = false);
 
 		/*! Reads from @c address. */
 		uint8_t read(int address, bool dma_acknowledge = false);
 
+		/*! @returns The SCSI ID assigned to this device. */
+		size_t scsi_id();
+
+		/*! @return @c true if DMA request is active; @c false otherwise. */
+		bool dma_request();
+
+		/*! Signals DMA acknowledge with a simultaneous read. */
+		uint8_t dma_acknowledge();
+
+		/*! Signals DMA acknowledge with a simultaneous write. */
+		void dma_acknowledge(uint8_t);
+
 	private:
 		SCSI::Bus &bus_;
 
@@ -46,6 +57,10 @@ class NCR5380 final: public SCSI::Bus::Observer {
 		bool assert_data_bus_ = false;
 		bool dma_request_ = false;
 		bool dma_acknowledge_ = false;
+		bool end_of_dma_ = false;
+
+		bool irq_ = false;
+		bool phase_mismatch_ = false;
 
 		enum class ExecutionState {
 			None,
@@ -63,13 +78,13 @@ class NCR5380 final: public SCSI::Bus::Observer {
 
 		void set_execution_state(ExecutionState state);
 
-		SCSI::BusState target_output();
+		SCSI::BusState target_output() const;
 		void update_control_output();
 
 		void scsi_bus_did_change(SCSI::Bus *, SCSI::BusState new_state, double time_since_change) final;
+		bool phase_matches() const;
 };
 
-}
 }
 
 #endif /* ncr5380_hpp */

Components/6522/6522.hpp

@@ -10,15 +10,12 @@
 #define _522_hpp
 
 #include <cstdint>
-#include <typeinfo>
-#include <cstdio>
 
 #include "Implementation/6522Storage.hpp"
 
 #include "../../ClockReceiver/ClockReceiver.hpp"
 
-namespace MOS {
-namespace MOS6522 {
+namespace MOS::MOS6522 {
 
 enum Port {
 	A = 0,
@@ -37,22 +34,24 @@ enum Line {
 class PortHandler {
 	public:
 		/// Requests the current input value of @c port from the port handler.
-	uint8_t get_port_input([[maybe_unused]] Port port)										{	return 0xff;	}
+		uint8_t get_port_input([[maybe_unused]] Port port) {
+			return 0xff;
+		}
 
 		/// Sets the current output value of @c port and provides @c direction_mask, indicating which pins are marked as output.
-		void set_port_output([[maybe_unused]] Port port, [[maybe_unused]] uint8_t value, [[maybe_unused]] uint8_t direction_mask)	{}
+		void set_port_output([[maybe_unused]] Port port, [[maybe_unused]] uint8_t value, [[maybe_unused]] uint8_t direction_mask) {}
 
 		/// Sets the current logical output level for line @c line on port @c port.
-		void set_control_line_output([[maybe_unused]] Port port, [[maybe_unused]] Line line, [[maybe_unused]] bool value)			{}
+		void set_control_line_output([[maybe_unused]] Port port, [[maybe_unused]] Line line, [[maybe_unused]] bool value) {}
 
 		/// Sets the current logical value of the interrupt line.
-		void set_interrupt_status([[maybe_unused]] bool status)									{}
+		void set_interrupt_status([[maybe_unused]] bool status) {}
 
 		/// Provides a measure of time elapsed between other calls.
-		void run_for([[maybe_unused]] HalfCycles duration)										{}
+		void run_for([[maybe_unused]] HalfCycles duration) {}
 
 		/// Receives passed-on flush() calls from the 6522.
-		void flush()																			{}
+		void flush() {}
 };
 
 /*!
@@ -88,9 +87,9 @@ class IRQDelegatePortHandler: public PortHandler {
 	Consumers should derive their own curiously-recurring-template-pattern subclass,
 	implementing bus communications as required.
 */
-template <class T> class MOS6522: public MOS6522Storage {
+template <class BusHandlerT> class MOS6522: public MOS6522Storage {
 	public:
-		MOS6522(T &bus_handler) noexcept : bus_handler_(bus_handler) {}
+		MOS6522(BusHandlerT &bus_handler) noexcept : bus_handler_(bus_handler) {}
 		MOS6522(const MOS6522 &) = delete;
 
 		/*! Sets a register value. */
@@ -100,7 +99,7 @@ template <class T> class MOS6522: public MOS6522Storage {
 		uint8_t read(int address);
 
 		/*! @returns the bus handler. */
-		T &bus_handler();
+		BusHandlerT &bus_handler();
 
 		/// Sets the input value of line @c line on port @c port.
 		void set_control_line_input(Port port, Line line, bool value);
@@ -123,7 +122,7 @@ template <class T> class MOS6522: public MOS6522Storage {
 		void shift_in();
 		void shift_out();
 
-		T &bus_handler_;
+		BusHandlerT &bus_handler_;
 		HalfCycles time_since_bus_handler_call_;
 
 		void access(int address);
@@ -138,7 +137,6 @@ template <class T> class MOS6522: public MOS6522Storage {
 		void evaluate_port_b_output();
 };
 
-}
 }
 
 #include "Implementation/6522Implementation.hpp"

Components/6522/Implementation/6522Implementation.hpp

@@ -12,8 +12,7 @@
 //
 //	PB6 count-down mode for timer 2.
 
-namespace MOS {
-namespace MOS6522 {
+namespace MOS::MOS6522 {
 
 template <typename T> void MOS6522<T>::access(int address) {
 	switch(address) {
@@ -272,7 +271,7 @@ template <typename T> void MOS6522<T>::set_control_line_input(Port port, Line li
 				// TODO: and at least one full clock since the shift register was written?
 				if(port == Port::B) {
 					switch(shift_mode()) {
-						default: 													break;
+						default:													break;
 						case ShiftMode::InUnderCB1:		if(value)	shift_in();		break;	// Shifts in are captured on a low-to-high transition.
 						case ShiftMode::OutUnderCB1:	if(!value)	shift_out();	break;	// Shifts out are updated on a high-to-low transition.
 					}
@@ -330,7 +329,7 @@ template <typename T> void MOS6522<T>::do_phase2() {
 
 	// If the shift register is shifting according to the input clock, do a shift.
 	switch(shift_mode()) {
-		default: 											break;
+		default:											break;
 		case ShiftMode::InUnderPhase2:		shift_in();		break;
 		case ShiftMode::OutUnderPhase2:		shift_out();	break;
 	}
@@ -346,9 +345,9 @@ template <typename T> void MOS6522<T>::do_phase1() {
 		// If the shift register is shifting according to this timer, do a shift.
 		// TODO: "shift register is driven by only the low order 8 bits of timer 2"?
 		switch(shift_mode()) {
-			default: 												break;
+			default:												break;
 			case ShiftMode::InUnderT2:				shift_in();		break;
-			case ShiftMode::OutUnderT2FreeRunning: 	shift_out();	break;
+			case ShiftMode::OutUnderT2FreeRunning:	shift_out();	break;
 			case ShiftMode::OutUnderT2:				shift_out();	break;	// TODO: present a clock on CB1.
 		}
 
@@ -494,4 +493,3 @@ template <typename T> void MOS6522<T>::shift_out() {
 }
 
 }
-}

Components/6522/Implementation/6522Storage.hpp

@@ -11,8 +11,7 @@
 
 #include <cstdint>
 
-namespace MOS {
-namespace MOS6522 {
+namespace MOS::MOS6522 {
 
 class MOS6522Storage {
 	protected:
@@ -107,7 +106,6 @@ class MOS6522Storage {
 		}
 };
 
-}
 }
 
 #endif /* _522Storage_hpp */

Components/6526/6526.hpp

@@ -0,0 +1,92 @@
+//
+//  6526.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef _526_h
+#define _526_h
+
+#include <cstdint>
+
+#include "Implementation/6526Storage.hpp"
+#include "../Serial/Line.hpp"
+
+namespace MOS::MOS6526 {
+
+enum Port {
+	A = 0,
+	B = 1
+};
+
+struct PortHandler {
+	/// Requests the current input value of @c port from the port handler.
+	uint8_t get_port_input([[maybe_unused]] Port port) {
+		return 0xff;
+	}
+
+	/// Sets the current output value of @c port; any bits marked as input will be supplied as 1s.
+	void set_port_output([[maybe_unused]] Port port, [[maybe_unused]] uint8_t value) {}
+};
+
+enum class Personality {
+	// The 6526, used in machines such as the C64, has a BCD time-of-day clock.
+	P6526,
+	// The 8250, used in the Amiga, provides a binary time-of-day clock.
+	P8250,
+};
+
+template <typename PortHandlerT, Personality personality> class MOS6526:
+	private MOS6526Storage,
+	private Serial::Line<true>::ReadDelegate
+{
+	public:
+		MOS6526(PortHandlerT &port_handler) noexcept : port_handler_(port_handler) {
+			serial_input.set_read_delegate(this);
+		}
+		MOS6526(const MOS6526 &) = delete;
+
+		/// Writes @c value to the register at @c address. Only the low two bits of the address are decoded.
+		void write(int address, uint8_t value);
+
+		/// Fetches the value of the register @c address. Only the low two bits of the address are decoded.
+		uint8_t read(int address);
+
+		/// Pulses Phi2 to advance by the specified number of half cycles.
+		void run_for(const HalfCycles half_cycles);
+
+		/// Pulses the TOD input the specified number of times.
+		void advance_tod(int count);
+
+		/// @returns @c true if the interrupt output is active, @c false otherwise.
+		bool get_interrupt_line();
+
+		/// Sets the current state of the CNT input.
+		void set_cnt_input(bool active);
+
+		/// Provides both the serial input bit and an additional source of CNT.
+		Serial::Line<true> serial_input;
+
+		/// Sets the current state of the FLG input.
+		void set_flag_input(bool low);
+
+	private:
+		PortHandlerT &port_handler_;
+		TODStorage<personality == Personality::P8250> tod_;
+
+		template <int port> void set_port_output();
+		template <int port> uint8_t get_port_input();
+		void update_interrupts();
+		void posit_interrupt(uint8_t mask);
+		void advance_counters(int);
+
+		bool serial_line_did_produce_bit(Serial::Line<true> *line, int bit) final;
+};
+
+}
+
+#include "Implementation/6526Implementation.hpp"
+
+#endif /* _526_h */

Components/6526/Implementation/6526Implementation.hpp

@@ -0,0 +1,242 @@
+//
+//  6526Implementation.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef _526Implementation_h
+#define _526Implementation_h
+
+#include <cassert>
+#include <cstdio>
+
+namespace MOS::MOS6526 {
+
+enum Interrupts: uint8_t {
+	TimerA = 1 << 0,
+	TimerB = 1 << 1,
+	Alarm = 1 << 2,
+	SerialPort = 1 << 3,
+	Flag = 1 << 4,
+};
+
+template <typename BusHandlerT, Personality personality>
+template <int port> void MOS6526<BusHandlerT, personality>::set_port_output() {
+	const uint8_t output = output_[port] | (~data_direction_[port]);
+	port_handler_.set_port_output(Port(port), output);
+}
+
+template <typename BusHandlerT, Personality personality>
+template <int port> uint8_t MOS6526<BusHandlerT, personality>::get_port_input() {
+	// Avoid bothering the port handler if there's no input active.
+	const uint8_t input_mask = ~data_direction_[port];
+	const uint8_t input = input_mask ? port_handler_.get_port_input(Port(port)) : 0x00;
+	return (input & input_mask) | (output_[port] & data_direction_[port]);
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::posit_interrupt(uint8_t mask) {
+	if(!mask) {
+		return;
+	}
+	interrupt_state_ |= mask;
+	update_interrupts();
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::update_interrupts() {
+	if(interrupt_state_ & interrupt_control_) {
+		pending_ |= InterruptInOne;
+	}
+}
+
+template <typename BusHandlerT, Personality personality>
+bool MOS6526<BusHandlerT, personality>::get_interrupt_line() {
+	return interrupt_state_ & 0x80;
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::set_cnt_input(bool active) {
+	cnt_edge_ = active && !cnt_state_;
+	cnt_state_ = active;
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::set_flag_input(bool low) {
+	if(low && !flag_state_) {
+		posit_interrupt(Interrupts::Flag);
+	}
+	flag_state_ = low;
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::write(int address, uint8_t value) {
+	address &= 0xf;
+	switch(address) {
+		// Port output.
+		case 0:
+			output_[0] = value;
+			set_port_output<0>();
+		break;
+		case 1:
+			output_[1] = value;
+			set_port_output<1>();
+		break;
+
+		// Port direction.
+		case 2:
+			data_direction_[0] = value;
+			set_port_output<0>();
+		break;
+		case 3:
+			data_direction_[1] = value;
+			set_port_output<1>();
+		break;
+
+		// Counters; writes set the reload values.
+		case 4:		counter_[0].template set_reload<0, personality == Personality::P8250>(value);	break;
+		case 5:		counter_[0].template set_reload<8, personality == Personality::P8250>(value);	break;
+		case 6:		counter_[1].template set_reload<0, personality == Personality::P8250>(value);	break;
+		case 7:		counter_[1].template set_reload<8, personality == Personality::P8250>(value);	break;
+
+		// Time-of-day clock.
+		case 8:		tod_.template write<0>(value);	break;
+		case 9:		tod_.template write<1>(value);	break;
+		case 10:	tod_.template write<2>(value);	break;
+		case 11:	tod_.template write<3>(value);	break;
+
+		// Interrupt control.
+		case 13: {
+			if(value & 0x80) {
+				interrupt_control_ |= value & 0x7f;
+			} else {
+				interrupt_control_ &= ~(value & 0x7f);
+			}
+			update_interrupts();
+		} break;
+
+		// Control. Posted to both the counters and the clock as it affects both.
+		case 14:
+			counter_[0].template set_control<false>(value);
+			tod_.template set_control<false>(value);
+			if(shifter_is_output_ != bool(value & 0x40)) {
+				shifter_is_output_ = value & 0x40;
+				shift_bits_ = 0;
+			}
+		break;
+		case 15:
+			counter_[1].template set_control<true>(value);
+			tod_.template set_control<true>(value);
+		break;
+
+		// Shift control.
+		case 12:
+			printf("TODO: write to shift register\n");
+		break;
+
+		default:
+			printf("Unhandled 6526 write: %02x to %d\n", value, address);
+			assert(false);
+		break;
+	}
+}
+
+template <typename BusHandlerT, Personality personality>
+uint8_t MOS6526<BusHandlerT, personality>::read(int address) {
+	address &= 0xf;
+	switch(address) {
+		case 0:		return get_port_input<0>();
+		case 1:		return get_port_input<1>();
+
+		case 2: case 3:
+		return data_direction_[address - 2];
+
+		// Counters; reads obtain the current values.
+		case 4:	return uint8_t(counter_[0].value >> 0);
+		case 5:	return uint8_t(counter_[0].value >> 8);
+		case 6:	return uint8_t(counter_[1].value >> 0);
+		case 7:	return uint8_t(counter_[1].value >> 8);
+
+		// Interrupt state.
+		case 13: {
+			const uint8_t result = interrupt_state_;
+			interrupt_state_ = 0;
+			pending_ &= ~(InterruptNow | InterruptInOne);
+			update_interrupts();
+			return result;
+		} break;
+
+		case 14: case 15:
+		return counter_[address - 14].control;
+
+		// Time-of-day clock.
+		case 8:		return tod_.template read<0>();
+		case 9:		return tod_.template read<1>();
+		case 10:	return tod_.template read<2>();
+		case 11:	return tod_.template read<3>();
+
+		// Shift register.
+		case 12:	return shift_data_;
+
+		default:
+			printf("Unhandled 6526 read from %d\n", address);
+			assert(false);
+		break;
+	}
+	return 0xff;
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::run_for(const HalfCycles half_cycles) {
+	half_divider_ += half_cycles;
+	int sub = half_divider_.divide_cycles().template as<int>();
+
+	while(sub--) {
+		pending_ <<= 1;
+		if(pending_ & InterruptNow) {
+			interrupt_state_ |= 0x80;
+		}
+		pending_ &= PendingClearMask;
+
+		// TODO: use CNT potentially to clock timer A, elimiante conditional above.
+		const bool timer1_did_reload = counter_[0].template advance<false>(false, cnt_state_, cnt_edge_);
+
+		const bool timer1_carry = timer1_did_reload && (counter_[1].control & 0x60) == 0x40;
+		const bool timer2_did_reload = counter_[1].template advance<true>(timer1_carry, cnt_state_, cnt_edge_);
+		posit_interrupt((timer1_did_reload ? Interrupts::TimerA : 0x00) | (timer2_did_reload ? Interrupts::TimerB : 0x00));
+
+		cnt_edge_ = false;
+	}
+}
+
+template <typename BusHandlerT, Personality personality>
+void MOS6526<BusHandlerT, personality>::advance_tod(int count) {
+	if(!count) return;
+	if(tod_.advance(count)) {
+		posit_interrupt(Interrupts::Alarm);
+	}
+}
+
+template <typename BusHandlerT, Personality personality>
+bool MOS6526<BusHandlerT, personality>::serial_line_did_produce_bit(Serial::Line<true> *, int bit) {
+	// TODO: post CNT change; might affect timer.
+
+	if(!shifter_is_output_) {
+		shift_register_ = uint8_t((shift_register_ << 1) | bit);
+		++shift_bits_;
+
+		if(shift_bits_ == 8) {
+			shift_bits_ = 0;
+			shift_data_ = shift_register_;
+			posit_interrupt(Interrupts::SerialPort);
+		}
+	}
+
+	return true;
+}
+
+}
+
+#endif /* _526Implementation_h */

Components/6526/Implementation/6526Storage.hpp

@@ -0,0 +1,337 @@
+//
+//  6526Storage.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/07/2021.
+//  Copyright © 2021 Thomas Harte. All rights reserved.
+//
+
+#ifndef _526Storage_h
+#define _526Storage_h
+
+#include <array>
+
+#include "../../../ClockReceiver/ClockReceiver.hpp"
+
+namespace MOS::MOS6526 {
+
+class TODBase {
+	public:
+		template <bool is_timer2> void set_control(uint8_t value) {
+			if constexpr (is_timer2) {
+				write_alarm = value & 0x80;
+			} else {
+				is_50Hz = value & 0x80;
+			}
+		}
+
+	protected:
+		bool write_alarm = false, is_50Hz = false;
+};
+
+template <bool is_8250> class TODStorage {};
+
+template <> class TODStorage<false>: public TODBase {
+	private:
+		bool increment_ = true, latched_ = false;
+		int divider_ = 0;
+		std::array<uint8_t, 4> value_;
+		std::array<uint8_t, 4> latch_;
+		std::array<uint8_t, 4> alarm_;
+
+		static constexpr uint8_t masks[4] = {0xf, 0x3f, 0x3f, 0x1f};
+
+		void bcd_increment(uint8_t &value) {
+			++value;
+			if((value&0x0f) > 0x09) value += 0x06;
+		}
+
+	public:
+		template <int byte> void write(uint8_t v) {
+			if(write_alarm) {
+				alarm_[byte] = v & masks[byte];
+			} else {
+				value_[byte] = v & masks[byte];
+
+				if constexpr (byte == 0) {
+					increment_ = true;
+				}
+				if constexpr (byte == 3) {
+					increment_ = false;
+				}
+			}
+		}
+
+		template <int byte> uint8_t read() {
+			if(latched_) {
+				const uint8_t result = latch_[byte];
+				if constexpr (byte == 0) {
+					latched_ = false;
+				}
+				return result;
+			}
+
+			if constexpr (byte == 3) {
+				latched_ = true;
+				latch_ = value_;
+			}
+			return value_[byte];
+		}
+
+		bool advance(int count) {
+			if(!increment_) {
+				return false;
+			}
+
+			while(count--) {
+				// Increment the pre-10ths divider.
+				++divider_;
+				if(divider_ < 5) continue;
+				if(divider_ < 6 && !is_50Hz) continue;
+				divider_ = 0;
+
+				// Increments 10ths of a second. One BCD digit.
+				++value_[0];
+				if(value_[0] < 10) {
+					continue;
+				}
+
+				// Increment seconds. Actual BCD needed from here onwards.
+				bcd_increment(value_[1]);
+				if(value_[1] != 60) {
+					continue;
+				}
+				value_[1] = 0;
+
+				// Increment minutes.
+				bcd_increment(value_[2]);
+				if(value_[2] != 60) {
+					continue;
+				}
+				value_[2] = 0;
+
+				// TODO: increment hours, keeping AM/PM separate?
+			}
+
+			return false;	// TODO: test against alarm.
+		}
+};
+
+template <> class TODStorage<true>: public TODBase {
+	private:
+		uint32_t increment_mask_ = uint32_t(~0);
+		uint32_t latch_ = 0;
+		uint32_t value_ = 0;
+		uint32_t alarm_ = 0xff'ffff;
+
+	public:
+		template <int byte> void write(uint8_t v) {
+			if constexpr (byte == 3) {
+				return;
+			}
+			constexpr int shift = byte << 3;
+
+			// Write to either the alarm or the current value as directed;
+			// writing to any part of the current value other than the LSB
+			// pauses incrementing until the LSB is written.
+			const uint32_t mask = uint32_t(~(0xff << shift));
+			if(write_alarm) {
+				alarm_ = (alarm_ & mask) | uint32_t(v << shift);
+			} else {
+				value_ = (value_ & mask) | uint32_t(v << shift);
+				increment_mask_ = (byte == 0) ? uint32_t(~0) : 0;
+			}
+		}
+
+		template <int byte> uint8_t read() {
+			if constexpr (byte == 3) {
+				return 0xff;	// Assumed. Just a guess.
+			}
+			constexpr int shift = byte << 3;
+
+			if constexpr (byte == 2) {
+				latch_ = value_ | 0xff00'0000;
+			}
+
+			const uint32_t source = latch_ ? latch_ : value_;
+			const uint8_t result = uint8_t((source >> shift) & 0xff);
+
+			if constexpr (byte == 0) {
+				latch_ = 0;
+			}
+
+			return result;
+		}
+
+		bool advance(int count) {
+			// The 8250 uses a simple binary counter to replace the
+			// 6526's time-of-day clock. So this is easy.
+			const uint32_t distance_to_alarm = (alarm_ - value_) & 0xff'ffff;
+			const auto increment = uint32_t(count) & increment_mask_;
+			value_ = (value_ + increment) & 0xff'ffff;
+			return distance_to_alarm <= increment;
+		}
+};
+
+struct MOS6526Storage {
+	bool cnt_state_ = false;	// Inactive by default.
+	bool cnt_edge_ = false;
+	bool flag_state_ = false;
+	HalfCycles half_divider_;
+
+	uint8_t output_[2] = {0, 0};
+	uint8_t data_direction_[2] = {0, 0};
+
+	uint8_t interrupt_control_ = 0;
+	uint8_t interrupt_state_ = 0;
+
+	uint8_t shift_data_ = 0;
+	uint8_t shift_register_ = 0;
+	int shift_bits_ = 0;
+	bool shifter_is_output_ = false;
+
+	struct Counter {
+		uint16_t reload = 0;
+		uint16_t value = 0;
+		uint8_t control = 0;
+
+		template <int shift, bool is_8250> void set_reload(uint8_t v) {
+			reload = (reload & (0xff00 >> shift)) | uint16_t(v << shift);
+
+			if constexpr (shift == 8) {
+				// This seems to be a special 8250 feature per the Amiga
+				// Hardware Reference Manual; cf. Appendix F.
+				if(is_8250) {
+					control |= 1;
+					pending |= ReloadInOne;
+				} else {
+					if(!(control&1)) {
+						pending |= ReloadInOne;
+					}
+				}
+			}
+
+			// If this write has hit during a reload cycle, reload.
+			if(pending & ReloadNow) {
+				value = reload;
+			}
+		}
+
+		template <bool is_counter_2> void set_control(uint8_t v) {
+			control = v;
+
+			if(v&2) {
+				printf("UNIMPLEMENTED: PB strobe\n");
+			}
+		}
+
+		template <bool is_counter_2> bool advance(bool chained_input, bool cnt_state, bool cnt_edge) {
+			// TODO: remove most of the conditionals here in favour of bit shuffling.
+
+			pending = (pending & PendingClearMask) << 1;
+
+			//
+			// Apply feeder states inputs: anything that
+			// will take effect in the future.
+			//
+
+			// Schedule a force reload if requested.
+			if(control & 0x10) {
+				pending |= ReloadInOne;
+				control &= ~0x10;
+			}
+
+			// Keep a history of the one-shot bit.
+			if(control & 0x08) {
+				pending |= OneShotInOne;
+			}
+
+			// Determine whether an input clock is applicable.
+			if constexpr(is_counter_2) {
+				switch(control&0x60) {
+					case 0x00:	// Count Phi2 pulses.
+						pending |= TestInputNow;
+					break;
+					case 0x20:	// Count negative CNTs, with an extra cycle of delay.
+						pending |= cnt_edge ? TestInputInOne : 0;
+					break;
+					case 0x40:	// Count timer A reloads.
+						pending |= chained_input ? TestInputNow : 0;
+					break;
+					case 0x60:	// Count timer A transitions when CNT is low.
+						pending |= chained_input && cnt_state ? TestInputNow : 0;
+					break;
+				}
+			} else {
+				if(!(control&0x20)) {
+					pending |= TestInputNow;
+				} else if (cnt_edge) {
+					pending |= TestInputInOne;
+				}
+			}
+			if(pending&TestInputNow && control&1) {
+				pending |= ApplyClockInTwo;
+			}
+
+
+			//
+			// Perform a timer tick and decide whether a reload is prompted.
+			//
+			if(pending & ApplyClockNow) {
+				--value;
+			}
+
+			const bool should_reload = !value && (pending & ApplyClockInOne);
+
+			// Schedule a reload if so ordered.
+			if(should_reload) {
+				pending |= ReloadNow;	// Combine this decision with a deferred
+										// input from the force-reoad test above.
+
+				// If this was one-shot, stop.
+				if(pending&(OneShotInOne | OneShotNow)) {
+					control &= ~1;
+					pending &= ~(ApplyClockInOne|ApplyClockInTwo);	// Cancel scheduled ticks.
+				}
+			}
+
+			// Reload if scheduled.
+			if(pending & ReloadNow) {
+				value = reload;
+				pending &= ~ApplyClockInOne;	// Skip next decrement.
+			}
+
+
+			return should_reload;
+		}
+
+		private:
+			int pending = 0;
+
+			static constexpr int ReloadInOne = 1 << 0;
+			static constexpr int ReloadNow = 1 << 1;
+
+			static constexpr int OneShotInOne = 1 << 2;
+			static constexpr int OneShotNow = 1 << 3;
+
+			static constexpr int ApplyClockInTwo = 1 << 4;
+			static constexpr int ApplyClockInOne = 1 << 5;
+			static constexpr int ApplyClockNow = 1 << 6;
+
+			static constexpr int TestInputInOne = 1 << 7;
+			static constexpr int TestInputNow = 1 << 8;
+
+			static constexpr int PendingClearMask = ~(ReloadNow | OneShotNow | ApplyClockNow);
+
+			bool active_ = false;
+	} counter_[2];
+
+	static constexpr int InterruptInOne = 1 << 0;
+	static constexpr int InterruptNow = 1 << 1;
+	static constexpr int PendingClearMask = ~(InterruptNow);
+	int pending_ = 0;
+};
+
+}
+
+#endif /* _526Storage_h */

Components/6560/6560.cpp

@@ -12,18 +12,18 @@
 
 using namespace MOS::MOS6560;
 
-AudioGenerator::AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue) :
+AudioGenerator::AudioGenerator(Concurrency::AsyncTaskQueue<false> &audio_queue) :
 	audio_queue_(audio_queue) {}
 
 
 void AudioGenerator::set_volume(uint8_t volume) {
-	audio_queue_.defer([this, volume]() {
+	audio_queue_.enqueue([this, volume]() {
 		volume_ = int16_t(volume) * range_multiplier_;
 	});
 }
 
 void AudioGenerator::set_control(int channel, uint8_t value) {
-	audio_queue_.defer([this, channel, value]() {
+	audio_queue_.enqueue([this, channel, value]() {
 		control_registers_[channel] = value;
 	});
 }

Components/6560/6560.hpp

@@ -15,13 +15,12 @@
 #include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
 #include "../../Outputs/Speaker/Implementation/SampleSource.hpp"
 
-namespace MOS {
-namespace MOS6560 {
+namespace MOS::MOS6560 {
 
 // audio state
 class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 	public:
-		AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue);
+		AudioGenerator(Concurrency::AsyncTaskQueue<false> &audio_queue);
 
 		void set_volume(uint8_t volume);
 		void set_control(int channel, uint8_t value);
@@ -33,7 +32,7 @@ class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 		static constexpr bool get_is_stereo() { return false; }
 
 	private:
-		Concurrency::DeferringAsyncTaskQueue &audio_queue_;
+		Concurrency::AsyncTaskQueue<false> &audio_queue_;
 
 		unsigned int counters_[4] = {2, 1, 0, 0};	// create a slight phase offset for the three channels
 		unsigned int shift_registers_[4] = {0, 0, 0, 0};
@@ -84,11 +83,11 @@ template <class BusHandler> class MOS6560 {
 			speaker_.set_input_rate(float(clock_rate / 4.0));
 		}
 
-		void set_scan_target(Outputs::Display::ScanTarget *scan_target)		{ crt_.set_scan_target(scan_target); 			}
+		void set_scan_target(Outputs::Display::ScanTarget *scan_target)		{ crt_.set_scan_target(scan_target);			}
 		Outputs::Display::ScanStatus get_scaled_scan_status() const			{ return crt_.get_scaled_scan_status() / 4.0f;	}
-		void set_display_type(Outputs::Display::DisplayType display_type)	{ crt_.set_display_type(display_type); 			}
-		Outputs::Display::DisplayType get_display_type() const				{ return crt_.get_display_type(); 				}
-		Outputs::Speaker::Speaker *get_speaker()	 						{ return &speaker_; 							}
+		void set_display_type(Outputs::Display::DisplayType display_type)	{ crt_.set_display_type(display_type);			}
+		Outputs::Display::DisplayType get_display_type() const				{ return crt_.get_display_type();				}
+		Outputs::Speaker::Speaker *get_speaker()							{ return &speaker_;								}
 
 		void set_high_frequency_cutoff(float cutoff) {
 			speaker_.set_high_frequency_cutoff(cutoff);
@@ -433,9 +432,9 @@ template <class BusHandler> class MOS6560 {
 		BusHandler &bus_handler_;
 		Outputs::CRT::CRT crt_;
 
-		Concurrency::DeferringAsyncTaskQueue audio_queue_;
+		Concurrency::AsyncTaskQueue<false> audio_queue_;
 		AudioGenerator audio_generator_;
-		Outputs::Speaker::LowpassSpeaker<AudioGenerator> speaker_;
+		Outputs::Speaker::PullLowpass<AudioGenerator> speaker_;
 
 		Cycles cycles_since_speaker_update_;
 		void update_audio() {
@@ -520,7 +519,6 @@ template <class BusHandler> class MOS6560 {
 		OutputMode output_mode_ = OutputMode::NTSC;
 };
 
-}
 }
 
 #endif /* _560_hpp */

Components/6845/CRTC6845.hpp

@@ -14,8 +14,7 @@
 #include <cstdint>
 #include <cstdio>
 
-namespace Motorola {
-namespace CRTC {
+namespace Motorola::CRTC {
 
 struct BusState {
 	bool display_enable = false;
@@ -269,7 +268,6 @@ template <class T> class CRTC6845 {
 		unsigned int character_is_visible_shifter_ = 0;
 };
 
-}
 }
 
 #endif /* CRTC6845_hpp */

Components/6850/6850.cpp

@@ -148,7 +148,7 @@ uint8_t ACIA::parity(uint8_t value) {
 	return value ^ (parity_ == Parity::Even);
 }
 
-bool ACIA::serial_line_did_produce_bit(Serial::Line *, int bit) {
+bool ACIA::serial_line_did_produce_bit(Serial::Line<false> *, int bit) {
 	// Shift this bit into the 11-bit input register; this is big enough to hold
 	// the largest transmission symbol.
 	++bits_received_;

Components/6850/6850.hpp

@@ -15,10 +15,9 @@
 #include "../../ClockReceiver/ClockingHintSource.hpp"
 #include "../Serial/Line.hpp"
 
-namespace Motorola {
-namespace ACIA {
+namespace Motorola::ACIA {
 
-class ACIA: public ClockingHint::Source, private Serial::Line::ReadDelegate {
+class ACIA: public ClockingHint::Source, private Serial::Line<false>::ReadDelegate {
 	public:
 		static constexpr const HalfCycles SameAsTransmit = HalfCycles(0);
 
@@ -77,13 +76,13 @@ class ACIA: public ClockingHint::Source, private Serial::Line::ReadDelegate {
 		void reset();
 
 		// Input lines.
-		Serial::Line receive;
-		Serial::Line clear_to_send;
-		Serial::Line data_carrier_detect;
+		Serial::Line<false> receive;
+		Serial::Line<false> clear_to_send;
+		Serial::Line<false> data_carrier_detect;
 
 		// Output lines.
-		Serial::Line transmit;
-		Serial::Line request_to_send;
+		Serial::Line<false> transmit;
+		Serial::Line<false> request_to_send;
 
 		// ClockingHint::Source.
 		ClockingHint::Preference preferred_clocking() const final;
@@ -118,7 +117,7 @@ class ACIA: public ClockingHint::Source, private Serial::Line::ReadDelegate {
 		HalfCycles transmit_clock_rate_;
 		HalfCycles receive_clock_rate_;
 
-		bool serial_line_did_produce_bit(Serial::Line *line, int bit) final;
+		bool serial_line_did_produce_bit(Serial::Line<false> *line, int bit) final;
 
 		bool interrupt_line_ = false;
 		void update_interrupt_line();
@@ -126,7 +125,6 @@ class ACIA: public ClockingHint::Source, private Serial::Line::ReadDelegate {
 		uint8_t get_status();
 };
 
-}
 }
 
 #endif /* Motorola_ACIA_6850_hpp */

Components/68901/MFP68901.hpp

@@ -9,12 +9,12 @@
 #ifndef MFP68901_hpp
 #define MFP68901_hpp
 
-#include <cstdint>
 #include "../../ClockReceiver/ClockReceiver.hpp"
 #include "../../ClockReceiver/ClockingHintSource.hpp"
 
-namespace Motorola {
-namespace MFP68901 {
+#include <cstdint>
+
+namespace Motorola::MFP68901 {
 
 class PortHandler {
 	public:
@@ -181,7 +181,6 @@ class MFP68901: public ClockingHint::Source {
 		}
 };
 
-}
 }
 
 #endif /* MFP68901_hpp */

Components/8255/i8255.hpp

@@ -11,8 +11,7 @@
 
 #include <cstdint>
 
-namespace Intel {
-namespace i8255 {
+namespace Intel::i8255 {
 
 class PortHandler {
 	public:
@@ -88,7 +87,6 @@ template <class T> class i8255 {
 		T &port_handler_;
 };
 
-}
 }
 
 #endif /* i8255_hpp */

Components/8272/i8272.hpp

@@ -15,8 +15,7 @@
 #include <memory>
 #include <vector>
 
-namespace Intel {
-namespace i8272 {
+namespace Intel::i8272 {
 
 class BusHandler {
 	public:
@@ -130,7 +129,6 @@ class i8272 : public Storage::Disk::MFMController {
 		bool is_sleeping_ = false;
 };
 
-}
 }
 
 #endif /* i8272_hpp */

Components/8530/z8530.hpp

@@ -11,8 +11,7 @@
 
 #include <cstdint>
 
-namespace Zilog {
-namespace SCC {
+namespace Zilog::SCC {
 
 /*!
 	Models the Zilog 8530 SCC, a serial adaptor.
@@ -110,7 +109,5 @@ class z8530 {
 };
 
 }
-}
-
 
 #endif /* z8530_hpp */

Components/9918/9918.hpp

@@ -12,12 +12,36 @@
 #include "../../Outputs/CRT/CRT.hpp"
 #include "../../ClockReceiver/ClockReceiver.hpp"
 
-#include "Implementation/9918Base.hpp"
-
 #include <cstdint>
 
-namespace TI {
-namespace TMS {
+namespace TI::TMS {
+
+enum Personality {
+	TMS9918A,	// includes the 9928 and 9929; set TV standard and output device as desired.
+
+	// Yamaha extensions.
+	V9938,
+	V9958,
+
+	// Sega extensions.
+	SMSVDP,
+	SMS2VDP,
+	GGVDP,
+	MDVDP,
+};
+
+enum class TVStandard {
+	/*! i.e. 50Hz output at around 312.5 lines/field */
+	PAL,
+	/*! i.e. 60Hz output at around 262.5 lines/field */
+	NTSC
+};
+
+}
+
+#include "Implementation/9918Base.hpp"
+
+namespace TI::TMS {
 
 /*!
 	Provides emulation of the TMS9918a, TMS9928 and TMS9929. Likely in the future to be the
@@ -30,13 +54,10 @@ namespace TMS {
 	These chips have only one non-on-demand interaction with the outside world: an interrupt line.
 	See get_time_until_interrupt and get_interrupt_line for asynchronous operation options.
 */
-class TMS9918: public Base {
+template <Personality personality> class TMS9918: private Base<personality> {
 	public:
-		/*!
-			Constructs an instance of the drive controller that behaves according to personality @c p.
-			@param p The type of controller to emulate.
-		*/
-		TMS9918(Personality p);
+		/*! Constructs an instance of the VDP that behaves according to the templated personality. */
+		TMS9918();
 
 		/*! Sets the TV standard for this TMS, if that is hard-coded in hardware. */
 		void set_tv_standard(TVStandard standard);
@@ -44,18 +65,24 @@ class TMS9918: public Base {
 		/*! Sets the scan target this TMS will post content to. */
 		void set_scan_target(Outputs::Display::ScanTarget *);
 
-		/// Gets the current scan status.
+		/*! Gets the current scan status. */
 		Outputs::Display::ScanStatus get_scaled_scan_status() const;
 
-		/*! Sets the type of display the CRT will request. */
+		/*! Sets the type of CRT display. */
 		void set_display_type(Outputs::Display::DisplayType);
 
-		/*! Gets the type of display the CRT will request. */
+		/*! Gets the type of CRT display. */
 		Outputs::Display::DisplayType get_display_type() const;
 
 		/*!
-			Runs the VCP for the number of cycles indicate; it is an implicit assumption of the code
-			that the input clock rate is 3579545 Hz, the NTSC colour clock rate.
+			Runs the VDP for the number of cycles indicate; the input clock rate is implicitly assumed.
+
+			For everything except the Mega Drive VDP:
+				* the input clock rate should be 3579545 Hz, the NTSC colour clock rate.
+
+			For the Mega Drive:
+				* the input clock rate should be around 7.6MHz; 15/7ths of the NTSC colour
+				clock rate for NTSC output and 12/7ths of the PAL colour clock rate for PAL output.
 		*/
 		void run_for(const HalfCycles cycles);
 
@@ -65,11 +92,11 @@ class TMS9918: public Base {
 		/*! Gets a register value. */
 		uint8_t read(int address);
 
-		/*! Gets the current scan line; provided by the Master System only. */
-		uint8_t get_current_line();
+		/*! Gets the current scan line; provided by the Sega VDPs only. */
+		uint8_t get_current_line() const;
 
-		/*! Gets the current latched horizontal counter; provided by the Master System only. */
-		uint8_t get_latched_horizontal_counter();
+		/*! Gets the current latched horizontal counter; provided by the Sega VDPs only. */
+		uint8_t get_latched_horizontal_counter() const;
 
 		/*! Latches the current horizontal counter. */
 		void latch_horizontal_counter();
@@ -81,7 +108,7 @@ class TMS9918: public Base {
 			If get_interrupt_line is true now of if get_interrupt_line would
 			never return true, returns HalfCycles::max().
 		*/
-		HalfCycles get_next_sequence_point();
+		HalfCycles get_next_sequence_point() const;
 
 		/*!
 			Returns the amount of time until the nominated line interrupt position is
@@ -96,10 +123,9 @@ class TMS9918: public Base {
 		/*!
 			@returns @c true if the interrupt line is currently active; @c false otherwise.
 		*/
-		bool get_interrupt_line();
+		bool get_interrupt_line() const;
 };
 
-}
 }
 
 #endif /* TMS9918_hpp */

Components/9918/Implementation/AccessEnums.hpp

@@ -0,0 +1,115 @@
+//
+//  AccessEnums.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 26/01/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef AccessEnums_hpp
+#define AccessEnums_hpp
+
+
+namespace TI::TMS {
+
+// The screen mode is a necessary predecessor to picking the line mode,
+// which is the thing latched per line.
+enum class ScreenMode {
+	// Original TMS modes.
+	Blank,
+	Text,
+	MultiColour,
+	ColouredText,
+	Graphics,
+
+	// 8-bit Sega modes.
+	SMSMode4,
+
+	// New Yamaha V9938 modes.
+	YamahaText80,
+	YamahaGraphics3,
+	YamahaGraphics4,
+	YamahaGraphics5,
+	YamahaGraphics6,
+	YamahaGraphics7,
+
+	// Rebranded Yamaha V9938 modes.
+	YamahaGraphics1 = ColouredText,
+	YamahaGraphics2 = Graphics,
+};
+
+constexpr int pixels_per_byte(ScreenMode mode) {
+	switch(mode) {
+		default:
+		case ScreenMode::Blank:				return 1;
+		case ScreenMode::Text:				return 6;
+		case ScreenMode::MultiColour:		return 2;
+		case ScreenMode::ColouredText:		return 8;
+		case ScreenMode::Graphics:			return 8;
+		case ScreenMode::SMSMode4:			return 2;
+		case ScreenMode::YamahaText80:		return 6;
+		case ScreenMode::YamahaGraphics3:	return 8;
+		case ScreenMode::YamahaGraphics4:	return 2;
+		case ScreenMode::YamahaGraphics5:	return 4;
+		case ScreenMode::YamahaGraphics6:	return 2;
+		case ScreenMode::YamahaGraphics7:	return 1;
+	}
+}
+
+constexpr int width(ScreenMode mode) {
+	switch(mode) {
+		default:
+		case ScreenMode::Blank:				return 0;
+		case ScreenMode::Text:				return 240;
+		case ScreenMode::MultiColour:		return 256;
+		case ScreenMode::ColouredText:		return 256;
+		case ScreenMode::Graphics:			return 256;
+		case ScreenMode::SMSMode4:			return 256;
+		case ScreenMode::YamahaText80:		return 480;
+		case ScreenMode::YamahaGraphics3:	return 256;
+		case ScreenMode::YamahaGraphics4:	return 256;
+		case ScreenMode::YamahaGraphics5:	return 512;
+		case ScreenMode::YamahaGraphics6:	return 512;
+		case ScreenMode::YamahaGraphics7:	return 256;
+	}
+}
+
+constexpr bool interleaves_banks(ScreenMode mode) {
+	return mode == ScreenMode::YamahaGraphics6 || mode == ScreenMode::YamahaGraphics7;
+}
+
+constexpr bool is_text(ScreenMode mode) {
+	return mode == ScreenMode::Text || mode == ScreenMode::YamahaText80;
+}
+
+enum class FetchMode {
+	Text,
+	Character,
+	Refresh,
+	SMS,
+	Yamaha,
+};
+
+enum class MemoryAccess {
+	Read, Write, None
+};
+
+enum class VerticalState {
+	/// Describes any line on which pixels do not appear and no fetching occurs, including
+	/// the border, blanking and sync.
+	Blank,
+	/// A line on which pixels do not appear but fetching occurs.
+	Prefetch,
+	/// A line on which pixels appear and fetching occurs.
+	Pixels,
+};
+
+enum class SpriteMode {
+	Mode1,
+	Mode2,
+	MasterSystem,
+};
+
+}
+
+#endif /* AccessEnums_hpp */

Components/9918/Implementation/ClockConverter.hpp

@@ -0,0 +1,187 @@
+//
+//  ClockConverter.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/01/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef ClockConverter_hpp
+#define ClockConverter_hpp
+
+#include "../9918.hpp"
+#include "PersonalityTraits.hpp"
+#include "LineLayout.hpp"
+
+namespace TI::TMS {
+
+enum class Clock {
+	/// Whatever rate this VDP runs at, with location 0 being "the start" of the line per internal preference.
+	Internal,
+	/// A 342-cycle/line clock with the same start position as ::Internal.
+	TMSPixel,
+	/// A 171-cycle/line clock that begins at the memory window which starts straight after ::Internal = 0.
+	TMSMemoryWindow,
+	/// A fixed 1368-cycle/line clock that is used to count output to the CRT.
+	CRT,
+};
+
+enum class Origin {
+	///
+	ModeLatch,
+
+	/// Provides the same clock rate as ::Internal but is relocated so that 0 is the start of horizontal sync — very not coincidentally,
+	/// where Grauw puts 0 on his detailed TMS and Yamaha timing diagrams.
+	StartOfSync,
+};
+
+template <Personality personality, Clock clk> constexpr int clock_rate() {
+	static_assert(
+		is_classic_vdp(personality) ||
+		is_yamaha_vdp(personality) ||
+		(personality == Personality::MDVDP)
+	);
+
+	switch(clk) {
+		case Clock::TMSPixel:			return 342;
+		case Clock::TMSMemoryWindow:	return 171;
+		case Clock::CRT:				return 1368;
+		case Clock::Internal:
+			if constexpr (is_classic_vdp(personality)) {
+				return 342;
+			} else if constexpr (is_yamaha_vdp(personality)) {
+				return 1368;
+			} else if constexpr (personality == Personality::MDVDP) {
+				return 3420;
+			}
+	}
+}
+
+/// Scales @c length from @c clock to the internal clock rate.
+template <Personality personality, Clock clock> constexpr int to_internal(int length) {
+	return length * clock_rate<personality, Clock::Internal>() / clock_rate<personality, clock>();
+}
+
+/// Moves @c position that is relative to @c Origin::StartOfSync so that it is relative to @c origin ;
+/// i.e. can be thought of as "to [internal with origin as specified]".
+template <Personality personality, Origin origin> constexpr int to_internal(int position) {
+	if constexpr (origin == Origin::ModeLatch) {
+		return (
+			position + LineLayout<personality>::CyclesPerLine - LineLayout<personality>::ModeLatchCycle
+		) % LineLayout<personality>::CyclesPerLine;
+	}
+	return position;
+}
+
+/// Converts @c position from one that is measured at the rate implied by @c clock and relative to @c Origin::StartOfSync
+/// to one that is at the internal clock rate and relative to @c origin.
+template <Personality personality, Origin origin, Clock clock> constexpr int to_internal(int position) {
+	position = to_internal<personality, clock>(position);
+	return to_internal<personality, origin>(position);
+}
+
+/// Scales @c length from the internal clock rate to @c clock.
+template <Personality personality, Clock clock> constexpr int from_internal(int length) {
+	return length * clock_rate<personality, clock>() / clock_rate<personality, Clock::Internal>();
+}
+
+/// Moves @c position that is relative to @c origin so that it is relative to @c Origin::StartOfSync ;
+/// i.e. can be thought of as "from [internal with origin as specified]".
+template <Personality personality, Origin origin> constexpr int from_internal(int length) {
+	if constexpr (origin == Origin::ModeLatch) {
+		return (
+			length + LineLayout<personality>::ModeLatchCycle
+		) % LineLayout<personality>::CyclesPerLine;
+	}
+	return length;
+}
+
+/// Converts @c position from one that is measured at the internal clock rate and relative to @c origin
+/// to one that is at the rate implied by @c clock and relative to @c Origin::StartOfSync 
+template <Personality personality, Origin origin, Clock clock> constexpr int from_internal(int position) {
+	position = from_internal<personality, origin>(position);
+	return from_internal<personality, clock>(position);
+}
+
+/*!
+	Provides a [potentially-]stateful conversion between the external and internal clocks.
+	Unlike the other clock conversions, this may be non-integral, requiring that
+	an error term be tracked.
+*/
+template <Personality personality> class ClockConverter {
+	public:
+		/*!
+			Given that another @c source external **half-cycles** has occurred,
+			indicates how many complete internal **cycles** have additionally elapsed
+			since the last call to @c to_internal.
+
+			E.g. for the TMS, @c source will count 456 ticks per line, and the internal clock
+			runs at 342 ticks per line, so the proper conversion is to multiply by 3/4.
+		*/
+		int to_internal(int source) {
+			switch(personality) {
+				// Default behaviour is to apply a multiplication by 3/4;
+				// this is correct for the TMS and Sega VDPs other than the Mega Drive.
+				default: {
+					const int result = source * 3 + cycles_error_;
+					cycles_error_ = result & 3;
+					return result >> 2;
+				}
+
+				// The two Yamaha chips have an internal clock that is four times
+				// as fast as the TMS, therefore a stateless translation is possible.
+				case Personality::V9938:
+				case Personality::V9958:
+				return source * 3;
+
+				// The Mega Drive runs at 3420 master clocks per line, which is then
+				// divided by 4 or 5 depending on other state. That's 7 times the
+				// rate provided to the CPU; given that the input is in half-cycles
+				// the proper multiplier is therefore 3.5.
+				case Personality::MDVDP: {
+					const int result = source * 7 + cycles_error_;
+					cycles_error_ = result & 1;
+					return result >> 1;
+				}
+			}
+		}
+
+		/*!
+			Provides the number of external cycles that need to begin from now in order to
+			get at least @c internal_cycles into the future.
+		*/
+		HalfCycles half_cycles_before_internal_cycles(int internal_cycles) const {
+			// Logic here correlates with multipliers as per @c to_internal.
+			switch(personality) {
+				default:
+					// Relative to the external clock multiplied by 3, it will definitely take this
+					// many cycles to complete a further (internal_cycles - 1) after the current one.
+					internal_cycles = (internal_cycles - 1) << 2;
+
+					// It will also be necessary to complete the current one.
+					internal_cycles += 4 - cycles_error_;
+
+					// Round up to get the first external cycle after
+					// the number of internal_cycles has elapsed.
+					return HalfCycles((internal_cycles + 2) / 3);
+
+				case Personality::V9938:
+				case Personality::V9958:
+					return HalfCycles((internal_cycles + 2) / 3);
+
+				case Personality::MDVDP:
+					internal_cycles = (internal_cycles - 1) << 1;
+					internal_cycles += 2 - cycles_error_;
+					return HalfCycles((internal_cycles + 6) / 7);
+			}
+		}
+
+	private:
+		// Holds current residue in conversion from the external to
+		// internal clock.
+		int cycles_error_ = 0;
+};
+
+}
+
+#endif /* ClockConverter_hpp */

Components/9918/Implementation/Draw.hpp

@@ -0,0 +1,572 @@
+//
+//  Draw.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 05/01/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef Draw_hpp
+#define Draw_hpp
+
+namespace TI::TMS {
+
+// MARK: - Sprites, as generalised.
+
+template <Personality personality>
+template <SpriteMode mode, bool double_width>
+void Base<personality>::draw_sprites([[maybe_unused]] uint8_t y, int start, int end, const std::array<uint32_t, 16> &palette, int *colour_buffer) {
+	if(!draw_line_buffer_->sprites) {
+		return;
+	}
+
+	auto &buffer = *draw_line_buffer_->sprites;
+	if(!buffer.active_sprite_slot) {
+		return;
+	}
+
+	const int shift_advance = sprites_magnified_ ? 1 : 2;
+
+	// If this is the start of the line clip any part of any sprites that is off to the left.
+	if(!start) {
+		for(int index = 0; index < buffer.active_sprite_slot; ++index) {
+			auto &sprite = buffer.active_sprites[index];
+			if(sprite.x < 0) sprite.shift_position -= shift_advance * sprite.x;
+		}
+	}
+
+	int sprite_buffer[256];
+	int sprite_collision = 0;
+	memset(&sprite_buffer[start], 0, size_t(end - start)*sizeof(sprite_buffer[0]));
+
+	if constexpr (mode == SpriteMode::MasterSystem) {
+		// Draw all sprites into the sprite buffer.
+		for(int index = buffer.active_sprite_slot - 1; index >= 0; --index) {
+			auto &sprite = buffer.active_sprites[index];
+			if(sprite.shift_position >= 16) {
+				continue;
+			}
+
+			const int pixel_start = std::max(start, sprite.x);
+
+			// TODO: it feels like the work below should be simplifiable;
+			// the double shift in particular, and hopefully the variable shift.
+			for(int c = pixel_start; c < end && sprite.shift_position < 16; ++c) {
+				const int shift = (sprite.shift_position >> 1);
+				const int sprite_colour =
+					(((sprite.image[3] << shift) & 0x80) >> 4) |
+					(((sprite.image[2] << shift) & 0x80) >> 5) |
+					(((sprite.image[1] << shift) & 0x80) >> 6) |
+					(((sprite.image[0] << shift) & 0x80) >> 7);
+
+				if(sprite_colour) {
+					sprite_collision |= sprite_buffer[c];
+					sprite_buffer[c] = sprite_colour | 0x10;
+				}
+
+				sprite.shift_position += shift_advance;
+			}
+		}
+
+		// Draw the sprite buffer onto the colour buffer, wherever the tile map doesn't have
+		// priority (or is transparent).
+		for(int c = start; c < end; ++c) {
+			if(
+				sprite_buffer[c] &&
+				(!(colour_buffer[c]&0x20) || !(colour_buffer[c]&0xf))
+			) colour_buffer[c] = sprite_buffer[c];
+		}
+
+		if(sprite_collision) {
+			status_ |= StatusSpriteCollision;
+		}
+
+		return;
+	}
+
+	if constexpr (SpriteBuffer::test_is_filling) {
+		assert(!buffer.is_filling);
+	}
+
+	constexpr uint32_t sprite_colour_selection_masks[2] = {0x00000000, 0xffffffff};
+	constexpr int colour_masks[16] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+	const int sprite_width = sprites_16x16_ ? 16 : 8;
+	const int shifter_target = sprite_width << 1;
+	const int pixel_width = sprites_magnified_ ? sprite_width << 1 : sprite_width;
+	int min_sprite = 0;
+
+	//
+	// Approach taken for Mode 2 sprites:
+	//
+	//	(1)	precompute full sprite images, at up to 32 pixels wide;
+	//	(2) for each sprite that is marked as CC, walk backwards until the
+	//		first sprite that is not marked CC, ORing it into the precomputed
+	//		image at each step;
+	//	(3)	subsequently, just draw each sprite image independently.
+	//
+	if constexpr (mode == SpriteMode::Mode2) {
+		// Determine the lowest visible sprite; exit early if that leaves no sprites visible.
+		for(; min_sprite < buffer.active_sprite_slot; min_sprite++) {
+			auto &sprite = buffer.active_sprites[min_sprite];
+			if(sprite.opaque()) {
+				break;
+			}
+		}
+		if(min_sprite == buffer.active_sprite_slot) {
+			return;
+		}
+
+		if(!start) {
+			// Pre-rasterise the sprites one-by-one.
+			if(sprites_magnified_) {
+				for(int index = min_sprite; index < buffer.active_sprite_slot; index++) {
+					auto &sprite = buffer.active_sprites[index];
+					for(int c = 0; c < 32; c+= 2) {
+						const int shift = (c >> 1) ^ 7;
+						const int bit = 1 & (sprite.image[shift >> 3] >> (shift & 7));
+
+						Storage<personality>::sprite_cache_[index][c] =
+						Storage<personality>::sprite_cache_[index][c + 1] =
+							(sprite.image[2] & 0xf & sprite_colour_selection_masks[bit]) |
+							uint8_t((bit << StatusSpriteCollisionShift) & sprite.collision_bit());
+					}
+				}
+			} else {
+				for(int index = min_sprite; index < buffer.active_sprite_slot; index++) {
+					auto &sprite = buffer.active_sprites[index];
+					for(int c = 0; c < 16; c++) {
+						const int shift = c ^ 7;
+						const int bit = 1 & (sprite.image[shift >> 3] >> (shift & 7));
+
+						Storage<personality>::sprite_cache_[index][c] =
+							(sprite.image[2] & 0xf & sprite_colour_selection_masks[bit]) |
+							uint8_t((bit << StatusSpriteCollisionShift) & sprite.collision_bit());
+					}
+				}
+			}
+
+			// Go backwards compositing any sprites that are set as OR masks onto their parents.
+			for(int index = buffer.active_sprite_slot - 1; index >= min_sprite + 1; --index) {
+				auto &sprite = buffer.active_sprites[index];
+				if(sprite.opaque()) {
+					continue;
+				}
+
+				// Sprite may affect all previous up to and cindlugin the next one that is opaque.
+				for(int previous_index = index - 1; previous_index >= min_sprite; --previous_index) {
+					// Determine region of overlap (if any).
+					auto &previous = buffer.active_sprites[previous_index];
+					const int origin = sprite.x - previous.x;
+					const int x1 = std::max(0, -origin);
+					const int x2 = std::min(pixel_width - origin, pixel_width);
+
+					// Composite sprites.
+					for(int x = x1; x < x2; x++) {
+						Storage<personality>::sprite_cache_[previous_index][x + origin]
+							|= Storage<personality>::sprite_cache_[index][x];
+					}
+
+					// If a previous opaque sprite has been found, stop.
+					if(previous.opaque()) {
+						break;
+					}
+				}
+			}
+		}
+
+		// Draw.
+		for(int index = buffer.active_sprite_slot - 1; index >= min_sprite; --index) {
+			auto &sprite = buffer.active_sprites[index];
+			const int x1 = std::max(0, start - sprite.x);
+			const int x2 = std::min(end - sprite.x, pixel_width);
+
+			for(int x = x1; x < x2; x++) {
+				const uint8_t colour = Storage<personality>::sprite_cache_[index][x];
+
+				// Plot colour, if visible.
+				if(colour) {
+					pixel_origin_[sprite.x + x] = palette[colour & 0xf];
+				}
+
+				// TODO: is collision location recorded in mode 1?
+
+				// Check for a new collision.
+				if(!(status_ & StatusSpriteCollision)) {
+					sprite_collision |= sprite_buffer[sprite.x + x];
+					sprite_buffer[sprite.x + x] |= colour;
+					status_ |= sprite_collision & StatusSpriteCollision;
+
+					if(status_ & StatusSpriteCollision) {
+						Storage<personality>::collision_location_[0] = uint16_t(x);
+						Storage<personality>::collision_location_[1] = uint16_t(y);
+					}
+				}
+			}
+		}
+
+		return;
+	}
+
+	if constexpr (mode == SpriteMode::Mode1) {
+		for(int index = buffer.active_sprite_slot - 1; index >= min_sprite; --index) {
+			auto &sprite = buffer.active_sprites[index];
+			if(sprite.shift_position >= shifter_target) {
+				continue;
+			}
+
+			const int pixel_start = std::max(start, sprite.x);
+			for(int c = pixel_start; c < end && sprite.shift_position < shifter_target; ++c) {
+				const int shift = (sprite.shift_position >> 1) ^ 7;
+				int sprite_colour = (sprite.image[shift >> 3] >> (shift & 7)) & 1;
+
+				// A colision is detected regardless of sprite colour ...
+				sprite_collision |= sprite_buffer[c] & sprite_colour;
+				sprite_buffer[c] |= sprite_colour;
+
+				// ... but a sprite with the transparent colour won't actually be visible.
+				sprite_colour &= colour_masks[sprite.image[2] & 0xf];
+
+				pixel_origin_[c] =
+					(pixel_origin_[c] & sprite_colour_selection_masks[sprite_colour^1]) |
+					(palette[sprite.image[2] & 0xf] & sprite_colour_selection_masks[sprite_colour]);
+
+				sprite.shift_position += shift_advance;
+			}
+		}
+
+		status_ |= sprite_collision << StatusSpriteCollisionShift;
+		return;
+	}
+}
+
+// Mode 2 logic, as I currently understand it, as a note for my future self:
+//
+//	If a sprite is marked as 'CC' then it doesn't collide, but its colour value is
+//	ORd with those of all lower-numbered sprites down to the next one that is visible on
+//	that line and not marked CC.
+//
+//	If no previous sprite meets that criteria, no pixels are displayed. But if one does
+//	then pixels are displayed even where they don't overlap with the earlier sprites.
+//
+//	... so in terms of my loop above, I guess I need temporary storage to accumulate
+//	an OR mask up until I hit a non-CC sprite, at which point I composite everything out?
+//	I'm not immediately sure whether I can appropriately reuse sprite_buffer, but possibly?
+
+// MARK: - TMS9918
+
+template <Personality personality>
+template <SpriteMode sprite_mode>
+void Base<personality>::draw_tms_character(int start, int end) {
+	auto &line_buffer = *draw_line_buffer_;
+
+	// Paint the background tiles.
+	const int pixels_left = end - start;
+	if(this->screen_mode_ == ScreenMode::MultiColour) {
+		for(int c = start; c < end; ++c) {
+			pixel_target_[c] = palette()[
+				(line_buffer.tiles.patterns[c >> 3][0] >> (((c & 4)^4))) & 15
+			];
+		}
+	} else {
+		const int shift = start & 7;
+		int byte_column = start >> 3;
+
+		int length = std::min(pixels_left, 8 - shift);
+
+		int pattern = Numeric::bit_reverse(line_buffer.tiles.patterns[byte_column][0]) >> shift;
+		uint8_t colour = line_buffer.tiles.patterns[byte_column][1];
+		uint32_t colours[2] = {
+			palette()[(colour & 15) ? (colour & 15) : background_colour_],
+			palette()[(colour >> 4) ? (colour >> 4) : background_colour_]
+		};
+
+		int background_pixels_left = pixels_left;
+		while(true) {
+			background_pixels_left -= length;
+			for(int c = 0; c < length; ++c) {
+				pixel_target_[c] = colours[pattern&0x01];
+				pattern >>= 1;
+			}
+			pixel_target_ += length;
+
+			if(!background_pixels_left) break;
+			length = std::min(8, background_pixels_left);
+			byte_column++;
+
+			pattern = Numeric::bit_reverse(line_buffer.tiles.patterns[byte_column][0]);
+			colour = line_buffer.tiles.patterns[byte_column][1];
+			colours[0] = palette()[(colour & 15) ? (colour & 15) : background_colour_];
+			colours[1] = palette()[(colour >> 4) ? (colour >> 4) : background_colour_];
+		}
+	}
+
+	draw_sprites<sprite_mode, false>(0, start, end, palette());	// TODO: propagate a real 'y' into here.
+}
+
+template <Personality personality>
+template <bool apply_blink>
+void Base<personality>::draw_tms_text(int start, int end) {
+	auto &line_buffer = *draw_line_buffer_;
+	uint32_t colours[2][2] = {
+		{palette()[background_colour_], palette()[text_colour_]},
+		{0, 0}
+	};
+	if constexpr (apply_blink) {
+		colours[1][0] = palette()[Storage<personality>::blink_background_colour_];
+		colours[1][1] = palette()[Storage<personality>::blink_text_colour_];
+	}
+
+	const int shift = start % 6;
+	int byte_column = start / 6;
+	int pattern = Numeric::bit_reverse(line_buffer.characters.shapes[byte_column]) >> shift;
+	int pixels_left = end - start;
+	int length = std::min(pixels_left, 6 - shift);
+	int flag = 0;
+	if constexpr (apply_blink) {
+		flag = (line_buffer.characters.flags[byte_column >> 3] >> ((byte_column & 7) ^ 7)) & Storage<personality>::in_blink_;
+	}
+	while(true) {
+		pixels_left -= length;
+		for(int c = 0; c < length; ++c) {
+			pixel_target_[c] = colours[flag][(pattern&0x01)];
+			pattern >>= 1;
+		}
+		pixel_target_ += length;
+
+		if(!pixels_left) break;
+		length = std::min(6, pixels_left);
+		byte_column++;
+		pattern = Numeric::bit_reverse(line_buffer.characters.shapes[byte_column]);
+		if constexpr (apply_blink) {
+			flag = (line_buffer.characters.flags[byte_column >> 3] >> ((byte_column & 7) ^ 7)) & Storage<personality>::in_blink_;
+		}
+	}
+}
+
+// MARK: - Master System
+
+template <Personality personality>
+void Base<personality>::draw_sms([[maybe_unused]] int start, [[maybe_unused]] int end, [[maybe_unused]] uint32_t cram_dot) {
+	if constexpr (is_sega_vdp(personality)) {
+		int colour_buffer[256];
+		auto &line_buffer = *draw_line_buffer_;
+
+		/*
+			Add extra border for any pixels that fall before the fine scroll.
+		*/
+		int tile_start = start, tile_end = end;
+		int tile_offset = start;
+		if(output_pointer_.row >= 16 || !Storage<personality>::horizontal_scroll_lock_) {
+			for(int c = start; c < (line_buffer.latched_horizontal_scroll & 7); ++c) {
+				colour_buffer[c] = 16 + background_colour_;
+				++tile_offset;
+			}
+
+			// Remove the border area from that to which tiles will be drawn.
+			tile_start = std::max(start - (line_buffer.latched_horizontal_scroll & 7), 0);
+			tile_end = std::max(end - (line_buffer.latched_horizontal_scroll & 7), 0);
+		}
+
+
+		uint32_t pattern;
+		uint8_t *const pattern_index = reinterpret_cast<uint8_t *>(&pattern);
+
+		/*
+			Add background tiles; these will fill the colour_buffer with values in which
+			the low five bits are a palette index, and bit six is set if this tile has
+			priority over sprites.
+		*/
+		if(tile_start < end) {
+			const int shift = tile_start & 7;
+			int byte_column = tile_start >> 3;
+			int pixels_left = tile_end - tile_start;
+			int length = std::min(pixels_left, 8 - shift);
+
+			pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]);
+			if(line_buffer.tiles.flags[byte_column]&2)
+				pattern >>= shift;
+			else
+				pattern <<= shift;
+
+			while(true) {
+				const int palette_offset = (line_buffer.tiles.flags[byte_column]&0x18) << 1;
+				if(line_buffer.tiles.flags[byte_column]&2) {
+					for(int c = 0; c < length; ++c) {
+						colour_buffer[tile_offset] =
+							((pattern_index[3] & 0x01) << 3) |
+							((pattern_index[2] & 0x01) << 2) |
+							((pattern_index[1] & 0x01) << 1) |
+							((pattern_index[0] & 0x01) << 0) |
+							palette_offset;
+						++tile_offset;
+						pattern >>= 1;
+					}
+				} else {
+					for(int c = 0; c < length; ++c) {
+						colour_buffer[tile_offset] =
+							((pattern_index[3] & 0x80) >> 4) |
+							((pattern_index[2] & 0x80) >> 5) |
+							((pattern_index[1] & 0x80) >> 6) |
+							((pattern_index[0] & 0x80) >> 7) |
+							palette_offset;
+						++tile_offset;
+						pattern <<= 1;
+					}
+				}
+
+				pixels_left -= length;
+				if(!pixels_left) break;
+
+				length = std::min(8, pixels_left);
+				byte_column++;
+				pattern = *reinterpret_cast<const uint32_t *>(line_buffer.tiles.patterns[byte_column]);
+			}
+		}
+
+		/*
+			Apply sprites (if any).
+		*/
+		draw_sprites<SpriteMode::MasterSystem, false>(0, start, end, palette(), colour_buffer);	// TODO provide good y, as per elsewhere.
+
+		// Map from the 32-colour buffer to real output pixels, applying the specific CRAM dot if any.
+		pixel_target_[start] = Storage<personality>::colour_ram_[colour_buffer[start] & 0x1f] | cram_dot;
+		for(int c = start+1; c < end; ++c) {
+			pixel_target_[c] = Storage<personality>::colour_ram_[colour_buffer[c] & 0x1f];
+		}
+
+		// If the VDP is set to hide the left column and this is the final call that'll come
+		// this line, hide it.
+		if(end == 256) {
+			if(Storage<personality>::hide_left_column_) {
+				pixel_origin_[0] = pixel_origin_[1] = pixel_origin_[2] = pixel_origin_[3] =
+				pixel_origin_[4] = pixel_origin_[5] = pixel_origin_[6] = pixel_origin_[7] =
+					Storage<personality>::colour_ram_[16 + background_colour_];
+			}
+		}
+	}
+}
+
+// MARK: - Yamaha
+
+template <Personality personality>
+template <ScreenMode mode>
+void Base<personality>::draw_yamaha(uint8_t y, int start, int end) {
+	[[maybe_unused]] const auto active_palette = palette();
+	const int sprite_start = start >> 2;
+	const int sprite_end = end >> 2;
+	auto &line_buffer = *draw_line_buffer_;
+
+	// Observation justifying Duff's device below: it's acceptable to paint too many pixels — to paint
+	// beyond `end` — provided that the overpainting is within normal bitmap bounds, because any
+	// mispainted pixels will be replaced before becoming visible to the user.
+
+	if constexpr (mode == ScreenMode::YamahaGraphics4 || mode == ScreenMode::YamahaGraphics6) {
+		start >>= (mode == ScreenMode::YamahaGraphics4) ? 2 : 1;
+		end >>= (mode == ScreenMode::YamahaGraphics4) ? 2 : 1;
+
+		int column = start & ~1;
+		const int offset = start & 1;
+		start >>= 1;
+		end = (end + 1) >> 1;
+
+		switch(offset) {
+			case 0:
+				do {
+						pixel_target_[column+0] = active_palette[line_buffer.bitmap[start] >> 4];	[[fallthrough]];
+			case 1:		pixel_target_[column+1] = active_palette[line_buffer.bitmap[start] & 0xf];
+						++start;
+						column += 2;
+				} while(start < end);
+		}
+	}
+
+	if constexpr (mode == ScreenMode::YamahaGraphics5) {
+		start >>= 1;
+		end >>= 1;
+
+		int column = start & ~3;
+		const int offset = start & 3;
+		start >>= 2;
+		end = (end + 3) >> 2;
+
+		switch(offset) {
+			case 0:
+				do {
+					pixel_target_[column+0] = active_palette[line_buffer.bitmap[start] >> 6];			[[fallthrough]];
+			case 1:	pixel_target_[column+1] = active_palette[(line_buffer.bitmap[start] >> 4) & 3];		[[fallthrough]];
+			case 2:	pixel_target_[column+2] = active_palette[(line_buffer.bitmap[start] >> 2) & 3];		[[fallthrough]];
+			case 3:	pixel_target_[column+3] = active_palette[line_buffer.bitmap[start] & 3];
+					++start;
+					column += 4;
+				} while(start < end);
+		}
+	}
+
+	if constexpr (mode == ScreenMode::YamahaGraphics7) {
+		start >>= 2;
+		end >>= 2;
+
+		while(start < end) {
+			pixel_target_[start] =
+				palette_pack(
+					uint8_t((line_buffer.bitmap[start] & 0x1c) + ((line_buffer.bitmap[start] & 0x1c) << 3) + ((line_buffer.bitmap[start] & 0x1c) >> 3)),
+					uint8_t((line_buffer.bitmap[start] & 0xe0) + ((line_buffer.bitmap[start] & 0xe0) >> 3) + ((line_buffer.bitmap[start] & 0xe0) >> 6)),
+					uint8_t((line_buffer.bitmap[start] & 0x03) + ((line_buffer.bitmap[start] & 0x03) << 2) + ((line_buffer.bitmap[start] & 0x03) << 4) + ((line_buffer.bitmap[start] & 0x03) << 6))
+				);
+			++start;
+		}
+	}
+
+	constexpr std::array<uint32_t, 16> graphics7_sprite_palette = {
+		palette_pack(0b00000000, 0b00000000, 0b00000000),	palette_pack(0b00000000, 0b00000000, 0b01001001),
+		palette_pack(0b00000000, 0b01101101, 0b00000000),	palette_pack(0b00000000, 0b01101101, 0b01001001),
+		palette_pack(0b01101101, 0b00000000, 0b00000000),	palette_pack(0b01101101, 0b00000000, 0b01001001),
+		palette_pack(0b01101101, 0b01101101, 0b00000000),	palette_pack(0b01101101, 0b01101101, 0b01001001),
+
+		palette_pack(0b10010010, 0b11111111, 0b01001001),	palette_pack(0b00000000, 0b00000000, 0b11111111),
+		palette_pack(0b00000000, 0b11111111, 0b00000000),	palette_pack(0b00000000, 0b11111111, 0b11111111),
+		palette_pack(0b11111111, 0b00000000, 0b00000000),	palette_pack(0b11111111, 0b00000000, 0b11111111),
+		palette_pack(0b11111111, 0b11111111, 0b00000000),	palette_pack(0b11111111, 0b11111111, 0b11111111),
+	};
+
+	// Possibly TODO: is the data-sheet trying to allege some sort of colour mixing for sprites in Mode 6?
+	draw_sprites<
+		SpriteMode::Mode2,
+		mode == ScreenMode::YamahaGraphics5 || mode == ScreenMode::YamahaGraphics6
+	>(y, sprite_start, sprite_end, mode == ScreenMode::YamahaGraphics7 ? graphics7_sprite_palette : palette());
+}
+
+template <Personality personality>
+void Base<personality>::draw_yamaha(uint8_t y, int start, int end) {
+	if constexpr (is_yamaha_vdp(personality)) {
+		switch(draw_line_buffer_->screen_mode) {
+			// Modes that are the same (or close enough) to those on the TMS.
+			case ScreenMode::Text:			draw_tms_text<false>(start >> 2, end >> 2);	break;
+			case ScreenMode::YamahaText80:	draw_tms_text<true>(start >> 1, end >> 1);	break;
+			case ScreenMode::MultiColour:
+			case ScreenMode::ColouredText:
+			case ScreenMode::Graphics:		draw_tms_character(start >> 2, end >> 2);	break;
+
+			case ScreenMode::YamahaGraphics3:
+				draw_tms_character<SpriteMode::Mode2>(start >> 2, end >> 2);
+			break;
+
+#define Dispatch(x)	case ScreenMode::x:	draw_yamaha<ScreenMode::x>(y, start, end);	break;
+			Dispatch(YamahaGraphics4);
+			Dispatch(YamahaGraphics5);
+			Dispatch(YamahaGraphics6);
+			Dispatch(YamahaGraphics7);
+#undef Dispatch
+
+			default: break;
+		}
+	}
+}
+
+// MARK: - Mega Drive
+
+// TODO.
+
+}
+
+#endif /* Draw_hpp */

Components/9918/Implementation/Fetch.hpp

@@ -0,0 +1,796 @@
+//
+//  Fetch.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/01/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef Fetch_hpp
+#define Fetch_hpp
+
+namespace TI::TMS {
+
+/*
+	Fetching routines follow below; they obey the following rules:
+
+		1)	input is a start position and an end position; they should perform the proper
+			operations for the period: start <= time < end.
+		2)	times are measured relative to the an appropriate clock — they directly
+			count access windows on the TMS and Master System, and cycles on a Yamaha.
+		3)	within each sequencer, cycle are numbered as per Grauw's timing diagrams. The difference
+			between those and internal timing, if there is one, is handled by the dispatcher.
+		4)	all of these functions are templated with a `use_end` parameter. That will be true if
+			end is < [cycles per line], false otherwise. So functions can use it to eliminate
+			should-exit-now checks (which is likely to be the more usual path of execution).
+
+	Provided for the benefit of the methods below:
+
+		*	the function external_slot(), which will perform any pending VRAM read/write.
+
+	All functions should just spool data to intermediary storage. Fetching and drawing are decoupled.
+*/
+
+// MARK: - Address mask helpers.
+
+/// @returns An instance of @c AddressT with all top bits set down to and including
+/// bit @c end and all others clear.
+///
+/// So e.g. if @c AddressT is @c uint16_t and this VDP has a 15-bit address space then
+/// @c top_bits<10> will be the address with bits 15 to 10 (inclusive) set and the rest clear.
+template <typename AddressT, int end> constexpr AddressT top_bits() {
+	return AddressT(~0) - AddressT((1 << end) - 1);
+}
+
+/// Modifies and returns @c source so that all bits above position @c n are set; the others are unmodified.
+template <int n, typename AddressT> constexpr AddressT bits(AddressT source = 0) {
+	return AddressT(source | top_bits<AddressT, n>());
+}
+
+// MARK: - 171-window Dispatcher.
+
+template <Personality personality>
+template<bool use_end, typename SequencerT> void Base<personality>::dispatch(SequencerT &fetcher, int start, int end) {
+#define index(n)						\
+	if(use_end && end == n) return;		\
+	[[fallthrough]];					\
+	case n: fetcher.template fetch<from_internal<personality, Origin::StartOfSync>(n)>();
+
+	switch(start) {
+		default: assert(false);
+		index(0);	index(1);	index(2);	index(3);	index(4);	index(5);	index(6);	index(7);	index(8);	index(9);
+		index(10);	index(11);	index(12);	index(13);	index(14);	index(15);	index(16);	index(17);	index(18);	index(19);
+		index(20);	index(21);	index(22);	index(23);	index(24);	index(25);	index(26);	index(27);	index(28);	index(29);
+		index(30);	index(31);	index(32);	index(33);	index(34);	index(35);	index(36);	index(37);	index(38);	index(39);
+		index(40);	index(41);	index(42);	index(43);	index(44);	index(45);	index(46);	index(47);	index(48);	index(49);
+		index(50);	index(51);	index(52);	index(53);	index(54);	index(55);	index(56);	index(57);	index(58);	index(59);
+		index(60);	index(61);	index(62);	index(63);	index(64);	index(65);	index(66);	index(67);	index(68);	index(69);
+		index(70);	index(71);	index(72);	index(73);	index(74);	index(75);	index(76);	index(77);	index(78);	index(79);
+		index(80);	index(81);	index(82);	index(83);	index(84);	index(85);	index(86);	index(87);	index(88);	index(89);
+		index(90);	index(91);	index(92);	index(93);	index(94);	index(95);	index(96);	index(97);	index(98);	index(99);
+		index(100);	index(101);	index(102);	index(103);	index(104);	index(105);	index(106);	index(107);	index(108);	index(109);
+		index(110);	index(111);	index(112);	index(113);	index(114);	index(115);	index(116);	index(117);	index(118);	index(119);
+		index(120);	index(121);	index(122);	index(123);	index(124);	index(125);	index(126);	index(127);	index(128);	index(129);
+		index(130);	index(131);	index(132);	index(133);	index(134);	index(135);	index(136);	index(137);	index(138);	index(139);
+		index(140);	index(141);	index(142);	index(143);	index(144);	index(145);	index(146);	index(147);	index(148);	index(149);
+		index(150);	index(151);	index(152);	index(153);	index(154);	index(155);	index(156);	index(157);	index(158);	index(159);
+		index(160);	index(161);	index(162);	index(163);	index(164);	index(165);	index(166);	index(167);	index(168);	index(169);
+		index(170);
+	}
+
+#undef index
+}
+
+// MARK: - Fetchers.
+
+template <Personality personality>
+struct TextFetcher {
+	using AddressT = typename Base<personality>::AddressT;
+
+	TextFetcher(Base<personality> *base, uint8_t y) :
+		base(base),
+		row_base(base->pattern_name_address_ & bits<10>(AddressT((y >> 3) * 40))),
+		row_offset(base->pattern_generator_table_address_ & bits<11>(AddressT(y & 7))) {}
+
+	void fetch_name(AddressT column, int slot = 0) {
+		base->name_[slot] = base->ram_[row_base + column];
+	}
+
+	void fetch_pattern(AddressT column, int slot = 0) {
+		base->fetch_line_buffer_->characters.shapes[column] = base->ram_[row_offset + size_t(base->name_[slot] << 3)];
+	}
+
+	Base<personality> *const base;
+	const AddressT row_base;
+	const AddressT row_offset;
+};
+
+template <Personality personality>
+struct CharacterFetcher {
+	using AddressT = typename Base<personality>::AddressT;
+
+	CharacterFetcher(Base<personality> *base, uint8_t y) :
+		base(base),
+		y(y),
+		row_base(base->pattern_name_address_ & bits<10>(AddressT((y << 2)&~31)))
+	{
+		pattern_base = base->pattern_generator_table_address_;
+		colour_base = base->colour_table_address_;
+		colour_name_shift = 6;
+
+		const ScreenMode mode = base->fetch_line_buffer_->screen_mode;
+		if(mode == ScreenMode::Graphics || mode == ScreenMode::YamahaGraphics3) {
+			// If this is high resolution mode, allow the row number to affect the pattern and colour addresses.
+			pattern_base &= bits<13>(AddressT(((y & 0xc0) << 5)));
+			colour_base &= bits<13>(AddressT(((y & 0xc0) << 5)));
+
+			colour_base += AddressT(y & 7);
+			colour_name_shift = 0;
+		} else {
+			colour_base &= bits<6, AddressT>();
+			pattern_base &= bits<11, AddressT>();
+		}
+
+		if(mode == ScreenMode::MultiColour) {
+			pattern_base += AddressT((y >> 2) & 7);
+		} else {
+			pattern_base += AddressT(y & 7);
+		}
+	}
+
+	void fetch_name(int column) {
+		base->tile_offset_ = base->ram_[row_base + AddressT(column)];
+	}
+
+	void fetch_pattern(int column) {
+		base->fetch_line_buffer_->tiles.patterns[column][0] = base->ram_[pattern_base + AddressT(base->tile_offset_ << 3)];
+	}
+
+	void fetch_colour(int column) {
+		base->fetch_line_buffer_->tiles.patterns[column][1] = base->ram_[colour_base + AddressT((base->tile_offset_ << 3) >> colour_name_shift)];
+	}
+
+	Base<personality> *const base;
+	const uint8_t y;
+	const AddressT row_base;
+	AddressT pattern_base;
+	AddressT colour_base;
+	int colour_name_shift;
+};
+
+constexpr SpriteMode sprite_mode(ScreenMode screen_mode) {
+	switch(screen_mode) {
+		default:
+			return SpriteMode::Mode2;
+
+		case ScreenMode::MultiColour:
+		case ScreenMode::ColouredText:
+		case ScreenMode::Graphics:
+			return SpriteMode::Mode1;
+
+		case ScreenMode::SMSMode4:
+			return SpriteMode::MasterSystem;
+	}
+}
+
+// TODO: should this be extended to include Master System sprites?
+template <Personality personality, SpriteMode mode>
+class SpriteFetcher {
+	public:
+		using AddressT = typename Base<personality>::AddressT;
+
+		// The Yamaha VDP adds an additional table when in Sprite Mode 2, the sprite colour
+		// table, which is intended to fill the 512 bytes before the programmer-located sprite
+		// attribute table.
+		//
+		// It partially enforces this proximity by forcing bits 7 and 8 to 0 in the address of
+		// the attribute table, and forcing them to 1 but masking out bit 9 for the colour table.
+		//
+		// AttributeAddressMask is used to enable or disable that behaviour.
+		static constexpr AddressT AttributeAddressMask = (mode == SpriteMode::Mode2) ? AddressT(~0x180) : AddressT(~0x000);
+
+		SpriteFetcher(Base<personality> *base, uint8_t y) :
+			base(base),
+			y(y) {}
+
+		void fetch_location(int slot) {
+			fetch_xy(slot);
+
+			if constexpr (mode == SpriteMode::Mode2) {
+				fetch_xy(slot + 1);
+
+				base->name_[0] = name(slot);
+				base->name_[1] = name(slot + 1);
+			}
+		}
+
+		void fetch_pattern(int slot) {
+			switch(mode) {
+				case SpriteMode::Mode1:
+					fetch_image(slot, name(slot));
+				break;
+
+				case SpriteMode::Mode2:
+					fetch_image(slot, base->name_[0]);
+					fetch_image(slot + 1, base->name_[1]);
+				break;
+			}
+		}
+
+		void fetch_y(int sprite) {
+			const AddressT address = base->sprite_attribute_table_address_ & AttributeAddressMask & bits<7>(AddressT(sprite << 2));
+			const uint8_t sprite_y = base->ram_[address];
+			base->posit_sprite(sprite, sprite_y, y);
+		}
+
+	private:
+		void fetch_xy(int slot) {
+			auto &buffer = *base->fetch_sprite_buffer_;
+			buffer.active_sprites[slot].x =
+				base->ram_[
+					base->sprite_attribute_table_address_ & AttributeAddressMask & bits<7>(AddressT((buffer.active_sprites[slot].index << 2) | 1))
+				];
+		}
+
+		uint8_t name(int slot) {
+			auto &buffer = *base->fetch_sprite_buffer_;
+			const AddressT address =
+				base->sprite_attribute_table_address_ &
+				AttributeAddressMask &
+				bits<7>(AddressT((buffer.active_sprites[slot].index << 2) | 2));
+			const uint8_t name = base->ram_[address] & (base->sprites_16x16_ ? ~3 : ~0);
+			return name;
+		}
+
+		void fetch_image(int slot, uint8_t name) {
+			uint8_t colour = 0;
+			auto &sprite = base->fetch_sprite_buffer_->active_sprites[slot];
+			switch(mode) {
+				case SpriteMode::Mode1:
+					// Fetch colour from the attribute table, per this sprite's slot.
+					colour = base->ram_[
+						base->sprite_attribute_table_address_ & bits<7>(AddressT((sprite.index << 2) | 3))
+					];
+				break;
+
+				case SpriteMode::Mode2: {
+					// Fetch colour from the colour table, per this sprite's slot and row.
+					const AddressT colour_table_address = (base->sprite_attribute_table_address_ | ~AttributeAddressMask) & AddressT(~0x200);
+					colour = base->ram_[
+						colour_table_address &
+						bits<9>(
+							AddressT(sprite.index << 4) |
+							AddressT(sprite.row)
+						)
+					];
+				} break;
+			}
+			sprite.image[2] = colour;
+			sprite.x -= sprite.early_clock();
+
+			const AddressT graphic_location = base->sprite_generator_table_address_ & bits<11>(AddressT((name << 3) | sprite.row));
+			sprite.image[0] = base->ram_[graphic_location];
+			sprite.image[1] = base->ram_[graphic_location+16];
+
+			if constexpr (SpriteBuffer::test_is_filling) {
+				if(slot == ((mode == SpriteMode::Mode2) ? 7 : 3)) {
+					base->fetch_sprite_buffer_->is_filling = false;
+				}
+			}
+		}
+
+		Base<personality> *const base;
+		const uint8_t y;
+};
+
+template <Personality personality>
+struct SMSFetcher {
+	using AddressT = typename Base<personality>::AddressT;
+	struct RowInfo {
+		AddressT pattern_address_base;
+		AddressT sub_row[2];
+	};
+
+	SMSFetcher(Base<personality> *base, uint8_t y) :
+		base(base),
+		storage(static_cast<Storage<personality> *>(base)),
+		y(y),
+		horizontal_offset((y >= 16 || !storage->horizontal_scroll_lock_) ? (base->fetch_line_buffer_->latched_horizontal_scroll >> 3) : 0)
+	{
+		// Limit address bits in use if this is a SMS2 mode.
+		const bool is_tall_mode = base->mode_timing_.pixel_lines != 192;
+		const AddressT pattern_name_address = storage->pattern_name_address_ | (is_tall_mode ? 0x800 : 0);
+		const AddressT pattern_name_offset = is_tall_mode ? 0x100 : 0;
+
+		// Determine row info for the screen both (i) if vertical scrolling is applied; and (ii) if it isn't.
+		// The programmer can opt out of applying vertical scrolling to the right-hand portion of the display.
+		const int scrolled_row = (y + storage->latched_vertical_scroll_) % (is_tall_mode ? 256 : 224);
+		scrolled_row_info.pattern_address_base = (pattern_name_address & bits<11>(AddressT((scrolled_row & ~7) << 3))) - pattern_name_offset;
+		scrolled_row_info.sub_row[0] = AddressT((scrolled_row & 7) << 2);
+		scrolled_row_info.sub_row[1] = AddressT(28 ^ ((scrolled_row & 7) << 2));
+		if(storage->vertical_scroll_lock_) {
+			static_row_info.pattern_address_base = bits<11>(AddressT(pattern_name_address & ((y & ~7) << 3))) - pattern_name_offset;
+			static_row_info.sub_row[0] = AddressT((y & 7) << 2);
+			static_row_info.sub_row[1] = 28 ^ AddressT((y & 7) << 2);
+		} else static_row_info = scrolled_row_info;
+	}
+
+	void fetch_sprite(int sprite) {
+		auto &sprite_buffer = *base->fetch_sprite_buffer_;
+		sprite_buffer.active_sprites[sprite].x =
+			base->ram_[
+				storage->sprite_attribute_table_address_ & bits<7>((sprite_buffer.active_sprites[sprite].index << 1) | 0)
+			] - (storage->shift_sprites_8px_left_ ? 8 : 0);
+		const uint8_t name = base->ram_[
+				storage->sprite_attribute_table_address_ & bits<7>((sprite_buffer.active_sprites[sprite].index << 1) | 1)
+			] & (base->sprites_16x16_ ? ~1 : ~0);
+
+		const AddressT graphic_location =
+			storage->sprite_generator_table_address_ &
+			bits<13>(AddressT((name << 5) | (sprite_buffer.active_sprites[sprite].row << 2)));
+		sprite_buffer.active_sprites[sprite].image[0] = base->ram_[graphic_location];
+		sprite_buffer.active_sprites[sprite].image[1] = base->ram_[graphic_location+1];
+		sprite_buffer.active_sprites[sprite].image[2] = base->ram_[graphic_location+2];
+		sprite_buffer.active_sprites[sprite].image[3] = base->ram_[graphic_location+3];
+	}
+
+	void fetch_tile_name(int column) {
+		const RowInfo &row_info = column < 24 ? scrolled_row_info : static_row_info;
+		const size_t scrolled_column = (column - horizontal_offset) & 0x1f;
+		const size_t address = row_info.pattern_address_base + (scrolled_column << 1);
+		auto &line_buffer = *base->fetch_line_buffer_;
+
+		line_buffer.tiles.flags[column] = base->ram_[address+1];
+		base->tile_offset_ = AddressT(
+			(((line_buffer.tiles.flags[column]&1) << 8) | base->ram_[address]) << 5
+		) + row_info.sub_row[(line_buffer.tiles.flags[column]&4) >> 2];
+	}
+
+	void fetch_tile_pattern(int column) {
+		auto &line_buffer = *base->fetch_line_buffer_;
+		line_buffer.tiles.patterns[column][0] = base->ram_[base->tile_offset_];
+		line_buffer.tiles.patterns[column][1] = base->ram_[base->tile_offset_+1];
+		line_buffer.tiles.patterns[column][2] = base->ram_[base->tile_offset_+2];
+		line_buffer.tiles.patterns[column][3] = base->ram_[base->tile_offset_+3];
+	}
+
+	void posit_sprite(int sprite) {
+		base->posit_sprite(sprite, base->ram_[storage->sprite_attribute_table_address_ & bits<8>(AddressT(sprite))], y);
+	}
+
+	Base<personality> *const base;
+	const Storage<personality> *const storage;
+	const uint8_t y;
+	const int horizontal_offset;
+	RowInfo scrolled_row_info, static_row_info;
+};
+
+// MARK: - TMS Sequencers.
+
+template <Personality personality>
+struct RefreshSequencer {
+	RefreshSequencer(Base<personality> *base) : base(base) {}
+
+	template <int cycle> void fetch() {
+		if(cycle < 26 || (cycle & 1) || cycle >= 154) {
+			base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+	}
+
+	Base<personality> *const base;
+};
+
+template <Personality personality>
+struct TextSequencer {
+	template <typename... Args> TextSequencer(Args&&... args) : fetcher(std::forward<Args>(args)...) {}
+
+	template <int cycle> void fetch() {
+		// The first 30 and the final 4 slots are external.
+		if constexpr (cycle < 30 || cycle >= 150) {
+			fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+			return;
+		} else {
+			// For the 120 slots in between follow a three-step pattern of:
+			constexpr int offset = cycle - 30;
+			constexpr auto column = AddressT(offset / 3);
+			switch(offset % 3) {
+				case 0:		// (1) fetch tile name.
+					fetcher.fetch_name(column);
+				break;
+				case 1:		// (2) external slot.
+					fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+				break;
+				case 2:		// (3) fetch tile pattern.
+					fetcher.fetch_pattern(column);
+				break;
+			}
+		}
+	}
+
+	using AddressT = typename Base<personality>::AddressT;
+	TextFetcher<personality> fetcher;
+};
+
+template <Personality personality>
+struct CharacterSequencer {
+	template <typename... Args> CharacterSequencer(Args&&... args) :
+		character_fetcher(std::forward<Args>(args)...),
+		sprite_fetcher(std::forward<Args>(args)...) {}
+
+	template <int cycle> void fetch() {
+		if(cycle < 5) {
+			character_fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		if(cycle == 5) {
+			// Fetch: n1, c2, pat2a, pat2b, y3, x3, n3, c3, pat3a, pat3b.
+			sprite_fetcher.fetch_pattern(2);
+			sprite_fetcher.fetch_location(3);
+			sprite_fetcher.fetch_pattern(3);
+		}
+
+		if(cycle > 14 && cycle < 19) {
+			character_fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		// Fetch 8 new sprite Y coordinates, to begin selecting sprites for next line.
+		if(cycle == 19) {
+			sprite_fetcher.fetch_y(0);	sprite_fetcher.fetch_y(1);	sprite_fetcher.fetch_y(2);	sprite_fetcher.fetch_y(3);
+			sprite_fetcher.fetch_y(4);	sprite_fetcher.fetch_y(5);	sprite_fetcher.fetch_y(6);	sprite_fetcher.fetch_y(7);
+		}
+
+		// Body of line: tiles themselves, plus some additional potential sprites.
+		if(cycle >= 27 && cycle < 155) {
+			constexpr int offset = cycle - 27;
+			constexpr int block = offset >> 2;
+			constexpr int sub_block = offset & 3;
+			switch(sub_block) {
+				case 0:	character_fetcher.fetch_name(block);	break;
+				case 1:
+					if(!(block & 3)) {
+						character_fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+					} else {
+						constexpr int sprite = 8 + ((block >> 2) * 3) + ((block & 3) - 1);
+						sprite_fetcher.fetch_y(sprite);
+					}
+				break;
+				case 2:
+					character_fetcher.fetch_pattern(block);
+					character_fetcher.fetch_colour(block);
+				break;
+				default: break;
+			}
+		}
+
+		if(cycle >= 155 && cycle < 157) {
+			character_fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		if(cycle == 157) {
+			// Fetch: y0, x0, n0, c0, pat0a, pat0b, y1, x1, n1, c1, pat1a, pat1b, y2, x2.
+			sprite_fetcher.fetch_location(0);
+			sprite_fetcher.fetch_pattern(0);
+			sprite_fetcher.fetch_location(1);
+			sprite_fetcher.fetch_pattern(1);
+			sprite_fetcher.fetch_location(2);
+		}
+	}
+
+	using AddressT = typename Base<personality>::AddressT;
+	CharacterFetcher<personality> character_fetcher;
+	SpriteFetcher<personality, SpriteMode::Mode1> sprite_fetcher;
+};
+
+// MARK: - TMS fetch routines.
+
+template <Personality personality>
+template<bool use_end> void Base<personality>::fetch_tms_refresh(uint8_t, int start, int end) {
+	RefreshSequencer sequencer(this);
+	dispatch<use_end>(sequencer, start, end);
+}
+
+template <Personality personality>
+template<bool use_end> void Base<personality>::fetch_tms_text(uint8_t y, int start, int end) {
+	TextSequencer<personality> sequencer(this, y);
+	dispatch<use_end>(sequencer, start, end);
+}
+
+template <Personality personality>
+template<bool use_end> void Base<personality>::fetch_tms_character(uint8_t y, int start, int end) {
+	CharacterSequencer<personality> sequencer(this, y);
+	dispatch<use_end>(sequencer, start, end);
+}
+
+// MARK: - Master System
+
+template <Personality personality>
+struct SMSSequencer {
+	template <typename... Args> SMSSequencer(Args&&... args) : fetcher(std::forward<Args>(args)...) {}
+
+	// Cf. https://www.smspower.org/forums/16485-GenesisMode4VRAMTiming with this implementation pegging
+	// window 0 to HSYNC low.
+	template <int cycle> void fetch() {
+		if(cycle < 3) {
+			fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		if(cycle == 3) {
+			fetcher.fetch_sprite(4);
+			fetcher.fetch_sprite(5);
+			fetcher.fetch_sprite(6);
+			fetcher.fetch_sprite(7);
+		}
+
+		if(cycle == 15 || cycle == 16) {
+			fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		if(cycle == 17) {
+			fetcher.posit_sprite(0);	fetcher.posit_sprite(1);	fetcher.posit_sprite(2);	fetcher.posit_sprite(3);
+			fetcher.posit_sprite(4);	fetcher.posit_sprite(5);	fetcher.posit_sprite(6);	fetcher.posit_sprite(7);
+			fetcher.posit_sprite(8);	fetcher.posit_sprite(9);	fetcher.posit_sprite(10);	fetcher.posit_sprite(11);
+			fetcher.posit_sprite(12);	fetcher.posit_sprite(13);	fetcher.posit_sprite(14);	fetcher.posit_sprite(15);
+		}
+
+		if(cycle >= 25 && cycle < 153) {
+			constexpr int offset = cycle - 25;
+			constexpr int block = offset >> 2;
+			constexpr int sub_block = offset & 3;
+
+			switch(sub_block) {
+				default: break;
+
+				case 0:	fetcher.fetch_tile_name(block);		break;
+				case 1:
+					if(!(block & 3)) {
+						fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+					} else {
+						constexpr int sprite = (8 + ((block >> 2) * 3) + ((block & 3) - 1)) << 1;
+						fetcher.posit_sprite(sprite);
+						fetcher.posit_sprite(sprite+1);
+					}
+				break;
+				case 2:	fetcher.fetch_tile_pattern(block);	break;
+			}
+		}
+
+		if(cycle >= 153 && cycle < 157) {
+			fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+
+		if(cycle == 157) {
+			fetcher.fetch_sprite(0);
+			fetcher.fetch_sprite(1);
+			fetcher.fetch_sprite(2);
+			fetcher.fetch_sprite(3);
+		}
+
+		if(cycle >= 169) {
+			fetcher.base->do_external_slot(to_internal<personality, Origin::ModeLatch, Clock::TMSMemoryWindow>(cycle));
+		}
+	}
+
+	using AddressT = typename Base<personality>::AddressT;
+	SMSFetcher<personality> fetcher;
+};
+
+template <Personality personality>
+template<bool use_end> void Base<personality>::fetch_sms([[maybe_unused]] uint8_t y, [[maybe_unused]] int start, [[maybe_unused]] int end) {
+	if constexpr (is_sega_vdp(personality)) {
+		SMSSequencer<personality> sequencer(this, y);
+		dispatch<use_end>(sequencer, start, end);
+	}
+}
+
+// MARK: - Yamaha
+
+template <Personality personality>
+template<ScreenMode mode> void Base<personality>::fetch_yamaha(uint8_t y, int end) {
+	CharacterFetcher character_fetcher(this, y);
+	TextFetcher text_fetcher(this, y);
+	SpriteFetcher<personality, sprite_mode(mode)> sprite_fetcher(this, y);
+
+	using Type = typename Storage<personality>::Event::Type;
+	while(Storage<personality>::next_event_->offset < end) {
+		switch(Storage<personality>::next_event_->type) {
+			case Type::External:
+				do_external_slot(Storage<personality>::next_event_->offset);
+			break;
+
+			case Type::Name:
+				switch(mode) {
+					case ScreenMode::Text: {
+						const auto column = AddressT(Storage<personality>::next_event_->id << 1);
+
+						text_fetcher.fetch_name(column, 0);
+						text_fetcher.fetch_name(column + 1, 1);
+					} break;
+
+					case ScreenMode::YamahaText80: {
+						const auto column = AddressT(Storage<personality>::next_event_->id << 2);
+						const auto start = pattern_name_address_ & bits<12>(AddressT((y >> 3) * 80));
+
+						name_[0] = ram_[start + column + 0];
+						name_[1] = ram_[start + column + 1];
+						name_[2] = ram_[start + column + 2];
+						name_[3] = ram_[start + column + 3];
+					} break;
+
+					case ScreenMode::Graphics:
+					case ScreenMode::MultiColour:
+					case ScreenMode::ColouredText:
+						character_fetcher.fetch_name(Storage<personality>::next_event_->id);
+					break;
+
+					default: break;
+				}
+			break;
+
+			case Type::Colour:
+				switch(mode) {
+					case ScreenMode::YamahaText80: {
+						const auto column = AddressT(Storage<personality>::next_event_->id);
+						const auto address = colour_table_address_ & bits<9>(AddressT((y >> 3) * 10));
+						auto &line_buffer = *fetch_line_buffer_;
+						line_buffer.characters.flags[column] = ram_[address + column];
+					} break;
+
+					case ScreenMode::Graphics:
+					case ScreenMode::MultiColour:
+					case ScreenMode::ColouredText:
+						character_fetcher.fetch_colour(Storage<personality>::next_event_->id);
+					break;
+
+					default: break;
+				}
+			break;
+
+			case Type::Pattern:
+				switch(mode) {
+					case ScreenMode::Text: {
+						const auto column = AddressT(Storage<personality>::next_event_->id << 1);
+
+						text_fetcher.fetch_pattern(column, 0);
+						text_fetcher.fetch_pattern(column + 1, 1);
+					} break;
+
+					case ScreenMode::YamahaText80: {
+						const auto column = Storage<personality>::next_event_->id << 2;
+						const auto start = pattern_generator_table_address_ & bits<11>(AddressT(y & 7));
+						auto &line_buffer = *fetch_line_buffer_;
+
+						line_buffer.characters.shapes[column + 0] = ram_[start + AddressT(name_[0] << 3)];
+						line_buffer.characters.shapes[column + 1] = ram_[start + AddressT(name_[1] << 3)];
+						line_buffer.characters.shapes[column + 2] = ram_[start + AddressT(name_[2] << 3)];
+						line_buffer.characters.shapes[column + 3] = ram_[start + AddressT(name_[3] << 3)];
+					} break;
+
+					case ScreenMode::Graphics:
+					case ScreenMode::MultiColour:
+					case ScreenMode::ColouredText:
+						character_fetcher.fetch_pattern(Storage<personality>::next_event_->id);
+					break;
+
+					case ScreenMode::YamahaGraphics3:
+						// As per comment elsewhere; my _guess_ is that G3 is slotted as if it were
+						// a bitmap mode, with the three bytes that describe each column fitting into
+						// the relevant windows.
+						character_fetcher.fetch_name(Storage<personality>::next_event_->id);
+						character_fetcher.fetch_colour(Storage<personality>::next_event_->id);
+						character_fetcher.fetch_pattern(Storage<personality>::next_event_->id);
+					break;
+
+					case ScreenMode::YamahaGraphics4:
+					case ScreenMode::YamahaGraphics5: {
+						const int column = Storage<personality>::next_event_->id << 2;
+						const auto start = bits<15>((y << 7) | column);
+						auto &line_buffer = *fetch_line_buffer_;
+
+						line_buffer.bitmap[column + 0] = ram_[pattern_name_address_ & AddressT(start + 0)];
+						line_buffer.bitmap[column + 1] = ram_[pattern_name_address_ & AddressT(start + 1)];
+						line_buffer.bitmap[column + 2] = ram_[pattern_name_address_ & AddressT(start + 2)];
+						line_buffer.bitmap[column + 3] = ram_[pattern_name_address_ & AddressT(start + 3)];
+					} break;
+
+					case ScreenMode::YamahaGraphics6:
+					case ScreenMode::YamahaGraphics7: {
+						const uint8_t *const ram2 = &ram_[65536];
+						const int column = Storage<personality>::next_event_->id << 3;
+						const auto start = bits<15>((y << 7) | (column >> 1));
+						auto &line_buffer = *fetch_line_buffer_;
+
+						// Fetch from alternate banks.
+						line_buffer.bitmap[column + 0] = ram_[pattern_name_address_ & AddressT(start + 0) & 0xffff];
+						line_buffer.bitmap[column + 1] = ram2[pattern_name_address_ & AddressT(start + 0) & 0xffff];
+						line_buffer.bitmap[column + 2] = ram_[pattern_name_address_ & AddressT(start + 1) & 0xffff];
+						line_buffer.bitmap[column + 3] = ram2[pattern_name_address_ & AddressT(start + 1) & 0xffff];
+						line_buffer.bitmap[column + 4] = ram_[pattern_name_address_ & AddressT(start + 2) & 0xffff];
+						line_buffer.bitmap[column + 5] = ram2[pattern_name_address_ & AddressT(start + 2) & 0xffff];
+						line_buffer.bitmap[column + 6] = ram_[pattern_name_address_ & AddressT(start + 3) & 0xffff];
+						line_buffer.bitmap[column + 7] = ram2[pattern_name_address_ & AddressT(start + 3) & 0xffff];
+					} break;
+
+					default: break;
+				}
+			break;
+
+			case Type::SpriteY:
+				switch(mode) {
+					case ScreenMode::Blank:
+					case ScreenMode::Text:
+					case ScreenMode::YamahaText80:
+						// Ensure the compiler can discard character_fetcher in these modes.
+					break;
+
+					default:
+						sprite_fetcher.fetch_y(Storage<personality>::next_event_->id);
+					break;
+				}
+			break;
+
+			case Type::SpriteLocation:
+				switch(mode) {
+					case ScreenMode::Blank:
+					case ScreenMode::Text:
+					case ScreenMode::YamahaText80:
+						// Ensure the compiler can discard character_fetcher in these modes.
+					break;
+
+					default:
+						sprite_fetcher.fetch_location(Storage<personality>::next_event_->id);
+					break;
+				}
+			break;
+
+			case Type::SpritePattern:
+				switch(mode) {
+					case ScreenMode::Blank:
+					case ScreenMode::Text:
+					case ScreenMode::YamahaText80:
+						// Ensure the compiler can discard character_fetcher in these modes.
+					break;
+
+					default:
+						sprite_fetcher.fetch_pattern(Storage<personality>::next_event_->id);
+					break;
+				}
+			break;
+
+			default: break;
+		}
+
+		++Storage<personality>::next_event_;
+	}
+}
+
+
+template <Personality personality>
+template<bool use_end> void Base<personality>::fetch_yamaha(uint8_t y, int, int end) {
+	if constexpr (is_yamaha_vdp(personality)) {
+		// Dispatch according to [supported] screen mode.
+#define Dispatch(mode)	case mode:	fetch_yamaha<mode>(y, end);	break;
+		switch(fetch_line_buffer_->screen_mode) {
+			default: break;
+			Dispatch(ScreenMode::Blank);
+			Dispatch(ScreenMode::Text);
+			Dispatch(ScreenMode::MultiColour);
+			Dispatch(ScreenMode::ColouredText);
+			Dispatch(ScreenMode::Graphics);
+			Dispatch(ScreenMode::YamahaText80);
+			Dispatch(ScreenMode::YamahaGraphics3);
+			Dispatch(ScreenMode::YamahaGraphics4);
+			Dispatch(ScreenMode::YamahaGraphics5);
+			Dispatch(ScreenMode::YamahaGraphics6);
+			Dispatch(ScreenMode::YamahaGraphics7);
+		}
+#undef Dispatch
+	}
+}
+
+// MARK: - Mega Drive
+
+// TODO.
+
+}
+
+#endif /* Fetch_hpp */

Components/9918/Implementation/LineBuffer.hpp

@@ -0,0 +1,132 @@
+//
+//  LineBuffer.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 12/02/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef LineBuffer_hpp
+#define LineBuffer_hpp
+
+#include "AccessEnums.hpp"
+
+namespace TI::TMS {
+
+// Temporary buffers collect a representation of each line prior to pixel serialisation.
+
+struct SpriteBuffer {
+	// An active sprite is one that has been selected for composition onto
+	// _this_ line.
+	struct ActiveSprite {
+		int index = 0;		// The original in-table index of this sprite.
+		int row = 0;		// The row of the sprite that should be drawn.
+		int x = 0;			// The sprite's x position on screen.
+
+		uint8_t image[4];		// Up to four bytes of image information.
+								//
+								// In practice:
+								//
+								//	Master System mode: the four bytes of this 8x8 sprite;
+								//	TMS and Yamaha: [0] = the left half of this sprite; [1] = the right side (if 16x16 sprites enabled); [2] = colour, early-clock bit, etc.
+		int shift_position = 0;	// An offset representing how much of the image information has already been drawn.
+
+		// Yamaha helpers.
+		bool opaque() const {
+			return !(image[2] & 0x40);
+		}
+
+		/// @returns @c 0x20 if this sprite should generate collisions; @c 0x00 otherwise.
+		int collision_bit() const {
+			return ((image[2] & 0x20) | ((image[2] & 0x40) >> 1)) ^ 0x20;
+		}
+
+		// Yamaha and TMS helpers.
+		int early_clock() const {
+			return (image[2] & 0x80) >> 2;
+		}
+	} active_sprites[8];
+
+	int active_sprite_slot = 0;		// A pointer to the slot into which a new active sprite will be deposited, if required.
+	bool sprites_stopped = false;	// A special TMS feature is that a sentinel value can be used to prevent any further sprites
+									// being evaluated for display. This flag determines whether the sentinel has yet been reached.
+	uint8_t sprite_terminator = 0;
+
+#ifndef NDEBUG
+	static constexpr bool test_is_filling = true;
+#else
+	static constexpr bool test_is_filling = false;
+#endif
+	bool is_filling = false;
+
+	void reset_sprite_collection();
+};
+
+struct LineBuffer {
+	LineBuffer() {}
+
+	// The fetch mode describes the proper timing diagram for this line;
+	// screen mode captures proper output mode.
+	FetchMode fetch_mode = FetchMode::Text;
+	ScreenMode screen_mode = ScreenMode::Text;
+	VerticalState vertical_state = VerticalState::Blank;
+	SpriteBuffer *sprites = nullptr;
+
+	// Holds the horizontal scroll position to apply to this line;
+	// of those VDPs currently implemented, affects the Master System only.
+	uint8_t latched_horizontal_scroll = 0;
+
+	// The names array holds pattern names, as an offset into memory, and
+	// potentially flags also.
+	union {
+		// This struct captures maximal potential detail across the TMS9918
+		// and Sega VDP for tiled modes (plus multicolour).
+		struct {
+			uint8_t flags[32]{};
+
+			// The patterns array holds tile patterns, corresponding 1:1 with names.
+			// Four bytes per pattern is the maximum required by any
+			// currently-implemented VDP.
+			uint8_t patterns[32][4]{};
+		} tiles;
+
+		// The Yamaha and TMS both have text modes, with the former going up to
+		// 80 columns plus 10 bytes of colour-esque flags.
+		struct {
+			uint8_t shapes[80];
+			uint8_t flags[10];
+		} characters;
+
+		// The Yamaha VDP also has a variety of bitmap modes,
+		// the widest of which is 512px @ 4bpp.
+		uint8_t bitmap[256];
+	};
+
+	/*
+		Horizontal layout (on a 342-cycle clock):
+
+			15 cycles right border
+			58 cycles blanking & sync
+			13 cycles left border
+
+			... i.e. to cycle 86, then:
+
+			border up to first_pixel_output_column;
+			pixels up to next_border_column;
+			border up to the end.
+
+		e.g. standard 256-pixel modes will want to set
+		first_pixel_output_column = 86, next_border_column = 342.
+	*/
+	int first_pixel_output_column = 94;
+	int next_border_column = 334;
+	int pixel_count = 256;
+};
+
+struct LineBufferPointer {
+	int row = 0, column = 0;
+};
+
+}
+
+#endif /* LineBuffer_hpp */

Components/9918/Implementation/LineLayout.hpp

@@ -0,0 +1,110 @@
+//
+//  LineLayout.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/05/2023.
+//  Copyright © 2023 Thomas Harte. All rights reserved.
+//
+
+#ifndef LineLayout_h
+#define LineLayout_h
+
+namespace TI::TMS {
+
+template <Personality personality, typename Enable = void> struct LineLayout;
+
+//	Line layout is:
+//
+//	[0, EndOfSync]							sync
+//	(EndOfSync, StartOfColourBurst]			blank
+//	(StartOfColourBurst, EndOfColourBurst]	colour burst
+//	(EndOfColourBurst, EndOfLeftErase]		blank
+//	(EndOfLeftErase, EndOfLeftBorder]		border colour
+//	(EndOfLeftBorder, EndOfPixels]			pixel content
+//	(EndOfPixels, EndOfRightBorder]			border colour
+//	[EndOfRightBorder, <end of line>]		blank
+//
+//	... with minor caveats:
+//		* horizontal adjust on the Yamaha VDPs is applied to EndOfLeftBorder and EndOfPixels;
+//		* the Sega VDPs may programatically extend the left border; and
+//		* text mode on all VDPs adjusts border width.
+//
+//	ModeLaytchCycle is the cycle at which the video mode, blank disable/enable and
+//	sprite enable/disable are latched for the line.
+
+template <Personality personality> struct LineLayout<personality, std::enable_if_t<is_classic_vdp(personality) && !is_sega_vdp(personality)>> {
+	constexpr static int StartOfSync		= 0;
+	constexpr static int EndOfSync			= 26;
+	constexpr static int StartOfColourBurst	= 29;
+	constexpr static int EndOfColourBurst	= 43;
+	constexpr static int EndOfLeftErase		= 50;
+	constexpr static int EndOfLeftBorder	= 63;
+	constexpr static int EndOfPixels		= 319;
+	constexpr static int EndOfRightBorder	= 334;
+
+	constexpr static int CyclesPerLine		= 342;
+
+	constexpr static int TextModeEndOfLeftBorder	= 69;
+	constexpr static int TextModeEndOfPixels		= 309;
+
+	constexpr static int ModeLatchCycle		= 36;	// Just a guess; correlates with the known 144 for the Yamaha VDPs,
+													// and falls into the collection gap between the final sprite
+													// graphics and the initial tiles or pixels.
+
+	constexpr static bool HasDynamicLineInterrupt = false;
+	constexpr static bool HasFixedLineInterrupt = false;
+	constexpr static int EndOfFrameInterrupt = 313;
+
+	/// The number of internal cycles that must elapse between a request to read or write and
+	/// it becoming a candidate for action.
+	constexpr static int VRAMAccessDelay = 6;
+};
+
+template <Personality personality> struct LineLayout<personality, std::enable_if_t<is_sega_vdp(personality)>> :
+	public LineLayout<Personality::TMS9918A> {
+
+	// Cf. https://www.smspower.org/forums/8161-SMSDisplayTiming
+
+	// "For a line interrupt, /INT is pulled low 608 mclks into the appropriate scanline relative to pixel 0.
+	// This is 3 mclks before the rising edge of /HSYNC which starts the next scanline."
+	//
+	// i.e. it's 304 internal clocks after the end of the left border.
+	constexpr static bool HasFixedLineInterrupt = false;
+	constexpr static int FixedLineInterrupt = (EndOfLeftBorder + 304) % CyclesPerLine;
+
+	// For a frame interrupt, /INT is pulled low 607 mclks into scanline 192 (of scanlines 0 through 261) relative to pixel 0.
+	// This is 4 mclks before the rising edge of /HSYNC which starts the next scanline.
+	//
+	// i.e. it's 1/2 cycle before the line interrupt position, which I have rounded. Ugh.
+	constexpr static int EndOfFrameInterrupt = 313;
+};
+
+template <Personality personality> struct LineLayout<personality, std::enable_if_t<is_yamaha_vdp(personality)>> {
+	constexpr static int StartOfSync		= 0;
+	constexpr static int EndOfSync			= 100;
+	constexpr static int StartOfColourBurst	= 113;
+	constexpr static int EndOfColourBurst	= 167;
+	constexpr static int EndOfLeftErase		= 202;
+	constexpr static int EndOfLeftBorder	= 258;
+	constexpr static int EndOfPixels		= 1282;
+	constexpr static int EndOfRightBorder	= 1341;
+
+	constexpr static int CyclesPerLine		= 1368;
+
+	constexpr static int TextModeEndOfLeftBorder	= 294;
+	constexpr static int TextModeEndOfPixels		= 1254;
+
+	constexpr static int ModeLatchCycle		= 144;
+
+	constexpr static bool HasDynamicLineInterrupt = true;
+	constexpr static bool HasFixedLineInterrupt = false;
+	constexpr static int EndOfFrameInterrupt = 313;
+
+	/// The number of internal cycles that must elapse between a request to read or write and
+	/// it becoming a candidate for action.
+	constexpr static int VRAMAccessDelay = 16;
+};
+
+}
+
+#endif /* LineLayout_h */