From 21efb32b6f97974dbbfc33ddb0153f8612c250ce Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Wed, 24 Jan 2018 21:48:44 -0500 Subject: [PATCH] Integrates the static and nascent dynamic analyser namespaces. --- .../Dynamic}/ConfidenceCounter.cpp | 0 .../Dynamic}/ConfidenceCounter.hpp | 0 .../Dynamic}/ConfidenceSource.hpp | 0 .../Dynamic}/ConfidenceSummary.cpp | 0 .../Dynamic}/ConfidenceSummary.hpp | 0 Analyser/Machines.hpp | 26 + .../Static}/Acorn/Disk.cpp | 14 +- .../Static}/Acorn/Disk.hpp | 6 +- .../Static}/Acorn/File.hpp | 4 +- .../Static}/Acorn/StaticAnalyser.cpp | 6 +- .../Static}/Acorn/StaticAnalyser.hpp | 4 +- .../Static}/Acorn/Tape.cpp | 9 +- .../Static}/Acorn/Tape.hpp | 6 +- .../Static}/AmstradCPC/StaticAnalyser.cpp | 12 +- .../Static}/AmstradCPC/StaticAnalyser.hpp | 4 +- .../Static}/Atari/StaticAnalyser.cpp | 62 +-- .../Static}/Atari/StaticAnalyser.hpp | 4 +- .../Static}/Commodore/Disk.cpp | 10 +- .../Static}/Commodore/Disk.hpp | 8 +- .../Static}/Commodore/File.cpp | 2 +- .../Static}/Commodore/File.hpp | 4 +- .../Static}/Commodore/StaticAnalyser.cpp | 10 +- .../Static}/Commodore/StaticAnalyser.hpp | 4 +- .../Static}/Commodore/Tape.cpp | 6 +- .../Static}/Commodore/Tape.hpp | 7 +- .../Static}/Disassembler/6502.cpp | 8 +- .../Static}/Disassembler/6502.hpp | 4 +- .../Static}/Disassembler/AddressMapper.cpp | 0 .../Static}/Disassembler/AddressMapper.hpp | 4 +- .../Static}/Disassembler/Kernel.hpp | 4 +- .../Static}/Disassembler/Z80.cpp | 8 +- .../Static}/Disassembler/Z80.hpp | 4 +- .../Static}/MSX/StaticAnalyser.cpp | 46 +- .../Static}/MSX/StaticAnalyser.hpp | 4 +- .../Static}/MSX/Tape.cpp | 6 +- .../Static}/MSX/Tape.hpp | 6 +- .../Static}/Oric/StaticAnalyser.cpp | 16 +- .../Static}/Oric/StaticAnalyser.hpp | 5 +- .../Static}/Oric/Tape.cpp | 6 +- .../Static}/Oric/Tape.hpp | 8 +- .../Static}/StaticAnalyser.cpp | 46 +- .../Static}/StaticAnalyser.hpp | 22 +- .../Static}/ZX8081/StaticAnalyser.cpp | 8 +- .../Static}/ZX8081/StaticAnalyser.hpp | 6 +- Machines/AmstradCPC/AmstradCPC.cpp | 10 +- Machines/Atari2600/Atari2600.cpp | 28 +- Machines/Commodore/Vic-20/Vic20.cpp | 10 +- Machines/ConfigurationTarget.hpp | 8 +- Machines/Electron/Electron.cpp | 4 +- Machines/MSX/MSX.cpp | 12 +- Machines/MSX/ROMSlotHandler.hpp | 2 +- Machines/Oric/Oric.cpp | 4 +- Machines/Utility/MachineForTarget.cpp | 58 +- Machines/Utility/MachineForTarget.hpp | 8 +- Machines/ZX8081/ZX8081.cpp | 12 +- Machines/ZX8081/ZX8081.hpp | 2 +- .../Clock Signal.xcodeproj/project.pbxproj | 502 +++++++++--------- .../Clock Signal/Machine/CSMachine+Target.h | 4 +- .../Mac/Clock Signal/Machine/CSMachine.mm | 6 +- .../CSStaticAnalyser+TargetVector.h | 2 +- .../StaticAnalyser/CSStaticAnalyser.mm | 24 +- .../Machine/Wrappers/CSZX8081+Instantiation.h | 2 +- .../Clock Signal/Machine/Wrappers/CSZX8081.mm | 2 +- .../AtariStaticAnalyserTests.mm | 10 +- .../MSXStaticAnalyserTests.mm | 10 +- OSBindings/SDL/main.cpp | 4 +- Storage/Tape/Parsers/Commodore.cpp | 4 +- Storage/Tape/Parsers/Commodore.hpp | 4 +- 68 files changed, 612 insertions(+), 539 deletions(-) rename {DynamicAnalyser => Analyser/Dynamic}/ConfidenceCounter.cpp (100%) rename {DynamicAnalyser => Analyser/Dynamic}/ConfidenceCounter.hpp (100%) rename {DynamicAnalyser => Analyser/Dynamic}/ConfidenceSource.hpp (100%) rename {DynamicAnalyser => Analyser/Dynamic}/ConfidenceSummary.cpp (100%) rename {DynamicAnalyser => Analyser/Dynamic}/ConfidenceSummary.hpp (100%) create mode 100644 Analyser/Machines.hpp rename {StaticAnalyser => Analyser/Static}/Acorn/Disk.cpp (90%) rename {StaticAnalyser => Analyser/Static}/Acorn/Disk.hpp (89%) rename {StaticAnalyser => Analyser/Static}/Acorn/File.hpp (94%) rename {StaticAnalyser => Analyser/Static}/Acorn/StaticAnalyser.cpp (95%) rename {StaticAnalyser => Analyser/Static}/Acorn/StaticAnalyser.hpp (90%) rename {StaticAnalyser => Analyser/Static}/Acorn/Tape.cpp (94%) rename {StaticAnalyser => Analyser/Static}/Acorn/Tape.hpp (81%) rename {StaticAnalyser => Analyser/Static}/AmstradCPC/StaticAnalyser.cpp (95%) rename {StaticAnalyser => Analyser/Static}/AmstradCPC/StaticAnalyser.hpp (91%) rename {StaticAnalyser => Analyser/Static}/Atari/StaticAnalyser.cpp (67%) rename {StaticAnalyser => Analyser/Static}/Atari/StaticAnalyser.hpp (90%) rename {StaticAnalyser => Analyser/Static}/Commodore/Disk.cpp (95%) rename {StaticAnalyser => Analyser/Static}/Commodore/Disk.hpp (82%) rename {StaticAnalyser => Analyser/Static}/Commodore/File.cpp (96%) rename {StaticAnalyser => Analyser/Static}/Commodore/File.hpp (93%) rename {StaticAnalyser => Analyser/Static}/Commodore/StaticAnalyser.cpp (94%) rename {StaticAnalyser => Analyser/Static}/Commodore/StaticAnalyser.hpp (91%) rename {StaticAnalyser => Analyser/Static}/Commodore/Tape.cpp (90%) rename {StaticAnalyser => Analyser/Static}/Commodore/Tape.hpp (81%) rename {StaticAnalyser => Analyser/Static}/Disassembler/6502.cpp (97%) rename {StaticAnalyser => Analyser/Static}/Disassembler/6502.hpp (98%) rename {StaticAnalyser => Analyser/Static}/Disassembler/AddressMapper.cpp (100%) rename {StaticAnalyser => Analyser/Static}/Disassembler/AddressMapper.hpp (93%) rename {StaticAnalyser => Analyser/Static}/Disassembler/Kernel.hpp (97%) rename {StaticAnalyser => Analyser/Static}/Disassembler/Z80.cpp (98%) rename {StaticAnalyser => Analyser/Static}/Disassembler/Z80.hpp (98%) rename {StaticAnalyser => Analyser/Static}/MSX/StaticAnalyser.cpp (77%) rename {StaticAnalyser => Analyser/Static}/MSX/StaticAnalyser.hpp (90%) rename {StaticAnalyser => Analyser/Static}/MSX/Tape.cpp (96%) rename {StaticAnalyser => Analyser/Static}/MSX/Tape.hpp (89%) rename {StaticAnalyser => Analyser/Static}/Oric/StaticAnalyser.cpp (89%) rename {StaticAnalyser => Analyser/Static}/Oric/StaticAnalyser.hpp (90%) rename {StaticAnalyser => Analyser/Static}/Oric/Tape.cpp (93%) rename {StaticAnalyser => Analyser/Static}/Oric/Tape.hpp (87%) rename {StaticAnalyser => Analyser/Static}/StaticAnalyser.cpp (83%) rename {StaticAnalyser => Analyser/Static}/StaticAnalyser.hpp (90%) rename {StaticAnalyser => Analyser/Static}/ZX8081/StaticAnalyser.cpp (86%) rename {StaticAnalyser => Analyser/Static}/ZX8081/StaticAnalyser.hpp (83%) diff --git a/DynamicAnalyser/ConfidenceCounter.cpp b/Analyser/Dynamic/ConfidenceCounter.cpp similarity index 100% rename from DynamicAnalyser/ConfidenceCounter.cpp rename to Analyser/Dynamic/ConfidenceCounter.cpp diff --git a/DynamicAnalyser/ConfidenceCounter.hpp b/Analyser/Dynamic/ConfidenceCounter.hpp similarity index 100% rename from DynamicAnalyser/ConfidenceCounter.hpp rename to Analyser/Dynamic/ConfidenceCounter.hpp diff --git a/DynamicAnalyser/ConfidenceSource.hpp b/Analyser/Dynamic/ConfidenceSource.hpp similarity index 100% rename from DynamicAnalyser/ConfidenceSource.hpp rename to Analyser/Dynamic/ConfidenceSource.hpp diff --git a/DynamicAnalyser/ConfidenceSummary.cpp b/Analyser/Dynamic/ConfidenceSummary.cpp similarity index 100% rename from DynamicAnalyser/ConfidenceSummary.cpp rename to Analyser/Dynamic/ConfidenceSummary.cpp diff --git a/DynamicAnalyser/ConfidenceSummary.hpp b/Analyser/Dynamic/ConfidenceSummary.hpp similarity index 100% rename from DynamicAnalyser/ConfidenceSummary.hpp rename to Analyser/Dynamic/ConfidenceSummary.hpp diff --git a/Analyser/Machines.hpp b/Analyser/Machines.hpp new file mode 100644 index 000000000..8ccbc5226 --- /dev/null +++ b/Analyser/Machines.hpp @@ -0,0 +1,26 @@ +// +// Machines.h +// Clock Signal +// +// Created by Thomas Harte on 24/01/2018. +// Copyright © 2018 Thomas Harte. All rights reserved. +// + +#ifndef Machines_h +#define Machines_h + +namespace Analyser { + +enum class Machine { + AmstradCPC, + Atari2600, + Electron, + MSX, + Oric, + Vic20, + ZX8081 +}; + +} + +#endif /* Machines_h */ diff --git a/StaticAnalyser/Acorn/Disk.cpp b/Analyser/Static/Acorn/Disk.cpp similarity index 90% rename from StaticAnalyser/Acorn/Disk.cpp rename to Analyser/Static/Acorn/Disk.cpp index 1249cca36..2dfd80bf5 100644 --- a/StaticAnalyser/Acorn/Disk.cpp +++ b/Analyser/Static/Acorn/Disk.cpp @@ -7,14 +7,16 @@ // #include "Disk.hpp" -#include "../../Storage/Disk/Controller/DiskController.hpp" -#include "../../Storage/Disk/Encodings/MFM/Parser.hpp" -#include "../../NumberTheory/CRC.hpp" + +#include "../../../Storage/Disk/Controller/DiskController.hpp" +#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp" +#include "../../../NumberTheory/CRC.hpp" + #include -using namespace StaticAnalyser::Acorn; +using namespace Analyser::Static::Acorn; -std::unique_ptr StaticAnalyser::Acorn::GetDFSCatalogue(const std::shared_ptr &disk) { +std::unique_ptr Analyser::Static::Acorn::GetDFSCatalogue(const std::shared_ptr &disk) { // c.f. http://beebwiki.mdfs.net/Acorn_DFS_disc_format std::unique_ptr catalogue(new Catalogue); Storage::Encodings::MFM::Parser parser(false, disk); @@ -72,7 +74,7 @@ std::unique_ptr StaticAnalyser::Acorn::GetDFSCatalogue(const std::sha return catalogue; } -std::unique_ptr StaticAnalyser::Acorn::GetADFSCatalogue(const std::shared_ptr &disk) { +std::unique_ptr Analyser::Static::Acorn::GetADFSCatalogue(const std::shared_ptr &disk) { std::unique_ptr catalogue(new Catalogue); Storage::Encodings::MFM::Parser parser(true, disk); diff --git a/StaticAnalyser/Acorn/Disk.hpp b/Analyser/Static/Acorn/Disk.hpp similarity index 89% rename from StaticAnalyser/Acorn/Disk.hpp rename to Analyser/Static/Acorn/Disk.hpp index 2bf33bcb8..447dcbb8a 100644 --- a/StaticAnalyser/Acorn/Disk.hpp +++ b/Analyser/Static/Acorn/Disk.hpp @@ -10,9 +10,10 @@ #define StaticAnalyser_Acorn_Disk_hpp #include "File.hpp" -#include "../../Storage/Disk/Disk.hpp" +#include "../../../Storage/Disk/Disk.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Acorn { /// Describes a DFS- or ADFS-format catalogue(/directory) — the list of files available and the catalogue's boot option. @@ -30,6 +31,7 @@ struct Catalogue { std::unique_ptr GetDFSCatalogue(const std::shared_ptr &disk); std::unique_ptr GetADFSCatalogue(const std::shared_ptr &disk); +} } } diff --git a/StaticAnalyser/Acorn/File.hpp b/Analyser/Static/Acorn/File.hpp similarity index 94% rename from StaticAnalyser/Acorn/File.hpp rename to Analyser/Static/Acorn/File.hpp index d2cfeb59b..29a5d6ea6 100644 --- a/StaticAnalyser/Acorn/File.hpp +++ b/Analyser/Static/Acorn/File.hpp @@ -13,7 +13,8 @@ #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Acorn { struct File { @@ -40,6 +41,7 @@ struct File { std::vector chunks; }; +} } } diff --git a/StaticAnalyser/Acorn/StaticAnalyser.cpp b/Analyser/Static/Acorn/StaticAnalyser.cpp similarity index 95% rename from StaticAnalyser/Acorn/StaticAnalyser.cpp rename to Analyser/Static/Acorn/StaticAnalyser.cpp index b7ab067ca..10f653fd0 100644 --- a/StaticAnalyser/Acorn/StaticAnalyser.cpp +++ b/Analyser/Static/Acorn/StaticAnalyser.cpp @@ -11,7 +11,7 @@ #include "Disk.hpp" #include "Tape.hpp" -using namespace StaticAnalyser::Acorn; +using namespace Analyser::Static::Acorn; static std::vector> AcornCartridgesFrom(const std::vector> &cartridges) { @@ -56,9 +56,9 @@ static std::vector> return acorn_cartridges; } -void StaticAnalyser::Acorn::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::Acorn::AddTargets(const Media &media, std::vector &destination) { Target target; - target.machine = Target::Electron; + target.machine = Machine::Electron; target.probability = 1.0; // TODO: a proper estimation target.acorn.has_dfs = false; target.acorn.has_adfs = false; diff --git a/StaticAnalyser/Acorn/StaticAnalyser.hpp b/Analyser/Static/Acorn/StaticAnalyser.hpp similarity index 90% rename from StaticAnalyser/Acorn/StaticAnalyser.hpp rename to Analyser/Static/Acorn/StaticAnalyser.hpp index c578321b3..a5f18efb3 100644 --- a/StaticAnalyser/Acorn/StaticAnalyser.hpp +++ b/Analyser/Static/Acorn/StaticAnalyser.hpp @@ -11,11 +11,13 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Acorn { void AddTargets(const Media &media, std::vector &destination); +} } } diff --git a/StaticAnalyser/Acorn/Tape.cpp b/Analyser/Static/Acorn/Tape.cpp similarity index 94% rename from StaticAnalyser/Acorn/Tape.cpp rename to Analyser/Static/Acorn/Tape.cpp index 60cb030d5..7873e4a52 100644 --- a/StaticAnalyser/Acorn/Tape.cpp +++ b/Analyser/Static/Acorn/Tape.cpp @@ -9,10 +9,11 @@ #include "Tape.hpp" #include -#include "../../NumberTheory/CRC.hpp" -#include "../../Storage/Tape/Parsers/Acorn.hpp" -using namespace StaticAnalyser::Acorn; +#include "../../../NumberTheory/CRC.hpp" +#include "../../../Storage/Tape/Parsers/Acorn.hpp" + +using namespace Analyser::Static::Acorn; static std::unique_ptr GetNextChunk(const std::shared_ptr &tape, Storage::Tape::Acorn::Parser &parser) { std::unique_ptr new_chunk(new File::Chunk); @@ -118,7 +119,7 @@ static std::unique_ptr GetNextFile(std::deque &chunks) { return file; } -std::vector StaticAnalyser::Acorn::GetFiles(const std::shared_ptr &tape) { +std::vector Analyser::Static::Acorn::GetFiles(const std::shared_ptr &tape) { Storage::Tape::Acorn::Parser parser; // populate chunk list diff --git a/StaticAnalyser/Acorn/Tape.hpp b/Analyser/Static/Acorn/Tape.hpp similarity index 81% rename from StaticAnalyser/Acorn/Tape.hpp rename to Analyser/Static/Acorn/Tape.hpp index 3f16aad1d..863acc6ad 100644 --- a/StaticAnalyser/Acorn/Tape.hpp +++ b/Analyser/Static/Acorn/Tape.hpp @@ -12,13 +12,15 @@ #include #include "File.hpp" -#include "../../Storage/Tape/Tape.hpp" +#include "../../../Storage/Tape/Tape.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Acorn { std::vector GetFiles(const std::shared_ptr &tape); +} } } diff --git a/StaticAnalyser/AmstradCPC/StaticAnalyser.cpp b/Analyser/Static/AmstradCPC/StaticAnalyser.cpp similarity index 95% rename from StaticAnalyser/AmstradCPC/StaticAnalyser.cpp rename to Analyser/Static/AmstradCPC/StaticAnalyser.cpp index 5fa6bc977..8299da24b 100644 --- a/StaticAnalyser/AmstradCPC/StaticAnalyser.cpp +++ b/Analyser/Static/AmstradCPC/StaticAnalyser.cpp @@ -11,8 +11,8 @@ #include #include -#include "../../Storage/Disk/Parsers/CPM.hpp" -#include "../../Storage/Disk/Encodings/MFM/Parser.hpp" +#include "../../../Storage/Disk/Parsers/CPM.hpp" +#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp" static bool strcmp_insensitive(const char *a, const char *b) { if(std::strlen(a) != std::strlen(b)) return false; @@ -58,7 +58,7 @@ static std::string RunCommandFor(const Storage::Disk::CPM::File &file) { static void InspectCatalogue( const Storage::Disk::CPM::Catalogue &catalogue, - StaticAnalyser::Target &target) { + Analyser::Static::Target &target) { std::vector candidate_files; candidate_files.reserve(catalogue.files.size()); @@ -153,7 +153,7 @@ static void InspectCatalogue( target.loading_command = "cat\n"; } -static bool CheckBootSector(const std::shared_ptr &disk, StaticAnalyser::Target &target) { +static bool CheckBootSector(const std::shared_ptr &disk, Analyser::Static::Target &target) { Storage::Encodings::MFM::Parser parser(true, disk); Storage::Encodings::MFM::Sector *boot_sector = parser.get_sector(0, 0, 0x41); if(boot_sector != nullptr && !boot_sector->samples.empty()) { @@ -177,9 +177,9 @@ static bool CheckBootSector(const std::shared_ptr &disk, St return false; } -void StaticAnalyser::AmstradCPC::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::AmstradCPC::AddTargets(const Media &media, std::vector &destination) { Target target; - target.machine = Target::AmstradCPC; + target.machine = Machine::AmstradCPC; target.probability = 1.0; target.media.disks = media.disks; target.media.tapes = media.tapes; diff --git a/StaticAnalyser/AmstradCPC/StaticAnalyser.hpp b/Analyser/Static/AmstradCPC/StaticAnalyser.hpp similarity index 91% rename from StaticAnalyser/AmstradCPC/StaticAnalyser.hpp rename to Analyser/Static/AmstradCPC/StaticAnalyser.hpp index 1f91e58bb..ac37b21b5 100644 --- a/StaticAnalyser/AmstradCPC/StaticAnalyser.hpp +++ b/Analyser/Static/AmstradCPC/StaticAnalyser.hpp @@ -11,11 +11,13 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace AmstradCPC { void AddTargets(const Media &media, std::vector &destination); +} } } diff --git a/StaticAnalyser/Atari/StaticAnalyser.cpp b/Analyser/Static/Atari/StaticAnalyser.cpp similarity index 67% rename from StaticAnalyser/Atari/StaticAnalyser.cpp rename to Analyser/Static/Atari/StaticAnalyser.cpp index fb36d427f..365aa6e8f 100644 --- a/StaticAnalyser/Atari/StaticAnalyser.cpp +++ b/Analyser/Static/Atari/StaticAnalyser.cpp @@ -10,9 +10,9 @@ #include "../Disassembler/6502.hpp" -using namespace StaticAnalyser::Atari; +using namespace Analyser::Static::Atari; -static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) { +static void DeterminePagingFor2kCartridge(Analyser::Static::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) { // if this is a 2kb cartridge then it's definitely either unpaged or a CommaVid uint16_t entry_address, break_address; @@ -26,17 +26,17 @@ static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const address &= 0x1fff; return static_cast(address - 0x1800); }; - StaticAnalyser::MOS6502::Disassembly high_location_disassembly = - StaticAnalyser::MOS6502::Disassemble(segment.data, high_location_mapper, {entry_address, break_address}); + Analyser::Static::MOS6502::Disassembly high_location_disassembly = + Analyser::Static::MOS6502::Disassemble(segment.data, high_location_mapper, {entry_address, break_address}); // assume that any kind of store that looks likely to be intended for large amounts of memory implies // large amounts of memory bool has_wide_area_store = false; - for(std::map::value_type &entry : high_location_disassembly.instructions_by_address) { - if(entry.second.operation == StaticAnalyser::MOS6502::Instruction::STA) { - has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::Indirect; - has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::IndexedIndirectX; - has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::IndirectIndexedY; + for(std::map::value_type &entry : high_location_disassembly.instructions_by_address) { + if(entry.second.operation == Analyser::Static::MOS6502::Instruction::STA) { + has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::Indirect; + has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndexedIndirectX; + has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndirectIndexedY; if(has_wide_area_store) break; } @@ -46,10 +46,10 @@ static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const // caveat: false positives aren't likely to be problematic; a false positive is a 2KB ROM that always addresses // itself so as to land in ROM even if mapped as a CommaVid and this code is on the fence as to whether it // attempts to modify itself but it probably doesn't - if(has_wide_area_store) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::CommaVid; + if(has_wide_area_store) target.atari.paging_model = Analyser::Static::Atari2600PagingModel::CommaVid; } -static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) { +static void DeterminePagingFor8kCartridge(Analyser::Static::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) { // Activision stack titles have their vectors at the top of the low 4k, not the top, and // always list 0xf000 as both vectors; they do not repeat them, and, inexplicably, they all // issue an SEI as their first instruction (maybe some sort of relic of the development environment?) @@ -58,12 +58,12 @@ static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const (segment.data[8191] != 0xf0 || segment.data[8189] != 0xf0 || segment.data[8190] != 0x00 || segment.data[8188] != 0x00) && segment.data[0] == 0x78 ) { - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::ActivisionStack; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::ActivisionStack; return; } // make an assumption that this is the Atari paging model - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari8k; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Atari8k; std::set internal_accesses; internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end()); @@ -83,13 +83,13 @@ static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const tigervision_access_count += masked_address == 0x3f; } - if(parker_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::ParkerBros; - else if(tigervision_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Tigervision; + if(parker_access_count > atari_access_count) target.atari.paging_model = Analyser::Static::Atari2600PagingModel::ParkerBros; + else if(tigervision_access_count > atari_access_count) target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Tigervision; } -static void DeterminePagingFor16kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) { +static void DeterminePagingFor16kCartridge(Analyser::Static::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) { // make an assumption that this is the Atari paging model - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari16k; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Atari16k; std::set internal_accesses; internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end()); @@ -104,17 +104,17 @@ static void DeterminePagingFor16kCartridge(StaticAnalyser::Target &target, const mnetwork_access_count += masked_address >= 0x1fe0 && masked_address < 0x1ffb; } - if(mnetwork_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::MNetwork; + if(mnetwork_access_count > atari_access_count) target.atari.paging_model = Analyser::Static::Atari2600PagingModel::MNetwork; } -static void DeterminePagingFor64kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) { +static void DeterminePagingFor64kCartridge(Analyser::Static::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) { // make an assumption that this is a Tigervision if there is a write to 3F target.atari.paging_model = (disassembly.external_stores.find(0x3f) != disassembly.external_stores.end()) ? - StaticAnalyser::Atari2600PagingModel::Tigervision : StaticAnalyser::Atari2600PagingModel::MegaBoy; + Analyser::Static::Atari2600PagingModel::Tigervision : Analyser::Static::Atari2600PagingModel::MegaBoy; } -static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) { +static void DeterminePagingForCartridge(Analyser::Static::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) { if(segment.data.size() == 2048) { DeterminePagingFor2kCartridge(target, segment); return; @@ -131,23 +131,23 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St }; std::vector final_4k(segment.data.end() - 4096, segment.data.end()); - StaticAnalyser::MOS6502::Disassembly disassembly = StaticAnalyser::MOS6502::Disassemble(final_4k, address_mapper, {entry_address, break_address}); + Analyser::Static::MOS6502::Disassembly disassembly = Analyser::Static::MOS6502::Disassemble(final_4k, address_mapper, {entry_address, break_address}); switch(segment.data.size()) { case 8192: DeterminePagingFor8kCartridge(target, segment, disassembly); break; case 10495: - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Pitfall2; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Pitfall2; break; case 12288: - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::CBSRamPlus; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::CBSRamPlus; break; case 16384: DeterminePagingFor16kCartridge(target, segment, disassembly); break; case 32768: - target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari32k; + target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Atari32k; break; case 65536: DeterminePagingFor64kCartridge(target, segment, disassembly); @@ -159,8 +159,8 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St // check for a Super Chip. Atari ROM images [almost] always have the same value stored over RAM // regions; when they don't they at least seem to have the first 128 bytes be the same as the // next 128 bytes. So check for that. - if( target.atari.paging_model != StaticAnalyser::Atari2600PagingModel::CBSRamPlus && - target.atari.paging_model != StaticAnalyser::Atari2600PagingModel::MNetwork) { + if( target.atari.paging_model != Analyser::Static::Atari2600PagingModel::CBSRamPlus && + target.atari.paging_model != Analyser::Static::Atari2600PagingModel::MNetwork) { bool has_superchip = true; for(std::size_t address = 0; address < 128; address++) { if(segment.data[address] != segment.data[address+128]) { @@ -172,16 +172,16 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St } // check for a Tigervision or Tigervision-esque scheme - if(target.atari.paging_model == StaticAnalyser::Atari2600PagingModel::None && segment.data.size() > 4096) { + if(target.atari.paging_model == Analyser::Static::Atari2600PagingModel::None && segment.data.size() > 4096) { bool looks_like_tigervision = disassembly.external_stores.find(0x3f) != disassembly.external_stores.end(); - if(looks_like_tigervision) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Tigervision; + if(looks_like_tigervision) target.atari.paging_model = Analyser::Static::Atari2600PagingModel::Tigervision; } } -void StaticAnalyser::Atari::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::Atari::AddTargets(const Media &media, std::vector &destination) { // TODO: sanity checking; is this image really for an Atari 2600. Target target; - target.machine = Target::Atari2600; + target.machine = Machine::Atari2600; target.probability = 1.0; target.media.cartridges = media.cartridges; target.atari.paging_model = Atari2600PagingModel::None; diff --git a/StaticAnalyser/Atari/StaticAnalyser.hpp b/Analyser/Static/Atari/StaticAnalyser.hpp similarity index 90% rename from StaticAnalyser/Atari/StaticAnalyser.hpp rename to Analyser/Static/Atari/StaticAnalyser.hpp index 866e4bead..45957b675 100644 --- a/StaticAnalyser/Atari/StaticAnalyser.hpp +++ b/Analyser/Static/Atari/StaticAnalyser.hpp @@ -11,11 +11,13 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Atari { void AddTargets(const Media &media, std::vector &destination); +} } } diff --git a/StaticAnalyser/Commodore/Disk.cpp b/Analyser/Static/Commodore/Disk.cpp similarity index 95% rename from StaticAnalyser/Commodore/Disk.cpp rename to Analyser/Static/Commodore/Disk.cpp index 1af2fedb2..d9ee799e6 100644 --- a/StaticAnalyser/Commodore/Disk.cpp +++ b/Analyser/Static/Commodore/Disk.cpp @@ -7,15 +7,15 @@ // #include "Disk.hpp" -#include "../../Storage/Disk/Controller/DiskController.hpp" -#include "../../Storage/Disk/Encodings/CommodoreGCR.hpp" -#include "../../Storage/Data/Commodore.hpp" +#include "../../../Storage/Disk/Controller/DiskController.hpp" +#include "../../../Storage/Disk/Encodings/CommodoreGCR.hpp" +#include "../../../Storage/Data/Commodore.hpp" #include #include #include -using namespace StaticAnalyser::Commodore; +using namespace Analyser::Static::Commodore; class CommodoreGCRParser: public Storage::Disk::Controller { public: @@ -165,7 +165,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller { } }; -std::vector StaticAnalyser::Commodore::GetFiles(const std::shared_ptr &disk) { +std::vector Analyser::Static::Commodore::GetFiles(const std::shared_ptr &disk) { std::vector files; CommodoreGCRParser parser; parser.drive->set_disk(disk); diff --git a/StaticAnalyser/Commodore/Disk.hpp b/Analyser/Static/Commodore/Disk.hpp similarity index 82% rename from StaticAnalyser/Commodore/Disk.hpp rename to Analyser/Static/Commodore/Disk.hpp index ab1d8a0a2..52000d939 100644 --- a/StaticAnalyser/Commodore/Disk.hpp +++ b/Analyser/Static/Commodore/Disk.hpp @@ -9,17 +9,19 @@ #ifndef StaticAnalyser_Commodore_Disk_hpp #define StaticAnalyser_Commodore_Disk_hpp -#include "../../Storage/Disk/Disk.hpp" +#include "../../../Storage/Disk/Disk.hpp" #include "File.hpp" + #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Commodore { std::vector GetFiles(const std::shared_ptr &disk); } } - +} #endif /* Disk_hpp */ diff --git a/StaticAnalyser/Commodore/File.cpp b/Analyser/Static/Commodore/File.cpp similarity index 96% rename from StaticAnalyser/Commodore/File.cpp rename to Analyser/Static/Commodore/File.cpp index 1b923d458..1654336e9 100644 --- a/StaticAnalyser/Commodore/File.cpp +++ b/Analyser/Static/Commodore/File.cpp @@ -8,7 +8,7 @@ #include "File.hpp" -bool StaticAnalyser::Commodore::File::is_basic() { +bool Analyser::Static::Commodore::File::is_basic() { // BASIC files are always relocatable (?) if(type != File::RelocatableProgram) return false; diff --git a/StaticAnalyser/Commodore/File.hpp b/Analyser/Static/Commodore/File.hpp similarity index 93% rename from StaticAnalyser/Commodore/File.hpp rename to Analyser/Static/Commodore/File.hpp index a6bab1e0e..4b084f7fb 100644 --- a/StaticAnalyser/Commodore/File.hpp +++ b/Analyser/Static/Commodore/File.hpp @@ -12,7 +12,8 @@ #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Commodore { struct File { @@ -34,6 +35,7 @@ struct File { bool is_basic(); }; +} } } diff --git a/StaticAnalyser/Commodore/StaticAnalyser.cpp b/Analyser/Static/Commodore/StaticAnalyser.cpp similarity index 94% rename from StaticAnalyser/Commodore/StaticAnalyser.cpp rename to Analyser/Static/Commodore/StaticAnalyser.cpp index 9f98b4c7c..2bfa6971a 100644 --- a/StaticAnalyser/Commodore/StaticAnalyser.cpp +++ b/Analyser/Static/Commodore/StaticAnalyser.cpp @@ -8,14 +8,14 @@ #include "StaticAnalyser.hpp" +#include "Disk.hpp" #include "File.hpp" #include "Tape.hpp" -#include "Disk.hpp" -#include "../../Storage/Cartridge/Encodings/CommodoreROM.hpp" +#include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp" #include -using namespace StaticAnalyser::Commodore; +using namespace Analyser::Static::Commodore; static std::vector> Vic20CartridgesFrom(const std::vector> &cartridges) { @@ -38,9 +38,9 @@ static std::vector> return vic20_cartridges; } -void StaticAnalyser::Commodore::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::Commodore::AddTargets(const Media &media, std::vector &destination) { Target target; - target.machine = Target::Vic20; // TODO: machine estimation + target.machine = Machine::Vic20; // TODO: machine estimation target.probability = 1.0; // TODO: a proper estimation int device = 0; diff --git a/StaticAnalyser/Commodore/StaticAnalyser.hpp b/Analyser/Static/Commodore/StaticAnalyser.hpp similarity index 91% rename from StaticAnalyser/Commodore/StaticAnalyser.hpp rename to Analyser/Static/Commodore/StaticAnalyser.hpp index 536560f7f..4a5f3adde 100644 --- a/StaticAnalyser/Commodore/StaticAnalyser.hpp +++ b/Analyser/Static/Commodore/StaticAnalyser.hpp @@ -11,11 +11,13 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Commodore { void AddTargets(const Media &media, std::vector &destination); +} } } diff --git a/StaticAnalyser/Commodore/Tape.cpp b/Analyser/Static/Commodore/Tape.cpp similarity index 90% rename from StaticAnalyser/Commodore/Tape.cpp rename to Analyser/Static/Commodore/Tape.cpp index 9e20774c1..2609ba66a 100644 --- a/StaticAnalyser/Commodore/Tape.cpp +++ b/Analyser/Static/Commodore/Tape.cpp @@ -8,11 +8,11 @@ #include "Tape.hpp" -#include "../../Storage/Tape/Parsers/Commodore.hpp" +#include "../../../Storage/Tape/Parsers/Commodore.hpp" -using namespace StaticAnalyser::Commodore; +using namespace Analyser::Static::Commodore; -std::vector StaticAnalyser::Commodore::GetFiles(const std::shared_ptr &tape) { +std::vector Analyser::Static::Commodore::GetFiles(const std::shared_ptr &tape) { Storage::Tape::Commodore::Parser parser; std::vector file_list; diff --git a/StaticAnalyser/Commodore/Tape.hpp b/Analyser/Static/Commodore/Tape.hpp similarity index 81% rename from StaticAnalyser/Commodore/Tape.hpp rename to Analyser/Static/Commodore/Tape.hpp index fef2130b0..59c21a96e 100644 --- a/StaticAnalyser/Commodore/Tape.hpp +++ b/Analyser/Static/Commodore/Tape.hpp @@ -9,15 +9,16 @@ #ifndef StaticAnalyser_Commodore_Tape_hpp #define StaticAnalyser_Commodore_Tape_hpp -#include "../../Storage/Tape/Tape.hpp" +#include "../../../Storage/Tape/Tape.hpp" #include "File.hpp" -#include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Commodore { std::vector GetFiles(const std::shared_ptr &tape); +} } } diff --git a/StaticAnalyser/Disassembler/6502.cpp b/Analyser/Static/Disassembler/6502.cpp similarity index 97% rename from StaticAnalyser/Disassembler/6502.cpp rename to Analyser/Static/Disassembler/6502.cpp index 6ddfb67a5..20216a896 100644 --- a/StaticAnalyser/Disassembler/6502.cpp +++ b/Analyser/Static/Disassembler/6502.cpp @@ -10,10 +10,10 @@ #include "Kernel.hpp" -using namespace StaticAnalyser::MOS6502; +using namespace Analyser::Static::MOS6502; namespace { -using PartialDisassembly = StaticAnalyser::Disassembly::PartialDisassembly; +using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly; struct MOS6502Disassembler { @@ -312,9 +312,9 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector< } // end of anonymous namespace -Disassembly StaticAnalyser::MOS6502::Disassemble( +Disassembly Analyser::Static::MOS6502::Disassemble( const std::vector &memory, const std::function &address_mapper, std::vector entry_points) { - return StaticAnalyser::Disassembly::Disassemble(memory, address_mapper, entry_points); + return Analyser::Static::Disassembly::Disassemble(memory, address_mapper, entry_points); } diff --git a/StaticAnalyser/Disassembler/6502.hpp b/Analyser/Static/Disassembler/6502.hpp similarity index 98% rename from StaticAnalyser/Disassembler/6502.hpp rename to Analyser/Static/Disassembler/6502.hpp index a5b0b1fe4..d414c09c7 100644 --- a/StaticAnalyser/Disassembler/6502.hpp +++ b/Analyser/Static/Disassembler/6502.hpp @@ -16,7 +16,8 @@ #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace MOS6502 { /*! @@ -95,5 +96,6 @@ Disassembly Disassemble( } } +} #endif /* Disassembler6502_hpp */ diff --git a/StaticAnalyser/Disassembler/AddressMapper.cpp b/Analyser/Static/Disassembler/AddressMapper.cpp similarity index 100% rename from StaticAnalyser/Disassembler/AddressMapper.cpp rename to Analyser/Static/Disassembler/AddressMapper.cpp diff --git a/StaticAnalyser/Disassembler/AddressMapper.hpp b/Analyser/Static/Disassembler/AddressMapper.hpp similarity index 93% rename from StaticAnalyser/Disassembler/AddressMapper.hpp rename to Analyser/Static/Disassembler/AddressMapper.hpp index ffb3f8d14..95d4b4b9f 100644 --- a/StaticAnalyser/Disassembler/AddressMapper.hpp +++ b/Analyser/Static/Disassembler/AddressMapper.hpp @@ -11,7 +11,8 @@ #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Disassembler { /*! @@ -24,6 +25,7 @@ template std::function OffsetMapper(T start_address }; } +} } } diff --git a/StaticAnalyser/Disassembler/Kernel.hpp b/Analyser/Static/Disassembler/Kernel.hpp similarity index 97% rename from StaticAnalyser/Disassembler/Kernel.hpp rename to Analyser/Static/Disassembler/Kernel.hpp index 6c6d45e7a..9fcb89b9d 100644 --- a/StaticAnalyser/Disassembler/Kernel.hpp +++ b/Analyser/Static/Disassembler/Kernel.hpp @@ -9,7 +9,8 @@ #ifndef Kernel_hpp #define Kernel_hpp -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Disassembly { template struct PartialDisassembly { @@ -44,6 +45,7 @@ template D Disassemble( return partial_disassembly.disassembly; } +} } } diff --git a/StaticAnalyser/Disassembler/Z80.cpp b/Analyser/Static/Disassembler/Z80.cpp similarity index 98% rename from StaticAnalyser/Disassembler/Z80.cpp rename to Analyser/Static/Disassembler/Z80.cpp index 918a915d3..695372a14 100644 --- a/StaticAnalyser/Disassembler/Z80.cpp +++ b/Analyser/Static/Disassembler/Z80.cpp @@ -10,10 +10,10 @@ #include "Kernel.hpp" -using namespace StaticAnalyser::Z80; +using namespace Analyser::Static::Z80; namespace { -using PartialDisassembly = StaticAnalyser::Disassembly::PartialDisassembly; +using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly; class Accessor { public: @@ -611,9 +611,9 @@ struct Z80Disassembler { } // end of anonymous namespace -Disassembly StaticAnalyser::Z80::Disassemble( +Disassembly Analyser::Static::Z80::Disassemble( const std::vector &memory, const std::function &address_mapper, std::vector entry_points) { - return StaticAnalyser::Disassembly::Disassemble(memory, address_mapper, entry_points); + return Analyser::Static::Disassembly::Disassemble(memory, address_mapper, entry_points); } diff --git a/StaticAnalyser/Disassembler/Z80.hpp b/Analyser/Static/Disassembler/Z80.hpp similarity index 98% rename from StaticAnalyser/Disassembler/Z80.hpp rename to Analyser/Static/Disassembler/Z80.hpp index 8d822f7da..26a05f54a 100644 --- a/StaticAnalyser/Disassembler/Z80.hpp +++ b/Analyser/Static/Disassembler/Z80.hpp @@ -15,7 +15,8 @@ #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Z80 { struct Instruction { @@ -84,5 +85,6 @@ Disassembly Disassemble( } } +} #endif /* StaticAnalyser_Disassembler_Z80_hpp */ diff --git a/StaticAnalyser/MSX/StaticAnalyser.cpp b/Analyser/Static/MSX/StaticAnalyser.cpp similarity index 77% rename from StaticAnalyser/MSX/StaticAnalyser.cpp rename to Analyser/Static/MSX/StaticAnalyser.cpp index 7946a1c15..9e7328cad 100644 --- a/StaticAnalyser/MSX/StaticAnalyser.cpp +++ b/Analyser/Static/MSX/StaticAnalyser.cpp @@ -25,7 +25,7 @@ DEFS 6,0 ; room reserved for future extensions */ static std::vector> - MSXCartridgesFrom(const std::vector> &cartridges, StaticAnalyser::Target &target) { + MSXCartridgesFrom(const std::vector> &cartridges, Analyser::Static::Target &target) { std::vector> msx_cartridges; for(const auto &cartridge : cartridges) { @@ -59,20 +59,20 @@ static std::vector> // If this ROM is greater than 48kb in size then some sort of MegaROM scheme must // be at play; disassemble to try to figure it out. - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::None; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::None; if(data_size > 0xc000) { std::vector first_16k; first_16k.insert(first_16k.begin(), segment.data.begin(), segment.data.begin() + 8192); - StaticAnalyser::Z80::Disassembly disassembly = - StaticAnalyser::Z80::Disassemble( + Analyser::Static::Z80::Disassembly disassembly = + Analyser::Static::Z80::Disassemble( first_16k, - StaticAnalyser::Disassembler::OffsetMapper(start_address), + Analyser::Static::Disassembler::OffsetMapper(start_address), { init_address } ); // Look for a indirect store followed by an unconditional JP or CALL into another // segment, that's a fairly explicit sign where found. - using Instruction = StaticAnalyser::Z80::Instruction; + using Instruction = Analyser::Static::Z80::Instruction; std::map &instructions = disassembly.instructions_by_address; bool is_ascii = false; auto iterator = instructions.begin(); @@ -104,17 +104,17 @@ static std::vector> switch(iterator->second.operand) { case 0x6000: if(address >= 0x6000 && address < 0x8000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::KonamiWithSCC; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC; } break; case 0x6800: if(address >= 0x6000 && address < 0x6800) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::ASCII8kb; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb; } break; case 0x7000: if(address >= 0x6000 && address < 0x8000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::KonamiWithSCC; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC; } if(address >= 0x7000 && address < 0x7800) { is_ascii = true; @@ -122,32 +122,32 @@ static std::vector> break; case 0x77ff: if(address >= 0x7000 && address < 0x7800) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::ASCII16kb; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII16kb; } break; case 0x7800: if(address >= 0xa000 && address < 0xc000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::ASCII8kb; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb; } break; case 0x8000: if(address >= 0x8000 && address < 0xa000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::KonamiWithSCC; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC; } break; case 0x9000: if(address >= 0x8000 && address < 0xa000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::KonamiWithSCC; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC; } break; case 0xa000: if(address >= 0xa000 && address < 0xc000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::Konami; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::Konami; } break; case 0xb000: if(address >= 0xa000 && address < 0xc000) { - target.msx.cartridge_type = StaticAnalyser::MSXCartridgeType::KonamiWithSCC; + target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC; } break; } @@ -156,7 +156,7 @@ static std::vector> iterator = next_iterator; } - if(target.msx.cartridge_type == StaticAnalyser::MSXCartridgeType::None) { + if(target.msx.cartridge_type == Analyser::Static::MSXCartridgeType::None) { // Look for LD (nnnn), A instructions, and collate those addresses. std::map address_counts; for(const auto &instruction_pair : instructions) { @@ -168,14 +168,14 @@ static std::vector> } // Sort possible cartridge types. - using Possibility = std::pair; + using Possibility = std::pair; std::vector possibilities; // Add to list in order of declining probability, so that stable_sort below prefers // the more likely option in a tie. - possibilities.push_back(std::make_pair(StaticAnalyser::MSXCartridgeType::ASCII8kb, address_counts[0x6000] + address_counts[0x6800] + address_counts[0x7000] + address_counts[0x7800])); - possibilities.push_back(std::make_pair(StaticAnalyser::MSXCartridgeType::ASCII16kb, address_counts[0x6000] + address_counts[0x7000] + address_counts[0x77ff])); - if(!is_ascii) possibilities.push_back(std::make_pair(StaticAnalyser::MSXCartridgeType::Konami, address_counts[0x6000] + address_counts[0x8000] + address_counts[0xa000])); - if(!is_ascii) possibilities.push_back(std::make_pair(StaticAnalyser::MSXCartridgeType::KonamiWithSCC, address_counts[0x5000] + address_counts[0x7000] + address_counts[0x9000] + address_counts[0xb000])); + possibilities.push_back(std::make_pair(Analyser::Static::MSXCartridgeType::ASCII8kb, address_counts[0x6000] + address_counts[0x6800] + address_counts[0x7000] + address_counts[0x7800])); + possibilities.push_back(std::make_pair(Analyser::Static::MSXCartridgeType::ASCII16kb, address_counts[0x6000] + address_counts[0x7000] + address_counts[0x77ff])); + if(!is_ascii) possibilities.push_back(std::make_pair(Analyser::Static::MSXCartridgeType::Konami, address_counts[0x6000] + address_counts[0x8000] + address_counts[0xa000])); + if(!is_ascii) possibilities.push_back(std::make_pair(Analyser::Static::MSXCartridgeType::KonamiWithSCC, address_counts[0x5000] + address_counts[0x7000] + address_counts[0x9000] + address_counts[0xb000])); std::stable_sort(possibilities.begin(), possibilities.end(), [](const Possibility &a, const Possibility &b) { return a.second > b.second; }); @@ -200,7 +200,7 @@ static std::vector> return msx_cartridges; } -void StaticAnalyser::MSX::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::MSX::AddTargets(const Media &media, std::vector &destination) { Target target; // Obtain only those cartridges which it looks like an MSX would understand. @@ -224,7 +224,7 @@ void StaticAnalyser::MSX::AddTargets(const Media &media, std::vector &de target.media.disks = media.disks; if(!target.media.empty()) { - target.machine = Target::MSX; + target.machine = Machine::MSX; target.probability = 1.0; destination.push_back(target); } diff --git a/StaticAnalyser/MSX/StaticAnalyser.hpp b/Analyser/Static/MSX/StaticAnalyser.hpp similarity index 90% rename from StaticAnalyser/MSX/StaticAnalyser.hpp rename to Analyser/Static/MSX/StaticAnalyser.hpp index 22bed2c79..9e03b783e 100644 --- a/StaticAnalyser/MSX/StaticAnalyser.hpp +++ b/Analyser/Static/MSX/StaticAnalyser.hpp @@ -11,11 +11,13 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace MSX { void AddTargets(const Media &media, std::vector &destination); +} } } diff --git a/StaticAnalyser/MSX/Tape.cpp b/Analyser/Static/MSX/Tape.cpp similarity index 96% rename from StaticAnalyser/MSX/Tape.cpp rename to Analyser/Static/MSX/Tape.cpp index fa49afe90..63d7696f2 100644 --- a/StaticAnalyser/MSX/Tape.cpp +++ b/Analyser/Static/MSX/Tape.cpp @@ -8,9 +8,9 @@ #include "Tape.hpp" -#include "../../Storage/Tape/Parsers/MSX.hpp" +#include "../../../Storage/Tape/Parsers/MSX.hpp" -using namespace StaticAnalyser::MSX; +using namespace Analyser::Static::MSX; File::File(File &&rhs) : name(std::move(rhs.name)), @@ -24,7 +24,7 @@ File::File() : starting_address(0), entry_address(0) {} // For the sake of initialising in a defined state. -std::vector StaticAnalyser::MSX::GetFiles(const std::shared_ptr &tape) { +std::vector Analyser::Static::MSX::GetFiles(const std::shared_ptr &tape) { std::vector files; Storage::Tape::BinaryTapePlayer tape_player(1000000); diff --git a/StaticAnalyser/MSX/Tape.hpp b/Analyser/Static/MSX/Tape.hpp similarity index 89% rename from StaticAnalyser/MSX/Tape.hpp rename to Analyser/Static/MSX/Tape.hpp index c7150852b..b0509b8b9 100644 --- a/StaticAnalyser/MSX/Tape.hpp +++ b/Analyser/Static/MSX/Tape.hpp @@ -9,12 +9,13 @@ #ifndef StaticAnalyser_MSX_Tape_hpp #define StaticAnalyser_MSX_Tape_hpp -#include "../../Storage/Tape/Tape.hpp" +#include "../../../Storage/Tape/Tape.hpp" #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace MSX { struct File { @@ -36,6 +37,7 @@ struct File { std::vector GetFiles(const std::shared_ptr &tape); +} } } diff --git a/StaticAnalyser/Oric/StaticAnalyser.cpp b/Analyser/Static/Oric/StaticAnalyser.cpp similarity index 89% rename from StaticAnalyser/Oric/StaticAnalyser.cpp rename to Analyser/Static/Oric/StaticAnalyser.cpp index 1aea8e986..53dfb2990 100644 --- a/StaticAnalyser/Oric/StaticAnalyser.cpp +++ b/Analyser/Static/Oric/StaticAnalyser.cpp @@ -12,9 +12,9 @@ #include "../Disassembler/6502.hpp" #include "../Disassembler/AddressMapper.hpp" -using namespace StaticAnalyser::Oric; +using namespace Analyser::Static::Oric; -static int Score(const StaticAnalyser::MOS6502::Disassembly &disassembly, const std::set &rom_functions, const std::set &variable_locations) { +static int Score(const Analyser::Static::MOS6502::Disassembly &disassembly, const std::set &rom_functions, const std::set &variable_locations) { int score = 0; for(auto address : disassembly.outward_calls) score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1; @@ -24,7 +24,7 @@ static int Score(const StaticAnalyser::MOS6502::Disassembly &disassembly, const return score; } -static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) { +static int Basic10Score(const Analyser::Static::MOS6502::Disassembly &disassembly) { std::set rom_functions = { 0x0228, 0x022b, 0xc3ca, 0xc3f8, 0xc448, 0xc47c, 0xc4b5, 0xc4e3, 0xc4e0, 0xc524, 0xc56f, 0xc5a2, 0xc5f8, 0xc60a, 0xc6a5, 0xc6de, 0xc719, 0xc738, @@ -48,7 +48,7 @@ static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) return Score(disassembly, rom_functions, variable_locations); } -static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) { +static int Basic11Score(const Analyser::Static::MOS6502::Disassembly &disassembly) { std::set rom_functions = { 0x0238, 0x023b, 0x023e, 0x0241, 0x0244, 0x0247, 0xc3c6, 0xc3f4, 0xc444, 0xc47c, 0xc4a8, 0xc4d3, 0xc4e0, 0xc524, 0xc55f, 0xc592, 0xc5e8, 0xc5fa, 0xc692, 0xc6b3, 0xc6ee, 0xc70d, @@ -73,9 +73,9 @@ static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) return Score(disassembly, rom_functions, variable_locations); } -void StaticAnalyser::Oric::AddTargets(const Media &media, std::vector &destination) { +void Analyser::Static::Oric::AddTargets(const Media &media, std::vector &destination) { Target target; - target.machine = Target::Oric; + target.machine = Machine::Oric; target.probability = 1.0; int basic10_votes = 0; @@ -88,8 +88,8 @@ void StaticAnalyser::Oric::AddTargets(const Media &media, std::vector &d for(auto file : tape_files) { if(file.data_type == File::MachineCode) { std::vector entry_points = {file.starting_address}; - StaticAnalyser::MOS6502::Disassembly disassembly = - StaticAnalyser::MOS6502::Disassemble(file.data, StaticAnalyser::Disassembler::OffsetMapper(file.starting_address), entry_points); + Analyser::Static::MOS6502::Disassembly disassembly = + Analyser::Static::MOS6502::Disassemble(file.data, Analyser::Static::Disassembler::OffsetMapper(file.starting_address), entry_points); int basic10_score = Basic10Score(disassembly); int basic11_score = Basic11Score(disassembly); diff --git a/StaticAnalyser/Oric/StaticAnalyser.hpp b/Analyser/Static/Oric/StaticAnalyser.hpp similarity index 90% rename from StaticAnalyser/Oric/StaticAnalyser.hpp rename to Analyser/Static/Oric/StaticAnalyser.hpp index 53a1f6085..decf9ebd1 100644 --- a/StaticAnalyser/Oric/StaticAnalyser.hpp +++ b/Analyser/Static/Oric/StaticAnalyser.hpp @@ -11,13 +11,14 @@ #include "../StaticAnalyser.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Oric { void AddTargets(const Media &media, std::vector &destination); } } - +} #endif /* StaticAnalyser_hpp */ diff --git a/StaticAnalyser/Oric/Tape.cpp b/Analyser/Static/Oric/Tape.cpp similarity index 93% rename from StaticAnalyser/Oric/Tape.cpp rename to Analyser/Static/Oric/Tape.cpp index 7e1aeefd6..7409abaa0 100644 --- a/StaticAnalyser/Oric/Tape.cpp +++ b/Analyser/Static/Oric/Tape.cpp @@ -7,11 +7,11 @@ // #include "Tape.hpp" -#include "../../Storage/Tape/Parsers/Oric.hpp" +#include "../../../Storage/Tape/Parsers/Oric.hpp" -using namespace StaticAnalyser::Oric; +using namespace Analyser::Static::Oric; -std::vector StaticAnalyser::Oric::GetFiles(const std::shared_ptr &tape) { +std::vector Analyser::Static::Oric::GetFiles(const std::shared_ptr &tape) { std::vector files; Storage::Tape::Oric::Parser parser; diff --git a/StaticAnalyser/Oric/Tape.hpp b/Analyser/Static/Oric/Tape.hpp similarity index 87% rename from StaticAnalyser/Oric/Tape.hpp rename to Analyser/Static/Oric/Tape.hpp index 00073df6d..e81a85a6b 100644 --- a/StaticAnalyser/Oric/Tape.hpp +++ b/Analyser/Static/Oric/Tape.hpp @@ -9,12 +9,13 @@ #ifndef StaticAnalyser_Oric_Tape_hpp #define StaticAnalyser_Oric_Tape_hpp -#include "../../Storage/Tape/Tape.hpp" -#include +#include "../../../Storage/Tape/Tape.hpp" + #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace Oric { struct File { @@ -32,6 +33,7 @@ struct File { std::vector GetFiles(const std::shared_ptr &tape); +} } } diff --git a/StaticAnalyser/StaticAnalyser.cpp b/Analyser/Static/StaticAnalyser.cpp similarity index 83% rename from StaticAnalyser/StaticAnalyser.cpp rename to Analyser/Static/StaticAnalyser.cpp index eb63f3b7b..9851a6d09 100644 --- a/StaticAnalyser/StaticAnalyser.cpp +++ b/Analyser/Static/StaticAnalyser.cpp @@ -21,34 +21,34 @@ #include "ZX8081/StaticAnalyser.hpp" // Cartridges -#include "../Storage/Cartridge/Formats/BinaryDump.hpp" -#include "../Storage/Cartridge/Formats/PRG.hpp" +#include "../../Storage/Cartridge/Formats/BinaryDump.hpp" +#include "../../Storage/Cartridge/Formats/PRG.hpp" // Disks -#include "../Storage/Disk/DiskImage/Formats/AcornADF.hpp" -#include "../Storage/Disk/DiskImage/Formats/CPCDSK.hpp" -#include "../Storage/Disk/DiskImage/Formats/D64.hpp" -#include "../Storage/Disk/DiskImage/Formats/G64.hpp" -#include "../Storage/Disk/DiskImage/Formats/DMK.hpp" -#include "../Storage/Disk/DiskImage/Formats/HFE.hpp" -#include "../Storage/Disk/DiskImage/Formats/MSXDSK.hpp" -#include "../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp" -#include "../Storage/Disk/DiskImage/Formats/SSD.hpp" +#include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp" +#include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp" +#include "../../Storage/Disk/DiskImage/Formats/D64.hpp" +#include "../../Storage/Disk/DiskImage/Formats/G64.hpp" +#include "../../Storage/Disk/DiskImage/Formats/DMK.hpp" +#include "../../Storage/Disk/DiskImage/Formats/HFE.hpp" +#include "../../Storage/Disk/DiskImage/Formats/MSXDSK.hpp" +#include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp" +#include "../../Storage/Disk/DiskImage/Formats/SSD.hpp" // Tapes -#include "../Storage/Tape/Formats/CAS.hpp" -#include "../Storage/Tape/Formats/CommodoreTAP.hpp" -#include "../Storage/Tape/Formats/CSW.hpp" -#include "../Storage/Tape/Formats/OricTAP.hpp" -#include "../Storage/Tape/Formats/TapePRG.hpp" -#include "../Storage/Tape/Formats/TapeUEF.hpp" -#include "../Storage/Tape/Formats/TZX.hpp" -#include "../Storage/Tape/Formats/ZX80O81P.hpp" +#include "../../Storage/Tape/Formats/CAS.hpp" +#include "../../Storage/Tape/Formats/CommodoreTAP.hpp" +#include "../../Storage/Tape/Formats/CSW.hpp" +#include "../../Storage/Tape/Formats/OricTAP.hpp" +#include "../../Storage/Tape/Formats/TapePRG.hpp" +#include "../../Storage/Tape/Formats/TapeUEF.hpp" +#include "../../Storage/Tape/Formats/TZX.hpp" +#include "../../Storage/Tape/Formats/ZX80O81P.hpp" // Target Platform Types -#include "../Storage/TargetPlatforms.hpp" +#include "../../Storage/TargetPlatforms.hpp" -using namespace StaticAnalyser; +using namespace Analyser::Static; static Media GetMediaAndPlatforms(const char *file_name, TargetPlatform::IntType &potential_platforms) { // Get the extension, if any; it will be assumed that extensions are reliable, so an extension is a broad-phase @@ -134,12 +134,12 @@ static Media GetMediaAndPlatforms(const char *file_name, TargetPlatform::IntType return result; } -Media StaticAnalyser::GetMedia(const char *file_name) { +Media Analyser::Static::GetMedia(const char *file_name) { TargetPlatform::IntType throwaway; return GetMediaAndPlatforms(file_name, throwaway); } -std::vector StaticAnalyser::GetTargets(const char *file_name) { +std::vector Analyser::Static::GetTargets(const char *file_name) { std::vector targets; // Collect all disks, tapes and ROMs as can be extrapolated from this file, forming the diff --git a/StaticAnalyser/StaticAnalyser.hpp b/Analyser/Static/StaticAnalyser.hpp similarity index 90% rename from StaticAnalyser/StaticAnalyser.hpp rename to Analyser/Static/StaticAnalyser.hpp index 3b44864ba..b027245f0 100644 --- a/StaticAnalyser/StaticAnalyser.hpp +++ b/Analyser/Static/StaticAnalyser.hpp @@ -9,14 +9,17 @@ #ifndef StaticAnalyser_hpp #define StaticAnalyser_hpp -#include "../Storage/Tape/Tape.hpp" -#include "../Storage/Disk/Disk.hpp" -#include "../Storage/Cartridge/Cartridge.hpp" +#include "../Machines.hpp" + +#include "../../Storage/Tape/Tape.hpp" +#include "../../Storage/Disk/Disk.hpp" +#include "../../Storage/Cartridge/Cartridge.hpp" #include #include -namespace StaticAnalyser { +namespace Analyser { +namespace Static { enum class Vic20MemoryModel { Unexpanded, @@ -78,15 +81,7 @@ struct Media { and instructions on how to launch the software attached, plus a measure of confidence in this target's correctness. */ struct Target { - enum Machine { - AmstradCPC, - Atari2600, - Electron, - MSX, - Oric, - Vic20, - ZX8081 - } machine; + Machine machine; float probability; // TODO: this is too C-like a solution; make Target a base class and @@ -143,6 +138,7 @@ std::vector GetTargets(const char *file_name); */ Media GetMedia(const char *file_name); +} } #endif /* StaticAnalyser_hpp */ diff --git a/StaticAnalyser/ZX8081/StaticAnalyser.cpp b/Analyser/Static/ZX8081/StaticAnalyser.cpp similarity index 86% rename from StaticAnalyser/ZX8081/StaticAnalyser.cpp rename to Analyser/Static/ZX8081/StaticAnalyser.cpp index 464bc6041..8e1aefa4a 100644 --- a/StaticAnalyser/ZX8081/StaticAnalyser.cpp +++ b/Analyser/Static/ZX8081/StaticAnalyser.cpp @@ -11,7 +11,7 @@ #include #include -#include "../../Storage/Tape/Parsers/ZX8081.hpp" +#include "../../../Storage/Tape/Parsers/ZX8081.hpp" static std::vector GetFiles(const std::shared_ptr &tape) { std::vector files; @@ -27,13 +27,13 @@ static std::vector GetFiles(const std::shared_ptr &destination, TargetPlatform::IntType potential_platforms) { +void Analyser::Static::ZX8081::AddTargets(const Media &media, std::vector &destination, TargetPlatform::IntType potential_platforms) { if(!media.tapes.empty()) { std::vector files = GetFiles(media.tapes.front()); media.tapes.front()->reset(); if(!files.empty()) { - StaticAnalyser::Target target; - target.machine = Target::ZX8081; + Analyser::Static::Target target; + target.machine = Machine::ZX8081; // Guess the machine type from the file only if it isn't already known. switch(potential_platforms & (TargetPlatform::ZX80 | TargetPlatform::ZX81)) { diff --git a/StaticAnalyser/ZX8081/StaticAnalyser.hpp b/Analyser/Static/ZX8081/StaticAnalyser.hpp similarity index 83% rename from StaticAnalyser/ZX8081/StaticAnalyser.hpp rename to Analyser/Static/ZX8081/StaticAnalyser.hpp index 4cc381c46..bf1f071ec 100644 --- a/StaticAnalyser/ZX8081/StaticAnalyser.hpp +++ b/Analyser/Static/ZX8081/StaticAnalyser.hpp @@ -10,13 +10,15 @@ #define StaticAnalyser_ZX8081_StaticAnalyser_hpp #include "../StaticAnalyser.hpp" -#include "../../Storage/TargetPlatforms.hpp" +#include "../../../Storage/TargetPlatforms.hpp" -namespace StaticAnalyser { +namespace Analyser { +namespace Static { namespace ZX8081 { void AddTargets(const Media &media, std::vector &destination, TargetPlatform::IntType potential_platforms); +} } } diff --git a/Machines/AmstradCPC/AmstradCPC.cpp b/Machines/AmstradCPC/AmstradCPC.cpp index 3faa8397c..880b6a335 100644 --- a/Machines/AmstradCPC/AmstradCPC.cpp +++ b/Machines/AmstradCPC/AmstradCPC.cpp @@ -867,19 +867,19 @@ class ConcreteMachine: } /// The ConfigurationTarget entry point; should configure this meachine as described by @c target. - void configure_as_target(const StaticAnalyser::Target &target) override final { + void configure_as_target(const Analyser::Static::Target &target) override final { switch(target.amstradcpc.model) { - case StaticAnalyser::AmstradCPCModel::CPC464: + case Analyser::Static::AmstradCPCModel::CPC464: rom_model_ = ROMType::OS464; has_128k_ = false; has_fdc_ = false; break; - case StaticAnalyser::AmstradCPCModel::CPC664: + case Analyser::Static::AmstradCPCModel::CPC664: rom_model_ = ROMType::OS664; has_128k_ = false; has_fdc_ = true; break; - case StaticAnalyser::AmstradCPCModel::CPC6128: + case Analyser::Static::AmstradCPCModel::CPC6128: rom_model_ = ROMType::OS6128; has_128k_ = true; has_fdc_ = true; @@ -908,7 +908,7 @@ class ConcreteMachine: insert_media(target.media); } - bool insert_media(const StaticAnalyser::Media &media) override final { + bool insert_media(const Analyser::Static::Media &media) override final { // If there are any tapes supplied, use the first of them. if(!media.tapes.empty()) { tape_player_.set_tape(media.tapes.front()); diff --git a/Machines/Atari2600/Atari2600.cpp b/Machines/Atari2600/Atari2600.cpp index edfef0680..109b1e7a1 100644 --- a/Machines/Atari2600/Atari2600.cpp +++ b/Machines/Atari2600/Atari2600.cpp @@ -72,34 +72,34 @@ class ConcreteMachine: close_output(); } - void configure_as_target(const StaticAnalyser::Target &target) override { + void configure_as_target(const Analyser::Static::Target &target) override { const std::vector &rom = target.media.cartridges.front()->get_segments().front().data; switch(target.atari.paging_model) { - case StaticAnalyser::Atari2600PagingModel::ActivisionStack: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::CBSRamPlus: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::CommaVid: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::MegaBoy: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::MNetwork: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::None: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::ParkerBros: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::Pitfall2: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::Tigervision: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::ActivisionStack: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::CBSRamPlus: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::CommaVid: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::MegaBoy: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::MNetwork: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::None: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::ParkerBros: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::Pitfall2: bus_.reset(new Cartridge::Cartridge(rom)); break; + case Analyser::Static::Atari2600PagingModel::Tigervision: bus_.reset(new Cartridge::Cartridge(rom)); break; - case StaticAnalyser::Atari2600PagingModel::Atari8k: + case Analyser::Static::Atari2600PagingModel::Atari8k: if(target.atari.uses_superchip) { bus_.reset(new Cartridge::Cartridge(rom)); } else { bus_.reset(new Cartridge::Cartridge(rom)); } break; - case StaticAnalyser::Atari2600PagingModel::Atari16k: + case Analyser::Static::Atari2600PagingModel::Atari16k: if(target.atari.uses_superchip) { bus_.reset(new Cartridge::Cartridge(rom)); } else { bus_.reset(new Cartridge::Cartridge(rom)); } break; - case StaticAnalyser::Atari2600PagingModel::Atari32k: + case Analyser::Static::Atari2600PagingModel::Atari32k: if(target.atari.uses_superchip) { bus_.reset(new Cartridge::Cartridge(rom)); } else { @@ -112,7 +112,7 @@ class ConcreteMachine: joysticks_.emplace_back(new Joystick(bus_.get(), 4, 1)); } - bool insert_media(const StaticAnalyser::Media &media) override { + bool insert_media(const Analyser::Static::Media &media) override { return false; } diff --git a/Machines/Commodore/Vic-20/Vic20.cpp b/Machines/Commodore/Vic-20/Vic20.cpp index c1b5825e6..8a4754218 100644 --- a/Machines/Commodore/Vic-20/Vic20.cpp +++ b/Machines/Commodore/Vic-20/Vic20.cpp @@ -346,19 +346,19 @@ class ConcreteMachine: return true; } - void configure_as_target(const StaticAnalyser::Target &target) override final { + void configure_as_target(const Analyser::Static::Target &target) override final { if(target.loading_command.length()) { type_string(target.loading_command); } switch(target.vic20.memory_model) { - case StaticAnalyser::Vic20MemoryModel::Unexpanded: + case Analyser::Static::Vic20MemoryModel::Unexpanded: set_memory_size(Default); break; - case StaticAnalyser::Vic20MemoryModel::EightKB: + case Analyser::Static::Vic20MemoryModel::EightKB: set_memory_size(ThreeKB); break; - case StaticAnalyser::Vic20MemoryModel::ThirtyTwoKB: + case Analyser::Static::Vic20MemoryModel::ThirtyTwoKB: set_memory_size(ThirtyTwoKB); break; } @@ -377,7 +377,7 @@ class ConcreteMachine: insert_media(target.media); } - bool insert_media(const StaticAnalyser::Media &media) override final { + bool insert_media(const Analyser::Static::Media &media) override final { if(!media.tapes.empty()) { tape_->set_tape(media.tapes.front()); } diff --git a/Machines/ConfigurationTarget.hpp b/Machines/ConfigurationTarget.hpp index 1dd5f54ec..600f76730 100644 --- a/Machines/ConfigurationTarget.hpp +++ b/Machines/ConfigurationTarget.hpp @@ -9,7 +9,7 @@ #ifndef ConfigurationTarget_hpp #define ConfigurationTarget_hpp -#include "../StaticAnalyser/StaticAnalyser.hpp" +#include "../Analyser/Static/StaticAnalyser.hpp" #include "../Configurable/Configurable.hpp" #include @@ -17,20 +17,20 @@ namespace ConfigurationTarget { /*! - A ConfigurationTarget::Machine is anything that can accept a StaticAnalyser::Target + A ConfigurationTarget::Machine is anything that can accept a Analyser::Static::Target and configure itself appropriately, or accept a list of media subsequently to insert. */ class Machine { public: /// Instructs the machine to configure itself as described by @c target and insert the included media. - virtual void configure_as_target(const StaticAnalyser::Target &target) = 0; + virtual void configure_as_target(const Analyser::Static::Target &target) = 0; /*! Requests that the machine insert @c media as a modification to current state @returns @c true if any media was inserted; @c false otherwise. */ - virtual bool insert_media(const StaticAnalyser::Media &media) = 0; + virtual bool insert_media(const Analyser::Static::Media &media) = 0; }; } diff --git a/Machines/Electron/Electron.cpp b/Machines/Electron/Electron.cpp index b48a6f675..7697ceef8 100644 --- a/Machines/Electron/Electron.cpp +++ b/Machines/Electron/Electron.cpp @@ -119,7 +119,7 @@ class ConcreteMachine: use_fast_tape_hack_ = activate; } - void configure_as_target(const StaticAnalyser::Target &target) override final { + void configure_as_target(const Analyser::Static::Target &target) override final { if(target.loading_command.length()) { type_string(target.loading_command); } @@ -143,7 +143,7 @@ class ConcreteMachine: insert_media(target.media); } - bool insert_media(const StaticAnalyser::Media &media) override final { + bool insert_media(const Analyser::Static::Media &media) override final { if(!media.tapes.empty()) { tape_.set_tape(media.tapes.front()); } diff --git a/Machines/MSX/MSX.cpp b/Machines/MSX/MSX.cpp index ed926a5f0..40a697f06 100644 --- a/Machines/MSX/MSX.cpp +++ b/Machines/MSX/MSX.cpp @@ -160,7 +160,7 @@ class ConcreteMachine: } } - void configure_as_target(const StaticAnalyser::Target &target) override { + void configure_as_target(const Analyser::Static::Target &target) override { // Add a disk cartridge if any disks were supplied. if(!target.media.disks.empty()) { map(2, 0, 0x4000, 0x2000); @@ -179,22 +179,22 @@ class ConcreteMachine: // Attach the hardware necessary for a game cartridge, if any. switch(target.msx.cartridge_type) { default: break; - case StaticAnalyser::MSXCartridgeType::Konami: + case Analyser::Static::MSXCartridgeType::Konami: memory_slots_[1].set_handler(new Cartridge::KonamiROMSlotHandler(*this, 1)); break; - case StaticAnalyser::MSXCartridgeType::KonamiWithSCC: + case Analyser::Static::MSXCartridgeType::KonamiWithSCC: memory_slots_[1].set_handler(new Cartridge::KonamiWithSCCROMSlotHandler(*this, 1, scc_)); break; - case StaticAnalyser::MSXCartridgeType::ASCII8kb: + case Analyser::Static::MSXCartridgeType::ASCII8kb: memory_slots_[1].set_handler(new Cartridge::ASCII8kbROMSlotHandler(*this, 1)); break; - case StaticAnalyser::MSXCartridgeType::ASCII16kb: + case Analyser::Static::MSXCartridgeType::ASCII16kb: memory_slots_[1].set_handler(new Cartridge::ASCII16kbROMSlotHandler(*this, 1)); break; } } - bool insert_media(const StaticAnalyser::Media &media) override { + bool insert_media(const Analyser::Static::Media &media) override { if(!media.cartridges.empty()) { const auto &segment = media.cartridges.front()->get_segments().front(); memory_slots_[1].source = segment.data; diff --git a/Machines/MSX/ROMSlotHandler.hpp b/Machines/MSX/ROMSlotHandler.hpp index ba62db932..6d3c53b0f 100644 --- a/Machines/MSX/ROMSlotHandler.hpp +++ b/Machines/MSX/ROMSlotHandler.hpp @@ -10,7 +10,7 @@ #define ROMSlotHandler_hpp #include "../../ClockReceiver/ClockReceiver.hpp" -#include "../../DynamicAnalyser/ConfidenceCounter.hpp" +#include "../../Analyser/Dynamic/ConfidenceCounter.hpp" #include #include diff --git a/Machines/Oric/Oric.cpp b/Machines/Oric/Oric.cpp index 63e7abb5c..6a0e42b27 100644 --- a/Machines/Oric/Oric.cpp +++ b/Machines/Oric/Oric.cpp @@ -254,7 +254,7 @@ class ConcreteMachine: } // to satisfy ConfigurationTarget::Machine - void configure_as_target(const StaticAnalyser::Target &target) override final { + void configure_as_target(const Analyser::Static::Target &target) override final { if(target.oric.has_microdisc) { microdisc_is_enabled_ = true; microdisc_did_change_paging_flags(µdisc_); @@ -284,7 +284,7 @@ class ConcreteMachine: insert_media(target.media); } - bool insert_media(const StaticAnalyser::Media &media) override final { + bool insert_media(const Analyser::Static::Media &media) override final { if(media.tapes.size()) { tape_player_.set_tape(media.tapes.front()); } diff --git a/Machines/Utility/MachineForTarget.cpp b/Machines/Utility/MachineForTarget.cpp index ef96f1d15..78f962495 100644 --- a/Machines/Utility/MachineForTarget.cpp +++ b/Machines/Utility/MachineForTarget.cpp @@ -18,44 +18,44 @@ #include "TypedDynamicMachine.hpp" -::Machine::DynamicMachine *::Machine::MachineForTargets(const std::vector &targets) { +::Machine::DynamicMachine *::Machine::MachineForTargets(const std::vector &targets) { // TODO: deal with target lists containing more than one machine. switch(targets.front().machine) { - case StaticAnalyser::Target::AmstradCPC: return new TypedDynamicMachine(AmstradCPC::Machine::AmstradCPC()); - case StaticAnalyser::Target::Atari2600: return new TypedDynamicMachine(Atari2600::Machine::Atari2600()); - case StaticAnalyser::Target::Electron: return new TypedDynamicMachine(Electron::Machine::Electron()); - case StaticAnalyser::Target::MSX: return new TypedDynamicMachine(MSX::Machine::MSX()); - case StaticAnalyser::Target::Oric: return new TypedDynamicMachine(Oric::Machine::Oric()); - case StaticAnalyser::Target::Vic20: return new TypedDynamicMachine(Commodore::Vic20::Machine::Vic20()); - case StaticAnalyser::Target::ZX8081: return new TypedDynamicMachine(ZX8081::Machine::ZX8081(targets.front())); + case Analyser::Machine::AmstradCPC: return new TypedDynamicMachine(AmstradCPC::Machine::AmstradCPC()); + case Analyser::Machine::Atari2600: return new TypedDynamicMachine(Atari2600::Machine::Atari2600()); + case Analyser::Machine::Electron: return new TypedDynamicMachine(Electron::Machine::Electron()); + case Analyser::Machine::MSX: return new TypedDynamicMachine(MSX::Machine::MSX()); + case Analyser::Machine::Oric: return new TypedDynamicMachine(Oric::Machine::Oric()); + case Analyser::Machine::Vic20: return new TypedDynamicMachine(Commodore::Vic20::Machine::Vic20()); + case Analyser::Machine::ZX8081: return new TypedDynamicMachine(ZX8081::Machine::ZX8081(targets.front())); default: return nullptr; } } -std::string Machine::ShortNameForTargetMachine(const StaticAnalyser::Target::Machine machine) { +std::string Machine::ShortNameForTargetMachine(const Analyser::Machine machine) { switch(machine) { - case StaticAnalyser::Target::AmstradCPC: return "AmstradCPC"; - case StaticAnalyser::Target::Atari2600: return "Atari2600"; - case StaticAnalyser::Target::Electron: return "Electron"; - case StaticAnalyser::Target::MSX: return "MSX"; - case StaticAnalyser::Target::Oric: return "Oric"; - case StaticAnalyser::Target::Vic20: return "Vic20"; - case StaticAnalyser::Target::ZX8081: return "ZX8081"; + case Analyser::Machine::AmstradCPC: return "AmstradCPC"; + case Analyser::Machine::Atari2600: return "Atari2600"; + case Analyser::Machine::Electron: return "Electron"; + case Analyser::Machine::MSX: return "MSX"; + case Analyser::Machine::Oric: return "Oric"; + case Analyser::Machine::Vic20: return "Vic20"; + case Analyser::Machine::ZX8081: return "ZX8081"; default: return ""; } } -std::string Machine::LongNameForTargetMachine(StaticAnalyser::Target::Machine machine) { +std::string Machine::LongNameForTargetMachine(Analyser::Machine machine) { switch(machine) { - case StaticAnalyser::Target::AmstradCPC: return "Amstrad CPC"; - case StaticAnalyser::Target::Atari2600: return "Atari 2600"; - case StaticAnalyser::Target::Electron: return "Acorn Electron"; - case StaticAnalyser::Target::MSX: return "MSX"; - case StaticAnalyser::Target::Oric: return "Oric"; - case StaticAnalyser::Target::Vic20: return "Vic 20"; - case StaticAnalyser::Target::ZX8081: return "ZX80/81"; + case Analyser::Machine::AmstradCPC: return "Amstrad CPC"; + case Analyser::Machine::Atari2600: return "Atari 2600"; + case Analyser::Machine::Electron: return "Acorn Electron"; + case Analyser::Machine::MSX: return "MSX"; + case Analyser::Machine::Oric: return "Oric"; + case Analyser::Machine::Vic20: return "Vic 20"; + case Analyser::Machine::ZX8081: return "ZX80/81"; default: return ""; } @@ -64,11 +64,11 @@ std::string Machine::LongNameForTargetMachine(StaticAnalyser::Target::Machine ma std::map>> Machine::AllOptionsByMachineName() { std::map>> options; - options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Electron), Electron::get_options())); - options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::MSX), MSX::get_options())); - options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Oric), Oric::get_options())); - options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::Vic20), Commodore::Vic20::get_options())); - options.emplace(std::make_pair(LongNameForTargetMachine(StaticAnalyser::Target::ZX8081), ZX8081::get_options())); + options.emplace(std::make_pair(LongNameForTargetMachine(Analyser::Machine::Electron), Electron::get_options())); + options.emplace(std::make_pair(LongNameForTargetMachine(Analyser::Machine::MSX), MSX::get_options())); + options.emplace(std::make_pair(LongNameForTargetMachine(Analyser::Machine::Oric), Oric::get_options())); + options.emplace(std::make_pair(LongNameForTargetMachine(Analyser::Machine::Vic20), Commodore::Vic20::get_options())); + options.emplace(std::make_pair(LongNameForTargetMachine(Analyser::Machine::ZX8081), ZX8081::get_options())); return options; } diff --git a/Machines/Utility/MachineForTarget.hpp b/Machines/Utility/MachineForTarget.hpp index 95f0ef035..0b04e3853 100644 --- a/Machines/Utility/MachineForTarget.hpp +++ b/Machines/Utility/MachineForTarget.hpp @@ -9,7 +9,7 @@ #ifndef MachineForTarget_hpp #define MachineForTarget_hpp -#include "../../StaticAnalyser/StaticAnalyser.hpp" +#include "../../Analyser/Static/StaticAnalyser.hpp" #include "../../Configurable/Configurable.hpp" #include "../ConfigurationTarget.hpp" @@ -42,20 +42,20 @@ struct DynamicMachine { receive the supplied static analyser result. The machine has been allocated on the heap. It is the caller's responsibility to delete the class when finished. */ -DynamicMachine *MachineForTargets(const std::vector &target); +DynamicMachine *MachineForTargets(const std::vector &target); /*! Returns a short string name for the machine identified by the target, which is guaranteed not to have any spaces or other potentially filesystem-bothering contents. */ -std::string ShortNameForTargetMachine(const StaticAnalyser::Target::Machine target); +std::string ShortNameForTargetMachine(const Analyser::Machine target); /*! Returns a long string name for the machine identified by the target, usable for presentation to a human. */ -std::string LongNameForTargetMachine(const StaticAnalyser::Target::Machine target); +std::string LongNameForTargetMachine(const Analyser::Machine target); /*! Returns a map from machine name to the list of options that machine diff --git a/Machines/ZX8081/ZX8081.cpp b/Machines/ZX8081/ZX8081.cpp index 3061726af..6906915c4 100644 --- a/Machines/ZX8081/ZX8081.cpp +++ b/Machines/ZX8081/ZX8081.cpp @@ -238,7 +238,7 @@ template class ConcreteMachine: z80_.run_for(cycles); } - void configure_as_target(const StaticAnalyser::Target &target) override final { + void configure_as_target(const Analyser::Static::Target &target) override final { is_zx81_ = target.zx8081.isZX81; if(is_zx81_) { rom_ = zx81_rom_; @@ -260,17 +260,17 @@ template class ConcreteMachine: rom_mask_ = static_cast(rom_.size() - 1); switch(target.zx8081.memory_model) { - case StaticAnalyser::ZX8081MemoryModel::Unexpanded: + case Analyser::Static::ZX8081MemoryModel::Unexpanded: ram_.resize(1024); ram_base_ = 16384; ram_mask_ = 1023; break; - case StaticAnalyser::ZX8081MemoryModel::SixteenKB: + case Analyser::Static::ZX8081MemoryModel::SixteenKB: ram_.resize(16384); ram_base_ = 16384; ram_mask_ = 16383; break; - case StaticAnalyser::ZX8081MemoryModel::SixtyFourKB: + case Analyser::Static::ZX8081MemoryModel::SixtyFourKB: ram_.resize(65536); ram_base_ = 8192; ram_mask_ = 65535; @@ -285,7 +285,7 @@ template class ConcreteMachine: insert_media(target.media); } - bool insert_media(const StaticAnalyser::Media &media) override final { + bool insert_media(const Analyser::Static::Media &media) override final { if(!media.tapes.empty()) { tape_player_.set_tape(media.tapes.front()); } @@ -442,7 +442,7 @@ template class ConcreteMachine: using namespace ZX8081; // See header; constructs and returns an instance of the ZX80 or 81. -Machine *Machine::ZX8081(const StaticAnalyser::Target &target_hint) { +Machine *Machine::ZX8081(const Analyser::Static::Target &target_hint) { // Instantiate the correct type of machine. if(target_hint.zx8081.isZX81) return new ZX8081::ConcreteMachine(); diff --git a/Machines/ZX8081/ZX8081.hpp b/Machines/ZX8081/ZX8081.hpp index 6f70a03c1..14993c44e 100644 --- a/Machines/ZX8081/ZX8081.hpp +++ b/Machines/ZX8081/ZX8081.hpp @@ -27,7 +27,7 @@ class Machine: public: virtual ~Machine(); - static Machine *ZX8081(const StaticAnalyser::Target &target_hint); + static Machine *ZX8081(const Analyser::Static::Target &target_hint); virtual void set_tape_is_playing(bool is_playing) = 0; }; diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj index 8bc87dc20..994095090 100644 --- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj +++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj @@ -11,20 +11,6 @@ 4B049CDD1DA3C82F00322067 /* BCDTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B049CDC1DA3C82F00322067 /* BCDTest.swift */; }; 4B055A7A1FAE78A00060FFFF /* SDL2.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4B055A771FAE78210060FFFF /* SDL2.framework */; }; 4B055A7E1FAE84AA0060FFFF /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B055A7C1FAE84A50060FFFF /* main.cpp */; }; - 4B055A7F1FAE852F0060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF1354A1D6D2C300054B2EA /* StaticAnalyser.cpp */; }; - 4B055A801FAE85350060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BA799931D8B656E0045123D /* StaticAnalyser.cpp */; }; - 4B055A811FAE853A0060FFFF /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF829641D8F732B001BAE39 /* Disk.cpp */; }; - 4B055A821FAE853D0060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD14B0F1D74627C0088EAD6 /* StaticAnalyser.cpp */; }; - 4B055A831FAE85410060FFFF /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B96F7201D75119A0058BB2D /* Tape.cpp */; }; - 4B055A841FAE85450060FFFF /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BA22B051D8817CE0008C640 /* Disk.cpp */; }; - 4B055A851FAE85480060FFFF /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE77A2C1D84ADFB00BC3827 /* File.cpp */; }; - 4B055A861FAE854C0060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC5E4901D7ED365008CF980 /* StaticAnalyser.cpp */; }; - 4B055A871FAE854F0060FFFF /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC830CF1D6E7C690000A26F /* Tape.cpp */; }; - 4B055A881FAE85530060FFFF /* 6502.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5A12551DD55862007A2231 /* 6502.cpp */; }; - 4B055A891FAE85580060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCF1FA91DADD41B0039D2E7 /* StaticAnalyser.cpp */; }; - 4B055A8A1FAE855B0060FFFF /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805FC1DD02552003085B1 /* Tape.cpp */; }; - 4B055A8B1FAE85670060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B1497891EE4AC5E00CE2596 /* StaticAnalyser.cpp */; }; - 4B055A8C1FAE85670060FFFF /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B38F3421F2EB3E900D9235D /* StaticAnalyser.cpp */; }; 4B055A8D1FAE85920060FFFF /* AsyncTaskQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B3940E51DA83C8300427841 /* AsyncTaskQueue.cpp */; }; 4B055A8E1FAE85920060FFFF /* BestEffortUpdater.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B80ACFE1F85CAC900176895 /* BestEffortUpdater.cpp */; }; 4B055A8F1FAE85A90060FFFF /* FileHolder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5FADB81DE3151600AEC565 /* FileHolder.cpp */; }; @@ -130,9 +116,7 @@ 4B0CCC451C62D0B3001CAC5F /* CRT.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0CCC421C62D0B3001CAC5F /* CRT.cpp */; }; 4B0E04EA1FC9E5DA00F43484 /* CAS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04E81FC9E5DA00F43484 /* CAS.cpp */; }; 4B0E04EB1FC9E78800F43484 /* CAS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04E81FC9E5DA00F43484 /* CAS.cpp */; }; - 4B0E04EE1FC9E88300F43484 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04EC1FC9E88300F43484 /* StaticAnalyser.cpp */; }; 4B0E04F11FC9EA9500F43484 /* MSX.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B79A4FF1FC913C900EEDAD5 /* MSX.cpp */; }; - 4B0E04F21FC9EAA800F43484 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04EC1FC9E88300F43484 /* StaticAnalyser.cpp */; }; 4B0E04FA1FC9FA3100F43484 /* 9918.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04F91FC9FA3100F43484 /* 9918.cpp */; }; 4B0E04FB1FC9FA3100F43484 /* 9918.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E04F91FC9FA3100F43484 /* 9918.cpp */; }; 4B0E61071FF34737002A9DBD /* MSX.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E61051FF34737002A9DBD /* MSX.cpp */; }; @@ -143,7 +127,6 @@ 4B1414601B58885000E04248 /* WolfgangLorenzTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B14145F1B58885000E04248 /* WolfgangLorenzTests.swift */; }; 4B1414621B58888700E04248 /* KlausDormannTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B1414611B58888700E04248 /* KlausDormannTests.swift */; }; 4B1497881EE4A1DA00CE2596 /* ZX80O81P.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B1497861EE4A1DA00CE2596 /* ZX80O81P.cpp */; }; - 4B14978B1EE4AC5E00CE2596 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B1497891EE4AC5E00CE2596 /* StaticAnalyser.cpp */; }; 4B14978F1EE4B4D200CE2596 /* CSZX8081.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B14978E1EE4B4D200CE2596 /* CSZX8081.mm */; }; 4B1497921EE4B5A800CE2596 /* ZX8081.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B1497901EE4B5A800CE2596 /* ZX8081.cpp */; }; 4B1497981EE4B97F00CE2596 /* ZX8081Options.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B1497961EE4B97F00CE2596 /* ZX8081Options.xib */; }; @@ -164,13 +147,11 @@ 4B2C45421E3C3896002A2389 /* cartridge.png in Resources */ = {isa = PBXBuildFile; fileRef = 4B2C45411E3C3896002A2389 /* cartridge.png */; }; 4B2E2D9A1C3A06EC00138695 /* Atari2600.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2E2D971C3A06EC00138695 /* Atari2600.cpp */; }; 4B2E2D9D1C3A070400138695 /* Electron.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2E2D9B1C3A070400138695 /* Electron.cpp */; }; - 4B2F67F12018312F00251FB5 /* Z80.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9C9D731FF81CC00030A129 /* Z80.cpp */; }; 4B30512D1D989E2200B4FED8 /* Drive.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B30512B1D989E2200B4FED8 /* Drive.cpp */; }; 4B3051301D98ACC600B4FED8 /* Plus3.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B30512E1D98ACC600B4FED8 /* Plus3.cpp */; }; 4B322E011F5A2990004EB04C /* Z80AllRAM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B322DFD1F5A2981004EB04C /* Z80AllRAM.cpp */; }; 4B322E041F5A2E3C004EB04C /* Z80Base.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B322E031F5A2E3C004EB04C /* Z80Base.cpp */; }; 4B37EE821D7345A6006A09A4 /* BinaryDump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B37EE801D7345A6006A09A4 /* BinaryDump.cpp */; }; - 4B38F3441F2EB3E900D9235D /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B38F3421F2EB3E900D9235D /* StaticAnalyser.cpp */; }; 4B38F3481F2EC11D00D9235D /* AmstradCPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B38F3461F2EC11D00D9235D /* AmstradCPC.cpp */; }; 4B38F34F1F2EC6BA00D9235D /* AmstradCPCOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B38F34D1F2EC6BA00D9235D /* AmstradCPCOptions.xib */; }; 4B3940E71DA83C8300427841 /* AsyncTaskQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B3940E51DA83C8300427841 /* AsyncTaskQueue.cpp */; }; @@ -213,21 +194,14 @@ 4B54C0C51F8D91D90050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0C41F8D91D90050900F /* Keyboard.cpp */; }; 4B54C0C81F8D91E50050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0C61F8D91E50050900F /* Keyboard.cpp */; }; 4B54C0CB1F8D92590050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0CA1F8D92580050900F /* Keyboard.cpp */; }; - 4B5539FF201583AD00027510 /* ConfidenceCounter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5539FD201583AD00027510 /* ConfidenceCounter.cpp */; }; - 4B553A00201583AD00027510 /* ConfidenceCounter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5539FD201583AD00027510 /* ConfidenceCounter.cpp */; }; - 4B553A032015855900027510 /* ConfidenceSummary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B553A012015855900027510 /* ConfidenceSummary.cpp */; }; - 4B553A042015855900027510 /* ConfidenceSummary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B553A012015855900027510 /* ConfidenceSummary.cpp */; }; 4B55CE5D1C3B7D6F0093A61B /* CSOpenGLView.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B55CE5C1C3B7D6F0093A61B /* CSOpenGLView.m */; }; 4B55CE5F1C3B7D960093A61B /* MachineDocument.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B55CE5E1C3B7D960093A61B /* MachineDocument.swift */; }; 4B58601E1F806AB200AEE2E3 /* MFMSectorDump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B58601C1F806AB200AEE2E3 /* MFMSectorDump.cpp */; }; 4B59199C1DAC6C46005BB85C /* OricTAP.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B59199A1DAC6C46005BB85C /* OricTAP.cpp */; }; - 4B5A12571DD55862007A2231 /* 6502.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5A12551DD55862007A2231 /* 6502.cpp */; }; 4B5FADBA1DE3151600AEC565 /* FileHolder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5FADB81DE3151600AEC565 /* FileHolder.cpp */; }; 4B5FADC01DE3BF2B00AEC565 /* Microdisc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B5FADBE1DE3BF2B00AEC565 /* Microdisc.cpp */; }; 4B643F3A1D77AD1900D431D6 /* CSStaticAnalyser.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B643F391D77AD1900D431D6 /* CSStaticAnalyser.mm */; }; 4B643F3F1D77B88000D431D6 /* DocumentController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B643F3E1D77B88000D431D6 /* DocumentController.swift */; }; - 4B651F9E1FF1B04100E18D9A /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B651F9C1FF1B04100E18D9A /* Tape.cpp */; }; - 4B651F9F1FF1B2AE00E18D9A /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B651F9C1FF1B04100E18D9A /* Tape.cpp */; }; 4B69FB3D1C4D908A00B5F0AA /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B69FB3B1C4D908A00B5F0AA /* Tape.cpp */; }; 4B69FB441C4D941400B5F0AA /* TapeUEF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B69FB421C4D941400B5F0AA /* TapeUEF.cpp */; }; 4B69FB461C4D950F00B5F0AA /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 4B69FB451C4D950F00B5F0AA /* libz.tbd */; }; @@ -255,8 +229,47 @@ 4B8805F41DCFD22A003085B1 /* Commodore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805F21DCFD22A003085B1 /* Commodore.cpp */; }; 4B8805F71DCFF6C9003085B1 /* Commodore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805F51DCFF6C9003085B1 /* Commodore.cpp */; }; 4B8805FB1DCFF807003085B1 /* Oric.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805F91DCFF807003085B1 /* Oric.cpp */; }; - 4B8805FE1DD02552003085B1 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8805FC1DD02552003085B1 /* Tape.cpp */; }; 4B89449520194CB3007DE474 /* MachineForTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B055ABE1FAE98000060FFFF /* MachineForTarget.cpp */; }; + 4B894518201967B4007DE474 /* ConfidenceCounter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944E6201967B4007DE474 /* ConfidenceCounter.cpp */; }; + 4B894519201967B4007DE474 /* ConfidenceCounter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944E6201967B4007DE474 /* ConfidenceCounter.cpp */; }; + 4B89451A201967B4007DE474 /* ConfidenceSummary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944E8201967B4007DE474 /* ConfidenceSummary.cpp */; }; + 4B89451B201967B4007DE474 /* ConfidenceSummary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944E8201967B4007DE474 /* ConfidenceSummary.cpp */; }; + 4B89451C201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944EC201967B4007DE474 /* Disk.cpp */; }; + 4B89451D201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944EC201967B4007DE474 /* Disk.cpp */; }; + 4B89451E201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F0201967B4007DE474 /* Tape.cpp */; }; + 4B89451F201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F0201967B4007DE474 /* Tape.cpp */; }; + 4B894520201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F2201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894521201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F2201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894522201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F5201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894523201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F5201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894524201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F9201967B4007DE474 /* Tape.cpp */; }; + 4B894525201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944F9201967B4007DE474 /* Tape.cpp */; }; + 4B894526201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FA201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894527201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FA201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894528201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; }; + 4B894529201967B4007DE474 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; }; + 4B89452A201967B4007DE474 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; }; + 4B89452B201967B4007DE474 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; }; + 4B89452C201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; }; + 4B89452D201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; }; + 4B89452E201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894503201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89452F201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894503201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894530201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894506201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894531201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894506201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B894532201967B4007DE474 /* 6502.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450B201967B4007DE474 /* 6502.cpp */; }; + 4B894533201967B4007DE474 /* 6502.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450B201967B4007DE474 /* 6502.cpp */; }; + 4B894534201967B4007DE474 /* AddressMapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450C201967B4007DE474 /* AddressMapper.cpp */; }; + 4B894535201967B4007DE474 /* AddressMapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450C201967B4007DE474 /* AddressMapper.cpp */; }; + 4B894536201967B4007DE474 /* Z80.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450D201967B4007DE474 /* Z80.cpp */; }; + 4B894537201967B4007DE474 /* Z80.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B89450D201967B4007DE474 /* Z80.cpp */; }; + 4B894538201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894512201967B4007DE474 /* Tape.cpp */; }; + 4B894539201967B4007DE474 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894512201967B4007DE474 /* Tape.cpp */; }; + 4B89453A201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894513201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89453B201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894513201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89453C201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894516201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89453D201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894516201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89453E201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894517201967B4007DE474 /* StaticAnalyser.cpp */; }; + 4B89453F201967B4007DE474 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894517201967B4007DE474 /* StaticAnalyser.cpp */; }; 4B8FE21B1DA19D5F0090D3CE /* Atari2600Options.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B8FE2131DA19D5F0090D3CE /* Atari2600Options.xib */; }; 4B8FE21C1DA19D5F0090D3CE /* MachineDocument.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B8FE2151DA19D5F0090D3CE /* MachineDocument.xib */; }; 4B8FE21D1DA19D5F0090D3CE /* QuickLoadCompositeOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B8FE2171DA19D5F0090D3CE /* QuickLoadCompositeOptions.xib */; }; @@ -268,18 +281,13 @@ 4B9252CE1E74D28200B76AF1 /* Atari ROMs in Resources */ = {isa = PBXBuildFile; fileRef = 4B9252CD1E74D28200B76AF1 /* Atari ROMs */; }; 4B92EACA1B7C112B00246143 /* 6502TimingTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B92EAC91B7C112B00246143 /* 6502TimingTests.swift */; }; 4B95FA9D1F11893B0008E395 /* ZX8081OptionsPanel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B95FA9C1F11893B0008E395 /* ZX8081OptionsPanel.swift */; }; - 4B96F7221D75119A0058BB2D /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B96F7201D75119A0058BB2D /* Tape.cpp */; }; 4B98A05E1FFAD3F600ADF63B /* CSROMFetcher.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B98A05D1FFAD3F600ADF63B /* CSROMFetcher.mm */; }; 4B98A05F1FFAD62400ADF63B /* CSROMFetcher.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B98A05D1FFAD3F600ADF63B /* CSROMFetcher.mm */; }; 4B98A0611FFADCDE00ADF63B /* MSXStaticAnalyserTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B98A0601FFADCDE00ADF63B /* MSXStaticAnalyserTests.mm */; }; 4B98A1CE1FFADEC500ADF63B /* MSX ROMs in Resources */ = {isa = PBXBuildFile; fileRef = 4B98A1CD1FFADEC400ADF63B /* MSX ROMs */; }; - 4B9C9D751FF81CC00030A129 /* Z80.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9C9D731FF81CC00030A129 /* Z80.cpp */; }; - 4B9C9D781FF81ED30030A129 /* AddressMapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9C9D761FF81ED30030A129 /* AddressMapper.cpp */; }; 4B9CCDA11DA279CA0098B625 /* Vic20OptionsPanel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B9CCDA01DA279CA0098B625 /* Vic20OptionsPanel.swift */; }; 4BA0F68E1EEA0E8400E9489E /* ZX8081.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BA0F68C1EEA0E8400E9489E /* ZX8081.cpp */; }; - 4BA22B071D8817CE0008C640 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BA22B051D8817CE0008C640 /* Disk.cpp */; }; 4BA61EB01D91515900B3C876 /* NSData+StdVector.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BA61EAF1D91515900B3C876 /* NSData+StdVector.mm */; }; - 4BA799951D8B656E0045123D /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BA799931D8B656E0045123D /* StaticAnalyser.cpp */; }; 4BAD13441FF709C700FD114A /* MSX.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B0E61051FF34737002A9DBD /* MSX.cpp */; }; 4BAF2B4E2004580C00480230 /* DMK.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BAF2B4C2004580C00480230 /* DMK.cpp */; }; 4BAF2B4F2004580C00480230 /* DMK.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BAF2B4C2004580C00480230 /* DMK.cpp */; }; @@ -568,25 +576,20 @@ 4BBFFEE61F7B27F1005F3FEB /* TrackSerialiser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBFFEE51F7B27F1005F3FEB /* TrackSerialiser.cpp */; }; 4BC3B74F1CD194CC00F86E85 /* Shader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B74D1CD194CC00F86E85 /* Shader.cpp */; }; 4BC3B7521CD1956900F86E85 /* OutputShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B7501CD1956900F86E85 /* OutputShader.cpp */; }; - 4BC5E4921D7ED365008CF980 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC5E4901D7ED365008CF980 /* StaticAnalyser.cpp */; }; 4BC751B21D157E61006C31D9 /* 6522Tests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BC751B11D157E61006C31D9 /* 6522Tests.swift */; }; 4BC76E691C98E31700E6EF73 /* FIRFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC76E671C98E31700E6EF73 /* FIRFilter.cpp */; }; 4BC76E6B1C98F43700E6EF73 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */; }; - 4BC830D11D6E7C690000A26F /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC830CF1D6E7C690000A26F /* Tape.cpp */; }; 4BC91B831D1F160E00884B76 /* CommodoreTAP.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC91B811D1F160E00884B76 /* CommodoreTAP.cpp */; }; 4BC9DF451D044FCA00F44158 /* ROMImages in Resources */ = {isa = PBXBuildFile; fileRef = 4BC9DF441D044FCA00F44158 /* ROMImages */; }; 4BC9DF4F1D04691600F44158 /* 6560.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC9DF4D1D04691600F44158 /* 6560.cpp */; }; 4BC9E1EE1D23449A003FCEE4 /* 6502InterruptTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BC9E1ED1D23449A003FCEE4 /* 6502InterruptTests.swift */; }; 4BCA6CC81D9DD9F000C2D7B2 /* CommodoreROM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCA6CC61D9DD9F000C2D7B2 /* CommodoreROM.cpp */; }; 4BCF1FA41DADC3DD0039D2E7 /* Oric.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCF1FA21DADC3DD0039D2E7 /* Oric.cpp */; }; - 4BCF1FAB1DADD41B0039D2E7 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCF1FA91DADD41B0039D2E7 /* StaticAnalyser.cpp */; }; - 4BD14B111D74627C0088EAD6 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD14B0F1D74627C0088EAD6 /* StaticAnalyser.cpp */; }; 4BD3A30B1EE755C800B5B501 /* Video.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD3A3091EE755C800B5B501 /* Video.cpp */; }; 4BD468F71D8DF41D0084958B /* 1770.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD468F51D8DF41D0084958B /* 1770.cpp */; }; 4BD4A8D01E077FD20020D856 /* PCMTrackTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4A8CF1E077FD20020D856 /* PCMTrackTests.mm */; }; 4BD5F1951D13528900631CD1 /* CSBestEffortUpdater.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BD5F1941D13528900631CD1 /* CSBestEffortUpdater.mm */; }; 4BDDBA991EF3451200347E61 /* Z80MachineCycleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BDDBA981EF3451200347E61 /* Z80MachineCycleTests.swift */; }; - 4BE77A2E1D84ADFB00BC3827 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE77A2C1D84ADFB00BC3827 /* File.cpp */; }; 4BE7C9181E3D397100A5496D /* TIA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE7C9161E3D397100A5496D /* TIA.cpp */; }; 4BE9A6B11EDE293000CBCB47 /* zexdoc.com in Resources */ = {isa = PBXBuildFile; fileRef = 4BE9A6B01EDE293000CBCB47 /* zexdoc.com */; }; 4BEA525E1DF33323007E74F2 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BEA525D1DF33323007E74F2 /* Tape.cpp */; }; @@ -600,8 +603,6 @@ 4BEE0A701D72496600532C7B /* PRG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BEE0A6D1D72496600532C7B /* PRG.cpp */; }; 4BEF6AAA1D35CE9E00E73575 /* DigitalPhaseLockedLoopBridge.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BEF6AA91D35CE9E00E73575 /* DigitalPhaseLockedLoopBridge.mm */; }; 4BEF6AAC1D35D1C400E73575 /* DPLLTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BEF6AAB1D35D1C400E73575 /* DPLLTests.swift */; }; - 4BF1354C1D6D2C300054B2EA /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF1354A1D6D2C300054B2EA /* StaticAnalyser.cpp */; }; - 4BF829661D8F732B001BAE39 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF829641D8F732B001BAE39 /* Disk.cpp */; }; 4BFCA1241ECBDCB400AC40C1 /* AllRAMProcessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFCA1211ECBDCAF00AC40C1 /* AllRAMProcessor.cpp */; }; 4BFCA1271ECBE33200AC40C1 /* TestMachineZ80.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BFCA1261ECBE33200AC40C1 /* TestMachineZ80.mm */; }; 4BFCA1291ECBE7A700AC40C1 /* zexall.com in Resources */ = {isa = PBXBuildFile; fileRef = 4BFCA1281ECBE7A700AC40C1 /* zexall.com */; }; @@ -660,8 +661,6 @@ 4B0CCC431C62D0B3001CAC5F /* CRT.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = CRT.hpp; sourceTree = ""; }; 4B0E04E81FC9E5DA00F43484 /* CAS.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CAS.cpp; sourceTree = ""; }; 4B0E04E91FC9E5DA00F43484 /* CAS.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = CAS.hpp; sourceTree = ""; }; - 4B0E04EC1FC9E88300F43484 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/MSX/StaticAnalyser.cpp; sourceTree = ""; }; - 4B0E04ED1FC9E88300F43484 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/MSX/StaticAnalyser.hpp; sourceTree = ""; }; 4B0E04F81FC9FA3000F43484 /* 9918.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = 9918.hpp; path = 9918/9918.hpp; sourceTree = ""; }; 4B0E04F91FC9FA3100F43484 /* 9918.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = 9918.cpp; path = 9918/9918.cpp; sourceTree = ""; }; 4B0E61051FF34737002A9DBD /* MSX.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = MSX.cpp; path = Parsers/MSX.cpp; sourceTree = ""; }; @@ -675,8 +674,6 @@ 4B1414611B58888700E04248 /* KlausDormannTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = KlausDormannTests.swift; sourceTree = ""; }; 4B1497861EE4A1DA00CE2596 /* ZX80O81P.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ZX80O81P.cpp; sourceTree = ""; }; 4B1497871EE4A1DA00CE2596 /* ZX80O81P.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ZX80O81P.hpp; sourceTree = ""; }; - 4B1497891EE4AC5E00CE2596 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/ZX8081/StaticAnalyser.cpp; sourceTree = ""; }; - 4B14978A1EE4AC5E00CE2596 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/ZX8081/StaticAnalyser.hpp; sourceTree = ""; }; 4B14978D1EE4B4D200CE2596 /* CSZX8081.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSZX8081.h; sourceTree = ""; }; 4B14978E1EE4B4D200CE2596 /* CSZX8081.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CSZX8081.mm; sourceTree = ""; }; 4B1497901EE4B5A800CE2596 /* ZX8081.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ZX8081.cpp; path = ZX8081/ZX8081.cpp; sourceTree = ""; }; @@ -734,8 +731,6 @@ 4B322E051F5A30F5004EB04C /* Z80Implementation.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Z80Implementation.hpp; sourceTree = ""; }; 4B37EE801D7345A6006A09A4 /* BinaryDump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BinaryDump.cpp; sourceTree = ""; }; 4B37EE811D7345A6006A09A4 /* BinaryDump.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = BinaryDump.hpp; sourceTree = ""; }; - 4B38F3421F2EB3E900D9235D /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/AmstradCPC/StaticAnalyser.cpp; sourceTree = ""; }; - 4B38F3431F2EB3E900D9235D /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/AmstradCPC/StaticAnalyser.hpp; sourceTree = ""; }; 4B38F3461F2EC11D00D9235D /* AmstradCPC.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AmstradCPC.cpp; path = AmstradCPC/AmstradCPC.cpp; sourceTree = ""; }; 4B38F3471F2EC11D00D9235D /* AmstradCPC.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = AmstradCPC.hpp; path = AmstradCPC/AmstradCPC.hpp; sourceTree = ""; }; 4B38F34E1F2EC6BA00D9235D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = "Clock Signal/Base.lproj/AmstradCPCOptions.xib"; sourceTree = SOURCE_ROOT; }; @@ -806,7 +801,6 @@ 4B5073051DDD3B9400C48FBD /* ArrayBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ArrayBuilder.cpp; sourceTree = ""; }; 4B5073061DDD3B9400C48FBD /* ArrayBuilder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ArrayBuilder.hpp; sourceTree = ""; }; 4B5073091DDFCFDF00C48FBD /* ArrayBuilderTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ArrayBuilderTests.mm; sourceTree = ""; }; - 4B5342211FF9A30800D42660 /* Kernel.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = Kernel.hpp; path = ../../StaticAnalyser/Disassembler/Kernel.hpp; sourceTree = ""; }; 4B54C0BB1F8D8E790050900F /* KeyboardMachine.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = KeyboardMachine.cpp; sourceTree = ""; }; 4B54C0BD1F8D8F450050900F /* Keyboard.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Keyboard.cpp; path = Oric/Keyboard.cpp; sourceTree = ""; }; 4B54C0BE1F8D8F450050900F /* Keyboard.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = Keyboard.hpp; path = Oric/Keyboard.hpp; sourceTree = ""; }; @@ -818,11 +812,6 @@ 4B54C0C71F8D91E50050900F /* Keyboard.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Keyboard.hpp; path = Electron/Keyboard.hpp; sourceTree = ""; }; 4B54C0C91F8D92580050900F /* Keyboard.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Keyboard.hpp; path = ZX8081/Keyboard.hpp; sourceTree = ""; }; 4B54C0CA1F8D92580050900F /* Keyboard.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Keyboard.cpp; path = ZX8081/Keyboard.cpp; sourceTree = ""; }; - 4B5539F62015820B00027510 /* ConfidenceSource.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceSource.hpp; sourceTree = ""; }; - 4B5539FD201583AD00027510 /* ConfidenceCounter.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ConfidenceCounter.cpp; sourceTree = ""; }; - 4B5539FE201583AD00027510 /* ConfidenceCounter.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceCounter.hpp; sourceTree = ""; }; - 4B553A012015855900027510 /* ConfidenceSummary.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ConfidenceSummary.cpp; sourceTree = ""; }; - 4B553A022015855900027510 /* ConfidenceSummary.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceSummary.hpp; sourceTree = ""; }; 4B55CE5B1C3B7D6F0093A61B /* CSOpenGLView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSOpenGLView.h; sourceTree = ""; }; 4B55CE5C1C3B7D6F0093A61B /* CSOpenGLView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSOpenGLView.m; sourceTree = ""; }; 4B55CE5E1C3B7D960093A61B /* MachineDocument.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MachineDocument.swift; sourceTree = ""; }; @@ -830,8 +819,6 @@ 4B58601D1F806AB200AEE2E3 /* MFMSectorDump.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = MFMSectorDump.hpp; sourceTree = ""; }; 4B59199A1DAC6C46005BB85C /* OricTAP.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OricTAP.cpp; sourceTree = ""; }; 4B59199B1DAC6C46005BB85C /* OricTAP.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = OricTAP.hpp; sourceTree = ""; }; - 4B5A12551DD55862007A2231 /* 6502.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = 6502.cpp; path = ../../StaticAnalyser/Disassembler/6502.cpp; sourceTree = ""; }; - 4B5A12561DD55862007A2231 /* 6502.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = 6502.hpp; path = ../../StaticAnalyser/Disassembler/6502.hpp; sourceTree = ""; }; 4B5FADB81DE3151600AEC565 /* FileHolder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileHolder.cpp; sourceTree = ""; }; 4B5FADB91DE3151600AEC565 /* FileHolder.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = FileHolder.hpp; sourceTree = ""; }; 4B5FADBE1DE3BF2B00AEC565 /* Microdisc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Microdisc.cpp; path = Oric/Microdisc.cpp; sourceTree = ""; }; @@ -840,8 +827,6 @@ 4B643F391D77AD1900D431D6 /* CSStaticAnalyser.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = CSStaticAnalyser.mm; path = StaticAnalyser/CSStaticAnalyser.mm; sourceTree = ""; }; 4B643F3C1D77AE5C00D431D6 /* CSMachine+Target.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "CSMachine+Target.h"; sourceTree = ""; }; 4B643F3E1D77B88000D431D6 /* DocumentController.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DocumentController.swift; sourceTree = ""; }; - 4B651F9C1FF1B04100E18D9A /* Tape.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Tape.cpp; path = ../../StaticAnalyser/MSX/Tape.cpp; sourceTree = ""; }; - 4B651F9D1FF1B04100E18D9A /* Tape.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = Tape.hpp; path = ../../StaticAnalyser/MSX/Tape.hpp; sourceTree = ""; }; 4B698D1A1FE768A100696C91 /* SampleSource.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = SampleSource.hpp; sourceTree = ""; }; 4B69FB3B1C4D908A00B5F0AA /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = ""; }; 4B69FB3C1C4D908A00B5F0AA /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = ""; }; @@ -896,9 +881,51 @@ 4B8805F61DCFF6C9003085B1 /* Commodore.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Commodore.hpp; path = Data/Commodore.hpp; sourceTree = ""; }; 4B8805F91DCFF807003085B1 /* Oric.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Oric.cpp; path = Parsers/Oric.cpp; sourceTree = ""; }; 4B8805FA1DCFF807003085B1 /* Oric.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Oric.hpp; path = Parsers/Oric.hpp; sourceTree = ""; }; - 4B8805FC1DD02552003085B1 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Tape.cpp; path = ../../StaticAnalyser/Oric/Tape.cpp; sourceTree = ""; }; - 4B8805FD1DD02552003085B1 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Tape.hpp; path = ../../StaticAnalyser/Oric/Tape.hpp; sourceTree = ""; }; 4B89449220194A47007DE474 /* CSStaticAnalyser+TargetVector.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "CSStaticAnalyser+TargetVector.h"; path = "StaticAnalyser/CSStaticAnalyser+TargetVector.h"; sourceTree = ""; }; + 4B8944E4201967B4007DE474 /* ConfidenceSummary.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceSummary.hpp; sourceTree = ""; }; + 4B8944E5201967B4007DE474 /* ConfidenceSource.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceSource.hpp; sourceTree = ""; }; + 4B8944E6201967B4007DE474 /* ConfidenceCounter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConfidenceCounter.cpp; sourceTree = ""; }; + 4B8944E7201967B4007DE474 /* ConfidenceCounter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ConfidenceCounter.hpp; sourceTree = ""; }; + 4B8944E8201967B4007DE474 /* ConfidenceSummary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConfidenceSummary.cpp; sourceTree = ""; }; + 4B8944EA201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B8944EC201967B4007DE474 /* Disk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Disk.cpp; sourceTree = ""; }; + 4B8944ED201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B8944EE201967B4007DE474 /* File.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = File.hpp; sourceTree = ""; }; + 4B8944EF201967B4007DE474 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = ""; }; + 4B8944F0201967B4007DE474 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = ""; }; + 4B8944F1201967B4007DE474 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Disk.hpp; sourceTree = ""; }; + 4B8944F2201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B8944F4201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B8944F5201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B8944F7201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B8944F8201967B4007DE474 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = ""; }; + 4B8944F9201967B4007DE474 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = ""; }; + 4B8944FA201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B8944FC201967B4007DE474 /* Disk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Disk.cpp; sourceTree = ""; }; + 4B8944FD201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B8944FE201967B4007DE474 /* File.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = File.hpp; sourceTree = ""; }; + 4B8944FF201967B4007DE474 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = ""; }; + 4B894500201967B4007DE474 /* File.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = File.cpp; sourceTree = ""; }; + 4B894501201967B4007DE474 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = ""; }; + 4B894502201967B4007DE474 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Disk.hpp; sourceTree = ""; }; + 4B894503201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B894505201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B894506201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B894508201967B4007DE474 /* 6502.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = 6502.hpp; sourceTree = ""; }; + 4B894509201967B4007DE474 /* AddressMapper.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = AddressMapper.hpp; sourceTree = ""; }; + 4B89450A201967B4007DE474 /* Z80.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Z80.hpp; sourceTree = ""; }; + 4B89450B201967B4007DE474 /* 6502.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = 6502.cpp; sourceTree = ""; }; + 4B89450C201967B4007DE474 /* AddressMapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AddressMapper.cpp; sourceTree = ""; }; + 4B89450D201967B4007DE474 /* Z80.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Z80.cpp; sourceTree = ""; }; + 4B89450E201967B4007DE474 /* Kernel.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Kernel.hpp; sourceTree = ""; }; + 4B894510201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B894511201967B4007DE474 /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Tape.hpp; sourceTree = ""; }; + 4B894512201967B4007DE474 /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Tape.cpp; sourceTree = ""; }; + 4B894513201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B894515201967B4007DE474 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = StaticAnalyser.hpp; sourceTree = ""; }; + 4B894516201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B894517201967B4007DE474 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StaticAnalyser.cpp; sourceTree = ""; }; + 4B894540201967D6007DE474 /* Machines.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Machines.hpp; sourceTree = ""; }; 4B8D287E1F77207100645199 /* TrackSerialiser.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = TrackSerialiser.hpp; sourceTree = ""; }; 4B8E4ECD1DCE483D003716C3 /* KeyboardMachine.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = KeyboardMachine.hpp; sourceTree = ""; }; 4B8EF6071FE5AF830076CCDD /* LowpassSpeaker.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = LowpassSpeaker.hpp; sourceTree = ""; }; @@ -914,25 +941,15 @@ 4B9252CD1E74D28200B76AF1 /* Atari ROMs */ = {isa = PBXFileReference; lastKnownFileType = folder; path = "Atari ROMs"; sourceTree = ""; }; 4B92EAC91B7C112B00246143 /* 6502TimingTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = 6502TimingTests.swift; sourceTree = ""; }; 4B95FA9C1F11893B0008E395 /* ZX8081OptionsPanel.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ZX8081OptionsPanel.swift; sourceTree = ""; }; - 4B96F7201D75119A0058BB2D /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Tape.cpp; path = ../../StaticAnalyser/Acorn/Tape.cpp; sourceTree = ""; }; - 4B96F7211D75119A0058BB2D /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Tape.hpp; path = ../../StaticAnalyser/Acorn/Tape.hpp; sourceTree = ""; }; 4B98A05C1FFAD3F600ADF63B /* CSROMFetcher.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = CSROMFetcher.hpp; sourceTree = ""; }; 4B98A05D1FFAD3F600ADF63B /* CSROMFetcher.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = CSROMFetcher.mm; sourceTree = ""; }; 4B98A0601FFADCDE00ADF63B /* MSXStaticAnalyserTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MSXStaticAnalyserTests.mm; sourceTree = ""; }; 4B98A1CD1FFADEC400ADF63B /* MSX ROMs */ = {isa = PBXFileReference; lastKnownFileType = folder; path = "MSX ROMs"; sourceTree = ""; }; - 4B9C9D731FF81CC00030A129 /* Z80.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = Z80.cpp; path = ../../StaticAnalyser/Disassembler/Z80.cpp; sourceTree = ""; }; - 4B9C9D741FF81CC00030A129 /* Z80.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = Z80.hpp; path = ../../StaticAnalyser/Disassembler/Z80.hpp; sourceTree = ""; }; - 4B9C9D761FF81ED30030A129 /* AddressMapper.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = AddressMapper.cpp; path = ../../StaticAnalyser/Disassembler/AddressMapper.cpp; sourceTree = ""; }; - 4B9C9D771FF81ED30030A129 /* AddressMapper.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = AddressMapper.hpp; path = ../../StaticAnalyser/Disassembler/AddressMapper.hpp; sourceTree = ""; }; 4B9CCDA01DA279CA0098B625 /* Vic20OptionsPanel.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Vic20OptionsPanel.swift; sourceTree = ""; }; 4BA0F68C1EEA0E8400E9489E /* ZX8081.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ZX8081.cpp; path = Data/ZX8081.cpp; sourceTree = ""; }; 4BA0F68D1EEA0E8400E9489E /* ZX8081.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = ZX8081.hpp; path = Data/ZX8081.hpp; sourceTree = ""; }; - 4BA22B051D8817CE0008C640 /* Disk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Disk.cpp; path = ../../StaticAnalyser/Commodore/Disk.cpp; sourceTree = ""; }; - 4BA22B061D8817CE0008C640 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Disk.hpp; path = ../../StaticAnalyser/Commodore/Disk.hpp; sourceTree = ""; }; 4BA61EAE1D91515900B3C876 /* NSData+StdVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSData+StdVector.h"; sourceTree = ""; }; 4BA61EAF1D91515900B3C876 /* NSData+StdVector.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = "NSData+StdVector.mm"; sourceTree = ""; }; - 4BA799931D8B656E0045123D /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/Atari/StaticAnalyser.cpp; sourceTree = ""; }; - 4BA799941D8B656E0045123D /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/Atari/StaticAnalyser.hpp; sourceTree = ""; }; 4BA9C3CF1D8164A9002DDB61 /* ConfigurationTarget.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ConfigurationTarget.hpp; sourceTree = ""; }; 4BAB62AC1D3272D200DF5BA0 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Disk.hpp; sourceTree = ""; }; 4BAB62AE1D32730D00DF5BA0 /* Storage.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = Storage.hpp; sourceTree = ""; }; @@ -1247,14 +1264,10 @@ 4BC3B74E1CD194CC00F86E85 /* Shader.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Shader.hpp; sourceTree = ""; }; 4BC3B7501CD1956900F86E85 /* OutputShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OutputShader.cpp; sourceTree = ""; }; 4BC3B7511CD1956900F86E85 /* OutputShader.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = OutputShader.hpp; sourceTree = ""; }; - 4BC5E4901D7ED365008CF980 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/Commodore/StaticAnalyser.cpp; sourceTree = ""; }; - 4BC5E4911D7ED365008CF980 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/Commodore/StaticAnalyser.hpp; sourceTree = ""; }; 4BC751B11D157E61006C31D9 /* 6522Tests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = 6522Tests.swift; sourceTree = ""; }; 4BC76E671C98E31700E6EF73 /* FIRFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FIRFilter.cpp; sourceTree = ""; }; 4BC76E681C98E31700E6EF73 /* FIRFilter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = FIRFilter.hpp; sourceTree = ""; }; 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = System/Library/Frameworks/Accelerate.framework; sourceTree = SDKROOT; }; - 4BC830CF1D6E7C690000A26F /* Tape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Tape.cpp; path = ../../StaticAnalyser/Commodore/Tape.cpp; sourceTree = ""; }; - 4BC830D01D6E7C690000A26F /* Tape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Tape.hpp; path = ../../StaticAnalyser/Commodore/Tape.hpp; sourceTree = ""; }; 4BC91B811D1F160E00884B76 /* CommodoreTAP.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CommodoreTAP.cpp; sourceTree = ""; }; 4BC91B821D1F160E00884B76 /* CommodoreTAP.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = CommodoreTAP.hpp; sourceTree = ""; }; 4BC9DF441D044FCA00F44158 /* ROMImages */ = {isa = PBXFileReference; lastKnownFileType = folder; name = ROMImages; path = ../../../../ROMImages; sourceTree = ""; }; @@ -1266,11 +1279,7 @@ 4BCA98C21D065CA20062F44C /* 6522.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = 6522.hpp; sourceTree = ""; }; 4BCF1FA21DADC3DD0039D2E7 /* Oric.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Oric.cpp; path = Oric/Oric.cpp; sourceTree = ""; }; 4BCF1FA31DADC3DD0039D2E7 /* Oric.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Oric.hpp; path = Oric/Oric.hpp; sourceTree = ""; }; - 4BCF1FA91DADD41B0039D2E7 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/Oric/StaticAnalyser.cpp; sourceTree = ""; }; - 4BCF1FAA1DADD41B0039D2E7 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/Oric/StaticAnalyser.hpp; sourceTree = ""; }; 4BD060A51FE49D3C006E14BE /* Speaker.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Speaker.hpp; sourceTree = ""; }; - 4BD14B0F1D74627C0088EAD6 /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/Acorn/StaticAnalyser.cpp; sourceTree = ""; }; - 4BD14B101D74627C0088EAD6 /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/Acorn/StaticAnalyser.hpp; sourceTree = ""; }; 4BD388411FE34E010042B588 /* 9918Base.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = 9918Base.hpp; path = 9918/Implementation/9918Base.hpp; sourceTree = ""; }; 4BD3A3091EE755C800B5B501 /* Video.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Video.cpp; path = ZX8081/Video.cpp; sourceTree = ""; }; 4BD3A30A1EE755C800B5B501 /* Video.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Video.hpp; path = ZX8081/Video.hpp; sourceTree = ""; }; @@ -1282,8 +1291,6 @@ 4BD9137D1F311BC5009BCF85 /* i8255.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = i8255.hpp; path = 8255/i8255.hpp; sourceTree = ""; }; 4BDCC5F81FB27A5E001220C5 /* ROMMachine.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = ROMMachine.hpp; sourceTree = ""; }; 4BDDBA981EF3451200347E61 /* Z80MachineCycleTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Z80MachineCycleTests.swift; sourceTree = ""; }; - 4BE77A2C1D84ADFB00BC3827 /* File.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = File.cpp; path = ../../StaticAnalyser/Commodore/File.cpp; sourceTree = ""; }; - 4BE77A2D1D84ADFB00BC3827 /* File.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = File.hpp; path = ../../StaticAnalyser/Commodore/File.hpp; sourceTree = ""; }; 4BE7C9161E3D397100A5496D /* TIA.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TIA.cpp; sourceTree = ""; }; 4BE7C9171E3D397100A5496D /* TIA.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = TIA.hpp; sourceTree = ""; }; 4BE845201F2FF7F100A5EA22 /* CRTC6845.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = CRTC6845.hpp; path = 6845/CRTC6845.hpp; sourceTree = ""; }; @@ -1321,15 +1328,10 @@ 4BEF6AA81D35CE9E00E73575 /* DigitalPhaseLockedLoopBridge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DigitalPhaseLockedLoopBridge.h; sourceTree = ""; }; 4BEF6AA91D35CE9E00E73575 /* DigitalPhaseLockedLoopBridge.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DigitalPhaseLockedLoopBridge.mm; sourceTree = ""; }; 4BEF6AAB1D35D1C400E73575 /* DPLLTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DPLLTests.swift; sourceTree = ""; }; - 4BF1354A1D6D2C300054B2EA /* StaticAnalyser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StaticAnalyser.cpp; path = ../../StaticAnalyser/StaticAnalyser.cpp; sourceTree = ""; }; - 4BF1354B1D6D2C300054B2EA /* StaticAnalyser.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = StaticAnalyser.hpp; path = ../../StaticAnalyser/StaticAnalyser.hpp; sourceTree = ""; }; 4BF4A2D91F534DB300B171F4 /* TargetPlatforms.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = TargetPlatforms.hpp; sourceTree = ""; }; 4BF4A2DA1F5365C600B171F4 /* CSZX8081+Instantiation.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "CSZX8081+Instantiation.h"; sourceTree = ""; }; 4BF6606A1F281573002CB053 /* ClockReceiver.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = ClockReceiver.hpp; sourceTree = ""; }; 4BF8295F1D8F3C87001BAE39 /* CRC.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = CRC.hpp; path = ../../NumberTheory/CRC.hpp; sourceTree = ""; }; - 4BF829641D8F732B001BAE39 /* Disk.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Disk.cpp; path = ../../StaticAnalyser/Acorn/Disk.cpp; sourceTree = ""; }; - 4BF829651D8F732B001BAE39 /* Disk.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Disk.hpp; path = ../../StaticAnalyser/Acorn/Disk.hpp; sourceTree = ""; }; - 4BF829681D8F7361001BAE39 /* File.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = File.hpp; path = ../../StaticAnalyser/Acorn/File.hpp; sourceTree = ""; }; 4BFCA1211ECBDCAF00AC40C1 /* AllRAMProcessor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AllRAMProcessor.cpp; sourceTree = ""; }; 4BFCA1221ECBDCAF00AC40C1 /* AllRAMProcessor.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = AllRAMProcessor.hpp; sourceTree = ""; }; 4BFCA1251ECBE33200AC40C1 /* TestMachineZ80.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TestMachineZ80.h; sourceTree = ""; }; @@ -1410,17 +1412,6 @@ path = ../../Outputs/CRT; sourceTree = ""; }; - 4B0E04F01FC9E89100F43484 /* MSX */ = { - isa = PBXGroup; - children = ( - 4B0E04EC1FC9E88300F43484 /* StaticAnalyser.cpp */, - 4B0E04ED1FC9E88300F43484 /* StaticAnalyser.hpp */, - 4B651F9C1FF1B04100E18D9A /* Tape.cpp */, - 4B651F9D1FF1B04100E18D9A /* Tape.hpp */, - ); - name = MSX; - sourceTree = ""; - }; 4B0E04F71FC9F2C800F43484 /* 9918 */ = { isa = PBXGroup; children = ( @@ -1456,15 +1447,6 @@ name = "Test Binaries"; sourceTree = ""; }; - 4B14978C1EE4AC6200CE2596 /* ZX80/81 */ = { - isa = PBXGroup; - children = ( - 4B1497891EE4AC5E00CE2596 /* StaticAnalyser.cpp */, - 4B14978A1EE4AC5E00CE2596 /* StaticAnalyser.hpp */, - ); - name = ZX80/81; - sourceTree = ""; - }; 4B1497931EE4B5AC00CE2596 /* ZX8081 */ = { isa = PBXGroup; children = ( @@ -1659,15 +1641,6 @@ name = Outputs; sourceTree = ""; }; - 4B38F3451F2EB41800D9235D /* AmstradCPC */ = { - isa = PBXGroup; - children = ( - 4B38F3421F2EB3E900D9235D /* StaticAnalyser.cpp */, - 4B38F3431F2EB3E900D9235D /* StaticAnalyser.hpp */, - ); - name = AmstradCPC; - sourceTree = ""; - }; 4B38F3491F2EC12000D9235D /* AmstradCPC */ = { isa = PBXGroup; children = ( @@ -1847,19 +1820,6 @@ path = 1540; sourceTree = ""; }; - 4B5539F52015820B00027510 /* DynamicAnalyser */ = { - isa = PBXGroup; - children = ( - 4B5539F62015820B00027510 /* ConfidenceSource.hpp */, - 4B5539FD201583AD00027510 /* ConfidenceCounter.cpp */, - 4B5539FE201583AD00027510 /* ConfidenceCounter.hpp */, - 4B553A012015855900027510 /* ConfidenceSummary.cpp */, - 4B553A022015855900027510 /* ConfidenceSummary.hpp */, - ); - name = DynamicAnalyser; - path = ../../DynamicAnalyser; - sourceTree = ""; - }; 4B55CE551C3B7D360093A61B /* Documents */ = { isa = PBXGroup; children = ( @@ -1888,20 +1848,6 @@ path = Views; sourceTree = ""; }; - 4B5A12581DD55873007A2231 /* Disassembler */ = { - isa = PBXGroup; - children = ( - 4B5A12551DD55862007A2231 /* 6502.cpp */, - 4B9C9D761FF81ED30030A129 /* AddressMapper.cpp */, - 4B9C9D731FF81CC00030A129 /* Z80.cpp */, - 4B5A12561DD55862007A2231 /* 6502.hpp */, - 4B9C9D771FF81ED30030A129 /* AddressMapper.hpp */, - 4B5342211FF9A30800D42660 /* Kernel.hpp */, - 4B9C9D741FF81CC00030A129 /* Z80.hpp */, - ); - name = Disassembler; - sourceTree = ""; - }; 4B643F3B1D77AD6D00D431D6 /* StaticAnalyser */ = { isa = PBXGroup; children = ( @@ -2100,6 +2046,138 @@ name = Data; sourceTree = ""; }; + 4B8944E2201967B4007DE474 /* Analyser */ = { + isa = PBXGroup; + children = ( + 4B894540201967D6007DE474 /* Machines.hpp */, + 4B8944E3201967B4007DE474 /* Dynamic */, + 4B8944E9201967B4007DE474 /* Static */, + ); + name = Analyser; + path = ../../Analyser; + sourceTree = ""; + }; + 4B8944E3201967B4007DE474 /* Dynamic */ = { + isa = PBXGroup; + children = ( + 4B8944E4201967B4007DE474 /* ConfidenceSummary.hpp */, + 4B8944E5201967B4007DE474 /* ConfidenceSource.hpp */, + 4B8944E6201967B4007DE474 /* ConfidenceCounter.cpp */, + 4B8944E7201967B4007DE474 /* ConfidenceCounter.hpp */, + 4B8944E8201967B4007DE474 /* ConfidenceSummary.cpp */, + ); + path = Dynamic; + sourceTree = ""; + }; + 4B8944E9201967B4007DE474 /* Static */ = { + isa = PBXGroup; + children = ( + 4B894517201967B4007DE474 /* StaticAnalyser.cpp */, + 4B8944EA201967B4007DE474 /* StaticAnalyser.hpp */, + 4B8944EB201967B4007DE474 /* Acorn */, + 4B894514201967B4007DE474 /* AmstradCPC */, + 4B8944F3201967B4007DE474 /* Atari */, + 4B8944FB201967B4007DE474 /* Commodore */, + 4B894507201967B4007DE474 /* Disassembler */, + 4B89450F201967B4007DE474 /* MSX */, + 4B8944F6201967B4007DE474 /* Oric */, + 4B894504201967B4007DE474 /* ZX8081 */, + ); + path = Static; + sourceTree = ""; + }; + 4B8944EB201967B4007DE474 /* Acorn */ = { + isa = PBXGroup; + children = ( + 4B8944EC201967B4007DE474 /* Disk.cpp */, + 4B8944ED201967B4007DE474 /* StaticAnalyser.hpp */, + 4B8944EE201967B4007DE474 /* File.hpp */, + 4B8944EF201967B4007DE474 /* Tape.hpp */, + 4B8944F0201967B4007DE474 /* Tape.cpp */, + 4B8944F1201967B4007DE474 /* Disk.hpp */, + 4B8944F2201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = Acorn; + sourceTree = ""; + }; + 4B8944F3201967B4007DE474 /* Atari */ = { + isa = PBXGroup; + children = ( + 4B8944F4201967B4007DE474 /* StaticAnalyser.hpp */, + 4B8944F5201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = Atari; + sourceTree = ""; + }; + 4B8944F6201967B4007DE474 /* Oric */ = { + isa = PBXGroup; + children = ( + 4B8944F7201967B4007DE474 /* StaticAnalyser.hpp */, + 4B8944F8201967B4007DE474 /* Tape.hpp */, + 4B8944F9201967B4007DE474 /* Tape.cpp */, + 4B8944FA201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = Oric; + sourceTree = ""; + }; + 4B8944FB201967B4007DE474 /* Commodore */ = { + isa = PBXGroup; + children = ( + 4B8944FC201967B4007DE474 /* Disk.cpp */, + 4B894502201967B4007DE474 /* Disk.hpp */, + 4B894500201967B4007DE474 /* File.cpp */, + 4B8944FE201967B4007DE474 /* File.hpp */, + 4B894503201967B4007DE474 /* StaticAnalyser.cpp */, + 4B8944FD201967B4007DE474 /* StaticAnalyser.hpp */, + 4B894501201967B4007DE474 /* Tape.cpp */, + 4B8944FF201967B4007DE474 /* Tape.hpp */, + ); + path = Commodore; + sourceTree = ""; + }; + 4B894504201967B4007DE474 /* ZX8081 */ = { + isa = PBXGroup; + children = ( + 4B894505201967B4007DE474 /* StaticAnalyser.hpp */, + 4B894506201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = ZX8081; + sourceTree = ""; + }; + 4B894507201967B4007DE474 /* Disassembler */ = { + isa = PBXGroup; + children = ( + 4B894508201967B4007DE474 /* 6502.hpp */, + 4B894509201967B4007DE474 /* AddressMapper.hpp */, + 4B89450A201967B4007DE474 /* Z80.hpp */, + 4B89450B201967B4007DE474 /* 6502.cpp */, + 4B89450C201967B4007DE474 /* AddressMapper.cpp */, + 4B89450D201967B4007DE474 /* Z80.cpp */, + 4B89450E201967B4007DE474 /* Kernel.hpp */, + ); + path = Disassembler; + sourceTree = ""; + }; + 4B89450F201967B4007DE474 /* MSX */ = { + isa = PBXGroup; + children = ( + 4B894510201967B4007DE474 /* StaticAnalyser.hpp */, + 4B894511201967B4007DE474 /* Tape.hpp */, + 4B894512201967B4007DE474 /* Tape.cpp */, + 4B894513201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = MSX; + sourceTree = ""; + }; + 4B894514201967B4007DE474 /* AmstradCPC */ = { + isa = PBXGroup; + children = ( + 4B894515201967B4007DE474 /* StaticAnalyser.hpp */, + 4B894516201967B4007DE474 /* StaticAnalyser.cpp */, + ); + path = AmstradCPC; + sourceTree = ""; + }; 4B8EF6051FE5AF830076CCDD /* Implementation */ = { isa = PBXGroup; children = ( @@ -2110,15 +2188,6 @@ path = Implementation; sourceTree = ""; }; - 4BA799961D8B65730045123D /* Atari */ = { - isa = PBXGroup; - children = ( - 4BA799931D8B656E0045123D /* StaticAnalyser.cpp */, - 4BA799941D8B656E0045123D /* StaticAnalyser.hpp */, - ); - name = Atari; - sourceTree = ""; - }; 4BAB62AA1D3272D200DF5BA0 /* Disk */ = { isa = PBXGroup; children = ( @@ -2430,6 +2499,7 @@ isa = PBXGroup; children = ( 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */, + 4B8944E2201967B4007DE474 /* Analyser */, 4BB73EA01B587A5100552FC2 /* Clock Signal */, 4BB73EB51B587A5100552FC2 /* Clock SignalTests */, 4BB73EC01B587A5100552FC2 /* Clock SignalUITests */, @@ -2437,7 +2507,6 @@ 4BC9DF4A1D04691600F44158 /* Components */, 4B3940E81DA83C8700427841 /* Concurrency */, 4B31B88E1FBFBCD800C140D5 /* Configurable */, - 4B5539F52015820B00027510 /* DynamicAnalyser */, 4B055A761FAE78210060FFFF /* Frameworks */, 4B86E2581F8C628F006FAA45 /* Inputs */, 4BB73EDC1B587CA500552FC2 /* Machines */, @@ -2447,7 +2516,6 @@ 4BB73E9F1B587A5100552FC2 /* Products */, 4B055A7B1FAE84A50060FFFF /* SDL */, 4B2409591C45DF85004DA684 /* SignalProcessing */, - 4BF1354D1D6D2C360054B2EA /* StaticAnalyser */, 4B69FB391C4D908A00B5F0AA /* Storage */, ); indentWidth = 4; @@ -2614,21 +2682,6 @@ path = Shaders; sourceTree = ""; }; - 4BC830D21D6E7C6D0000A26F /* Commodore */ = { - isa = PBXGroup; - children = ( - 4BA22B051D8817CE0008C640 /* Disk.cpp */, - 4BA22B061D8817CE0008C640 /* Disk.hpp */, - 4BE77A2C1D84ADFB00BC3827 /* File.cpp */, - 4BE77A2D1D84ADFB00BC3827 /* File.hpp */, - 4BC5E4901D7ED365008CF980 /* StaticAnalyser.cpp */, - 4BC5E4911D7ED365008CF980 /* StaticAnalyser.hpp */, - 4BC830CF1D6E7C690000A26F /* Tape.cpp */, - 4BC830D01D6E7C690000A26F /* Tape.hpp */, - ); - name = Commodore; - sourceTree = ""; - }; 4BC9DF4A1D04691600F44158 /* Components */ = { isa = PBXGroup; children = ( @@ -2689,17 +2742,6 @@ name = Oric; sourceTree = ""; }; - 4BCF1FAC1DADD41F0039D2E7 /* Oric */ = { - isa = PBXGroup; - children = ( - 4BCF1FA91DADD41B0039D2E7 /* StaticAnalyser.cpp */, - 4BCF1FAA1DADD41B0039D2E7 /* StaticAnalyser.hpp */, - 4B8805FC1DD02552003085B1 /* Tape.cpp */, - 4B8805FD1DD02552003085B1 /* Tape.hpp */, - ); - name = Oric; - sourceTree = ""; - }; 4BD060A41FE49D3C006E14BE /* Speaker */ = { isa = PBXGroup; children = ( @@ -2710,20 +2752,6 @@ path = ../../Outputs/Speaker; sourceTree = ""; }; - 4BD14B121D7462810088EAD6 /* Acorn */ = { - isa = PBXGroup; - children = ( - 4BF829641D8F732B001BAE39 /* Disk.cpp */, - 4BF829651D8F732B001BAE39 /* Disk.hpp */, - 4BF829681D8F7361001BAE39 /* File.hpp */, - 4BD14B0F1D74627C0088EAD6 /* StaticAnalyser.cpp */, - 4BD14B101D74627C0088EAD6 /* StaticAnalyser.hpp */, - 4B96F7201D75119A0058BB2D /* Tape.cpp */, - 4B96F7211D75119A0058BB2D /* Tape.hpp */, - ); - name = Acorn; - sourceTree = ""; - }; 4BD388431FE34E060042B588 /* Implementation */ = { isa = PBXGroup; children = ( @@ -2826,23 +2854,6 @@ path = Formats; sourceTree = ""; }; - 4BF1354D1D6D2C360054B2EA /* StaticAnalyser */ = { - isa = PBXGroup; - children = ( - 4BF1354A1D6D2C300054B2EA /* StaticAnalyser.cpp */, - 4BF1354B1D6D2C300054B2EA /* StaticAnalyser.hpp */, - 4BD14B121D7462810088EAD6 /* Acorn */, - 4B38F3451F2EB41800D9235D /* AmstradCPC */, - 4BA799961D8B65730045123D /* Atari */, - 4BC830D21D6E7C6D0000A26F /* Commodore */, - 4B5A12581DD55873007A2231 /* Disassembler */, - 4B0E04F01FC9E89100F43484 /* MSX */, - 4BCF1FAC1DADD41F0039D2E7 /* Oric */, - 4B14978C1EE4AC6200CE2596 /* ZX80/81 */, - ); - name = StaticAnalyser; - sourceTree = ""; - }; 4BF660691F281573002CB053 /* ClockReceiver */ = { isa = PBXGroup; children = ( @@ -3319,21 +3330,21 @@ 4B055A9B1FAE85DA0060FFFF /* AcornADF.cpp in Sources */, 4B0E04F11FC9EA9500F43484 /* MSX.cpp in Sources */, 4B055AD51FAE9B0B0060FFFF /* Video.cpp in Sources */, - 4B055A811FAE853A0060FFFF /* Disk.cpp in Sources */, 4B055AE11FAE9B6F0060FFFF /* ArrayBuilder.cpp in Sources */, + 4B894521201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B055AA51FAE85EF0060FFFF /* Encoder.cpp in Sources */, + 4B894529201967B4007DE474 /* Disk.cpp in Sources */, 4B055AEA1FAE9B990060FFFF /* 6502Storage.cpp in Sources */, - 4B055A8A1FAE855B0060FFFF /* Tape.cpp in Sources */, - 4B553A042015855900027510 /* ConfidenceSummary.cpp in Sources */, 4B055AA71FAE85EF0060FFFF /* SegmentParser.cpp in Sources */, 4B055AC11FAE98DC0060FFFF /* MachineForTarget.cpp in Sources */, 4B055AD81FAE9B180060FFFF /* Video.cpp in Sources */, + 4B89452F201967B4007DE474 /* StaticAnalyser.cpp in Sources */, + 4B894531201967B4007DE474 /* StaticAnalyser.cpp in Sources */, + 4B894539201967B4007DE474 /* Tape.cpp in Sources */, 4B055AE51FAE9B6F0060FFFF /* IntermediateShader.cpp in Sources */, - 4B055A851FAE85480060FFFF /* File.cpp in Sources */, 4B055AD31FAE9B0B0060FFFF /* Microdisc.cpp in Sources */, 4B055AB41FAE860F0060FFFF /* OricTAP.cpp in Sources */, 4B055AB71FAE860F0060FFFF /* TZX.cpp in Sources */, - 4B055A8C1FAE85670060FFFF /* StaticAnalyser.cpp in Sources */, 4B055ADA1FAE9B460060FFFF /* 1770.cpp in Sources */, 4B055ADC1FAE9B460060FFFF /* AY38910.cpp in Sources */, 4B055AD71FAE9B180060FFFF /* Keyboard.cpp in Sources */, @@ -3346,8 +3357,10 @@ 4B055AAB1FAE85FD0060FFFF /* PCMPatchedTrack.cpp in Sources */, 4B055AC71FAE9AEE0060FFFF /* TIA.cpp in Sources */, 4B055AD21FAE9B0B0060FFFF /* Keyboard.cpp in Sources */, + 4B89451B201967B4007DE474 /* ConfidenceSummary.cpp in Sources */, 4B055AA31FAE85DF0060FFFF /* ImplicitSectors.cpp in Sources */, 4B055AAE1FAE85FD0060FFFF /* TrackSerialiser.cpp in Sources */, + 4B89452B201967B4007DE474 /* File.cpp in Sources */, 4B055A981FAE85C50060FFFF /* Drive.cpp in Sources */, 4B4B1A3D200198CA00A0F866 /* KonamiSCC.cpp in Sources */, 4B055AE21FAE9B6F0060FFFF /* CRTOpenGL.cpp in Sources */, @@ -3356,15 +3369,14 @@ 4B055AB81FAE860F0060FFFF /* ZX80O81P.cpp in Sources */, 4B055A8E1FAE85920060FFFF /* BestEffortUpdater.cpp in Sources */, 4B055AB01FAE86070060FFFF /* PulseQueuedTape.cpp in Sources */, - 4B055A801FAE85350060FFFF /* StaticAnalyser.cpp in Sources */, 4B055AAC1FAE85FD0060FFFF /* PCMSegment.cpp in Sources */, 4B055AB31FAE860F0060FFFF /* CSW.cpp in Sources */, + 4B89451D201967B4007DE474 /* Disk.cpp in Sources */, 4B055ACF1FAE9B030060FFFF /* SoundGenerator.cpp in Sources */, + 4B894519201967B4007DE474 /* ConfidenceCounter.cpp in Sources */, 4B055AEE1FAE9BBF0060FFFF /* Keyboard.cpp in Sources */, - 4B055A881FAE85530060FFFF /* 6502.cpp in Sources */, 4B055AED1FAE9BA20060FFFF /* Z80Storage.cpp in Sources */, 4B055AD11FAE9B030060FFFF /* Video.cpp in Sources */, - 4B2F67F12018312F00251FB5 /* Z80.cpp in Sources */, 4B055AA21FAE85DA0060FFFF /* SSD.cpp in Sources */, 4BEBFB4E2002C4BF000708CC /* MSXDSK.cpp in Sources */, 4B055ADD1FAE9B460060FFFF /* i8272.cpp in Sources */, @@ -3374,8 +3386,9 @@ 4B055ABA1FAE86170060FFFF /* Commodore.cpp in Sources */, 4B055AA61FAE85EF0060FFFF /* Parser.cpp in Sources */, 4B055AE91FAE9B990060FFFF /* 6502Base.cpp in Sources */, - 4B055A861FAE854C0060FFFF /* StaticAnalyser.cpp in Sources */, 4B055AEF1FAE9BF00060FFFF /* Typer.cpp in Sources */, + 4B89453F201967B4007DE474 /* StaticAnalyser.cpp in Sources */, + 4B89453D201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B055ACA1FAE9AFB0060FFFF /* Vic20.cpp in Sources */, 4B055ABC1FAE86170060FFFF /* ZX8081.cpp in Sources */, 4B055AC91FAE9AFB0060FFFF /* Keyboard.cpp in Sources */, @@ -3383,14 +3396,13 @@ 4B055ACC1FAE9B030060FFFF /* Electron.cpp in Sources */, 4B055AB11FAE86070060FFFF /* Tape.cpp in Sources */, 4BFE7B881FC39D8900160B38 /* StandardOptions.cpp in Sources */, + 4B894533201967B4007DE474 /* 6502.cpp in Sources */, 4B055AA91FAE85EF0060FFFF /* CommodoreGCR.cpp in Sources */, - 4B055A7F1FAE852F0060FFFF /* StaticAnalyser.cpp in Sources */, 4B055ADB1FAE9B460060FFFF /* 6560.cpp in Sources */, 4B055AA01FAE85DA0060FFFF /* MFMSectorDump.cpp in Sources */, 4BEBFB522002DB30000708CC /* DiskROM.cpp in Sources */, 4B055AA11FAE85DA0060FFFF /* OricMFMDSK.cpp in Sources */, 4B055A951FAE85BB0060FFFF /* BitReverse.cpp in Sources */, - 4B055A891FAE85580060FFFF /* StaticAnalyser.cpp in Sources */, 4B055ACE1FAE9B030060FFFF /* Plus3.cpp in Sources */, 4B055A8D1FAE85920060FFFF /* AsyncTaskQueue.cpp in Sources */, 4BAD13441FF709C700FD114A /* MSX.cpp in Sources */, @@ -3398,44 +3410,44 @@ 4B055A941FAE85B50060FFFF /* CommodoreROM.cpp in Sources */, 4B055A971FAE85BB0060FFFF /* ZX8081.cpp in Sources */, 4B055AAD1FAE85FD0060FFFF /* PCMTrack.cpp in Sources */, - 4B055A841FAE85450060FFFF /* Disk.cpp in Sources */, - 4B055A831FAE85410060FFFF /* Tape.cpp in Sources */, - 4B553A00201583AD00027510 /* ConfidenceCounter.cpp in Sources */, 4B055AC61FAE9AEE0060FFFF /* TIASound.cpp in Sources */, + 4B89451F201967B4007DE474 /* Tape.cpp in Sources */, 4B055AA81FAE85EF0060FFFF /* Shifter.cpp in Sources */, 4B055AC81FAE9AFB0060FFFF /* C1540.cpp in Sources */, 4B055A8F1FAE85A90060FFFF /* FileHolder.cpp in Sources */, 4B055A911FAE85B50060FFFF /* Cartridge.cpp in Sources */, + 4B894525201967B4007DE474 /* Tape.cpp in Sources */, 4B055ACD1FAE9B030060FFFF /* Keyboard.cpp in Sources */, - 4B055A8B1FAE85670060FFFF /* StaticAnalyser.cpp in Sources */, 4B055AB21FAE860F0060FFFF /* CommodoreTAP.cpp in Sources */, 4B055ADF1FAE9B4C0060FFFF /* IRQDelegatePortHandler.cpp in Sources */, 4B055AB51FAE860F0060FFFF /* TapePRG.cpp in Sources */, 4B055AE01FAE9B660060FFFF /* CRT.cpp in Sources */, + 4B894527201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4BAF2B4F2004580C00480230 /* DMK.cpp in Sources */, - 4B0E04F21FC9EAA800F43484 /* StaticAnalyser.cpp in Sources */, 4B055AD01FAE9B030060FFFF /* Tape.cpp in Sources */, 4B055A961FAE85BB0060FFFF /* Commodore.cpp in Sources */, 4B055ADE1FAE9B4C0060FFFF /* 6522Base.cpp in Sources */, + 4B894535201967B4007DE474 /* AddressMapper.cpp in Sources */, 4B055AD41FAE9B0B0060FFFF /* Oric.cpp in Sources */, - 4B055A821FAE853D0060FFFF /* StaticAnalyser.cpp in Sources */, 4B055A921FAE85B50060FFFF /* PRG.cpp in Sources */, 4B055AAF1FAE85FD0060FFFF /* UnformattedTrack.cpp in Sources */, 4B055A7E1FAE84AA0060FFFF /* main.cpp in Sources */, + 4B894537201967B4007DE474 /* Z80.cpp in Sources */, 4B055A9F1FAE85DA0060FFFF /* HFE.cpp in Sources */, 4B07835B1FC11D42001D12BB /* Configurable.cpp in Sources */, 4B055AE71FAE9B6F0060FFFF /* Shader.cpp in Sources */, + 4B894523201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B055AEC1FAE9BA20060FFFF /* Z80Base.cpp in Sources */, 4B0E04EB1FC9E78800F43484 /* CAS.cpp in Sources */, 4B055AE31FAE9B6F0060FFFF /* TextureBuilder.cpp in Sources */, 4B055AB91FAE86170060FFFF /* Acorn.cpp in Sources */, 4B055A931FAE85B50060FFFF /* BinaryDump.cpp in Sources */, + 4B89452D201967B4007DE474 /* Tape.cpp in Sources */, 4B055AD61FAE9B130060FFFF /* MemoryFuzzer.cpp in Sources */, - 4B651F9F1FF1B2AE00E18D9A /* Tape.cpp in Sources */, 4B055AC21FAE9AE30060FFFF /* KeyboardMachine.cpp in Sources */, 4B055AD91FAE9B180060FFFF /* ZX8081.cpp in Sources */, + 4B89453B201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B055AEB1FAE9BA20060FFFF /* PartialMachineCycle.cpp in Sources */, - 4B055A871FAE854F0060FFFF /* Tape.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -3446,6 +3458,7 @@ 4B2BFC5F1D613E0200BA3AA9 /* TapePRG.cpp in Sources */, 4BC9DF4F1D04691600F44158 /* 6560.cpp in Sources */, 4B59199C1DAC6C46005BB85C /* OricTAP.cpp in Sources */, + 4B89451E201967B4007DE474 /* Tape.cpp in Sources */, 4BAF2B4E2004580C00480230 /* DMK.cpp in Sources */, 4BB697CE1D4BA44400248BDF /* CommodoreGCR.cpp in Sources */, 4B7136861F78724F008B8ED9 /* Encoder.cpp in Sources */, @@ -3453,71 +3466,69 @@ 4B58601E1F806AB200AEE2E3 /* MFMSectorDump.cpp in Sources */, 4B448E841F1C4C480009ABD6 /* PulseQueuedTape.cpp in Sources */, 4B0E61071FF34737002A9DBD /* MSX.cpp in Sources */, - 4BD14B111D74627C0088EAD6 /* StaticAnalyser.cpp in Sources */, 4BBF99151C8FBA6F0075DAFB /* CRTOpenGL.cpp in Sources */, 4B4518A01F75FD1C00926311 /* CPCDSK.cpp in Sources */, 4B95FA9D1F11893B0008E395 /* ZX8081OptionsPanel.swift in Sources */, 4B0CCC451C62D0B3001CAC5F /* CRT.cpp in Sources */, 4B322E041F5A2E3C004EB04C /* Z80Base.cpp in Sources */, + 4B894530201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B4518A31F75FD1C00926311 /* HFE.cpp in Sources */, 4B4518A11F75FD1C00926311 /* D64.cpp in Sources */, 4B1558C01F844ECD006E9A97 /* BitReverse.cpp in Sources */, 4BCF1FA41DADC3DD0039D2E7 /* Oric.cpp in Sources */, + 4B894538201967B4007DE474 /* Tape.cpp in Sources */, 4B54C0CB1F8D92590050900F /* Keyboard.cpp in Sources */, 4BEA525E1DF33323007E74F2 /* Tape.cpp in Sources */, 4B07835A1FC11D10001D12BB /* Configurable.cpp in Sources */, 4B8334951F5E25B60097E338 /* C1540.cpp in Sources */, + 4B89453C201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B1497921EE4B5A800CE2596 /* ZX8081.cpp in Sources */, 4B643F3F1D77B88000D431D6 /* DocumentController.swift in Sources */, 4B4518861F75E91A00926311 /* MFMDiskController.cpp in Sources */, - 4BA799951D8B656E0045123D /* StaticAnalyser.cpp in Sources */, 4B54C0BF1F8D8F450050900F /* Keyboard.cpp in Sources */, 4B3FE75E1F3CF68B00448EE4 /* CPM.cpp in Sources */, - 4B9C9D781FF81ED30030A129 /* AddressMapper.cpp in Sources */, 4B2BFDB21DAEF5FF001A68B8 /* Video.cpp in Sources */, 4B4DC82B1D2C27A4003C5BF8 /* SerialBus.cpp in Sources */, 4BBFFEE61F7B27F1005F3FEB /* TrackSerialiser.cpp in Sources */, 4BC3B74F1CD194CC00F86E85 /* Shader.cpp in Sources */, + 4B894518201967B4007DE474 /* ConfidenceCounter.cpp in Sources */, + 4B89452E201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B38F3481F2EC11D00D9235D /* AmstradCPC.cpp in Sources */, 4B8FE2221DA19FB20090D3CE /* MachinePanel.swift in Sources */, 4B4518A41F75FD1C00926311 /* OricMFMDSK.cpp in Sources */, 4BBB14311CD2CECE00BDB55C /* IntermediateShader.cpp in Sources */, 4B4B1A3C200198CA00A0F866 /* KonamiSCC.cpp in Sources */, 4BD5F1951D13528900631CD1 /* CSBestEffortUpdater.mm in Sources */, - 4B96F7221D75119A0058BB2D /* Tape.cpp in Sources */, + 4B894532201967B4007DE474 /* 6502.cpp in Sources */, 4B4518811F75E91A00926311 /* PCMPatchedTrack.cpp in Sources */, 4B8805F71DCFF6C9003085B1 /* Commodore.cpp in Sources */, 4BBF99181C8FBA6F0075DAFB /* TextureTarget.cpp in Sources */, - 4B9C9D751FF81CC00030A129 /* Z80.cpp in Sources */, 4BC76E691C98E31700E6EF73 /* FIRFilter.cpp in Sources */, 4B3BF5B01F146265005B6C36 /* CSW.cpp in Sources */, 4B4518A51F75FD1C00926311 /* SSD.cpp in Sources */, 4B55CE5F1C3B7D960093A61B /* MachineDocument.swift in Sources */, 4B2B3A4C1F9B8FA70062DABF /* MemoryFuzzer.cpp in Sources */, 4B7913CC1DFCD80E00175A82 /* Video.cpp in Sources */, - 4B0E04EE1FC9E88300F43484 /* StaticAnalyser.cpp in Sources */, 4B4518831F75E91A00926311 /* PCMTrack.cpp in Sources */, 4B45189F1F75FD1C00926311 /* AcornADF.cpp in Sources */, 4B2A53A11D117D36003C6002 /* CSAtari2600.mm in Sources */, 4B7136911F789C93008B8ED9 /* SegmentParser.cpp in Sources */, 4B4518A21F75FD1C00926311 /* G64.cpp in Sources */, - 4BF829661D8F732B001BAE39 /* Disk.cpp in Sources */, + 4B89452C201967B4007DE474 /* Tape.cpp in Sources */, 4B448E811F1C45A00009ABD6 /* TZX.cpp in Sources */, 4BEBFB512002DB30000708CC /* DiskROM.cpp in Sources */, + 4B89451C201967B4007DE474 /* Disk.cpp in Sources */, 4BEA52631DF339D7007E74F2 /* SoundGenerator.cpp in Sources */, - 4BC5E4921D7ED365008CF980 /* StaticAnalyser.cpp in Sources */, - 4BC830D11D6E7C690000A26F /* Tape.cpp in Sources */, + 4B89451A201967B4007DE474 /* ConfidenceSummary.cpp in Sources */, 4B54C0C51F8D91D90050900F /* Keyboard.cpp in Sources */, 4B69FB441C4D941400B5F0AA /* TapeUEF.cpp in Sources */, 4B86E25B1F8C628F006FAA45 /* Keyboard.cpp in Sources */, - 4B651F9E1FF1B04100E18D9A /* Tape.cpp in Sources */, 4B4518851F75E91A00926311 /* DiskController.cpp in Sources */, 4B8334841F5DA0360097E338 /* Z80Storage.cpp in Sources */, 4BA61EB01D91515900B3C876 /* NSData+StdVector.mm in Sources */, + 4B89452A201967B4007DE474 /* File.cpp in Sources */, 4B4DC8211D2C2425003C5BF8 /* Vic20.cpp in Sources */, 4B71368E1F788112008B8ED9 /* Parser.cpp in Sources */, - 4BE77A2E1D84ADFB00BC3827 /* File.cpp in Sources */, - 4B14978B1EE4AC5E00CE2596 /* StaticAnalyser.cpp in Sources */, 4B12C0ED1FCFA98D005BFD93 /* Keyboard.cpp in Sources */, 4BA0F68E1EEA0E8400E9489E /* ZX8081.cpp in Sources */, 4BD468F71D8DF41D0084958B /* 1770.cpp in Sources */, @@ -3526,9 +3537,10 @@ 4B5FADBA1DE3151600AEC565 /* FileHolder.cpp in Sources */, 4B643F3A1D77AD1900D431D6 /* CSStaticAnalyser.mm in Sources */, 4B1497881EE4A1DA00CE2596 /* ZX80O81P.cpp in Sources */, - 4B5A12571DD55862007A2231 /* 6502.cpp in Sources */, + 4B894520201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B2B3A4B1F9B8FA70062DABF /* Typer.cpp in Sources */, 4B4518821F75E91A00926311 /* PCMSegment.cpp in Sources */, + 4B894522201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4BE7C9181E3D397100A5496D /* TIA.cpp in Sources */, 4B80AD001F85CACA00176895 /* BestEffortUpdater.cpp in Sources */, 4B2E2D9D1C3A070400138695 /* Electron.cpp in Sources */, @@ -3537,12 +3549,12 @@ 4B69FB3D1C4D908A00B5F0AA /* Tape.cpp in Sources */, 4B4518841F75E91A00926311 /* UnformattedTrack.cpp in Sources */, 4B55CE5D1C3B7D6F0093A61B /* CSOpenGLView.m in Sources */, + 4B894528201967B4007DE474 /* Disk.cpp in Sources */, + 4B89453A201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4BB697CB1D4B6D3E00248BDF /* TimedEventLoop.cpp in Sources */, 4B54C0C21F8D91CD0050900F /* Keyboard.cpp in Sources */, - 4B553A032015855900027510 /* ConfidenceSummary.cpp in Sources */, 4BBC951E1F368D83008F4C34 /* i8272.cpp in Sources */, 4B89449520194CB3007DE474 /* MachineForTarget.cpp in Sources */, - 4BF1354C1D6D2C300054B2EA /* StaticAnalyser.cpp in Sources */, 4B4A76301DB1A3FA007AAE2E /* AY38910.cpp in Sources */, 4B6A4C991F58F09E00E3F787 /* 6502Base.cpp in Sources */, 4B4518871F75E91A00926311 /* DigitalPhaseLockedLoop.cpp in Sources */, @@ -3551,29 +3563,28 @@ 4B8FE2201DA19D7C0090D3CE /* Atari2600OptionsPanel.swift in Sources */, 4B8805F41DCFD22A003085B1 /* Commodore.cpp in Sources */, 4B2E2D9A1C3A06EC00138695 /* Atari2600.cpp in Sources */, - 4B8805FE1DD02552003085B1 /* Tape.cpp in Sources */, 4B9CCDA11DA279CA0098B625 /* Vic20OptionsPanel.swift in Sources */, 4B8805F01DCFC99C003085B1 /* Acorn.cpp in Sources */, - 4B38F3441F2EB3E900D9235D /* StaticAnalyser.cpp in Sources */, 4B3051301D98ACC600B4FED8 /* Plus3.cpp in Sources */, 4B30512D1D989E2200B4FED8 /* Drive.cpp in Sources */, 4B83348C1F5DB99C0097E338 /* 6522Base.cpp in Sources */, + 4B894536201967B4007DE474 /* Z80.cpp in Sources */, 4BCA6CC81D9DD9F000C2D7B2 /* CommodoreROM.cpp in Sources */, - 4BA22B071D8817CE0008C640 /* Disk.cpp in Sources */, 4BEA52661DF3472B007E74F2 /* TIASound.cpp in Sources */, 4BEBFB4D2002C4BF000708CC /* MSXDSK.cpp in Sources */, 4BBFBB6C1EE8401E00C01E7A /* ZX8081.cpp in Sources */, 4B83348A1F5DB94B0097E338 /* IRQDelegatePortHandler.cpp in Sources */, + 4B894524201967B4007DE474 /* Tape.cpp in Sources */, 4B7136891F78725F008B8ED9 /* Shifter.cpp in Sources */, 4BFDD78C1F7F2DB4008579B9 /* ImplicitSectors.cpp in Sources */, 4BC3B7521CD1956900F86E85 /* OutputShader.cpp in Sources */, 4B5073071DDD3B9400C48FBD /* ArrayBuilder.cpp in Sources */, + 4B894526201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4BEE0A6F1D72496600532C7B /* Cartridge.cpp in Sources */, 4B8805FB1DCFF807003085B1 /* Oric.cpp in Sources */, 4BFE7B871FC39BF100160B38 /* StandardOptions.cpp in Sources */, 4B5FADC01DE3BF2B00AEC565 /* Microdisc.cpp in Sources */, 4B54C0C81F8D91E50050900F /* Keyboard.cpp in Sources */, - 4B5539FF201583AD00027510 /* ConfidenceCounter.cpp in Sources */, 4B79A5011FC913C900EEDAD5 /* MSX.cpp in Sources */, 4BEE0A701D72496600532C7B /* PRG.cpp in Sources */, 4B8334861F5DA3780097E338 /* 6502Storage.cpp in Sources */, @@ -3581,12 +3592,13 @@ 4B2A53A01D117D36003C6002 /* CSMachine.mm in Sources */, 4B14978F1EE4B4D200CE2596 /* CSZX8081.mm in Sources */, 4BC91B831D1F160E00884B76 /* CommodoreTAP.cpp in Sources */, - 4BCF1FAB1DADD41B0039D2E7 /* StaticAnalyser.cpp in Sources */, 4B2A539F1D117D36003C6002 /* CSAudioQueue.m in Sources */, + 4B89453E201967B4007DE474 /* StaticAnalyser.cpp in Sources */, 4B37EE821D7345A6006A09A4 /* BinaryDump.cpp in Sources */, 4B8334821F5D9FF70097E338 /* PartialMachineCycle.cpp in Sources */, 4B54C0BC1F8D8E790050900F /* KeyboardMachine.cpp in Sources */, 4BB73EA21B587A5100552FC2 /* AppDelegate.swift in Sources */, + 4B894534201967B4007DE474 /* AddressMapper.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine+Target.h b/OSBindings/Mac/Clock Signal/Machine/CSMachine+Target.h index f2f299396..c754dd1a2 100644 --- a/OSBindings/Mac/Clock Signal/Machine/CSMachine+Target.h +++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine+Target.h @@ -12,7 +12,7 @@ @interface CSMachine(Target) -- (void)applyTarget:(const StaticAnalyser::Target &)target; -- (void)applyMedia:(const StaticAnalyser::Media &)media; +- (void)applyTarget:(const Analyser::Static::Target &)target; +- (void)applyMedia:(const Analyser::Static::Media &)media; @end diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm index 61aa9d38d..af37e18e4 100644 --- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm +++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm @@ -63,7 +63,7 @@ struct MachineDelegate: CRTMachine::Machine::Delegate, public LockProtectedDeleg MachineDelegate _machineDelegate; NSLock *_delegateMachineAccessLock; - std::vector _targets; + std::vector _targets; std::unique_ptr _machine; } @@ -185,14 +185,14 @@ struct MachineDelegate: CRTMachine::Machine::Delegate, public LockProtectedDeleg keyboardMachine->type_string([paste UTF8String]); } -- (void)applyTarget:(const StaticAnalyser::Target &)target { +- (void)applyTarget:(const Analyser::Static::Target &)target { @synchronized(self) { ConfigurationTarget::Machine *const configurationTarget = _machine->configuration_target(); if(configurationTarget) configurationTarget->configure_as_target(target); } } -- (void)applyMedia:(const StaticAnalyser::Media &)media { +- (void)applyMedia:(const Analyser::Static::Media &)media { @synchronized(self) { ConfigurationTarget::Machine *const configurationTarget = _machine->configuration_target(); if(configurationTarget) configurationTarget->insert_media(media); diff --git a/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser+TargetVector.h b/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser+TargetVector.h index c7bfa41c4..a7d0dc5a0 100644 --- a/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser+TargetVector.h +++ b/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser+TargetVector.h @@ -10,6 +10,6 @@ @interface CSStaticAnalyser (ResultVector) -- (std::vector &)targets; +- (std::vector &)targets; @end diff --git a/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser.mm b/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser.mm index 41c8196ca..fc29fbc25 100644 --- a/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser.mm +++ b/OSBindings/Mac/Clock Signal/Machine/StaticAnalyser/CSStaticAnalyser.mm @@ -17,13 +17,13 @@ #import "Clock_Signal-Swift.h" @implementation CSStaticAnalyser { - std::vector _targets; + std::vector _targets; } - (instancetype)initWithFileAtURL:(NSURL *)url { self = [super init]; if(self) { - _targets = StaticAnalyser::GetTargets([url fileSystemRepresentation]); + _targets = Analyser::Static::GetTargets([url fileSystemRepresentation]); if(!_targets.size()) return nil; // TODO: could this better be supplied by the analyser? A hypothetical file format might @@ -35,13 +35,13 @@ - (NSString *)optionsPanelNibName { switch(_targets.front().machine) { - case StaticAnalyser::Target::AmstradCPC: return nil; - case StaticAnalyser::Target::Atari2600: return @"Atari2600Options"; - case StaticAnalyser::Target::Electron: return @"QuickLoadCompositeOptions"; - case StaticAnalyser::Target::MSX: return @"QuickLoadCompositeOptions"; - case StaticAnalyser::Target::Oric: return @"OricOptions"; - case StaticAnalyser::Target::Vic20: return @"Vic20Options"; - case StaticAnalyser::Target::ZX8081: return @"ZX8081Options"; + case Analyser::Machine::AmstradCPC: return nil; + case Analyser::Machine::Atari2600: return @"Atari2600Options"; + case Analyser::Machine::Electron: return @"QuickLoadCompositeOptions"; + case Analyser::Machine::MSX: return @"QuickLoadCompositeOptions"; + case Analyser::Machine::Oric: return @"OricOptions"; + case Analyser::Machine::Vic20: return @"Vic20Options"; + case Analyser::Machine::ZX8081: return @"ZX8081Options"; default: return nil; } } @@ -50,20 +50,20 @@ [machine applyTarget:_targets.front()]; } -- (std::vector &)targets { +- (std::vector &)targets { return _targets; } @end @implementation CSMediaSet { - StaticAnalyser::Media _media; + Analyser::Static::Media _media; } - (instancetype)initWithFileAtURL:(NSURL *)url { self = [super init]; if(self) { - _media = StaticAnalyser::GetMedia([url fileSystemRepresentation]); + _media = Analyser::Static::GetMedia([url fileSystemRepresentation]); } return self; } diff --git a/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081+Instantiation.h b/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081+Instantiation.h index 42930215a..600046fb2 100644 --- a/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081+Instantiation.h +++ b/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081+Instantiation.h @@ -11,6 +11,6 @@ @interface CSZX8081 (Instantiation) -- (instancetype)initWithIntendedTarget:(const StaticAnalyser::Target &)target; +- (instancetype)initWithIntendedTarget:(const Analyser::Static::Target &)target; @end diff --git a/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081.mm b/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081.mm index b66f2c0de..86b1adf5b 100644 --- a/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081.mm +++ b/OSBindings/Mac/Clock Signal/Machine/Wrappers/CSZX8081.mm @@ -15,7 +15,7 @@ Machine::TypedDynamicMachine _zx8081; } -- (instancetype)initWithIntendedTarget:(const StaticAnalyser::Target &)target { +- (instancetype)initWithIntendedTarget:(const Analyser::Static::Target &)target { _zx8081 = Machine::TypedDynamicMachine(ZX8081::Machine::ZX8081(target)); return nil;//[super initWithMachine:&_zx8081]; } diff --git a/OSBindings/Mac/Clock SignalTests/AtariStaticAnalyserTests.mm b/OSBindings/Mac/Clock SignalTests/AtariStaticAnalyserTests.mm index 49af40019..8d6319118 100644 --- a/OSBindings/Mac/Clock SignalTests/AtariStaticAnalyserTests.mm +++ b/OSBindings/Mac/Clock SignalTests/AtariStaticAnalyserTests.mm @@ -12,13 +12,13 @@ #include "../../../StaticAnalyser/StaticAnalyser.hpp" @interface AtariROMRecord : NSObject -@property(nonatomic, readonly) StaticAnalyser::Atari2600PagingModel pagingModel; +@property(nonatomic, readonly) Analyser::Static::Atari2600PagingModel pagingModel; @property(nonatomic, readonly) BOOL usesSuperchip; -+ (instancetype)recordWithPagingModel:(StaticAnalyser::Atari2600PagingModel)pagingModel usesSuperchip:(BOOL)usesSuperchip; ++ (instancetype)recordWithPagingModel:(Analyser::Static::Atari2600PagingModel)pagingModel usesSuperchip:(BOOL)usesSuperchip; @end @implementation AtariROMRecord -+ (instancetype)recordWithPagingModel:(StaticAnalyser::Atari2600PagingModel)pagingModel usesSuperchip:(BOOL)usesSuperchip ++ (instancetype)recordWithPagingModel:(Analyser::Static::Atari2600PagingModel)pagingModel usesSuperchip:(BOOL)usesSuperchip { AtariROMRecord *record = [[AtariROMRecord alloc] init]; record->_pagingModel = pagingModel; @@ -27,7 +27,7 @@ } @end -#define Record(sha, model, uses) sha : [AtariROMRecord recordWithPagingModel:StaticAnalyser::Atari2600PagingModel::model usesSuperchip:uses], +#define Record(sha, model, uses) sha : [AtariROMRecord recordWithPagingModel:Analyser::Static::Atari2600PagingModel::model usesSuperchip:uses], static NSDictionary *romRecordsBySHA1 = @{ Record(@"58dbcbdffbe80be97746e94a0a75614e64458fdc", None, NO) // 4kraVCS Record(@"9967a76efb68017f793188f691159f04e6bb4447", None, NO) // 'X'Mission @@ -591,7 +591,7 @@ static NSDictionary *romRecordsBySHA1 = @{ for(int c = 0; c < CC_SHA1_DIGEST_LENGTH; c++) [sha1 appendFormat:@"%02x", sha1Bytes[c]]; // get an analysis of the file - std::list targets = StaticAnalyser::GetTargets([fullPath UTF8String]); + std::list targets = Analyser::Static::GetTargets([fullPath UTF8String]); // grab the ROM record AtariROMRecord *romRecord = romRecordsBySHA1[sha1]; diff --git a/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm b/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm index 5a628a09d..89db00c89 100644 --- a/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm +++ b/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm @@ -12,19 +12,19 @@ #include "../../../StaticAnalyser/StaticAnalyser.hpp" @interface MSXROMRecord : NSObject -@property(nonatomic, readonly) StaticAnalyser::MSXCartridgeType cartridgeType; -+ (instancetype)recordWithCartridgeType:(StaticAnalyser::MSXCartridgeType)cartridgeType; +@property(nonatomic, readonly) Analyser::Static::MSXCartridgeType cartridgeType; ++ (instancetype)recordWithCartridgeType:(Analyser::Static::MSXCartridgeType)cartridgeType; @end @implementation MSXROMRecord -+ (instancetype)recordWithCartridgeType:(StaticAnalyser::MSXCartridgeType)cartridgeType { ++ (instancetype)recordWithCartridgeType:(Analyser::Static::MSXCartridgeType)cartridgeType { MSXROMRecord *record = [[MSXROMRecord alloc] init]; record->_cartridgeType = cartridgeType; return record; } @end -#define Record(sha, type) sha : [MSXROMRecord recordWithCartridgeType:StaticAnalyser::MSXCartridgeType::type], +#define Record(sha, type) sha : [MSXROMRecord recordWithCartridgeType:Analyser::Static::MSXCartridgeType::type], static NSDictionary *romRecordsBySHA1 = @{ Record(@"da397e783d677d1a78fff222d9d6cb48b915dada", ASCII8kb) // 1942 (1986)(ASCII)(JP).rom Record(@"0733cd627467a866846e15caf1770a5594eaf4cc", ASCII8kb) // 1942 (1986)(ASCII)(JP)[a].rom @@ -211,7 +211,7 @@ static NSDictionary *romRecordsBySHA1 = @{ for(int c = 0; c < CC_SHA1_DIGEST_LENGTH; c++) [sha1 appendFormat:@"%02x", sha1Bytes[c]]; // get an analysis of the file - std::list targets = StaticAnalyser::GetTargets([fullPath UTF8String]); + std::list targets = Analyser::Static::GetTargets([fullPath UTF8String]); // grab the ROM record MSXROMRecord *romRecord = romRecordsBySHA1[sha1]; diff --git a/OSBindings/SDL/main.cpp b/OSBindings/SDL/main.cpp index d9faf5067..ee2e45f50 100644 --- a/OSBindings/SDL/main.cpp +++ b/OSBindings/SDL/main.cpp @@ -250,7 +250,7 @@ int main(int argc, char *argv[]) { } // Determine the machine for the supplied file. - std::vector targets = StaticAnalyser::GetTargets(arguments.file_name.c_str()); + std::vector targets = Analyser::Static::GetTargets(arguments.file_name.c_str()); if(targets.empty()) { std::cerr << "Cannot open " << arguments.file_name << std::endl; return -1; @@ -432,7 +432,7 @@ int main(int argc, char *argv[]) { break; case SDL_DROPFILE: { - StaticAnalyser::Media media = StaticAnalyser::GetMedia(event.drop.file); + Analyser::Static::Media media = Analyser::Static::GetMedia(event.drop.file); machine->configuration_target()->insert_media(media); } break; diff --git a/Storage/Tape/Parsers/Commodore.cpp b/Storage/Tape/Parsers/Commodore.cpp index 2d9556a4b..59e619b9f 100644 --- a/Storage/Tape/Parsers/Commodore.cpp +++ b/Storage/Tape/Parsers/Commodore.cpp @@ -257,7 +257,7 @@ uint16_t Parser::get_next_short(const std::shared_ptr &tape } /*! - Per the contract with StaticAnalyser::TapeParser; sums time across pulses. If this pulse + Per the contract with Analyser::Static::TapeParser; sums time across pulses. If this pulse indicates a high to low transition, inspects the time since the last transition, to produce a long, medium, short or unrecognised wave period. */ @@ -284,7 +284,7 @@ void Parser::process_pulse(const Storage::Tape::Tape::Pulse &pulse) } /*! - Per the contract with StaticAnalyser::TapeParser; produces any of a word marker, an end-of-block marker, + Per the contract with Analyser::Static::TapeParser; produces any of a word marker, an end-of-block marker, a zero, a one or a lead-in symbol based on the currently captured waves. */ void Parser::inspect_waves(const std::vector &waves) diff --git a/Storage/Tape/Parsers/Commodore.hpp b/Storage/Tape/Parsers/Commodore.hpp index 991168595..c1b7eb863 100644 --- a/Storage/Tape/Parsers/Commodore.hpp +++ b/Storage/Tape/Parsers/Commodore.hpp @@ -122,7 +122,7 @@ class Parser: public Storage::Tape::PulseClassificationParser &tape); /*! - Per the contract with StaticAnalyser::TapeParser; sums time across pulses. If this pulse + Per the contract with Analyser::Static::TapeParser; sums time across pulses. If this pulse indicates a high to low transition, inspects the time since the last transition, to produce a long, medium, short or unrecognised wave period. */ @@ -131,7 +131,7 @@ class Parser: public Storage::Tape::PulseClassificationParser &waves);