From b89ecadc3a0c54331ac9008d90f6ad449c727cb6 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Tue, 3 Dec 2024 22:54:29 -0500 Subject: [PATCH] Improve interface. --- Machines/Acorn/Electron/Electron.cpp | 2 +- Machines/Acorn/Electron/Tape.cpp | 2 +- Machines/Acorn/Electron/Tape.hpp | 4 +- Machines/AmstradCPC/AmstradCPC.cpp | 6 +-- Machines/Commodore/Vic-20/Vic20.cpp | 14 ++--- Machines/MSX/MSX.cpp | 4 +- Machines/Oric/Oric.cpp | 8 +-- Machines/Sinclair/ZX8081/ZX8081.cpp | 10 ++-- Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp | 10 ++-- Storage/Tape/Formats/CAS.cpp | 2 +- Storage/Tape/Formats/CAS.hpp | 2 +- Storage/Tape/Formats/CSW.cpp | 24 +++++---- Storage/Tape/Formats/CSW.hpp | 2 +- Storage/Tape/Formats/CommodoreTAP.cpp | 4 +- Storage/Tape/Formats/CommodoreTAP.hpp | 2 +- Storage/Tape/Formats/OricTAP.cpp | 2 +- Storage/Tape/Formats/OricTAP.hpp | 2 +- Storage/Tape/Formats/TZX.cpp | 58 ++++++++++----------- Storage/Tape/Formats/TZX.hpp | 2 +- Storage/Tape/Formats/TapePRG.cpp | 8 +-- Storage/Tape/Formats/TapePRG.hpp | 2 +- Storage/Tape/Formats/TapeUEF.cpp | 7 ++- Storage/Tape/Formats/TapeUEF.hpp | 2 +- Storage/Tape/Formats/ZX80O81P.cpp | 2 +- Storage/Tape/Formats/ZX80O81P.hpp | 2 +- Storage/Tape/Formats/ZXSpectrumTAP.cpp | 2 +- Storage/Tape/Formats/ZXSpectrumTAP.hpp | 2 +- Storage/Tape/Parsers/MSX.cpp | 48 ++++++++--------- Storage/Tape/Parsers/TapeParser.hpp | 2 +- Storage/Tape/PulseQueuedTape.cpp | 4 +- Storage/Tape/PulseQueuedTape.hpp | 12 ++--- Storage/Tape/Tape.cpp | 36 ++++++------- Storage/Tape/Tape.hpp | 44 ++++++++-------- 33 files changed, 168 insertions(+), 165 deletions(-) diff --git a/Machines/Acorn/Electron/Electron.cpp b/Machines/Acorn/Electron/Electron.cpp index 8bdba0b7b..fdf095255 100644 --- a/Machines/Acorn/Electron/Electron.cpp +++ b/Machines/Acorn/Electron/Electron.cpp @@ -454,7 +454,7 @@ public: int cycles_left_while_plausibly_in_data = 50; tape_.clear_interrupts(Interrupt::ReceiveDataFull); - while(!tape_.get_tape()->is_at_end()) { + while(!tape_.tape()->is_at_end()) { tape_.run_for_input_pulse(); --cycles_left_while_plausibly_in_data; if(!cycles_left_while_plausibly_in_data) fast_load_is_in_data_ = false; diff --git a/Machines/Acorn/Electron/Tape.cpp b/Machines/Acorn/Electron/Tape.cpp index 73d55a4a0..bb6580985 100644 --- a/Machines/Acorn/Electron/Tape.cpp +++ b/Machines/Acorn/Electron/Tape.cpp @@ -68,7 +68,7 @@ uint8_t Tape::get_data_register() { return uint8_t(data_register_ >> 2); } -void Tape::process_input_pulse(const Storage::Tape::Pulse &pulse) { +void Tape::process(const Storage::Tape::Pulse &pulse) { shifter_.process_pulse(pulse); } diff --git a/Machines/Acorn/Electron/Tape.hpp b/Machines/Acorn/Electron/Tape.hpp index 1ecf532b2..548dde30d 100644 --- a/Machines/Acorn/Electron/Tape.hpp +++ b/Machines/Acorn/Electron/Tape.hpp @@ -43,10 +43,10 @@ public: inline void set_is_enabled(bool is_enabled) { is_enabled_ = is_enabled; } void set_is_in_input_mode(bool is_in_input_mode); - void acorn_shifter_output_bit(int value); + void acorn_shifter_output_bit(int value) override; private: - void process_input_pulse(const Storage::Tape::Pulse &pulse); + void process(const Storage::Tape::Pulse &pulse) override; inline void push_tape_bit(uint16_t bit); inline void get_next_tape_pulse(); diff --git a/Machines/AmstradCPC/AmstradCPC.cpp b/Machines/AmstradCPC/AmstradCPC.cpp index 04ded757c..dfa0ebcdb 100644 --- a/Machines/AmstradCPC/AmstradCPC.cpp +++ b/Machines/AmstradCPC/AmstradCPC.cpp @@ -721,7 +721,7 @@ public: case 0: return ay_.ay().get_data_output(); // Port A is wired to the AY case 1: return (crtc_.get_bus_state().vsync ? 0x01 : 0x00) | // Bit 0 returns CRTC vsync. - (tape_player_.get_input() ? 0x80 : 0x00) | // Bit 7 returns cassette input. + (tape_player_.input() ? 0x80 : 0x00) | // Bit 7 returns cassette input. 0x7e; // Bits unimplemented: // // Bit 6: printer ready (1 = not) @@ -899,8 +899,8 @@ public: // Seed with the current pulse; the CPC will have finished the // preceding symbol and be a short way into the pulse that should determine the // first bit of this byte. - parser.process_pulse(tape_player_.get_current_pulse()); - const auto byte = parser.get_byte(tape_player_.get_tape()); + parser.process_pulse(tape_player_.current_pulse()); + const auto byte = parser.get_byte(tape_player_.tape()); auto flags = z80_.value_of(CPU::Z80::Register::Flags); if(byte) { diff --git a/Machines/Commodore/Vic-20/Vic20.cpp b/Machines/Commodore/Vic-20/Vic20.cpp index 54ea08660..dfc0462c4 100644 --- a/Machines/Commodore/Vic-20/Vic20.cpp +++ b/Machines/Commodore/Vic-20/Vic20.cpp @@ -526,9 +526,9 @@ class ConcreteMachine: // Address 0xf7b2 contains a JSR to 0xf8c0 that will fill the tape buffer with the next header. // So cancel that via a double NOP and fill in the next header programmatically. Storage::Tape::Commodore::Parser parser; - std::unique_ptr header = parser.get_next_header(tape_->get_tape()); + std::unique_ptr header = parser.get_next_header(tape_->tape()); - const uint64_t tape_position = tape_->get_tape()->get_offset(); + const auto tape_position = tape_->tape()->offset(); if(header) { // serialise to wherever b2:b3 points const uint16_t tape_buffer_pointer = uint16_t(ram_[0xb2]) | uint16_t(ram_[0xb3] << 8); @@ -537,7 +537,7 @@ class ConcreteMachine: logger.info().append("Found header"); } else { // no header found, so pretend this hack never interceded - tape_->get_tape()->set_offset(tape_position); + tape_->tape()->set_offset(tape_position); hold_tape_ = false; logger.info().append("Didn't find header"); } @@ -551,8 +551,8 @@ class ConcreteMachine: uint8_t x = uint8_t(m6502_.value_of(CPU::MOS6502::Register::X)); if(x == 0xe) { Storage::Tape::Commodore::Parser parser; - const uint64_t tape_position = tape_->get_tape()->get_offset(); - const std::unique_ptr data = parser.get_next_data(tape_->get_tape()); + const auto tape_position = tape_->tape()->offset(); + const std::unique_ptr data = parser.get_next_data(tape_->tape()); if(data) { uint16_t start_address, end_address; start_address = uint16_t(ram_[0xc1] | (ram_[0xc2] << 8)); @@ -582,7 +582,7 @@ class ConcreteMachine: hold_tape_ = true; logger.info().append("Found data"); } else { - tape_->get_tape()->set_offset(tape_position); + tape_->tape()->set_offset(tape_position); hold_tape_ = false; logger.info().append("Didn't find data"); } @@ -670,7 +670,7 @@ class ConcreteMachine: } void tape_did_change_input(Storage::Tape::BinaryTapePlayer *tape) final { - keyboard_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !tape->get_input()); + keyboard_via_.set_control_line_input(MOS::MOS6522::Port::A, MOS::MOS6522::Line::One, !tape->input()); } KeyboardMapper *get_keyboard_mapper() final { diff --git a/Machines/MSX/MSX.cpp b/Machines/MSX/MSX.cpp index 412627fdf..4d9950191 100644 --- a/Machines/MSX/MSX.cpp +++ b/Machines/MSX/MSX.cpp @@ -82,7 +82,7 @@ class AYPortHandler: public GI::AY38910::PortHandler { return (static_cast(joysticks_[selected_joystick_].get())->get_state() & 0x3f) | 0x40 | - (tape_player_.get_input() ? 0x00 : 0x80); + (tape_player_.input() ? 0x00 : 0x80); } return 0xff; } @@ -893,7 +893,7 @@ class ConcreteMachine: activity_observer_ = observer; if(activity_observer_) { activity_observer_->register_led("Tape motor"); - activity_observer_->set_led_status("Tape motor", tape_player_.get_motor_control()); + activity_observer_->set_led_status("Tape motor", tape_player_.motor_control()); } } diff --git a/Machines/Oric/Oric.cpp b/Machines/Oric/Oric.cpp index eab424a5d..1185e0c99 100644 --- a/Machines/Oric/Oric.cpp +++ b/Machines/Oric/Oric.cpp @@ -168,7 +168,7 @@ class TapePlayer: public Storage::Tape::BinaryTapePlayer { @returns The next byte from the tape. */ uint8_t get_next_byte(bool use_fast_encoding) { - return uint8_t(parser_.get_next_byte(get_tape(), use_fast_encoding)); + return uint8_t(parser_.get_next_byte(tape(), use_fast_encoding)); } private: @@ -469,7 +469,7 @@ template is_at_end()) { + !tape_player_.tape()->is_at_end()) { uint8_t next_byte = tape_player_.get_next_byte(!ram_[tape_speed_address_]); m6502_.set_value_of(CPU::MOS6502Esque::A, next_byte); @@ -632,8 +632,8 @@ template vsync() ); } diff --git a/Machines/Sinclair/ZX8081/ZX8081.cpp b/Machines/Sinclair/ZX8081/ZX8081.cpp index 95a6a2575..e2273717f 100644 --- a/Machines/Sinclair/ZX8081/ZX8081.cpp +++ b/Machines/Sinclair/ZX8081/ZX8081.cpp @@ -185,7 +185,7 @@ template class ConcreteMachine: if(!nmi_is_enabled_) set_vsync(true); value &= keyboard_.read(address); - value &= ~(tape_player_.get_input() ? 0x00 : 0x80); + value &= ~(tape_player_.input() ? 0x00 : 0x80); } // The below emulates the ZonX AY expansion device. @@ -232,8 +232,8 @@ template class ConcreteMachine: case CPU::Z80::PartialMachineCycle::ReadOpcode: // Check for use of the fast tape hack. if(use_fast_tape_hack_ && address == tape_trap_address_) { - const uint64_t prior_offset = tape_player_.get_tape()->get_offset(); - const int next_byte = parser_.get_next_byte(tape_player_.get_tape()); + const uint64_t prior_offset = tape_player_.tape()->offset(); + const int next_byte = parser_.get_next_byte(tape_player_.tape()); if(next_byte != -1) { const uint16_t hl = z80_.value_of(CPU::Z80::Register::HL); ram_[hl & ram_mask_] = uint8_t(next_byte); @@ -246,7 +246,7 @@ template class ConcreteMachine: tape_advance_delay_ = 1000; return 0; } else { - tape_player_.get_tape()->set_offset(prior_offset); + tape_player_.tape()->set_offset(prior_offset); } } @@ -365,7 +365,7 @@ template class ConcreteMachine: } bool get_tape_is_playing() final { - return tape_player_.get_motor_control(); + return tape_player_.motor_control(); } // MARK: - Typer timing diff --git a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp index a94b715f0..34d5bbc7e 100644 --- a/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp +++ b/Machines/Sinclair/ZXSpectrum/ZXSpectrum.cpp @@ -541,7 +541,7 @@ template class ConcreteMachine: // b6: tape input *cycle.value &= keyboard_.read(address); - *cycle.value &= tape_player_.get_input() ? 0xbf : 0xff; + *cycle.value &= tape_player_.input() ? 0xbf : 0xff; // Add Joystick input on top. if(!(address&0x1000)) *cycle.value &= static_cast(joysticks_[0].get())->get_sinclair(0); @@ -716,7 +716,7 @@ template class ConcreteMachine: } bool get_tape_is_playing() final { - return tape_player_.get_motor_control(); + return tape_player_.motor_control(); } // MARK: - Configuration options. @@ -921,7 +921,7 @@ template class ConcreteMachine: if(!(flags & 1)) return false; const uint8_t block_type = uint8_t(z80_.value_of(Register::ADash)); - const auto block = parser.find_block(tape_player_.get_tape()); + const auto block = parser.find_block(tape_player_.tape()); if(!block || block_type != (*block).type) return false; uint16_t length = z80_.value_of(Register::DE); @@ -930,7 +930,7 @@ template class ConcreteMachine: flags = 0x93; uint8_t parity = 0x00; while(length--) { - auto next = parser.get_byte(tape_player_.get_tape()); + auto next = parser.get_byte(tape_player_.tape()); if(!next) { flags &= ~1; break; @@ -941,7 +941,7 @@ template class ConcreteMachine: ++target; } - auto stored_parity = parser.get_byte(tape_player_.get_tape()); + auto stored_parity = parser.get_byte(tape_player_.tape()); if(!stored_parity) { flags &= ~1; } else { diff --git a/Storage/Tape/Formats/CAS.cpp b/Storage/Tape/Formats/CAS.cpp index cfca7aa43..43f1821a6 100644 --- a/Storage/Tape/Formats/CAS.cpp +++ b/Storage/Tape/Formats/CAS.cpp @@ -181,7 +181,7 @@ void CAS::Serialiser::reset() { distance_into_bit_ = 0; } -Pulse CAS::Serialiser::get_next_pulse() { +Pulse CAS::Serialiser::next_pulse() { Pulse pulse; pulse.length.clock_rate = 9600; // Clock rate is four times the baud rate (of 2400), because the quickest thing that might need diff --git a/Storage/Tape/Formats/CAS.hpp b/Storage/Tape/Formats/CAS.hpp index f21904fbc..afb9a4aa4 100644 --- a/Storage/Tape/Formats/CAS.hpp +++ b/Storage/Tape/Formats/CAS.hpp @@ -40,7 +40,7 @@ private: private: bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; // Storage for the array of data blobs to transcribe into audio; // each chunk is preceded by a header which may be long, and is optionally diff --git a/Storage/Tape/Formats/CSW.cpp b/Storage/Tape/Formats/CSW.cpp index 7524bc2ca..12b90e6dd 100644 --- a/Storage/Tape/Formats/CSW.cpp +++ b/Storage/Tape/Formats/CSW.cpp @@ -21,8 +21,7 @@ CSW::CSW(const std::vector &&data, CompressionType type, bool initial_l serialiser_(std::move(data), type, initial_level, sampling_rate) {} -CSW::Serialiser::Serialiser(const std::string &file_name) : - source_data_pointer_(0) { +CSW::Serialiser::Serialiser(const std::string &file_name) : source_data_pointer_(0) { Storage::FileHolder file(file_name, FileHolder::FileMode::Read); if(file.stats().st_size < 0x20) throw ErrorNotCSW; @@ -35,8 +34,8 @@ CSW::Serialiser::Serialiser(const std::string &file_name) : if(file.get8() != 0x1a) throw ErrorNotCSW; // Get version file number. - uint8_t major_version = file.get8(); - uint8_t minor_version = file.get8(); + const uint8_t major_version = file.get8(); + const uint8_t minor_version = file.get8(); // Reject if this is an unknown version. if(major_version > 2 || !major_version || minor_version > 1) throw ErrorNotCSW; @@ -70,7 +69,7 @@ CSW::Serialiser::Serialiser(const std::string &file_name) : // Grab all data remaining in the file. std::vector file_data; - std::size_t remaining_data = size_t(file.stats().st_size) - size_t(file.tell()); + const std::size_t remaining_data = size_t(file.stats().st_size) - size_t(file.tell()); file_data.resize(remaining_data); file.read(file_data.data(), remaining_data); @@ -93,7 +92,12 @@ CSW::Serialiser::Serialiser(const std::string &file_name) : invert_pulse(); } -CSW::Serialiser::Serialiser(const std::vector &&data, CompressionType compression_type, bool initial_level, uint32_t sampling_rate) : compression_type_(compression_type) { +CSW::Serialiser::Serialiser( + const std::vector &&data, + CompressionType compression_type, + bool initial_level, + uint32_t sampling_rate +) : compression_type_(compression_type) { pulse_.length.clock_rate = sampling_rate; pulse_.type = initial_level ? Pulse::High : Pulse::Low; source_data_ = std::move(data); @@ -101,14 +105,16 @@ CSW::Serialiser::Serialiser(const std::vector &&data, CompressionType c uint8_t CSW::Serialiser::get_next_byte() { if(source_data_pointer_ == source_data_.size()) return 0xff; - uint8_t result = source_data_[source_data_pointer_]; + + const uint8_t result = source_data_[source_data_pointer_]; source_data_pointer_++; return result; } uint32_t CSW::Serialiser::get_next_int32le() { if(source_data_pointer_ > source_data_.size() - 4) return 0xffff; - uint32_t result = uint32_t( + + const uint32_t result = uint32_t( (source_data_[source_data_pointer_ + 0] << 0) | (source_data_[source_data_pointer_ + 1] << 8) | (source_data_[source_data_pointer_ + 2] << 16) | @@ -129,7 +135,7 @@ void CSW::Serialiser::reset() { source_data_pointer_ = 0; } -Pulse CSW::Serialiser::get_next_pulse() { +Pulse CSW::Serialiser::next_pulse() { invert_pulse(); pulse_.length.length = get_next_byte(); if(!pulse_.length.length) pulse_.length.length = get_next_int32le(); diff --git a/Storage/Tape/Formats/CSW.hpp b/Storage/Tape/Formats/CSW.hpp index 19902113f..b61f98c56 100644 --- a/Storage/Tape/Formats/CSW.hpp +++ b/Storage/Tape/Formats/CSW.hpp @@ -51,7 +51,7 @@ private: // implemented to satisfy @c Tape bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; Pulse pulse_; CompressionType compression_type_; diff --git a/Storage/Tape/Formats/CommodoreTAP.cpp b/Storage/Tape/Formats/CommodoreTAP.cpp index 95749fb29..03509fb58 100644 --- a/Storage/Tape/Formats/CommodoreTAP.cpp +++ b/Storage/Tape/Formats/CommodoreTAP.cpp @@ -51,14 +51,14 @@ bool CommodoreTAP::Serialiser::is_at_end() const { return is_at_end_; } -Storage::Tape::Pulse CommodoreTAP::Serialiser::get_next_pulse() { +Storage::Tape::Pulse CommodoreTAP::Serialiser::next_pulse() { if(is_at_end_) { return current_pulse_; } if(current_pulse_.type == Pulse::High) { uint32_t next_length; - uint8_t next_byte = file_.get8(); + const uint8_t next_byte = file_.get8(); if(!updated_layout_ || next_byte > 0) { next_length = uint32_t(next_byte) << 3; } else { diff --git a/Storage/Tape/Formats/CommodoreTAP.hpp b/Storage/Tape/Formats/CommodoreTAP.hpp index cc0e80134..1e26d5616 100644 --- a/Storage/Tape/Formats/CommodoreTAP.hpp +++ b/Storage/Tape/Formats/CommodoreTAP.hpp @@ -39,7 +39,7 @@ private: private: bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; Storage::FileHolder file_; diff --git a/Storage/Tape/Formats/OricTAP.cpp b/Storage/Tape/Formats/OricTAP.cpp index 69678d747..9e349a09e 100644 --- a/Storage/Tape/Formats/OricTAP.cpp +++ b/Storage/Tape/Formats/OricTAP.cpp @@ -44,7 +44,7 @@ void OricTAP::Serialiser::reset() { pulse_counter_ = 0; } -Pulse OricTAP::Serialiser::get_next_pulse() { +Pulse OricTAP::Serialiser::next_pulse() { // Each byte byte is written as 13 bits: 0, eight bits of data, parity, three 1s. if(bit_count_ == 13) { if(next_phase_ != phase_) { diff --git a/Storage/Tape/Formats/OricTAP.hpp b/Storage/Tape/Formats/OricTAP.hpp index 0faa58875..c431ad4f5 100644 --- a/Storage/Tape/Formats/OricTAP.hpp +++ b/Storage/Tape/Formats/OricTAP.hpp @@ -39,7 +39,7 @@ private: private: bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; Storage::FileHolder file_; diff --git a/Storage/Tape/Formats/TZX.cpp b/Storage/Tape/Formats/TZX.cpp index 6b52c28cd..03ee816cb 100644 --- a/Storage/Tape/Formats/TZX.cpp +++ b/Storage/Tape/Formats/TZX.cpp @@ -32,8 +32,8 @@ TZX::Serialiser::Serialiser(const std::string &file_name) : if(file_.get8() != 0x1a) throw ErrorNotTZX; // Get version number - uint8_t major_version = file_.get8(); - uint8_t minor_version = file_.get8(); + const uint8_t major_version = file_.get8(); + const uint8_t minor_version = file_.get8(); // Reject if an incompatible version if(major_version != 1 || minor_version > 21) throw ErrorNotTZX; @@ -53,9 +53,9 @@ void TZX::Serialiser::reset() { post_gap(500); } -void TZX::Serialiser::get_next_pulses() { +void TZX::Serialiser::push_next_pulses() { while(empty()) { - uint8_t chunk_id = file_.get8(); + const uint8_t chunk_id = file_.get8(); if(file_.eof()) { set_is_at_end(true); return; @@ -115,7 +115,7 @@ void TZX::Serialiser::get_csw_recording_block() { CSW csw(std::move(raw_block), (compression_type == 2) ? CSW::CompressionType::ZRLE : CSW::CompressionType::RLE, current_level_, sampling_rate); while(!csw.is_at_end()) { - Pulse next_pulse = csw.get_next_pulse(); + Pulse next_pulse = csw.next_pulse(); current_level_ = (next_pulse.type == Pulse::High); push_back(next_pulse); } @@ -125,17 +125,17 @@ void TZX::Serialiser::get_csw_recording_block() { } void TZX::Serialiser::get_generalised_data_block() { - uint32_t block_length = file_.get32le(); - long endpoint = file_.tell() + long(block_length); - uint16_t pause_after_block = file_.get16le(); + const uint32_t block_length = file_.get32le(); + const long endpoint = file_.tell() + long(block_length); + const uint16_t pause_after_block = file_.get16le(); - uint32_t total_pilot_symbols = file_.get32le(); - uint8_t maximum_pulses_per_pilot_symbol = file_.get8(); - uint8_t symbols_in_pilot_table = file_.get8(); + const uint32_t total_pilot_symbols = file_.get32le(); + const uint8_t maximum_pulses_per_pilot_symbol = file_.get8(); + const uint8_t symbols_in_pilot_table = file_.get8(); - uint32_t total_data_symbols = file_.get32le(); - uint8_t maximum_pulses_per_data_symbol = file_.get8(); - uint8_t symbols_in_data_table = file_.get8(); + const uint32_t total_data_symbols = file_.get32le(); + const uint8_t maximum_pulses_per_data_symbol = file_.get8(); + const uint8_t symbols_in_data_table = file_.get8(); get_generalised_segment(total_pilot_symbols, maximum_pulses_per_pilot_symbol, symbols_in_pilot_table, false); get_generalised_segment(total_data_symbols, maximum_pulses_per_data_symbol, symbols_in_data_table, true); @@ -222,7 +222,7 @@ void TZX::Serialiser::get_standard_speed_data_block() { data_block.data.data_length = file_.get16le(); if(!data_block.data.data_length) return; - uint8_t first_byte = file_.get8(); + const uint8_t first_byte = file_.get8(); data_block.length_of_pilot_tone = (first_byte < 128) ? 8063 : 3223; file_.seek(-1, SEEK_CUR); @@ -275,8 +275,8 @@ void TZX::Serialiser::get_data(const Data &data) { } void TZX::Serialiser::get_pure_tone_data_block() { - uint16_t length_of_pulse = file_.get16le(); - uint16_t nunber_of_pulses = file_.get16le(); + const uint16_t length_of_pulse = file_.get16le(); + const uint16_t nunber_of_pulses = file_.get16le(); post_pulses(nunber_of_pulses, length_of_pulse); } @@ -330,7 +330,7 @@ void TZX::Serialiser::get_pulse_sequence() { } void TZX::Serialiser::get_pause() { - uint16_t duration = file_.get16le(); + const uint16_t duration = file_.get16le(); if(!duration) { // TODO (maybe): post a 'pause the tape' suggestion } else { @@ -428,7 +428,7 @@ void TZX::Serialiser::post_pulse(const Storage::Time &time) { // MARK: - Flow control; currently ignored void TZX::Serialiser::ignore_group_start() { - uint8_t length = file_.get8(); + const uint8_t length = file_.get8(); file_.seek(length, SEEK_CUR); } @@ -436,12 +436,12 @@ void TZX::Serialiser::ignore_group_end() { } void TZX::Serialiser::ignore_jump_to_block() { - uint16_t target = file_.get16le(); + const uint16_t target = file_.get16le(); (void)target; } void TZX::Serialiser::ignore_loop_start() { - uint16_t number_of_repetitions = file_.get16le(); + const uint16_t number_of_repetitions = file_.get16le(); (void)number_of_repetitions; } @@ -449,7 +449,7 @@ void TZX::Serialiser::ignore_loop_end() { } void TZX::Serialiser::ignore_call_sequence() { - uint16_t number_of_entries = file_.get16le(); + const uint16_t number_of_entries = file_.get16le(); file_.seek(number_of_entries * sizeof(uint16_t), SEEK_CUR); } @@ -457,7 +457,7 @@ void TZX::Serialiser::ignore_return_from_sequence() { } void TZX::Serialiser::ignore_select_block() { - uint16_t length_of_block = file_.get16le(); + const uint16_t length_of_block = file_.get16le(); file_.seek(length_of_block, SEEK_CUR); } @@ -467,32 +467,32 @@ void TZX::Serialiser::ignore_stop_tape_if_in_48kb_mode() { void TZX::Serialiser::ignore_custom_info_block() { file_.seek(0x10, SEEK_CUR); - uint32_t length = file_.get32le(); + const uint32_t length = file_.get32le(); file_.seek(length, SEEK_CUR); } // MARK: - Messaging void TZX::Serialiser::ignore_text_description() { - uint8_t length = file_.get8(); + const uint8_t length = file_.get8(); file_.seek(length, SEEK_CUR); } void TZX::Serialiser::ignore_message_block() { - uint8_t time_for_display = file_.get8(); - uint8_t length = file_.get8(); + const uint8_t time_for_display = file_.get8(); + const uint8_t length = file_.get8(); file_.seek(length, SEEK_CUR); (void)time_for_display; } void TZX::Serialiser::ignore_archive_info() { - uint16_t length = file_.get16le(); + const uint16_t length = file_.get16le(); file_.seek(length, SEEK_CUR); } void TZX::Serialiser::get_hardware_type() { // TODO: pick a way to retain and communicate this. - uint8_t number_of_machines = file_.get8(); + const uint8_t number_of_machines = file_.get8(); file_.seek(number_of_machines * 3, SEEK_CUR); } diff --git a/Storage/Tape/Formats/TZX.hpp b/Storage/Tape/Formats/TZX.hpp index c17e282b1..95bbc88c7 100644 --- a/Storage/Tape/Formats/TZX.hpp +++ b/Storage/Tape/Formats/TZX.hpp @@ -39,7 +39,7 @@ private: Storage::FileHolder file_; void reset() override; - void get_next_pulses() override; + void push_next_pulses() override; bool current_level_; diff --git a/Storage/Tape/Formats/TapePRG.cpp b/Storage/Tape/Formats/TapePRG.cpp index 1a1ff9c9c..58e5bce3c 100644 --- a/Storage/Tape/Formats/TapePRG.cpp +++ b/Storage/Tape/Formats/TapePRG.cpp @@ -65,7 +65,7 @@ PRG::Serialiser::Serialiser(const std::string &file_name) : throw ErrorBadFormat; } -Storage::Tape::Pulse PRG::Serialiser::get_next_pulse() { +Storage::Tape::Pulse PRG::Serialiser::next_pulse() { // these are all microseconds per pole constexpr unsigned int leader_zero_length = 179; constexpr unsigned int zero_length = 169; @@ -126,9 +126,9 @@ void PRG::Serialiser::get_next_output_token() { } // determine whether a new byte needs to be queued up - int block_offset = phase_offset_ - block_leadin_length; - int bit_offset = block_offset % 10; - int byte_offset = block_offset / 10; + const int block_offset = phase_offset_ - block_leadin_length; + const int bit_offset = block_offset % 10; + const int byte_offset = block_offset / 10; phase_offset_++; if(!bit_offset && diff --git a/Storage/Tape/Formats/TapePRG.hpp b/Storage/Tape/Formats/TapePRG.hpp index 45a0bdb0d..cdc1e64d7 100644 --- a/Storage/Tape/Formats/TapePRG.hpp +++ b/Storage/Tape/Formats/TapePRG.hpp @@ -38,7 +38,7 @@ private: Serialiser(const std::string &file_name); private: bool is_at_end() const override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; void reset() override; FileHolder file_; diff --git a/Storage/Tape/Formats/TapeUEF.cpp b/Storage/Tape/Formats/TapeUEF.cpp index 455760388..97ce557a7 100644 --- a/Storage/Tape/Formats/TapeUEF.cpp +++ b/Storage/Tape/Formats/TapeUEF.cpp @@ -28,8 +28,7 @@ float gzgetfloat(gzFile file) { was the first byte read from the UEF, Float[1] the second, etc */ /* decode mantissa */ - int mantissa; - mantissa = bytes[0] | (bytes[1] << 8) | ((bytes[2]&0x7f)|0x80) << 16; + const int mantissa = bytes[0] | (bytes[1] << 8) | ((bytes[2]&0x7f)|0x80) << 16; float result = float(mantissa); result = float(ldexp(result, -23)); @@ -82,7 +81,7 @@ UEF::Serialiser::Serialiser(const std::string &file_name) { file_ = gzopen(file_name.c_str(), "rb"); char identifier[10]; - int bytes_read = gzread(file_, identifier, 10); + const int bytes_read = gzread(file_, identifier, 10); if(bytes_read < 10 || std::strcmp(identifier, "UEF File!")) { throw ErrorNotUEF; } @@ -127,7 +126,7 @@ bool UEF::Serialiser::get_next_chunk(Chunk &result) { return true; } -void UEF::Serialiser::get_next_pulses() { +void UEF::Serialiser::push_next_pulses() { while(empty()) { // read chunk details Chunk next_chunk; diff --git a/Storage/Tape/Formats/TapeUEF.hpp b/Storage/Tape/Formats/TapeUEF.hpp index 0df5ca892..4a4435226 100644 --- a/Storage/Tape/Formats/TapeUEF.hpp +++ b/Storage/Tape/Formats/TapeUEF.hpp @@ -60,7 +60,7 @@ private: }; bool get_next_chunk(Chunk &); - void get_next_pulses() override; + void push_next_pulses() override; void queue_implicit_bit_pattern(uint32_t length); void queue_explicit_bit_pattern(uint32_t length); diff --git a/Storage/Tape/Formats/ZX80O81P.cpp b/Storage/Tape/Formats/ZX80O81P.cpp index d83c907f0..9730f4d5e 100644 --- a/Storage/Tape/Formats/ZX80O81P.cpp +++ b/Storage/Tape/Formats/ZX80O81P.cpp @@ -52,7 +52,7 @@ bool ZX80O81P::Serialiser::is_at_end() const { return has_finished_data() && has_ended_final_byte_; } -Pulse ZX80O81P::Serialiser::get_next_pulse() { +Pulse ZX80O81P::Serialiser::next_pulse() { Pulse pulse; // Start with 1 second of silence. diff --git a/Storage/Tape/Formats/ZX80O81P.hpp b/Storage/Tape/Formats/ZX80O81P.hpp index 406005463..08972f888 100644 --- a/Storage/Tape/Formats/ZX80O81P.hpp +++ b/Storage/Tape/Formats/ZX80O81P.hpp @@ -46,7 +46,7 @@ private: private: bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; bool has_finished_data() const; TargetPlatform::Type platform_type_; diff --git a/Storage/Tape/Formats/ZXSpectrumTAP.cpp b/Storage/Tape/Formats/ZXSpectrumTAP.cpp index c64f9b20f..d3e790e57 100644 --- a/Storage/Tape/Formats/ZXSpectrumTAP.cpp +++ b/Storage/Tape/Formats/ZXSpectrumTAP.cpp @@ -49,7 +49,7 @@ void ZXSpectrumTAP::Serialiser::reset() { read_next_block(); } -Pulse ZXSpectrumTAP::Serialiser::get_next_pulse() { +Pulse ZXSpectrumTAP::Serialiser::next_pulse() { // Adopt a general pattern of high then low. Pulse pulse; pulse.type = (distance_into_phase_ & 1) ? Pulse::Type::High : Pulse::Type::Low; diff --git a/Storage/Tape/Formats/ZXSpectrumTAP.hpp b/Storage/Tape/Formats/ZXSpectrumTAP.hpp index 6b6fe3482..550b9ea0c 100644 --- a/Storage/Tape/Formats/ZXSpectrumTAP.hpp +++ b/Storage/Tape/Formats/ZXSpectrumTAP.hpp @@ -53,7 +53,7 @@ private: // Implemented to satisfy @c Tape. bool is_at_end() const override; void reset() override; - Pulse get_next_pulse() override; + Pulse next_pulse() override; } serialiser_; }; diff --git a/Storage/Tape/Parsers/MSX.cpp b/Storage/Tape/Parsers/MSX.cpp index fed2c6a6a..bff397414 100644 --- a/Storage/Tape/Parsers/MSX.cpp +++ b/Storage/Tape/Parsers/MSX.cpp @@ -13,7 +13,7 @@ using namespace Storage::Tape::MSX; std::unique_ptr Parser::find_header(Storage::Tape::BinaryTapePlayer &tape_player) { - if(!tape_player.get_motor_control()) { + if(!tape_player.motor_control()) { return nullptr; } @@ -21,17 +21,17 @@ std::unique_ptr Parser::find_header(Storage::Tape::BinaryTape "When 1,111 cycles have been found with less than 35 microseconds variation in their lengths a header has been located." */ - bool last_level = tape_player.get_input(); + bool last_level = tape_player.input(); float low = std::numeric_limits::max(); float high = std::numeric_limits::min(); int samples = 0; - while(!tape_player.get_tape()->is_at_end()) { + while(!tape_player.tape()->is_at_end()) { float next_length = 0.0f; do { next_length += float(tape_player.get_cycles_until_next_event()) / float(tape_player.get_input_clock_rate()); tape_player.run_for_input_pulse(); - } while(last_level == tape_player.get_input()); - last_level = tape_player.get_input(); + } while(last_level == tape_player.input()); + last_level = tape_player.input(); low = std::min(low, next_length); high = std::max(high, next_length); samples++; @@ -43,24 +43,24 @@ std::unique_ptr Parser::find_header(Storage::Tape::BinaryTape if(samples == 1111*2) break; // Cycles are read, not half-cycles. } - if(tape_player.get_tape()->is_at_end()) return nullptr; + if(tape_player.tape()->is_at_end()) return nullptr; /* "The next 256 cycles are then read (1B34H) and averaged to determine the cassette HI cycle length." */ float total_length = 0.0f; samples = 512; - while(!tape_player.get_tape()->is_at_end()) { + while(!tape_player.tape()->is_at_end()) { total_length += float(tape_player.get_cycles_until_next_event()) / float(tape_player.get_input_clock_rate()); - if(tape_player.get_input() != last_level) { + if(tape_player.input() != last_level) { samples--; if(!samples) break; - last_level = tape_player.get_input(); + last_level = tape_player.input(); } tape_player.run_for_input_pulse(); } - if(tape_player.get_tape()->is_at_end()) return nullptr; + if(tape_player.tape()->is_at_end()) return nullptr; /* This figure is multiplied by 1.5 and placed in LOWLIM where it defines the minimum acceptable length @@ -88,7 +88,7 @@ std::unique_ptr Parser::find_header(Storage::Tape::BinaryTape -1 otherwise. */ int Parser::get_byte(const FileSpeed &speed, Storage::Tape::BinaryTapePlayer &tape_player) { - if(!tape_player.get_motor_control()) { + if(!tape_player.motor_control()) { return -1; } @@ -103,11 +103,11 @@ int Parser::get_byte(const FileSpeed &speed, Storage::Tape::BinaryTapePlayer &ta */ const float minimum_start_bit_duration = float(speed.minimum_start_bit_duration) * 0.00001145f * 0.5f; int input = 0; - while(!tape_player.get_tape()->is_at_end()) { + while(!tape_player.tape()->is_at_end()) { // Find next transition. - bool level = tape_player.get_input(); + bool level = tape_player.input(); float duration = 0.0; - while(level == tape_player.get_input()) { + while(level == tape_player.input()) { duration += float(tape_player.get_cycles_until_next_event()) / float(tape_player.get_input_clock_rate()); tape_player.run_for_input_pulse(); } @@ -131,25 +131,25 @@ int Parser::get_byte(const FileSpeed &speed, Storage::Tape::BinaryTapePlayer &ta float(tape_player.get_input_clock_rate()) ); int bits_left = 8; - bool level = tape_player.get_input(); - while(!tape_player.get_tape()->is_at_end() && bits_left--) { + bool level = tape_player.input(); + while(!tape_player.tape()->is_at_end() && bits_left--) { // Count number of transitions within cycles_per_window. int transitions = 0; int cycles_remaining = cycles_per_window; - while(!tape_player.get_tape()->is_at_end() && cycles_remaining) { + while(!tape_player.tape()->is_at_end() && cycles_remaining) { const int cycles_until_next_event = int(tape_player.get_cycles_until_next_event()); const int cycles_to_run_for = std::min(cycles_until_next_event, cycles_remaining); cycles_remaining -= cycles_to_run_for; tape_player.run_for(Cycles(cycles_to_run_for)); - if(level != tape_player.get_input()) { - level = tape_player.get_input(); + if(level != tape_player.input()) { + level = tape_player.input(); transitions++; } } - if(tape_player.get_tape()->is_at_end()) return -1; + if(tape_player.tape()->is_at_end()) return -1; int next_bit = 0; switch(transitions) { @@ -170,16 +170,16 @@ int Parser::get_byte(const FileSpeed &speed, Storage::Tape::BinaryTapePlayer &ta transition count two more." */ int required_transitions = 2 - (transitions&1); - while(!tape_player.get_tape()->is_at_end()) { + while(!tape_player.tape()->is_at_end()) { tape_player.run_for_input_pulse(); - if(level != tape_player.get_input()) { - level = tape_player.get_input(); + if(level != tape_player.input()) { + level = tape_player.input(); required_transitions--; if(!required_transitions) break; } } - if(tape_player.get_tape()->is_at_end()) return -1; + if(tape_player.tape()->is_at_end()) return -1; } return result; } diff --git a/Storage/Tape/Parsers/TapeParser.hpp b/Storage/Tape/Parsers/TapeParser.hpp index 6118906c3..18ca29d79 100644 --- a/Storage/Tape/Parsers/TapeParser.hpp +++ b/Storage/Tape/Parsers/TapeParser.hpp @@ -29,7 +29,7 @@ public: */ SymbolType get_next_symbol(const std::shared_ptr &tape) { while(!has_next_symbol_ && !tape->is_at_end()) { - process_pulse(tape->get_next_pulse()); + process_pulse(tape->next_pulse()); } if(!has_next_symbol_ && tape->is_at_end()) mark_end(); has_next_symbol_ = false; diff --git a/Storage/Tape/PulseQueuedTape.cpp b/Storage/Tape/PulseQueuedTape.cpp index 383db3bb9..bc5a7d09d 100644 --- a/Storage/Tape/PulseQueuedTape.cpp +++ b/Storage/Tape/PulseQueuedTape.cpp @@ -35,7 +35,7 @@ void PulseQueuedSerialiser::push_back(const Pulse pulse) { queued_pulses_.push_back(pulse); } -Pulse PulseQueuedSerialiser::get_next_pulse() { +Pulse PulseQueuedSerialiser::next_pulse() { const auto silence = [] { return Pulse(Pulse::Type::Zero, Storage::Time(1, 1)); }; @@ -46,7 +46,7 @@ Pulse PulseQueuedSerialiser::get_next_pulse() { if(pulse_pointer_ == queued_pulses_.size()) { clear(); - get_next_pulses(); + push_next_pulses(); if(is_at_end_ || pulse_pointer_ == queued_pulses_.size()) { return silence(); diff --git a/Storage/Tape/PulseQueuedTape.hpp b/Storage/Tape/PulseQueuedTape.hpp index 96a98837f..420203903 100644 --- a/Storage/Tape/PulseQueuedTape.hpp +++ b/Storage/Tape/PulseQueuedTape.hpp @@ -16,11 +16,11 @@ namespace Storage::Tape { /*! Provides a @c Tape with a queue of upcoming pulses and an is-at-end flag. - If is-at-end is set then get_next_pulse() returns a second of silence and - is_at_end() returns true. + If is-at-end is set then @c next_pulse() returns a second of silence and + @c is_at_end() returns @c true. - Otherwise get_next_pulse() returns something from the pulse queue if there is - anything there, and otherwise calls get_next_pulses(). get_next_pulses() is + Otherwise @c next_pulse() returns something from the pulse queue if there is + anything there, and otherwise calls @c push_next_pulses() which is virtual, giving subclasses a chance to provide the next batch of pulses. */ class PulseQueuedSerialiser: public TapeSerialiser { @@ -31,10 +31,10 @@ public: bool empty() const; void set_is_at_end(bool); - Pulse get_next_pulse() override; + Pulse next_pulse() override; bool is_at_end() const override; - virtual void get_next_pulses() = 0; + virtual void push_next_pulses() = 0; private: std::vector queued_pulses_; diff --git a/Storage/Tape/Tape.cpp b/Storage/Tape/Tape.cpp index 6c1050749..e8f97b745 100644 --- a/Storage/Tape/Tape.cpp +++ b/Storage/Tape/Tape.cpp @@ -24,17 +24,17 @@ void Storage::Tape::Tape::seek(const Time seek_time) { Time next_time(0); reset(); while(next_time <= seek_time) { - get_next_pulse(); + next_pulse(); next_time += pulse_.length; } } -Storage::Time Tape::get_current_time() { +Storage::Time Tape::current_time() { Time time(0); - uint64_t steps = get_offset(); + uint64_t steps = offset(); reset(); while(steps--) { - get_next_pulse(); + next_pulse(); time += pulse_.length; } return time; @@ -45,13 +45,13 @@ void Storage::Tape::Tape::reset() { serialiser_.reset(); } -Pulse Tape::get_next_pulse() { - pulse_ = serialiser_.get_next_pulse(); +Pulse Tape::next_pulse() { + pulse_ = serialiser_.next_pulse(); offset_++; return pulse_; } -uint64_t Tape::get_offset() const { +uint64_t Tape::offset() const { return offset_; } @@ -61,7 +61,7 @@ void Tape::set_offset(uint64_t offset) { reset(); } offset -= offset_; - while(offset--) get_next_pulse(); + while(offset--) next_pulse(); } bool Tape::is_at_end() const { @@ -78,11 +78,11 @@ ClockingHint::Preference TapePlayer::preferred_clocking() const { void TapePlayer::set_tape(std::shared_ptr tape) { tape_ = tape; reset_timer(); - get_next_pulse(); + next_pulse(); update_clocking_observer(); } -std::shared_ptr TapePlayer::get_tape() { +std::shared_ptr TapePlayer::tape() { return tape_; } @@ -90,10 +90,10 @@ bool TapePlayer::has_tape() const { return bool(tape_); } -void TapePlayer::get_next_pulse() { +void TapePlayer::next_pulse() { // get the new pulse if(tape_) { - current_pulse_ = tape_->get_next_pulse(); + current_pulse_ = tape_->next_pulse(); if(tape_->is_at_end()) update_clocking_observer(); } else { current_pulse_.length.length = 1; @@ -104,7 +104,7 @@ void TapePlayer::get_next_pulse() { set_next_event_time_interval(current_pulse_.length); } -Pulse TapePlayer::get_current_pulse() const { +Pulse TapePlayer::current_pulse() const { return current_pulse_; } @@ -123,8 +123,8 @@ void TapePlayer::run_for_input_pulse() { } void TapePlayer::process_next_event() { - process_input_pulse(current_pulse_); - get_next_pulse(); + process(current_pulse_); + next_pulse(); } // MARK: - Binary Player @@ -157,7 +157,7 @@ void BinaryTapePlayer::set_activity_observer(Activity::Observer *observer) { } } -bool BinaryTapePlayer::get_motor_control() const { +bool BinaryTapePlayer::motor_control() const { return motor_is_running_; } @@ -165,7 +165,7 @@ void BinaryTapePlayer::set_tape_output(bool) { // TODO } -bool BinaryTapePlayer::get_input() const { +bool BinaryTapePlayer::input() const { return motor_is_running_ && input_level_; } @@ -177,7 +177,7 @@ void BinaryTapePlayer::set_delegate(Delegate *delegate) { delegate_ = delegate; } -void BinaryTapePlayer::process_input_pulse(const Storage::Tape::Pulse &pulse) { +void BinaryTapePlayer::process(const Storage::Tape::Pulse &pulse) { bool new_input_level = pulse.type == Pulse::High; if(input_level_ != new_input_level) { input_level_ = new_input_level; diff --git a/Storage/Tape/Tape.hpp b/Storage/Tape/Tape.hpp index 6442a1a02..8771d577d 100644 --- a/Storage/Tape/Tape.hpp +++ b/Storage/Tape/Tape.hpp @@ -31,9 +31,12 @@ struct Pulse { Pulse() = default; }; +/*! + Provdes the means for tape serialiserion. +*/ class TapeSerialiser { public: - virtual Pulse get_next_pulse() = 0; + virtual Pulse next_pulse() = 0; virtual void reset() = 0; virtual bool is_at_end() const = 0; }; @@ -44,10 +47,6 @@ public: - high pulses exit from zero upward before returning to it; - low pulses exit from zero downward before returning to it; - zero pulses run along zero. - - Subclasses should implement at least @c get_next_pulse and @c reset to provide a serial feeding - of pulses and the ability to return to the start of the feed. They may also implement @c seek if - a better implementation than a linear search from the @c reset time can be implemented. */ class Tape { public: @@ -58,7 +57,7 @@ public: @returns the pulse that begins at the current cursor position. */ - Pulse get_next_pulse(); + Pulse next_pulse(); /// Returns the tape to the beginning. void reset(); @@ -71,7 +70,7 @@ public: required to be at least to the whole pulse. Greater numbers are later than earlier numbers, but not necessarily continuous. */ - uint64_t get_offset() const; + uint64_t offset() const; /*! Moves the tape to the first time at which the specified offset would be returned by get_offset. @@ -81,7 +80,7 @@ public: /*! Calculates and returns the amount of time that has elapsed since the time began. Potentially expensive. */ - Time get_current_time(); + Time current_time(); /*! Seeks to @c time. Potentially expensive. @@ -101,33 +100,32 @@ private: Provides a helper for: (i) retaining a reference to a tape; and (ii) running the tape at a certain input clock rate. - Will call @c process_input_pulse instantaneously upon reaching *the end* of a pulse. Therefore a subclass - can decode pulses into data within process_input_pulse, using the supplied pulse's @c length and @c type. + Will call @c process(Pulse) instantaneously upon reaching *the end* of a pulse. Therefore a subclass + can decode pulses into data within @c process, using the supplied pulse's @c length and @c type. */ class TapePlayer: public TimedEventLoop, public ClockingHint::Source { public: TapePlayer(int input_clock_rate); virtual ~TapePlayer() = default; - void set_tape(std::shared_ptr tape); + void set_tape(std::shared_ptr); bool has_tape() const; - std::shared_ptr get_tape(); + std::shared_ptr tape(); void run_for(const Cycles cycles); - void run_for_input_pulse(); ClockingHint::Preference preferred_clocking() const override; - Pulse get_current_pulse() const; + Pulse current_pulse() const; void complete_pulse(); protected: virtual void process_next_event() override; - virtual void process_input_pulse(const Pulse &pulse) = 0; + virtual void process(const Pulse &) = 0; private: - inline void get_next_pulse(); + inline void next_pulse(); std::shared_ptr tape_; Pulse current_pulse_; @@ -144,26 +142,26 @@ private: class BinaryTapePlayer : public TapePlayer { public: BinaryTapePlayer(int input_clock_rate); - void set_motor_control(bool enabled); - bool get_motor_control() const; + void set_motor_control(bool); + bool motor_control() const; - void set_tape_output(bool set); - bool get_input() const; + void set_tape_output(bool); + bool input() const; void run_for(const Cycles cycles); struct Delegate { - virtual void tape_did_change_input(BinaryTapePlayer *tape_player) = 0; + virtual void tape_did_change_input(BinaryTapePlayer *) = 0; }; void set_delegate(Delegate *delegate); ClockingHint::Preference preferred_clocking() const final; - void set_activity_observer(Activity::Observer *observer); + void set_activity_observer(Activity::Observer *); protected: Delegate *delegate_ = nullptr; - void process_input_pulse(const Storage::Tape::Pulse &pulse) final; + void process(const Pulse &) final; bool input_level_ = false; bool motor_is_running_ = false;