6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-12-23 20:29:42 +00:00
Code Issues Projects Releases Wiki Activity

'Tape' has joined the new underscore orthodoxy.

Browse Source
This commit is contained in:
Thomas Harte 2016-12-03 12:05:19 -05:00
parent 0dc2aa6454
commit 3f7f2c6117
8 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Storage/Tape/Parsers/Acorn.cpp
View File

@ -12,7 +12,7 @@ using namespace Storage::Tape::Acorn;
Parser::Parser() :
::Storage::Tape::Parser<WaveType, SymbolType>(),
_crc(0x1021, 0x0000) {}
crc_(0x1021, 0x0000) {}
int Parser::get_next_bit(const std::shared_ptr<Storage::Tape::Tape> &tape)
{
@ -38,7 +38,7 @@ int Parser::get_next_byte(const std::shared_ptr<Storage::Tape::Tape> &tape)
set_error_flag();
return -1;
}
_crc.add((uint8_t)value);
crc_.add((uint8_t)value);
return value;
}
@ -56,8 +56,8 @@ int Parser::get_next_word(const std::shared_ptr<Storage::Tape::Tape> &tape)
return result;
}
void Parser::reset_crc() { _crc.reset(); }
uint16_t Parser::get_crc() { return _crc.get_value(); }
void Parser::reset_crc() { crc_.reset(); }
uint16_t Parser::get_crc() { return crc_.get_value(); }
void Parser::process_pulse(Storage::Tape::Tape::Pulse pulse)
{

2
Storage/Tape/Parsers/Acorn.hpp
View File

@ -38,7 +38,7 @@ class Parser: public Storage::Tape::Parser<WaveType, SymbolType> {
private:
void process_pulse(Storage::Tape::Tape::Pulse pulse);
void inspect_waves(const std::vector<WaveType> &waves);
NumberTheory::CRC16 _crc;
NumberTheory::CRC16 crc_;
};
}

28
Storage/Tape/Parsers/Commodore.cpp
View File

@ -13,9 +13,9 @@ using namespace Storage::Tape::Commodore;
Parser::Parser() :
Storage::Tape::Parser<WaveType, SymbolType>(),
_wave_period(0.0f),
_previous_was_high(false),
_parity_byte(0) {}
wave_period_(0.0f),
previous_was_high_(false),
parity_byte_(0) {}
/*!
Advances to the next block on the tape, treating it as a header, then consumes, parses, and returns it.
@ -193,9 +193,9 @@ void Parser::expect_byte(const std::shared_ptr<Storage::Tape::Tape> &tape, uint8
if(next_byte != value) set_error_flag();
}
void Parser::reset_parity_byte() { _parity_byte = 0; }
uint8_t Parser::get_parity_byte() { return _parity_byte; }
void Parser::add_parity_byte(uint8_t byte) { _parity_byte ^= byte; }
void Parser::reset_parity_byte() { parity_byte_ = 0; }
uint8_t Parser::get_parity_byte() { return parity_byte_; }
void Parser::add_parity_byte(uint8_t byte) { parity_byte_ ^= byte; }
/*!
Proceeds to the next word marker then returns the result of @c get_next_byte_contents.
@ -255,19 +255,19 @@ void Parser::process_pulse(Storage::Tape::Tape::Pulse pulse)
// medium: 262µs => 0.000524s cycle
// long: 342µs => 0.000684s cycle
bool is_high = pulse.type == Storage::Tape::Tape::Pulse::High;
if(!is_high && _previous_was_high)
if(!is_high && previous_was_high_)
{
if(_wave_period >= 0.000764) push_wave(WaveType::Unrecognised);
else if(_wave_period >= 0.000604) push_wave(WaveType::Long);
else if(_wave_period >= 0.000444) push_wave(WaveType::Medium);
else if(_wave_period >= 0.000284) push_wave(WaveType::Short);
if(wave_period_ >= 0.000764) push_wave(WaveType::Unrecognised);
else if(wave_period_ >= 0.000604) push_wave(WaveType::Long);
else if(wave_period_ >= 0.000444) push_wave(WaveType::Medium);
else if(wave_period_ >= 0.000284) push_wave(WaveType::Short);
else push_wave(WaveType::Unrecognised);
_wave_period = 0.0f;
wave_period_ = 0.0f;
}
_wave_period += pulse.length.get_float();
_previous_was_high = is_high;
wave_period_ += pulse.length.get_float();
previous_was_high_ = is_high;
}
/*!

6
Storage/Tape/Parsers/Commodore.hpp
View File

@ -94,7 +94,7 @@ class Parser: public Storage::Tape::Parser<WaveType, SymbolType> {
*/
void expect_byte(const std::shared_ptr<Storage::Tape::Tape> &tape, uint8_t value);
uint8_t _parity_byte;
uint8_t parity_byte_;
void reset_parity_byte();
uint8_t get_parity_byte();
void add_parity_byte(uint8_t byte);
@ -122,8 +122,8 @@ class Parser: public Storage::Tape::Parser<WaveType, SymbolType> {
a long, medium, short or unrecognised wave period.
*/
void process_pulse(Storage::Tape::Tape::Pulse pulse);
bool _previous_was_high;
float _wave_period;
bool previous_was_high_;
float wave_period_;
/*!
Per the contract with StaticAnalyser::TapeParser; produces any of a word marker, an end-of-block marker,

24
Storage/Tape/Parsers/Oric.cpp
View File

@ -12,8 +12,8 @@ using namespace Storage::Tape::Oric;
int Parser::get_next_byte(const std::shared_ptr<Storage::Tape::Tape> &tape, bool use_fast_encoding)
{
_detection_mode = use_fast_encoding ? FastZero : SlowZero;
_cycle_length = 0.0f;
detection_mode_ = use_fast_encoding ? FastZero : SlowZero;
cycle_length_ = 0.0f;
int result = 0;
int bit_count = 0;
@ -21,7 +21,7 @@ int Parser::get_next_byte(const std::shared_ptr<Storage::Tape::Tape> &tape, bool
{
SymbolType symbol = get_next_symbol(tape);
if(!bit_count && symbol != SymbolType::Zero) continue;
_detection_mode = use_fast_encoding ? FastData : SlowData;
detection_mode_ = use_fast_encoding ? FastData : SlowData;
result |= ((symbol == SymbolType::One) ? 1 : 0) << bit_count;
bit_count++;
}
@ -31,7 +31,7 @@ int Parser::get_next_byte(const std::shared_ptr<Storage::Tape::Tape> &tape, bool
bool Parser::sync_and_get_encoding_speed(const std::shared_ptr<Storage::Tape::Tape> &tape)
{
_detection_mode = Sync;
detection_mode_ = Sync;
while(!tape->is_at_end())
{
SymbolType symbol = get_next_symbol(tape);
@ -52,22 +52,22 @@ void Parser::process_pulse(Storage::Tape::Tape::Pulse pulse)
const float maximum_long_length = 0.001456f;
bool wave_is_high = pulse.type == Storage::Tape::Tape::Pulse::High;
if(!_wave_was_high && wave_is_high != _wave_was_high)
if(!wave_was_high_ && wave_is_high != wave_was_high_)
{
if(_cycle_length < maximum_short_length) push_wave(WaveType::Short);
else if(_cycle_length < maximum_medium_length) push_wave(WaveType::Medium);
else if(_cycle_length < maximum_long_length) push_wave(WaveType::Long);
if(cycle_length_ < maximum_short_length) push_wave(WaveType::Short);
else if(cycle_length_ < maximum_medium_length) push_wave(WaveType::Medium);
else if(cycle_length_ < maximum_long_length) push_wave(WaveType::Long);
else push_wave(WaveType::Unrecognised);
_cycle_length = 0.0f;
cycle_length_ = 0.0f;
}
_wave_was_high = wave_is_high;
_cycle_length += pulse.length.get_float();
wave_was_high_ = wave_is_high;
cycle_length_ += pulse.length.get_float();
}
void Parser::inspect_waves(const std::vector<WaveType> &waves)
{
switch(_detection_mode)
switch(detection_mode_)
{
case FastZero:
if(waves.empty()) return;

6
Storage/Tape/Parsers/Oric.hpp
View File

@ -41,9 +41,9 @@ class Parser: public Storage::Tape::Parser<WaveType, SymbolType> {
FastZero,
SlowZero,
Sync
} _detection_mode;
bool _wave_was_high;
float _cycle_length;
} detection_mode_;
bool wave_was_high_;
float cycle_length_;
struct Pattern
{

50
Storage/Tape/Tape.cpp
View File

@ -21,23 +21,23 @@ TapePlayer::TapePlayer(unsigned int input_clock_rate) :
void Storage::Tape::Tape::seek(Time &seek_time)
{
_current_time.set_zero();
_next_time.set_zero();
while(_next_time < seek_time) get_next_pulse();
current_time_.set_zero();
next_time_.set_zero();
while(next_time_ < seek_time) get_next_pulse();
}
void Storage::Tape::Tape::reset()
{
_current_time.set_zero();
_next_time.set_zero();
current_time_.set_zero();
next_time_.set_zero();
virtual_reset();
}
Tape::Pulse Tape::get_next_pulse()
{
Tape::Pulse pulse = virtual_get_next_pulse();
_current_time = _next_time;
_next_time += pulse.length;
current_time_ = next_time_;
next_time_ += pulse.length;
return pulse;
}
@ -45,34 +45,34 @@ Tape::Pulse Tape::get_next_pulse()
void TapePlayer::set_tape(std::shared_ptr<Storage::Tape::Tape> tape)
{
_tape = tape;
tape_ = tape;
reset_timer();
get_next_pulse();
}
std::shared_ptr<Storage::Tape::Tape> TapePlayer::get_tape()
{
return _tape;
return tape_;
}
bool TapePlayer::has_tape()
{
return (bool)_tape;
return (bool)tape_;
}
void TapePlayer::get_next_pulse()
{
// get the new pulse
if(_tape)
_current_pulse = _tape->get_next_pulse();
if(tape_)
current_pulse_ = tape_->get_next_pulse();
else
{
_current_pulse.length.length = 1;
_current_pulse.length.clock_rate = 1;
_current_pulse.type = Tape::Pulse::Zero;
current_pulse_.length.length = 1;
current_pulse_.length.clock_rate = 1;
current_pulse_.type = Tape::Pulse::Zero;
}
set_next_event_time_interval(_current_pulse.length);
set_next_event_time_interval(current_pulse_.length);
}
void TapePlayer::run_for_cycles(int number_of_cycles)
@ -90,19 +90,19 @@ void TapePlayer::run_for_input_pulse()
void TapePlayer::process_next_event()
{
process_input_pulse(_current_pulse);
process_input_pulse(current_pulse_);
get_next_pulse();
}
#pragma mark - Binary Player
BinaryTapePlayer::BinaryTapePlayer(unsigned int input_clock_rate) :
TapePlayer(input_clock_rate), _motor_is_running(false)
TapePlayer(input_clock_rate), motor_is_running_(false)
{}
void BinaryTapePlayer::set_motor_control(bool enabled)
{
_motor_is_running = enabled;
motor_is_running_ = enabled;
}
void BinaryTapePlayer::set_tape_output(bool set)
@ -112,26 +112,26 @@ void BinaryTapePlayer::set_tape_output(bool set)
bool BinaryTapePlayer::get_input()
{
return _input_level;
return input_level_;
}
void BinaryTapePlayer::run_for_cycles(int number_of_cycles)
{
if(_motor_is_running) TapePlayer::run_for_cycles(number_of_cycles);
if(motor_is_running_) TapePlayer::run_for_cycles(number_of_cycles);
}
void BinaryTapePlayer::set_delegate(Delegate *delegate)
{
_delegate = delegate;
delegate_ = delegate;
}
void BinaryTapePlayer::process_input_pulse(Storage::Tape::Tape::Pulse pulse)
{
bool new_input_level = pulse.type == Tape::Pulse::Low;
if(_input_level != new_input_level)
if(input_level_ != new_input_level)
{
_input_level = new_input_level;
if(_delegate) _delegate->tape_did_change_input(this);
input_level_ = new_input_level;
if(delegate_) delegate_->tape_did_change_input(this);
}
}

14
Storage/Tape/Tape.hpp
View File

@ -53,13 +53,13 @@ class Tape {
virtual bool is_at_end() = 0;
/// @returns the amount of time preceeding the most recently-returned pulse.
virtual Time get_current_time() { return _current_time; }
virtual Time get_current_time() { return current_time_; }
/// Advances or reverses the tape to the last time before or at @c time from which a pulse starts.
virtual void seek(Time &time);
private:
Time _current_time, _next_time;
Time current_time_, next_time_;
virtual Pulse virtual_get_next_pulse() = 0;
virtual void virtual_reset() = 0;
@ -90,8 +90,8 @@ class TapePlayer: public TimedEventLoop {
private:
inline void get_next_pulse();
std::shared_ptr<Storage::Tape::Tape> _tape;
Tape::Pulse _current_pulse;
std::shared_ptr<Storage::Tape::Tape> tape_;
Tape::Pulse current_pulse_;
};
/*!
@ -118,10 +118,10 @@ class BinaryTapePlayer: public TapePlayer {
void set_delegate(Delegate *delegate);
protected:
Delegate *_delegate;
Delegate *delegate_;
virtual void process_input_pulse(Storage::Tape::Tape::Pulse pulse);
bool _input_level;
bool _motor_is_running;
bool input_level_;
bool motor_is_running_;
};
}