Add a simulacrum of C16+4 emulation.

Analyser/Static/Commodore/Disk.cpp

@@ -14,6 +14,7 @@
 #include <limits>
 #include <vector>
 #include <array>
+#include <unordered_map>
 
 using namespace Analyser::Static::Commodore;
 
@@ -37,7 +38,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 		@returns a sector if one was found; @c nullptr otherwise.
 	*/
-	std::shared_ptr<Sector> sector(const uint8_t track, const uint8_t sector) {
+	const Sector *sector(const uint8_t track, const uint8_t sector) {
 		int difference = int(track) - int(track_);
 		track_ = track;
 
@@ -68,7 +69,7 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 	int index_count_;
 	int bit_count_;
 	uint8_t track_;
-	std::shared_ptr<Sector> sector_cache_[65536];
+	std::unordered_map<uint16_t, std::unique_ptr<Sector>> sector_cache_;
 
 	void process_input_bit(const int value) override {
 		shift_register_ = ((shift_register_ << 1) | unsigned(value)) & 0x3ff;
@@ -111,23 +112,24 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		index_count_++;
 	}
 
-	std::shared_ptr<Sector> get_sector(const uint8_t sector) {
+	const Sector *get_sector(const uint8_t sector) {
 		const uint16_t sector_address = uint16_t((track_ << 8) | sector);
-		if(sector_cache_[sector_address]) return sector_cache_[sector_address];
+		auto existing = sector_cache_.find(sector_address);
+		if(existing != sector_cache_.end()) return existing->second.get();
 
-		const std::shared_ptr<Sector> first_sector = get_next_sector();
+		const auto first_sector = get_next_sector();
 		if(!first_sector) return first_sector;
 		if(first_sector->sector == sector) return first_sector;
 
-		while(1) {
-			const std::shared_ptr<Sector> next_sector = get_next_sector();
+		while(true) {
+			const auto next_sector = get_next_sector();
 			if(next_sector->sector == first_sector->sector) return nullptr;
 			if(next_sector->sector == sector) return next_sector;
 		}
 	}
 
-	std::shared_ptr<Sector> get_next_sector() {
-		auto sector = std::make_shared<Sector>();
+	const Sector *get_next_sector() {
+		auto sector = std::make_unique<Sector>();
 		const int max_index_count = index_count_ + 2;
 
 		while(index_count_ < max_index_count) {
@@ -160,8 +162,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 			if(checksum == get_next_byte()) {
 				uint16_t sector_address = uint16_t((sector->track << 8) | sector->sector);
-				sector_cache_[sector_address] = sector;
-				return sector;
+				auto pair = sector_cache_.emplace(sector_address, std::move(sector));
+				return pair.first->second.get();
 			}
 		}
 
@@ -171,21 +173,29 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	std::vector<File> files;
-	auto parser = std::make_unique<CommodoreGCRParser>();
-	parser->set_disk(disk);
+	CommodoreGCRParser parser;
+	parser.set_disk(disk);
 
 	// Assemble directory.
 	std::vector<uint8_t> directory;
 	uint8_t next_track = 18;
 	uint8_t next_sector = 1;
 	directory.reserve(20 * 1024);	// Probably more than plenty.
+	std::set<std::pair<uint8_t, uint8_t>> visited;
 	while(true) {
-		auto sector = parser->sector(next_track, next_sector);
+		// Don't be fooled by disks that are encoded with a looping directory.
+		const auto key = std::make_pair(next_track, next_sector);
+		if(visited.find(key) != visited.end()) break;
+		visited.insert(key);
+
+		// Append sector to directory and follow next link.
+		const auto sector = parser.sector(next_track, next_sector);
 		if(!sector) break;
 		directory.insert(directory.end(), sector->data.begin(), sector->data.end());
 		next_track = sector->data[0];
 		next_sector = sector->data[1];
 
+		// Check for end-of-directory.
 		if(!next_track) break;
 	}
 
@@ -222,7 +232,7 @@ std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<St
 
 			bool is_first_sector = true;
 			while(next_track) {
-				auto sector = parser->sector(next_track, next_sector);
+				const auto sector = parser.sector(next_track, next_sector);
 				if(!sector) break;
 
 				next_track = sector->data[0];

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -108,7 +108,7 @@ std::optional<BASICAnalysis> analyse(const File &file) {
 	while(true) {
 		// Analysis has failed if there isn't at least one complete BASIC line from here.
 		// Fall back on guessing the start address as a machine code entrypoint.
-		if(size_t(line_address - file.starting_address) + 5 >= file.data.size()) {
+		if(size_t(line_address - file.starting_address) + 5 >= file.data.size() || line_address < file.starting_address) {
 			analysis.machine_code_addresses.push_back(file.starting_address);
 			break;
 		}
@@ -209,10 +209,6 @@ Analyser::Static::TargetList Analyser::Static::Commodore::GetTargets(
 	// Inspect discovered files to try to divine machine and memory model.
 	auto vic_memory_model = Target::MemoryModel::Unexpanded;
 
-	if(files.size() > 1) {
-		printf("");
-	}
-
 	auto it = files.begin();
 	while(it != files.end()) {
 		const auto &file = *it;

Machines/Atari/ST/Video.cpp

@@ -127,7 +127,10 @@ Video::Video() :
 
 	// Show a total of 260 lines; a little short for PAL but a compromise between that and the ST's
 	// usual output height of 200 lines.
-	crt_.set_visible_area(crt_.get_rect_for_area(33, 260, 440, 1700, 4.0f / 3.0f));
+	crt_.set_visible_area(crt_.get_rect_for_area(
+		33, 260,
+		480, 1280,
+		4.0f / 3.0f));
 }
 
 void Video::set_ram(uint16_t *ram, size_t size) {

Machines/Commodore/1540/C1540.hpp

@@ -36,20 +36,20 @@ namespace Commodore::C1540 {
 	Provides an emulation of the C1540.
 */
 class Machine final: public MachineBase {
-	public:
-		static ROM::Request rom_request(Personality personality);
-		Machine(Personality personality, const ROM::Map &roms);
+public:
+	static ROM::Request rom_request(Personality personality);
+	Machine(Personality personality, const ROM::Map &roms);
 
-		/*!
-			Sets the serial bus to which this drive should attach itself.
-		*/
-		void set_serial_bus(std::shared_ptr<::Commodore::Serial::Bus> serial_bus);
+	/*!
+		Sets the serial bus to which this drive should attach itself.
+	*/
+	void set_serial_bus(Commodore::Serial::Bus &);
 
-		/// Advances time.
-		void run_for(const Cycles cycles);
+	/// Advances time.
+	void run_for(Cycles);
 
-		/// Inserts @c disk into the drive.
-		void set_disk(std::shared_ptr<Storage::Disk::Disk> disk);
+	/// Inserts @c disk into the drive.
+	void set_disk(std::shared_ptr<Storage::Disk::Disk> disk);
 };
 
 }

Machines/Commodore/1540/Implementation/C1540.cpp

@@ -16,56 +16,54 @@
 
 using namespace Commodore::C1540;
 
-ROM::Request Machine::rom_request(Personality personality) {
+namespace {
+ROM::Name rom_name(Personality personality) {
 	switch(personality) {
 		default:
-		case Personality::C1540:	return ROM::Request(ROM::Name::Commodore1540);
-		case Personality::C1541:	return ROM::Request(ROM::Name::Commodore1541);
+		case Personality::C1540:	return ROM::Name::Commodore1540;
+		case Personality::C1541:	return ROM::Name::Commodore1541;
 	}
 }
+}
+
+ROM::Request Machine::rom_request(Personality personality) {
+	return ROM::Request(rom_name(personality));
+}
 
 MachineBase::MachineBase(Personality personality, const ROM::Map &roms) :
 		Storage::Disk::Controller(1000000),
 		m6502_(*this),
-		serial_port_VIA_port_handler_(new SerialPortVIA(serial_port_VIA_)),
-		serial_port_(new SerialPort),
+		serial_port_VIA_port_handler_(serial_port_VIA_),
 		drive_VIA_(drive_VIA_port_handler_),
-		serial_port_VIA_(*serial_port_VIA_port_handler_) {
-	// attach the serial port to its VIA and vice versa
-	serial_port_->set_serial_port_via(serial_port_VIA_port_handler_);
-	serial_port_VIA_port_handler_->set_serial_port(serial_port_);
+		serial_port_VIA_(serial_port_VIA_port_handler_) {
+	// Attach the serial port to its VIA and vice versa.
+	serial_port_.set_serial_port_via(serial_port_VIA_port_handler_);
+	serial_port_VIA_port_handler_.set_serial_port(serial_port_);
 
-	// set this instance as the delegate to receive interrupt requests from both VIAs
-	serial_port_VIA_port_handler_->set_interrupt_delegate(this);
+	// Set this instance as the delegate to receive interrupt requests from both VIAs.
+	serial_port_VIA_port_handler_.set_interrupt_delegate(this);
 	drive_VIA_port_handler_.set_interrupt_delegate(this);
 	drive_VIA_port_handler_.set_delegate(this);
 
-	// set a bit rate
+	// Set a bit rate.
 	set_expected_bit_length(Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(3));
 
-	// attach the only drive there is
+	// Attach the only drive there is.
 	emplace_drive(1000000, 300, 2);
 	set_drive(1);
 
-	ROM::Name rom_name;
-	switch(personality) {
-		default:
-		case Personality::C1540:	rom_name = ROM::Name::Commodore1540;	break;
-		case Personality::C1541:	rom_name = ROM::Name::Commodore1541;	break;
-	}
-
-	auto rom = roms.find(rom_name);
+	const auto rom = roms.find(rom_name(personality));
 	if(rom == roms.end()) {
 		throw ROMMachine::Error::MissingROMs;
 	}
-	std::memcpy(rom_, roms.find(rom_name)->second.data(), std::min(sizeof(rom_), roms.find(rom_name)->second.size()));
+	std::memcpy(rom_, rom->second.data(), std::min(sizeof(rom_), rom->second.size()));
 }
 
 Machine::Machine(Personality personality, const ROM::Map &roms) :
 	MachineBase(personality, roms) {}
 
-void Machine::set_serial_bus(std::shared_ptr<::Commodore::Serial::Bus> serial_bus) {
-	Commodore::Serial::AttachPortAndBus(serial_port_, serial_bus);
+void Machine::set_serial_bus(Commodore::Serial::Bus &serial_bus) {
+	Commodore::Serial::attach(serial_port_, serial_bus);
 }
 
 Cycles MachineBase::perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
@@ -155,11 +153,11 @@ void MachineBase::process_index_hole()	{}
 
 // MARK: - Drive VIA delegate
 
-void MachineBase::drive_via_did_step_head(void *, int direction) {
+void MachineBase::drive_via_did_step_head(void *, const int direction) {
 	get_drive().step(Storage::Disk::HeadPosition(direction, 2));
 }
 
-void MachineBase::drive_via_did_set_data_density(void *, int density) {
+void MachineBase::drive_via_did_set_data_density(void *, const int density) {
 	set_expected_bit_length(Storage::Encodings::CommodoreGCR::length_of_a_bit_in_time_zone(unsigned(density)));
 }
 
@@ -174,14 +172,11 @@ uint8_t SerialPortVIA::get_port_input(MOS::MOS6522::Port port) {
 
 void SerialPortVIA::set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t) {
 	if(port) {
-		std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
-		if(serialPort) {
-			attention_acknowledge_level_ = !(value&0x10);
-			data_level_output_ = (value&0x02);
+		attention_acknowledge_level_ = !(value&0x10);
+		data_level_output_ = (value&0x02);
 
-			serialPort->set_output(::Commodore::Serial::Line::Clock, ::Commodore::Serial::LineLevel(!(value&0x08)));
-			update_data_line();
-		}
+		serial_port_->set_output(::Commodore::Serial::Line::Clock, ::Commodore::Serial::LineLevel(!(value&0x08)));
+		update_data_line();
 	}
 }
 
@@ -199,17 +194,14 @@ void SerialPortVIA::set_serial_line_state(::Commodore::Serial::Line line, bool v
 	}
 }
 
-void SerialPortVIA::set_serial_port(const std::shared_ptr<::Commodore::Serial::Port> &serialPort) {
-	serial_port_ = serialPort;
+void SerialPortVIA::set_serial_port(Commodore::Serial::Port &port) {
+	serial_port_ = &port;
 }
 
 void SerialPortVIA::update_data_line() {
-	std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
-	if(serialPort) {
-		// "ATN (Attention) is an input on pin 3 of P2 and P3 that is sensed at PB7 and CA1 of UC3 after being inverted by UA1"
-		serialPort->set_output(::Commodore::Serial::Line::Data,
-			::Commodore::Serial::LineLevel(!data_level_output_ && (attention_level_input_ != attention_acknowledge_level_)));
-	}
+	// "ATN (Attention) is an input on pin 3 of P2 and P3 that is sensed at PB7 and CA1 of UC3 after being inverted by UA1"
+	serial_port_->set_output(::Commodore::Serial::Line::Data,
+		Serial::LineLevel(!data_level_output_ && (attention_level_input_ != attention_acknowledge_level_)));
 }
 
 // MARK: - DriveVIA
@@ -248,23 +240,23 @@ void DriveVIA::set_control_line_output(MOS::MOS6522::Port port, MOS::MOS6522::Li
 void DriveVIA::set_port_output(MOS::MOS6522::Port port, uint8_t value, uint8_t) {
 	if(port) {
 		if(previous_port_b_output_ != value) {
-			// record drive motor state
-			drive_motor_ = !!(value&4);
+			// Record drive motor state.
+			drive_motor_ = value&4;
 
-			// check for a head step
-			int step_difference = ((value&3) - (previous_port_b_output_&3))&3;
+			// Check for a head step.
+			const int step_difference = ((value&3) - (previous_port_b_output_&3))&3;
 			if(step_difference) {
 				if(delegate_) delegate_->drive_via_did_step_head(this, (step_difference == 1) ? 1 : -1);
 			}
 
-			// check for a change in density
-			int density_difference = (previous_port_b_output_^value) & (3 << 5);
+			// Check for a change in density.
+			const int density_difference = (previous_port_b_output_^value) & (3 << 5);
 			if(density_difference && delegate_) {
 				delegate_->drive_via_did_set_data_density(this, (value >> 5)&3);
 			}
 
-			// post the LED status
-			if(observer_) observer_->set_led_status("Drive", !!(value&8));
+			// Post the LED status.
+			if(observer_) observer_->set_led_status("Drive", value&8);
 
 			previous_port_b_output_ = value;
 		}
@@ -275,17 +267,16 @@ void DriveVIA::set_activity_observer(Activity::Observer *observer) {
 	observer_ = observer;
 	if(observer) {
 		observer->register_led("Drive");
-		observer->set_led_status("Drive", !!(previous_port_b_output_&8));
+		observer->set_led_status("Drive", previous_port_b_output_&8);
 	}
 }
 
 // MARK: - SerialPort
 
-void SerialPort::set_input(::Commodore::Serial::Line line, ::Commodore::Serial::LineLevel level) {
-	std::shared_ptr<SerialPortVIA> serialPortVIA = serial_port_VIA_.lock();
-	if(serialPortVIA) serialPortVIA->set_serial_line_state(line, bool(level));
+void SerialPort::set_input(Serial::Line line, Serial::LineLevel level) {
+	serial_port_VIA_->set_serial_line_state(line, bool(level));
 }
 
-void SerialPort::set_serial_port_via(const std::shared_ptr<SerialPortVIA> &serialPortVIA) {
-	serial_port_VIA_ = serialPortVIA;
+void SerialPort::set_serial_port_via(SerialPortVIA &serialPortVIA) {
+	serial_port_VIA_ = &serialPortVIA;
 }