6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-09-08 03:54:27 +00:00
Code Issues Projects Releases Wiki Activity

Sought to reduce the amount of heap nonsense.

Browse Source
This commit is contained in:
Thomas Harte 2016-09-05 19:59:58 -04:00
parent 11850b872d
commit 463b74301d
1 changed files with 55 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
StaticAnalyser/Acorn/Tape.cpp
View File

@ -18,29 +18,7 @@ using namespace StaticAnalyser::Acorn;
*/ */
template <typename WaveType, typename SymbolType> class TapeParser { template <typename WaveType, typename SymbolType> class TapeParser {
public: public:
TapeParser(const std::shared_ptr<Storage::Tape::Tape> &tape) : _tape(tape) {} TapeParser(const std::shared_ptr<Storage::Tape::Tape> &tape) : _tape(tape), _has_next_symbol(false) {}
std::unique_ptr<SymbolType> get_next_symbol()
{
while(!_tape->is_at_end())
{
std::unique_ptr<SymbolType> symbol = dequeue_next_symbol(_wave_queue);
if(symbol) return symbol;
while(!_tape->is_at_end())
{
Storage::Tape::Tape::Pulse next_pulse = _tape->get_next_pulse();
std::unique_ptr<WaveType> next_wave = get_wave_type_for_pulse(next_pulse);
if(next_wave)
{
_wave_queue.push_back(*next_wave);
break;
}
}
}
return nullptr;
}
void reset_error_flag() { _error_flag = false; } void reset_error_flag() { _error_flag = false; }
bool get_error_flag() { return _error_flag; } bool get_error_flag() { return _error_flag; }
@ -48,11 +26,42 @@ template <typename WaveType, typename SymbolType> class TapeParser {
protected: protected:
bool _error_flag; bool _error_flag;
void push_wave(WaveType wave)
{
_wave_queue.push_back(wave);
inspect_waves(_wave_queue);
}
void remove_waves(int number_of_waves)
{
_wave_queue.erase(_wave_queue.begin(), _wave_queue.begin()+number_of_waves);
}
void push_symbol(SymbolType symbol, int number_of_waves)
{
_has_next_symbol = true;
_next_symbol = symbol;
remove_waves(number_of_waves);
}
SymbolType get_next_symbol()
{
while(!_has_next_symbol && !is_at_end())
{
process_pulse(_tape->get_next_pulse());
}
_has_next_symbol = false;
return _next_symbol;
}
private: private:
virtual std::unique_ptr<WaveType> get_wave_type_for_pulse(Storage::Tape::Tape::Pulse) = 0; virtual void process_pulse(Storage::Tape::Tape::Pulse pulse) = 0;
virtual std::unique_ptr<SymbolType> dequeue_next_symbol(std::deque<WaveType> &_wave_queue) = 0; virtual void inspect_waves(const std::vector<WaveType> &waves) = 0;
std::deque<WaveType> _wave_queue;
std::vector<WaveType> _wave_queue;
SymbolType _next_symbol;
bool _has_next_symbol;
std::shared_ptr<Storage::Tape::Tape> _tape; std::shared_ptr<Storage::Tape::Tape> _tape;
}; };
@ -70,8 +79,8 @@ class Acorn1200BaudTapeParser: public TapeParser<WaveType, SymbolType> {
int get_next_bit() int get_next_bit()
{ {
std::unique_ptr<SymbolType> symbol = get_next_symbol(); SymbolType symbol = get_next_symbol();
return (symbol && *symbol == SymbolType::One) ? 1 : 0; return (symbol == SymbolType::One) ? 1 : 0;
} }
int get_next_byte() int get_next_byte()
@ -114,47 +123,45 @@ class Acorn1200BaudTapeParser: public TapeParser<WaveType, SymbolType> {
uint16_t get_crc() { return _crc; } uint16_t get_crc() { return _crc; }
private: private:
std::unique_ptr<WaveType> get_wave_type_for_pulse(Storage::Tape::Tape::Pulse pulse) void process_pulse(Storage::Tape::Tape::Pulse pulse)
{ {
WaveType wave_type = WaveType::Unrecognised;
switch(pulse.type) switch(pulse.type)
{ {
default: break; default: break;
case Storage::Tape::Tape::Pulse::High: case Storage::Tape::Tape::Pulse::High:
case Storage::Tape::Tape::Pulse::Low: case Storage::Tape::Tape::Pulse::Low:
float pulse_length = pulse.length.get_float(); float pulse_length = pulse.length.get_float();
if(pulse_length >= 0.35 / 2400.0 && pulse_length < 0.7 / 2400.0) wave_type = WaveType::Short; if(pulse_length >= 0.35 / 2400.0 && pulse_length < 0.7 / 2400.0) { push_wave(WaveType::Short); return; }
if(pulse_length >= 0.35 / 1200.0 && pulse_length < 0.7 / 1200.0) wave_type = WaveType::Long; if(pulse_length >= 0.35 / 1200.0 && pulse_length < 0.7 / 1200.0) { push_wave(WaveType::Long); return; }
break; break;
} }
return std::unique_ptr<WaveType>(new WaveType(wave_type)); push_wave(WaveType::Unrecognised);
} }
std::unique_ptr<SymbolType> dequeue_next_symbol(std::deque<WaveType> &_wave_queue) void inspect_waves(const std::vector<WaveType> &waves)
{ {
while(_wave_queue.size() && _wave_queue.front() == WaveType::Unrecognised) while(waves.size() && waves[0] == WaveType::Unrecognised)
{ {
_wave_queue.pop_front(); remove_waves(1);
return;
} }
if(_wave_queue.size() >= 2 && _wave_queue[0] == WaveType::Long && _wave_queue[1] == WaveType::Long) if(waves.size() >= 2 && waves[0] == WaveType::Long && waves[1] == WaveType::Long)
{ {
_wave_queue.erase(_wave_queue.begin(), _wave_queue.begin()+2); push_symbol(SymbolType::Zero, 2);
return std::unique_ptr<SymbolType>(new SymbolType(SymbolType::Zero)); return;
} }
if( _wave_queue.size() >= 4 && if( waves.size() >= 4 &&
_wave_queue[0] == WaveType::Short && waves[0] == WaveType::Short &&
_wave_queue[1] == WaveType::Short && waves[1] == WaveType::Short &&
_wave_queue[2] == WaveType::Short && waves[2] == WaveType::Short &&
_wave_queue[3] == WaveType::Short) waves[3] == WaveType::Short)
{ {
_wave_queue.erase(_wave_queue.begin(), _wave_queue.begin()+4); push_symbol(SymbolType::One, 4);
return std::unique_ptr<SymbolType>(new SymbolType(SymbolType::One)); return;
} }
return nullptr;
} }
void add_to_crc(uint8_t value) void add_to_crc(uint8_t value)