Merge pull request #1790 from TomHarte/EmptyCoCo

Add an empty shell that proclaims itself to be a CoCo.

Analyser/Machines.hpp

@@ -28,6 +28,7 @@ enum class Machine {
 	Oric,
 	Plus4,
 	PCCompatible,
+	TandyCoCo,
 	ThomsonMO,
 	Vic20,
 	ZX8081,

Machines/Acorn/Archimedes/Archimedes.cpp

@@ -749,8 +749,8 @@ private:
 
 using namespace Archimedes;
 
-std::unique_ptr<Machine> Machine::Archimedes(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	const auto archimedes_target = dynamic_cast<const Analyser::Static::Acorn::ArchimedesTarget *>(target);

Machines/Acorn/Archimedes/Archimedes.hpp

@@ -19,7 +19,7 @@ namespace Archimedes {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> Archimedes(
+	static std::unique_ptr<Machine> create(
 		const Analyser::Static::Target *target,
 		const ROMMachine::ROMFetcher &rom_fetcher
 	);

Machines/Acorn/BBCMicro/BBCMicro.cpp

@@ -1349,8 +1349,8 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 }
 
-std::unique_ptr<Machine> Machine::BBCMicro(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	const Target *const acorn_target = dynamic_cast<const Target *>(target);

Machines/Acorn/BBCMicro/BBCMicro.hpp

@@ -20,10 +20,7 @@ namespace BBCMicro {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> BBCMicro(
-		const Analyser::Static::Target *target,
-		const ROMMachine::ROMFetcher &rom_fetcher
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/Acorn/Electron/Electron.cpp

@@ -792,7 +792,10 @@ private:
 
 using namespace Electron;
 
-std::unique_ptr<Machine> Machine::Electron(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	using Target = Analyser::Static::Acorn::ElectronTarget;
 	const Target *const acorn_target = dynamic_cast<const Target *>(target);
 

Machines/Acorn/Electron/Electron.hpp

@@ -27,10 +27,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Electron.
-	static std::unique_ptr<Machine> Electron(
-		const Analyser::Static::Target *target,
-		const ROMMachine::ROMFetcher &rom_fetcher
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Electron.
 	class Options:

Machines/Amiga/Amiga.cpp

@@ -251,7 +251,10 @@ private:
 
 using namespace Amiga;
 
-std::unique_ptr<Machine> Machine::Amiga(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	using Target = Analyser::Static::Amiga::Target;
 	const Target *const amiga_target = dynamic_cast<const Target *>(target);
 	return std::make_unique<Amiga::ConcreteMachine>(*amiga_target, rom_fetcher);

Machines/Amiga/Amiga.hpp

@@ -19,7 +19,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Amiga.
-	static std::unique_ptr<Machine> Amiga(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 };
 
 }

Machines/AmstradCPC/AmstradCPC.cpp

@@ -1390,8 +1390,8 @@ std::unique_ptr<Machine> machine(
 }
 
 // See header; constructs and returns an instance of the Amstrad CPC.
-std::unique_ptr<Machine> Machine::AmstradCPC(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::AmstradCPC::Target;

Machines/AmstradCPC/AmstradCPC.hpp

@@ -24,8 +24,8 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Amstrad CPC.
-	static std::unique_ptr<Machine> AmstradCPC(
-		const Analyser::Static::Target *const target,
+	static std::unique_ptr<Machine> create(
+		const Analyser::Static::Target *target,
 		const ROMMachine::ROMFetcher &rom_fetcher
 	);
 

Machines/Apple/AppleII/AppleII.cpp

@@ -1094,7 +1094,10 @@ public:
 
 using namespace Apple::II;
 
-std::unique_ptr<Machine> Machine::AppleII(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	using Target = Analyser::Static::AppleII::Target;
 	const Target *const appleii_target = dynamic_cast<const Target *>(target);
 

Machines/Apple/AppleII/AppleII.hpp

@@ -21,7 +21,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an AppleII.
-	static std::unique_ptr<Machine> AppleII(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Apple II.
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {

Machines/Apple/AppleIIgs/AppleIIgs.cpp

@@ -1010,6 +1010,9 @@ private:
 
 using namespace Apple::IIgs;
 
-std::unique_ptr<Machine> Machine::AppleIIgs(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	return std::make_unique<ConcreteMachine>(*dynamic_cast<const Analyser::Static::AppleIIgs::Target *>(target), rom_fetcher);
 }

Machines/Apple/AppleIIgs/AppleIIgs.hpp

@@ -21,7 +21,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an AppleIIgs.
-	static std::unique_ptr<Machine> AppleIIgs(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 };
 
 }

Machines/Apple/Macintosh/Macintosh.cpp

@@ -842,7 +842,10 @@ private:
 
 using namespace Apple::Macintosh;
 
-std::unique_ptr<Machine> Machine::Macintosh(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	auto *const mac_target = dynamic_cast<const Analyser::Static::Macintosh::Target *>(target);
 
 	using Model = Analyser::Static::Macintosh::Target::Model;

Machines/Apple/Macintosh/Macintosh.hpp

@@ -19,7 +19,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a Macintosh.
-	static std::unique_ptr<Machine> Macintosh(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::QuickBoot<Options> {
 		friend Configurable::Options::QuickBoot<Options>;

Machines/Atari/2600/Atari2600.cpp

@@ -219,7 +219,7 @@ private:
 
 using namespace Atari2600;
 
-std::unique_ptr<Machine> Machine::Atari2600(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &) {
+std::unique_ptr<Machine> Machine::create(const Analyser::Static::Target *const target, const ROMMachine::ROMFetcher &) {
 	const Target *const atari_target = dynamic_cast<const Target *>(target);
 	return std::make_unique<Atari2600::ConcreteMachine>(*atari_target);
 }

Machines/Atari/2600/Atari2600.hpp

@@ -25,7 +25,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns an Atari 2600 on the heap.
-	static std::unique_ptr<Machine> Atari2600(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	/// Sets the switch @c input to @c state.
 	virtual void set_switch_is_enabled(Atari2600Switch, bool) = 0;

Machines/Atari/ST/AtariST.cpp

@@ -708,7 +708,10 @@ private:
 
 using namespace Atari::ST;
 
-std::unique_ptr<Machine> Machine::AtariST(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	auto *const atari_target = dynamic_cast<const Analyser::Static::AtariST::Target *>(target);
 	if(!atari_target) {
 		return nullptr;

Machines/Atari/ST/AtariST.hpp

@@ -20,7 +20,7 @@ namespace Atari::ST {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> AtariST(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;

Machines/ColecoVision/ColecoVision.cpp

@@ -420,6 +420,9 @@ private:
 
 using namespace Coleco::Vision;
 
-std::unique_ptr<Machine> Machine::ColecoVision(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	return std::make_unique<ConcreteMachine>(*target, rom_fetcher);
 }

Machines/ColecoVision/ColecoVision.hpp

@@ -19,7 +19,7 @@ namespace Coleco::Vision {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> ColecoVision(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;

Machines/Commodore/Plus4/Plus4.cpp

@@ -751,8 +751,8 @@ private:
 };
 }
 
-std::unique_ptr<Machine> Machine::Plus4(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Commodore::Plus4Target;

Machines/Commodore/Plus4/Plus4.hpp

@@ -22,7 +22,7 @@ std::unique_ptr<Reflection::Struct> get_options();
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> Plus4(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/Commodore/Vic-20/Vic20.cpp

@@ -817,7 +817,7 @@ private:
 
 using namespace Commodore::Vic20;
 
-std::unique_ptr<Machine> Machine::Vic20(
+std::unique_ptr<Machine> Machine::create(
 	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {

Machines/Commodore/Vic-20/Vic20.hpp

@@ -24,7 +24,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a Vic-20.
-	static std::unique_ptr<Machine> Vic20(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/Enterprise/Enterprise.cpp

@@ -990,7 +990,7 @@ std::unique_ptr<Machine> machine(
 
 }
 
-std::unique_ptr<Machine> Machine::Enterprise(
+std::unique_ptr<Machine> Machine::create(
 	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {

Machines/Enterprise/Enterprise.hpp

@@ -25,7 +25,7 @@ namespace Enterprise {
 */
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> Enterprise(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options available for an Enterprise.
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {

Machines/MSX/MSX.cpp

@@ -1039,7 +1039,10 @@ private:
 
 using namespace MSX;
 
-std::unique_ptr<Machine> Machine::MSX(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	const auto msx_target = dynamic_cast<const Target *>(target);
 	if(msx_target->has_msx_music) {
 		switch(msx_target->model) {

Machines/MSX/MSX.hpp

@@ -19,7 +19,7 @@ namespace MSX {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> MSX(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/MasterSystem/MasterSystem.cpp

@@ -606,8 +606,8 @@ private:
 
 using namespace Sega::MasterSystem;
 
-std::unique_ptr<Machine> Machine::MasterSystem(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	using Target = Analyser::Static::Sega::Target;

Machines/MasterSystem/MasterSystem.hpp

@@ -19,7 +19,7 @@ namespace Sega::MasterSystem {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> MasterSystem(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options: public Reflection::StructImpl<Options>, public Configurable::Options::Display<Options> {
 		friend Configurable::Options::Display<Options>;

Machines/Oric/Oric.cpp

@@ -835,7 +835,10 @@ std::unique_ptr<Machine> machine(const Analyser::Static::Oric::Target &target, c
 
 }
 
-std::unique_ptr<Machine> Machine::Oric(const Analyser::Static::Target *target_hint, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target_hint,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	auto *const oric_target = dynamic_cast<const Analyser::Static::Oric::Target *>(target_hint);
 
 	switch(oric_target->processor) {

Machines/Oric/Oric.hpp

@@ -22,7 +22,7 @@ namespace Oric {
 */
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> Oric(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/PCCompatible/PCCompatible.cpp

@@ -1153,8 +1153,8 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 }
 
-std::unique_ptr<Machine> Machine::PCCompatible(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	const Target *const pc_target = dynamic_cast<const Target *>(target);

Machines/PCCompatible/PCCompatible.hpp

@@ -22,10 +22,7 @@ struct Machine {
 	virtual ~Machine() = default;
 
 	/// Creates and returns a PC Compatible.
-	static std::unique_ptr<Machine> PCCompatible(
-		const Analyser::Static::Target *target,
-		const ROMMachine::ROMFetcher &rom_fetcher
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	/// Defines the runtime options [sometimes] available for a PC.
 	class Options:

Machines/Sinclair/ZX8081/ZX8081.cpp

@@ -498,7 +498,10 @@ private:
 using namespace Sinclair::ZX8081;
 
 // See header; constructs and returns an instance of the ZX80 or 81.
-std::unique_ptr<Machine> Machine::ZX8081(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	const auto zx_target = dynamic_cast<const Analyser::Static::ZX8081::Target *>(target);
 
 	// Instantiate the correct type of machine.

Machines/Sinclair/ZX8081/ZX8081.hpp

@@ -20,7 +20,7 @@ namespace Sinclair::ZX8081 {
 /// The ZX80/81 machine.
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> ZX8081(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	virtual void set_tape_is_playing(bool is_playing) = 0;
 	virtual bool get_tape_is_playing() = 0;

Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp

@@ -1013,7 +1013,10 @@ private:
 
 using namespace Sinclair::ZXSpectrum;
 
-std::unique_ptr<Machine> Machine::ZXSpectrum(const Analyser::Static::Target *target, const ROMMachine::ROMFetcher &rom_fetcher) {
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
+	const ROMMachine::ROMFetcher &rom_fetcher
+) {
 	const auto zx_target = dynamic_cast<const Analyser::Static::ZXSpectrum::Target *>(target);
 
 	switch(zx_target->model) {

Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp

@@ -19,7 +19,7 @@ namespace Sinclair::ZXSpectrum {
 
 struct Machine {
 	virtual ~Machine() = default;
-	static std::unique_ptr<Machine> ZXSpectrum(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	virtual void set_tape_is_playing(bool is_playing) = 0;
 	virtual bool get_tape_is_playing() = 0;

Machines/Tandy/CoCo/CoCo.cpp

@@ -0,0 +1,18 @@
+//
+//  CoCo.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/05/2026.
+//  Copyright © 2026 Thomas Harte. All rights reserved.
+//
+
+#include "CoCo.hpp"
+
+using namespace Tandy::CoCo;
+
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const ,
+	const ROMMachine::ROMFetcher &
+) {
+	return nullptr;
+}

Machines/Tandy/CoCo/CoCo.hpp

@@ -0,0 +1,21 @@
+//
+//  CoCo.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 01/05/2026.
+//  Copyright © 2026 Thomas Harte. All rights reserved.
+//
+
+#pragma once
+
+#include "Analyser/Static/StaticAnalyser.hpp"
+#include "Machines/ROMMachine.hpp"
+
+namespace Tandy::CoCo {
+
+struct Machine {
+	virtual ~Machine() = default;
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
+};
+
+}

Machines/Thomson/MO/MO.cpp

@@ -738,8 +738,8 @@ std::unique_ptr<Machine> machine(const Target &target, const ROMMachine::ROMFetc
 }
 }
 
-std::unique_ptr<Machine> Machine::ThomsonMO(
-	const Analyser::Static::Target *target,
+std::unique_ptr<Machine> Machine::create(
+	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher
 ) {
 	const Target *const thomson_target = dynamic_cast<const Target *>(target);

Machines/Thomson/MO/MO.hpp

@@ -20,10 +20,7 @@ namespace Thomson::MO {
 struct Machine {
 	virtual ~Machine() = default;
 
-	static std::unique_ptr<Machine> ThomsonMO(
-		const Analyser::Static::Target *,
-		const ROMMachine::ROMFetcher &
-	);
+	static std::unique_ptr<Machine> create(const Analyser::Static::Target *, const ROMMachine::ROMFetcher &);
 
 	class Options:
 		public Reflection::StructImpl<Options>,

Machines/Utility/MachineForTarget.cpp

@@ -29,6 +29,7 @@
 #include "Machines/MSX/MSX.hpp"
 #include "Machines/Oric/Oric.hpp"
 #include "Machines/PCCompatible/PCCompatible.hpp"
+#include "Machines/Tandy/CoCo/CoCo.hpp"
 #include "Machines/Thomson/MO/MO.hpp"
 #include "Machines/Sinclair/ZX8081/ZX8081.hpp"
 #include "Machines/Sinclair/ZXSpectrum/ZXSpectrum.hpp"
@@ -55,53 +56,63 @@
 #include "Analyser/Dynamic/MultiMachine/MultiMachine.hpp"
 #include "TypedDynamicMachine.hpp"
 
+namespace {
+struct MachineGenerator {
+	MachineGenerator(
+		const Analyser::Static::Target *const target,
+		const ROMMachine::ROMFetcher &rom_fetcher
+	) : target(target), rom_fetcher(rom_fetcher) {}
+
+	const Analyser::Static::Target *const target;
+	const ROMMachine::ROMFetcher &rom_fetcher;
+
+	std::unique_ptr<Machine::DynamicMachine> machine;
+
+	template <typename MachineT>
+	void posit(const Analyser::Machine name) {
+		if(target->machine == name) {
+			machine = std::make_unique<Machine::TypedDynamicMachine<MachineT>>(MachineT::create(target, rom_fetcher));
+		}
+	}
+};
+}
+
 std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTarget(
 	const Analyser::Static::Target *const target,
 	const ROMMachine::ROMFetcher &rom_fetcher,
 	Machine::Error &error
 ) {
 	error = Machine::Error::None;
-	std::unique_ptr<Machine::DynamicMachine> machine;
+	MachineGenerator generator(target, rom_fetcher);
 
 	try {
+		using enum Analyser::Machine;
+		generator.posit<Amiga::Machine>(Amiga);
+		generator.posit<AmstradCPC::Machine>(AmstradCPC);
+		generator.posit<Archimedes::Machine>(Archimedes);
+		generator.posit<Apple::II::Machine>(AppleII);
+		generator.posit<Apple::IIgs::Machine>(AppleIIgs);
+		generator.posit<Apple::Macintosh::Machine>(Macintosh);
+		generator.posit<Atari2600::Machine>(Atari2600);
+		generator.posit<Atari::ST::Machine>(AtariST);
+		generator.posit<BBCMicro::Machine>(BBCMicro);
+		generator.posit<Coleco::Vision::Machine>(ColecoVision);
+		generator.posit<Commodore::Plus4::Machine>(Plus4);
+		generator.posit<Commodore::Vic20::Machine>(Vic20);
+		generator.posit<Electron::Machine>(Electron);
+		generator.posit<Enterprise::Machine>(Enterprise);
+		generator.posit<MSX::Machine>(MSX);
+		generator.posit<Oric::Machine>(Oric);
+		generator.posit<PCCompatible::Machine>(PCCompatible);
+		generator.posit<Sega::MasterSystem::Machine>(MasterSystem);
+		generator.posit<Sinclair::ZX8081::Machine>(ZX8081);
+		generator.posit<Sinclair::ZXSpectrum::Machine>(ZXSpectrum);
+		generator.posit<Tandy::CoCo::Machine>(TandyCoCo);
+		generator.posit<Thomson::MO::Machine>(ThomsonMO);
 
-#define BindD(name, m)	\
-	case Analyser::Machine::m: \
-		machine = std::make_unique<Machine::TypedDynamicMachine<::name::Machine>>(	\
-			name::Machine::m(target, rom_fetcher)	\
-		);		\
-	break;
-#define Bind(m)	BindD(m, m)
-		switch(target->machine) {
-			Bind(Amiga)
-			Bind(AmstradCPC)
-			Bind(Archimedes)
-			BindD(Apple::II, AppleII)
-			BindD(Apple::IIgs, AppleIIgs)
-			BindD(Apple::Macintosh, Macintosh)
-			Bind(Atari2600)
-			BindD(Atari::ST, AtariST)
-			Bind(BBCMicro)
-			BindD(Coleco::Vision, ColecoVision)
-			BindD(Commodore::Plus4, Plus4)
-			BindD(Commodore::Vic20, Vic20)
-			Bind(Electron)
-			Bind(Enterprise)
-			Bind(MSX)
-			Bind(Oric)
-			Bind(PCCompatible)
-			BindD(Sega::MasterSystem, MasterSystem)
-			BindD(Sinclair::ZX8081, ZX8081)
-			BindD(Sinclair::ZXSpectrum, ZXSpectrum)
-			BindD(Thomson::MO, ThomsonMO)
-
-			default:
-				error = Machine::Error::UnknownMachine;
-			return nullptr;
+		if(!generator.machine) {
+			error = Machine::Error::UnknownMachine;
 		}
-#undef Bind
-#undef BindD
-
 	} catch(ROMMachine::Error construction_error) {
 		switch(construction_error) {
 			case ROMMachine::Error::MissingROMs:
@@ -113,7 +124,7 @@ std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTarget(
 		}
 	}
 
-	return machine;
+	return std::move(generator.machine);
 }
 
 std::unique_ptr<Machine::DynamicMachine> Machine::MachineForTargets(
@@ -171,6 +182,7 @@ std::string Machine::ShortNameForTargetMachine(const Analyser::Machine machine)
 		case Analyser::Machine::Oric:			return "Oric";
 		case Analyser::Machine::Plus4:			return "Plus4";
 		case Analyser::Machine::PCCompatible:	return "PCCompatible";
+		case Analyser::Machine::TandyCoCo:		return "TandyCoCo";
 		case Analyser::Machine::ThomsonMO:		return "ThomsonMO";
 		case Analyser::Machine::Vic20:			return "Vic20";
 		case Analyser::Machine::ZX8081:			return "ZX8081";
@@ -199,6 +211,7 @@ std::string Machine::LongNameForTargetMachine(const Analyser::Machine machine) {
 		case Analyser::Machine::Oric:			return "Oric";
 		case Analyser::Machine::Plus4:			return "Commodore C16+4";
 		case Analyser::Machine::PCCompatible:	return "PC Compatible";
+		case Analyser::Machine::TandyCoCo:		return "Tandy CoCo";
 		case Analyser::Machine::ThomsonMO:		return "Thomson MO";
 		case Analyser::Machine::Vic20:			return "Vic 20";
 		case Analyser::Machine::ZX8081:			return "ZX80/81";
@@ -237,6 +250,7 @@ std::vector<std::string> Machine::AllMachines(const Type type, const bool long_n
 		add_name(Analyser::Machine::Oric);
 		add_name(Analyser::Machine::Plus4);
 		add_name(Analyser::Machine::PCCompatible);
+		add_name(Analyser::Machine::TandyCoCo);
 		add_name(Analyser::Machine::ThomsonMO);
 		add_name(Analyser::Machine::Vic20);
 		add_name(Analyser::Machine::ZX8081);
@@ -246,99 +260,100 @@ std::vector<std::string> Machine::AllMachines(const Type type, const bool long_n
 	return result;
 }
 
-std::map<std::string, std::unique_ptr<Reflection::Struct>> Machine::AllOptionsByMachineName() {
+namespace {
+struct OptionsList {
 	std::map<std::string, std::unique_ptr<Reflection::Struct>> options;
 
-#define Emplace(machine, class)														\
-	options.emplace(																\
-		LongNameForTargetMachine(Analyser::Machine::machine),						\
-		std::make_unique<class::Options>(Configurable::OptionsType::UserFriendly)	\
-	)
+	template <typename MachineT>
+	void emplace(const Analyser::Machine machine) {
+		options.emplace(
+			Machine::LongNameForTargetMachine(machine),
+			std::make_unique<typename MachineT::Options>(Configurable::OptionsType::UserFriendly)
+		);
+	};
+};
+}
 
-	Emplace(AmstradCPC, AmstradCPC::Machine);
-	Emplace(AppleII, Apple::II::Machine);
-	Emplace(Archimedes, Archimedes::Machine);
-	Emplace(AtariST, Atari::ST::Machine);
-	Emplace(BBCMicro, BBCMicro::Machine);
-	Emplace(ColecoVision, Coleco::Vision::Machine);
-	Emplace(Electron, Electron::Machine);
-	Emplace(Enterprise, Enterprise::Machine);
-	Emplace(Macintosh, Apple::Macintosh::Machine);
-	Emplace(MasterSystem, Sega::MasterSystem::Machine);
-	Emplace(MSX, MSX::Machine);
-	Emplace(Oric, Oric::Machine);
-	Emplace(Plus4, Commodore::Plus4::Machine);
-	Emplace(PCCompatible, PCCompatible::Machine);
-	Emplace(ThomsonMO, Thomson::MO::Machine);
-	Emplace(Vic20, Commodore::Vic20::Machine);
-	Emplace(ZX8081, Sinclair::ZX8081::Machine);
-	Emplace(ZXSpectrum, Sinclair::ZXSpectrum::Machine);
+std::map<std::string, std::unique_ptr<Reflection::Struct>> Machine::AllOptionsByMachineName() {
+	OptionsList options;
 
-#undef Emplace
+	using enum Analyser::Machine;
+	options.emplace<AmstradCPC::Machine>(AmstradCPC);
+	options.emplace<Apple::II::Machine>(AppleII);
+	options.emplace<Archimedes::Machine>(Archimedes);
+	options.emplace<Atari::ST::Machine>(AtariST);
+	options.emplace<BBCMicro::Machine>(BBCMicro);
+	options.emplace<Coleco::Vision::Machine>(ColecoVision);
+	options.emplace<Electron::Machine>(Electron);
+	options.emplace<Enterprise::Machine>(Enterprise);
+	options.emplace<Apple::Macintosh::Machine>(Macintosh);
+	options.emplace<Sega::MasterSystem::Machine>(MasterSystem);
+	options.emplace<MSX::Machine>(MSX);
+	options.emplace<Oric::Machine>(Oric);
+	options.emplace<Commodore::Plus4::Machine>(Plus4);
+	options.emplace<PCCompatible::Machine>(PCCompatible);
+	options.emplace<Thomson::MO::Machine>(ThomsonMO);
+	options.emplace<Commodore::Vic20::Machine>(Vic20);
+	options.emplace<Sinclair::ZX8081::Machine>(ZX8081);
+	options.emplace<Sinclair::ZXSpectrum::Machine>(ZXSpectrum);
 
-	return options;
+	return std::move(options.options);
+}
+
+namespace {
+struct TargetList {
+	std::map<std::string, std::unique_ptr<Analyser::Static::Target>> targets;
+
+	template <typename TargetT>
+	void emplace(const Analyser::Machine machine) {
+		targets.emplace(
+			Machine::LongNameForTargetMachine(machine),
+			std::make_unique<TargetT>()
+		);
+	};
+
+	void emplace(const Analyser::Machine machine, std::unique_ptr<Analyser::Static::Target> &&target) {
+		targets.emplace(
+			Machine::LongNameForTargetMachine(machine),
+			std::move(target)
+		);
+	}
+};
 }
 
 std::map<std::string, std::unique_ptr<Analyser::Static::Target>> Machine::TargetsByMachineName(
 	const bool meaningful_without_media_only
 ) {
-	std::map<std::string, std::unique_ptr<Analyser::Static::Target>> options;
+	TargetList targets;
 
-#define AddMapped(Name, TargetNamespace)								\
-	options.emplace(													\
-		LongNameForTargetMachine(Analyser::Machine::Name),				\
-		std::make_unique<Analyser::Static::TargetNamespace::Target>()	\
-	);
-#define Add(Name)	AddMapped(Name, Name)
-
-	Add(Amiga);
-	Add(AmstradCPC);
-	Add(AppleII);
-	Add(AppleIIgs);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::Archimedes),
-		std::make_unique<Analyser::Static::Acorn::ArchimedesTarget>()
-	);
-	Add(AtariST);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::BBCMicro),
-		std::make_unique<Analyser::Static::Acorn::BBCMicroTarget>()
-	);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::Electron),
-		std::make_unique<Analyser::Static::Acorn::ElectronTarget>()
-	);
-	Add(Enterprise);
-	Add(Macintosh);
-	Add(MSX);
-	Add(Oric);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::Plus4),
-		std::make_unique<Analyser::Static::Commodore::Plus4Target>()
-	);
-	Add(PCCompatible);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::ThomsonMO),
-		std::make_unique<Analyser::Static::Thomson::MOTarget>()
-	);
-	options.emplace(
-		LongNameForTargetMachine(Analyser::Machine::Vic20),
-		std::make_unique<Analyser::Static::Commodore::Vic20Target>()
-	);
-	Add(ZX8081);
-	Add(ZXSpectrum);
+	using enum Analyser::Machine;
+	targets.emplace<Analyser::Static::Amiga::Target>(Amiga);
+	targets.emplace<Analyser::Static::AmstradCPC::Target>(AmstradCPC);
+	targets.emplace<Analyser::Static::AppleII::Target>(AppleII);
+	targets.emplace<Analyser::Static::AppleIIgs::Target>(AppleIIgs);
+	targets.emplace<Analyser::Static::Acorn::ArchimedesTarget>(Archimedes);
+	targets.emplace<Analyser::Static::AtariST::Target>(AtariST);
+	targets.emplace<Analyser::Static::Acorn::BBCMicroTarget>(BBCMicro);
+	targets.emplace<Analyser::Static::Acorn::ElectronTarget>(Electron);
+	targets.emplace<Analyser::Static::Enterprise::Target>(Enterprise);
+	targets.emplace<Analyser::Static::Macintosh::Target>(Macintosh);
+	targets.emplace<Analyser::Static::MSX::Target>(MSX);
+	targets.emplace<Analyser::Static::Oric::Target>(Oric);
+	targets.emplace<Analyser::Static::Commodore::Plus4Target>(Plus4);
+	targets.emplace<Analyser::Static::PCCompatible::Target>(PCCompatible);
+	targets.emplace<Analyser::Static::Thomson::MOTarget>(ThomsonMO);
+	targets.emplace<Analyser::Static::Commodore::Vic20Target>(Vic20);
+	targets.emplace<Analyser::Static::ZX8081::Target>(ZX8081);
+	targets.emplace<Analyser::Static::ZXSpectrum::Target>(ZXSpectrum);
 
 	if(!meaningful_without_media_only) {
-		Add(Atari2600);
-		options.emplace(
-			LongNameForTargetMachine(Analyser::Machine::ColecoVision),
+		targets.emplace<Analyser::Static::Atari2600::Target>(Atari2600);
+		targets.emplace(
+			ColecoVision,
 			std::make_unique<Analyser::Static::Target>(Analyser::Machine::ColecoVision)
 		);
-		AddMapped(MasterSystem, Sega);
+		targets.emplace<Analyser::Static::Sega::Target>(MasterSystem);
 	}
 
-#undef Add
-#undef AddMapped
-
-	return options;
+	return std::move(targets.targets);
 }

OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj

@@ -347,6 +347,9 @@
 		4B3F76B925A1635300178AEC /* PowerPCDecoderTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B3F76B825A1635300178AEC /* PowerPCDecoderTests.mm */; };
 		4B3FCC40201EC24200960631 /* MultiMachine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B3FCC3F201EC24200960631 /* MultiMachine.cpp */; };
 		4B3FE75E1F3CF68B00448EE4 /* CPM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B3FE75C1F3CF68B00448EE4 /* CPM.cpp */; };
+		4B41EF722FA55F980086D909 /* CoCo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B41EF6F2FA55F980086D909 /* CoCo.cpp */; };
+		4B41EF732FA55F980086D909 /* CoCo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B41EF6F2FA55F980086D909 /* CoCo.cpp */; };
+		4B41EF742FA55F980086D909 /* CoCo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B41EF6F2FA55F980086D909 /* CoCo.cpp */; };
 		4B43983929620FC7006B0BFC /* 9918.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B43983829620FB1006B0BFC /* 9918.cpp */; };
 		4B43983A29620FC8006B0BFC /* 9918.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B43983829620FB1006B0BFC /* 9918.cpp */; };
 		4B43983B29620FC9006B0BFC /* 9918.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B43983829620FB1006B0BFC /* 9918.cpp */; };
@@ -1629,6 +1632,8 @@
 		4B4195F42EB8F061001C966D /* ULA.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ULA.hpp; sourceTree = "<group>"; };
 		4B4195F52EB92630001C966D /* Tube6502.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Tube6502.hpp; sourceTree = "<group>"; };
 		4B4195F62EBAB06C001C966D /* TubeZ80.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = TubeZ80.hpp; sourceTree = "<group>"; };
+		4B41EF6E2FA55F980086D909 /* CoCo.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = CoCo.hpp; sourceTree = "<group>"; };
+		4B41EF6F2FA55F980086D909 /* CoCo.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CoCo.cpp; sourceTree = "<group>"; };
 		4B43983829620FB1006B0BFC /* 9918.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = 9918.cpp; sourceTree = "<group>"; };
 		4B43983C29621024006B0BFC /* ClockConverter.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ClockConverter.hpp; sourceTree = "<group>"; };
 		4B43983E29628538006B0BFC /* Fetch.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Fetch.hpp; sourceTree = "<group>"; };
@@ -3407,6 +3412,23 @@
 			name = Parsers;
 			sourceTree = "<group>";
 		};
+		4B41EF702FA55F980086D909 /* CoCo */ = {
+			isa = PBXGroup;
+			children = (
+				4B41EF6E2FA55F980086D909 /* CoCo.hpp */,
+				4B41EF6F2FA55F980086D909 /* CoCo.cpp */,
+			);
+			path = CoCo;
+			sourceTree = "<group>";
+		};
+		4B41EF712FA55F980086D909 /* Tandy */ = {
+			isa = PBXGroup;
+			children = (
+				4B41EF702FA55F980086D909 /* CoCo */,
+			);
+			path = Tandy;
+			sourceTree = "<group>";
+		};
 		4B4518701F75E91800926311 /* Track */ = {
 			isa = PBXGroup;
 			children = (
@@ -5125,6 +5147,7 @@
 				4BCF1FA51DADC3E10039D2E7 /* Oric */,
 				425739352B051EA800B7D1E4 /* PCCompatible */,
 				4B0F1BC92602F17B00B85C66 /* Sinclair */,
+				4B41EF712FA55F980086D909 /* Tandy */,
 				4BCA6FAB2F589C0C000B9537 /* Thomson */,
 				4B2B3A461F9B8FA70062DABF /* Utility */,
 			);
@@ -6483,6 +6506,7 @@
 				4B2BF19123DCC6A200C3AD60 /* BD500.cpp in Sources */,
 				4B051CA926781D6500CA44E8 /* StaticAnalyser.cpp in Sources */,
 				4B055ADA1FAE9B460060FFFF /* 1770.cpp in Sources */,
+				4B41EF742FA55F980086D909 /* CoCo.cpp in Sources */,
 				4B80CD77256CA16600176FCC /* 2MG.cpp in Sources */,
 				4B0F1BE62602FF9D00B85C66 /* ZX8081.cpp in Sources */,
 				4B0F1BDE2602FF9900B85C66 /* Video.cpp in Sources */,
@@ -6768,6 +6792,7 @@
 				4BB8616E24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */,
 				4BB4BFB022A42F290069048D /* MacintoshIMG.cpp in Sources */,
 				4B05401E219D1618001BF69C /* ScanTarget.cpp in Sources */,
+				4B41EF732FA55F980086D909 /* CoCo.cpp in Sources */,
 				4B4518861F75E91A00926311 /* MFMDiskController.cpp in Sources */,
 				4B0ACC2C23775819008902D0 /* IntelligentKeyboard.cpp in Sources */,
 				4BC080CA26A238CC00D03FD8 /* AmigaADF.cpp in Sources */,
@@ -7234,6 +7259,7 @@
 				4B778F2E23A5F09E0000D260 /* IRQDelegatePortHandler.cpp in Sources */,
 				4B778EF323A5DB230000D260 /* PCMSegment.cpp in Sources */,
 				4B06AB0D2C6461610034D014 /* MultiMachine.cpp in Sources */,
+				4B41EF722FA55F980086D909 /* CoCo.cpp in Sources */,
 				4B06AAD52C645F290034D014 /* AppleII.cpp in Sources */,
 				4B06AAFC2C6460970034D014 /* Keyboard.cpp in Sources */,
 				4B778F0D23A5EC150000D260 /* ZX80O81P.cpp in Sources */,

OSBindings/Mac/Clock SignalTests/CPCShakerTests.mm

@@ -268,7 +268,7 @@ private:
 					// If this was the release of a carriage return, wait some more after release.
 					if(
 						key_delay.carriage_return_delay &&
-						(event.key == AmstradCPC::Key::KeyEnter || event.key == AmstradCPC::Key::KeyReturn)
+						(event.key == AmstradCPC::Key::Enter || event.key == AmstradCPC::Key::Return)
 					) {
 						delay(*key_delay.carriage_return_delay);
 					}

OSBindings/Qt/clksignal.pro

@@ -120,6 +120,7 @@ SOURCES += \
 	$$SRC/Machines/Sinclair/Keyboard/*.cpp \
 	$$SRC/Machines/Sinclair/ZX8081/*.cpp \
 	$$SRC/Machines/Sinclair/ZXSpectrum/*.cpp \
+	$$SRC/Machines/Tandy/CoCo/*.cpp \
 	$$SRC/Machines/Thomson/MO/*.cpp \
 \
 	$$SRC/Outputs/*.cpp \
@@ -267,6 +268,7 @@ HEADERS += \
 	$$SRC/Machines/Sinclair/Keyboard/*.hpp \
 	$$SRC/Machines/Sinclair/ZX8081/*.hpp \
 	$$SRC/Machines/Sinclair/ZXSpectrum/*.hpp \
+	$$SRC/Machines/Tandy/CoCo/*.hpp \
 	$$SRC/Machines/Thomson/MO/*.hpp \
 	$$SRC/Machines/Thomson/MO/FastTapeSchemes/*.hpp \
 \

OSBindings/SDL/SConstruct

@@ -102,6 +102,7 @@ SOURCES += glob.glob('../../Machines/Utility/*.cpp')
 SOURCES += glob.glob('../../Machines/Sinclair/Keyboard/*.cpp')
 SOURCES += glob.glob('../../Machines/Sinclair/ZX8081/*.cpp')
 SOURCES += glob.glob('../../Machines/Sinclair/ZXSpectrum/*.cpp')
+SOURCES += glob.glob('../../Machines/Tandy/CoCo/*.cpp')
 SOURCES += glob.glob('../../Machines/Thomson/MO/*.cpp')
 
 SOURCES += glob.glob('../../Outputs/*.cpp')

cmake/CLK_SOURCES.cmake

@@ -151,6 +151,7 @@ set(CLK_SOURCES
 	Machines/Sinclair/ZX8081/Video.cpp
 	Machines/Sinclair/ZX8081/ZX8081.cpp
 	Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp
+	Machines/Tandy/CoCo/CoCo.cpp
 	Machines/Thomson/MO/CD90-640.cpp
 	Machines/Thomson/MO/MO.cpp
 	Machines/Thomson/MO/Video.cpp