Commuted all of 'Storage' other than 'Tape' to postfix underscores.

Storage/Cartridge/Cartridge.hpp

@@ -51,10 +51,10 @@ class Cartridge {
 			std::vector<uint8_t> data;
 		};
 
-		const std::list<Segment> &get_segments() {	return _segments; }
+		const std::list<Segment> &get_segments() {	return segments_; }
 
 	protected:
-		std::list<Segment> _segments;
+		std::list<Segment> segments_;
 };
 
 }

Storage/Cartridge/Formats/BinaryDump.cpp

@@ -28,7 +28,7 @@ BinaryDump::BinaryDump(const char *file_name)
 	fclose(file);
 
 	// enshrine
-	_segments.emplace_back(
+	segments_.emplace_back(
 		::Storage::Cartridge::Cartridge::Segment::UnknownAddress,
 		::Storage::Cartridge::Cartridge::Segment::UnknownAddress,
 		std::move(contents));

Storage/Cartridge/Formats/PRG.cpp

@@ -46,5 +46,5 @@ PRG::PRG(const char *file_name)
 	if(!Storage::Cartridge::Encodings::CommodoreROM::isROM(contents))
 		throw ErrorNotROM;
 
-	_segments.emplace_back(0xa000, 0xa000 + data_length, std::move(contents));
+	segments_.emplace_back(0xa000, 0xa000 + data_length, std::move(contents));
 }

Storage/Disk/DigitalPhaseLockedLoop.cpp

@@ -13,58 +13,58 @@
 using namespace Storage;
 
 DigitalPhaseLockedLoop::DigitalPhaseLockedLoop(int clocks_per_bit, int tolerance, size_t length_of_history) :
-	_clocks_per_bit(clocks_per_bit),
+	clocks_per_bit_(clocks_per_bit),
-	_tolerance(tolerance),
+	tolerance_(tolerance),
 
-	_phase(0),
+	phase_(0),
-	_window_length(clocks_per_bit),
+	window_length_(clocks_per_bit),
 
-	_phase_error_pointer(0)
+	phase_error_pointer_(0)
 {
-	_phase_error_history.reset(new std::vector<int>(length_of_history, 0));
+	phase_error_history_.reset(new std::vector<int>(length_of_history, 0));
 }
 
 void DigitalPhaseLockedLoop::run_for_cycles(int number_of_cycles)
 {
-	_phase += number_of_cycles;
+	phase_ += number_of_cycles;
-	if(_phase >= _window_length)
+	if(phase_ >= window_length_)
 	{
-		int windows_crossed = _phase / _window_length;
+		int windows_crossed = phase_ / window_length_;
 
 		// check whether this triggers any 0s, if anybody cares
-		if(_delegate)
+		if(delegate_)
 		{
-			if(_window_was_filled) windows_crossed--;
+			if(window_was_filled_) windows_crossed--;
 			for(int c = 0; c < windows_crossed; c++)
-				_delegate->digital_phase_locked_loop_output_bit(0);
+				delegate_->digital_phase_locked_loop_output_bit(0);
 		}
 
-		_window_was_filled = false;
+		window_was_filled_ = false;
-		_phase %= _window_length;
+		phase_ %= window_length_;
 	}
 }
 
 void DigitalPhaseLockedLoop::add_pulse()
 {
-	if(!_window_was_filled)
+	if(!window_was_filled_)
 	{
-		if(_delegate) _delegate->digital_phase_locked_loop_output_bit(1);
+		if(delegate_) delegate_->digital_phase_locked_loop_output_bit(1);
-		_window_was_filled = true;
+		window_was_filled_ = true;
-		post_phase_error(_phase - (_window_length >> 1));
+		post_phase_error(phase_ - (window_length_ >> 1));
 	}
 }
 
 void DigitalPhaseLockedLoop::post_phase_error(int error)
 {
 	// use a simple spring mechanism as a lowpass filter for phase
-	_phase -= (error + 1) >> 1;
+	phase_ -= (error + 1) >> 1;
 
 	// use the average of the last few errors to affect frequency
-	std::vector<int> *phase_error_history = _phase_error_history.get();
+	std::vector<int> *phase_error_history = phase_error_history_.get();
 	size_t phase_error_history_size = phase_error_history->size();
 
-	(*phase_error_history)[_phase_error_pointer] = error;
+	(*phase_error_history)[phase_error_pointer_] = error;
-	_phase_error_pointer = (_phase_error_pointer + 1)%phase_error_history_size;
+	phase_error_pointer_ = (phase_error_pointer_ + 1)%phase_error_history_size;
 
 	int total_error = 0;
 	for(size_t c = 0; c < phase_error_history_size; c++)
@@ -72,6 +72,6 @@ void DigitalPhaseLockedLoop::post_phase_error(int error)
 		total_error += (*phase_error_history)[c];
 	}
 	int denominator = (int)(phase_error_history_size * 4);
-	_window_length += (total_error + (denominator >> 1)) / denominator;
+	window_length_ += (total_error + (denominator >> 1)) / denominator;
-	_window_length = std::max(std::min(_window_length, _clocks_per_bit + _tolerance), _clocks_per_bit - _tolerance);
+	window_length_ = std::max(std::min(window_length_, clocks_per_bit_ + tolerance_), clocks_per_bit_ - tolerance_);
 }

Storage/Disk/DigitalPhaseLockedLoop.hpp

@@ -46,22 +46,22 @@ class DigitalPhaseLockedLoop {
 		};
 		void set_delegate(Delegate *delegate)
 		{
-			_delegate = delegate;
+			delegate_ = delegate;
 		}
 
 	private:
-		Delegate *_delegate;
+		Delegate *delegate_;
 
 		void post_phase_error(int error);
-		std::unique_ptr<std::vector<int>> _phase_error_history;
+		std::unique_ptr<std::vector<int>> phase_error_history_;
-		size_t _phase_error_pointer;
+		size_t phase_error_pointer_;
 
-		int _phase;
+		int phase_;
-		int _window_length;
+		int window_length_;
-		bool _window_was_filled;
+		bool window_was_filled_;
 
-		int _clocks_per_bit;
+		int clocks_per_bit_;
-		int _tolerance;
+		int tolerance_;
 };
 
 }

Storage/Disk/DiskController.cpp

@@ -11,14 +11,14 @@
 using namespace Storage::Disk;
 
 Controller::Controller(unsigned int clock_rate, unsigned int clock_rate_multiplier, unsigned int revolutions_per_minute) :
-	_clock_rate(clock_rate * clock_rate_multiplier),
+	clock_rate_(clock_rate * clock_rate_multiplier),
-	_clock_rate_multiplier(clock_rate_multiplier),
+	clock_rate_multiplier_(clock_rate_multiplier),
 
 	TimedEventLoop(clock_rate * clock_rate_multiplier)
 {
-	_rotational_multiplier.length = 60;
+	rotational_multiplier_.length = 60;
-	_rotational_multiplier.clock_rate = revolutions_per_minute;
+	rotational_multiplier_.clock_rate = revolutions_per_minute;
-	_rotational_multiplier.simplify();
+	rotational_multiplier_.simplify();
 
 	// seed this class with a PLL, any PLL, so that it's safe to assume non-nullptr later
 	Time one;
@@ -27,38 +27,38 @@ Controller::Controller(unsigned int clock_rate, unsigned int clock_rate_multipli
 
 void Controller::setup_track()
 {
-	_track = _drive->get_track();
+	track_ = drive_->get_track();
 
 	Time offset;
-	if(_track && _time_into_track.length > 0)
+	if(track_ && time_into_track_.length > 0)
 	{
-		Time time_found = _track->seek_to(_time_into_track).simplify();
+		Time time_found = track_->seek_to(time_into_track_).simplify();
-		offset = (_time_into_track - time_found).simplify();
+		offset = (time_into_track_ - time_found).simplify();
-		_time_into_track = time_found;
+		time_into_track_ = time_found;
 	}
 	else
 	{
-		offset = _time_into_track;
+		offset = time_into_track_;
-		_time_into_track.set_zero();
+		time_into_track_.set_zero();
 	}
 
-	reset_timer_to_offset(offset * _rotational_multiplier);
+	reset_timer_to_offset(offset * rotational_multiplier_);
 	get_next_event();
 }
 
 void Controller::run_for_cycles(int number_of_cycles)
 {
-	if(_drive && _drive->has_disk() && _motor_is_on)
+	if(drive_ && drive_->has_disk() && motor_is_on_)
 	{
-		if(!_track) setup_track();
+		if(!track_) setup_track();
-		number_of_cycles *= _clock_rate_multiplier;
+		number_of_cycles *= clock_rate_multiplier_;
 		while(number_of_cycles)
 		{
 			int cycles_until_next_event = (int)get_cycles_until_next_event();
 			int cycles_to_run_for = std::min(cycles_until_next_event, number_of_cycles);
-			_cycles_since_index_hole += (unsigned int)cycles_to_run_for;
+			cycles_since_index_hole_ += (unsigned int)cycles_to_run_for;
 			number_of_cycles -= cycles_to_run_for;
-			_pll->run_for_cycles(cycles_to_run_for);
+			pll_->run_for_cycles(cycles_to_run_for);
 			TimedEventLoop::run_for_cycles(cycles_to_run_for);
 		}
 	}
@@ -68,31 +68,31 @@ void Controller::run_for_cycles(int number_of_cycles)
 
 void Controller::get_next_event()
 {
-	if(_track)
+	if(track_)
-		_current_event = _track->get_next_event();
+		current_event_ = track_->get_next_event();
 	else
 	{
-		_current_event.length.length = 1;
+		current_event_.length.length = 1;
-		_current_event.length.clock_rate = 1;
+		current_event_.length.clock_rate = 1;
-		_current_event.type = Track::Event::IndexHole;
+		current_event_.type = Track::Event::IndexHole;
 	}
 
 	// divide interval, which is in terms of a rotation of the disk, by rotation speed, and
 	// convert it into revolutions per second
-	set_next_event_time_interval(_current_event.length * _rotational_multiplier);
+	set_next_event_time_interval(current_event_.length * rotational_multiplier_);
 }
 
 void Controller::process_next_event()
 {
-	switch(_current_event.type)
+	switch(current_event_.type)
 	{
 		case Track::Event::FluxTransition:
-			_pll->add_pulse();
+			pll_->add_pulse();
-			_time_into_track += _current_event.length;
+			time_into_track_ += current_event_.length;
 		break;
 		case Track::Event::IndexHole:
-			_cycles_since_index_hole = 0;
+			cycles_since_index_hole_ = 0;
-			_time_into_track.set_zero();
+			time_into_track_.set_zero();
 			process_index_hole();
 		break;
 	}
@@ -103,57 +103,57 @@ void Controller::process_next_event()
 
 void Controller::set_expected_bit_length(Time bit_length)
 {
-	_bit_length = bit_length;
+	bit_length_ = bit_length;
 
 	// this conversion doesn't need to be exact because there's a lot of variation to be taken
 	// account of in rotation speed, air turbulence, etc, so a direct conversion will do
-	int clocks_per_bit = (int)((bit_length.length * _clock_rate) / bit_length.clock_rate);
+	int clocks_per_bit = (int)((bit_length.length * clock_rate_) / bit_length.clock_rate);
-	_pll.reset(new DigitalPhaseLockedLoop(clocks_per_bit, clocks_per_bit / 5, 3));
+	pll_.reset(new DigitalPhaseLockedLoop(clocks_per_bit, clocks_per_bit / 5, 3));
-	_pll->set_delegate(this);
+	pll_->set_delegate(this);
 }
 
 void Controller::digital_phase_locked_loop_output_bit(int value)
 {
-	process_input_bit(value, _cycles_since_index_hole);
+	process_input_bit(value, cycles_since_index_hole_);
 }
 
 #pragma mark - Drive actions
 
 bool Controller::get_is_track_zero()
 {
-	if(!_drive) return false;
+	if(!drive_) return false;
-	return _drive->get_is_track_zero();
+	return drive_->get_is_track_zero();
 }
 
 bool Controller::get_drive_is_ready()
 {
-	if(!_drive) return false;
+	if(!drive_) return false;
-	return _drive->has_disk();
+	return drive_->has_disk();
 }
 
 void Controller::step(int direction)
 {
-	if(_drive) _drive->step(direction);
+	if(drive_) drive_->step(direction);
 	invalidate_track();
 }
 
 void Controller::set_motor_on(bool motor_on)
 {
-	_motor_is_on = motor_on;
+	motor_is_on_ = motor_on;
 }
 
 bool Controller::get_motor_on()
 {
-	return _motor_is_on;
+	return motor_is_on_;
 }
 
 void Controller::set_drive(std::shared_ptr<Drive> drive)
 {
-	_drive = drive;
+	drive_ = drive;
 	invalidate_track();
 }
 
 void Controller::invalidate_track()
 {
-	_track = nullptr;
+	track_ = nullptr;
 }

Storage/Disk/DiskController.hpp

@@ -81,20 +81,20 @@ class Controller: public DigitalPhaseLockedLoop::Delegate, public TimedEventLoop
 		virtual bool get_drive_is_ready();
 
 	private:
-		Time _bit_length;
+		Time bit_length_;
-		unsigned int _clock_rate;
+		unsigned int clock_rate_;
-		unsigned int _clock_rate_multiplier;
+		unsigned int clock_rate_multiplier_;
-		Time _rotational_multiplier;
+		Time rotational_multiplier_;
 
-		std::shared_ptr<DigitalPhaseLockedLoop> _pll;
+		std::shared_ptr<DigitalPhaseLockedLoop> pll_;
-		std::shared_ptr<Drive> _drive;
+		std::shared_ptr<Drive> drive_;
-		std::shared_ptr<Track> _track;
+		std::shared_ptr<Track> track_;
-		unsigned int _cycles_since_index_hole;
+		unsigned int cycles_since_index_hole_;
 
 		inline void get_next_event();
-		Track::Event _current_event;
+		Track::Event current_event_;
-		Time _time_into_track;
+		Time time_into_track_;
-		bool _motor_is_on;
+		bool motor_is_on_;
 
 		void setup_track();
 };

Storage/Disk/Drive.cpp

@@ -12,35 +12,35 @@
 using namespace Storage::Disk;
 
 Drive::Drive()
-	: _head_position(0), _head(0) {}
+	: head_position_(0), head_(0) {}
 
 void Drive::set_disk(std::shared_ptr<Disk> disk)
 {
-	_disk = disk;
+	disk_ = disk;
 }
 
 bool Drive::has_disk()
 {
-	return (bool)_disk;
+	return (bool)disk_;
 }
 
 bool Drive::get_is_track_zero()
 {
-	return _head_position == 0;
+	return head_position_ == 0;
 }
 
 void Drive::step(int direction)
 {
-	_head_position = std::max(_head_position + direction, 0);
+	head_position_ = std::max(head_position_ + direction, 0);
 }
 
 void Drive::set_head(unsigned int head)
 {
-	_head = head;
+	head_ = head;
 }
 
 std::shared_ptr<Track> Drive::get_track()
 {
-	if(_disk) return _disk->get_track_at_position(_head, (unsigned int)_head_position);
+	if(disk_) return disk_->get_track_at_position(head_, (unsigned int)head_position_);
 	return nullptr;
 }

Storage/Disk/Drive.hpp

@@ -47,9 +47,9 @@ class Drive {
 		std::shared_ptr<Track> get_track();
 
 	private:
-		std::shared_ptr<Disk> _disk;
+		std::shared_ptr<Disk> disk_;
-		int _head_position;
+		int head_position_;
-		unsigned int _head;
+		unsigned int head_;
 };
 
 

Storage/Disk/PCMTrack.cpp

@@ -13,7 +13,7 @@ using namespace Storage::Disk;
 
 PCMTrack::PCMTrack(std::vector<PCMSegment> segments)
 {
-	_segments = std::move(segments);
+	segments_ = std::move(segments);
 	fix_length();
 }
 
@@ -21,7 +21,7 @@ PCMTrack::PCMTrack(PCMSegment segment)
 {
 	segment.length_of_a_bit.length = 1;
 	segment.length_of_a_bit.clock_rate = 1;
-	_segments.push_back(std::move(segment));
+	segments_.push_back(std::move(segment));
 	fix_length();
 }
 
@@ -29,54 +29,54 @@ PCMTrack::Event PCMTrack::get_next_event()
 {
 	// find the next 1 in the input stream, keeping count of length as we go, and assuming it's going
 	// to be a flux transition
-	_next_event.type = Track::Event::FluxTransition;
+	next_event_.type = Track::Event::FluxTransition;
-	_next_event.length.length = 0;
+	next_event_.length.length = 0;
-	while(_segment_pointer < _segments.size())
+	while(segment_pointer_ < segments_.size())
 	{
-		unsigned int clock_multiplier = _track_clock_rate / _segments[_segment_pointer].length_of_a_bit.clock_rate;
+		unsigned int clock_multiplier = track_clock_rate_ / segments_[segment_pointer_].length_of_a_bit.clock_rate;
-		unsigned int bit_length = clock_multiplier * _segments[_segment_pointer].length_of_a_bit.length;
+		unsigned int bit_length = clock_multiplier * segments_[segment_pointer_].length_of_a_bit.length;
 
-		const uint8_t *segment_data = &_segments[_segment_pointer].data[0];
+		const uint8_t *segment_data = &segments_[segment_pointer_].data[0];
-		while(_bit_pointer < _segments[_segment_pointer].number_of_bits)
+		while(bit_pointer_ < segments_[segment_pointer_].number_of_bits)
 		{
 			// for timing simplicity, bits are modelled as happening at the end of their window
 			// TODO: should I account for the converse bit ordering? Or can I assume MSB first?
-			int bit = segment_data[_bit_pointer >> 3] & (0x80 >> (_bit_pointer&7));
+			int bit = segment_data[bit_pointer_ >> 3] & (0x80 >> (bit_pointer_&7));
-			_bit_pointer++;
+			bit_pointer_++;
-			_next_event.length.length += bit_length;
+			next_event_.length.length += bit_length;
 
-			if(bit) return _next_event;
+			if(bit) return next_event_;
 		}
-		_bit_pointer = 0;
+		bit_pointer_ = 0;
-		_segment_pointer++;
+		segment_pointer_++;
 	}
 
 	// check whether we actually reached the index hole
-	if(_segment_pointer == _segments.size())
+	if(segment_pointer_ == segments_.size())
 	{
-		_segment_pointer = 0;
+		segment_pointer_ = 0;
-		_next_event.type = Track::Event::IndexHole;
+		next_event_.type = Track::Event::IndexHole;
 	}
 
-	return _next_event;
+	return next_event_;
 }
 
 Storage::Time PCMTrack::seek_to(Time time_since_index_hole)
 {
-	_segment_pointer = 0;
+	segment_pointer_ = 0;
 
 	// pick a common clock rate for counting time on this track and multiply up the time being sought appropriately
 	Time time_so_far;
-	time_so_far.clock_rate = NumberTheory::least_common_multiple(_next_event.length.clock_rate, time_since_index_hole.clock_rate);
+	time_so_far.clock_rate = NumberTheory::least_common_multiple(next_event_.length.clock_rate, time_since_index_hole.clock_rate);
 	time_since_index_hole.length *= time_so_far.clock_rate / time_since_index_hole.clock_rate;
 	time_since_index_hole.clock_rate = time_so_far.clock_rate;
 
-	while(_segment_pointer < _segments.size())
+	while(segment_pointer_ < segments_.size())
 	{
 		// determine how long this segment is in terms of the master clock
-		unsigned int clock_multiplier = time_so_far.clock_rate / _next_event.length.clock_rate;
+		unsigned int clock_multiplier = time_so_far.clock_rate / next_event_.length.clock_rate;
-		unsigned int bit_length = ((clock_multiplier / _track_clock_rate) / _segments[_segment_pointer].length_of_a_bit.clock_rate) * _segments[_segment_pointer].length_of_a_bit.length;
+		unsigned int bit_length = ((clock_multiplier / track_clock_rate_) / segments_[segment_pointer_].length_of_a_bit.clock_rate) * segments_[segment_pointer_].length_of_a_bit.length;
-		unsigned int time_in_this_segment = bit_length * _segments[_segment_pointer].number_of_bits;
+		unsigned int time_in_this_segment = bit_length * segments_[segment_pointer_].number_of_bits;
 
 		// if this segment goes on longer than the time being sought, end here
 		unsigned int time_remaining = time_since_index_hole.length - time_so_far.length;
@@ -86,7 +86,7 @@ Storage::Time PCMTrack::seek_to(Time time_since_index_hole)
 			unsigned int time_found = time_remaining - (time_remaining % bit_length);
 
 			// resolve that into the stateful bit count
-			_bit_pointer = 1 + (time_remaining / bit_length);
+			bit_pointer_ = 1 + (time_remaining / bit_length);
 
 			// update and return the time sought to
 			time_so_far.length += time_found;
@@ -95,7 +95,7 @@ Storage::Time PCMTrack::seek_to(Time time_since_index_hole)
 
 		// otherwise, accumulate time and keep moving
 		time_so_far.length += time_in_this_segment;
-		_segment_pointer++;
+		segment_pointer_++;
 	}
 	return time_since_index_hole;
 }
@@ -103,19 +103,19 @@ Storage::Time PCMTrack::seek_to(Time time_since_index_hole)
 void PCMTrack::fix_length()
 {
 	// find the least common multiple of all segment clock rates
-	_track_clock_rate = _segments[0].length_of_a_bit.clock_rate;
+	track_clock_rate_ = segments_[0].length_of_a_bit.clock_rate;
-	for(size_t c = 1; c < _segments.size(); c++)
+	for(size_t c = 1; c < segments_.size(); c++)
 	{
-		_track_clock_rate = NumberTheory::least_common_multiple(_track_clock_rate, _segments[c].length_of_a_bit.clock_rate);
+		track_clock_rate_ = NumberTheory::least_common_multiple(track_clock_rate_, segments_[c].length_of_a_bit.clock_rate);
 	}
 
 	// thereby determine the total length, storing it to next_event as the track-total divisor
-	_next_event.length.clock_rate = 0;
+	next_event_.length.clock_rate = 0;
-	for(size_t c = 0; c < _segments.size(); c++)
+	for(size_t c = 0; c < segments_.size(); c++)
 	{
-		unsigned int multiplier = _track_clock_rate / _segments[c].length_of_a_bit.clock_rate;
+		unsigned int multiplier = track_clock_rate_ / segments_[c].length_of_a_bit.clock_rate;
-		_next_event.length.clock_rate += _segments[c].length_of_a_bit.length * _segments[c].number_of_bits * multiplier;
+		next_event_.length.clock_rate += segments_[c].length_of_a_bit.length * segments_[c].number_of_bits * multiplier;
 	}
 
-	_segment_pointer = _bit_pointer = 0;
+	segment_pointer_ = bit_pointer_ = 0;
 }

Storage/Disk/PCMTrack.hpp

@@ -52,21 +52,21 @@ class PCMTrack: public Track {
 
 	private:
 		// storage for the segments that describe this track
-		std::vector<PCMSegment> _segments;
+		std::vector<PCMSegment> segments_;
 
 		// a helper to determine the overall track clock rate and it's length
 		void fix_length();
 
 		// the event perpetually returned; impliedly contains the length of the entire track
 		// as its clock rate, per the need for everything on a Track to sum to a length of 1
-		PCMTrack::Event _next_event;
+		PCMTrack::Event next_event_;
 
 		// contains the master clock rate
-		unsigned int _track_clock_rate;
+		unsigned int track_clock_rate_;
 
 		// a pointer to the first bit to consider as the next event
-		size_t _segment_pointer;
+		size_t segment_pointer_;
-		size_t _bit_pointer;
+		size_t bit_pointer_;
 };
 
 }

Storage/TimedEventLoop.cpp

@@ -13,12 +13,12 @@
 using namespace Storage;
 
 TimedEventLoop::TimedEventLoop(unsigned int input_clock_rate) :
-	_input_clock_rate(input_clock_rate) {}
+	input_clock_rate_(input_clock_rate) {}
 
 void TimedEventLoop::run_for_cycles(int number_of_cycles)
 {
-	_cycles_until_event -= number_of_cycles;
+	cycles_until_event_ -= number_of_cycles;
-	while(_cycles_until_event <= 0)
+	while(cycles_until_event_ <= 0)
 	{
 		process_next_event();
 	}
@@ -26,13 +26,13 @@ void TimedEventLoop::run_for_cycles(int number_of_cycles)
 
 unsigned int TimedEventLoop::get_cycles_until_next_event()
 {
-	return (unsigned int)std::max(_cycles_until_event, 0);
+	return (unsigned int)std::max(cycles_until_event_, 0);
 }
 
 void TimedEventLoop::reset_timer()
 {
-	_subcycles_until_event.set_zero();
+	subcycles_until_event_.set_zero();
-	_cycles_until_event = 0;
+	cycles_until_event_ = 0;
 }
 
 void TimedEventLoop::reset_timer_to_offset(Time offset)
@@ -49,10 +49,10 @@ void TimedEventLoop::jump_to_next_event()
 void TimedEventLoop::set_next_event_time_interval(Time interval)
 {
 	// Calculate [interval]*[input clock rate] + [subcycles until this event].
-	int64_t denominator = (int64_t)interval.clock_rate * (int64_t)_subcycles_until_event.clock_rate;
+	int64_t denominator = (int64_t)interval.clock_rate * (int64_t)subcycles_until_event_.clock_rate;
 	int64_t numerator =
-		(int64_t)_subcycles_until_event.clock_rate * (int64_t)_input_clock_rate * (int64_t)interval.length +
+		(int64_t)subcycles_until_event_.clock_rate * (int64_t)input_clock_rate_ * (int64_t)interval.length +
-		(int64_t)interval.clock_rate * (int64_t)_subcycles_until_event.length;
+		(int64_t)interval.clock_rate * (int64_t)subcycles_until_event_.length;
 
 	// Simplify now, to prepare for stuffing into possibly 32-bit quantities
 	int64_t common_divisor = NumberTheory::greatest_common_divisor(numerator % denominator, denominator);
@@ -61,9 +61,9 @@ void TimedEventLoop::set_next_event_time_interval(Time interval)
 
 	// So this event will fire in the integral number of cycles from now, putting us at the remainder
 	// number of subcycles
-	_cycles_until_event = (int)(numerator / denominator);
+	cycles_until_event_ = (int)(numerator / denominator);
-	_subcycles_until_event.length = (unsigned int)(numerator % denominator);
+	subcycles_until_event_.length = (unsigned int)(numerator % denominator);
-	_subcycles_until_event.clock_rate = (unsigned int)denominator;
+	subcycles_until_event_.clock_rate = (unsigned int)denominator;
 }
 
 Time TimedEventLoop::get_time_into_next_event()

Storage/TimedEventLoop.hpp

@@ -90,10 +90,9 @@ namespace Storage {
 			Time get_time_into_next_event();
 
 		private:
-			unsigned int _input_clock_rate;
+			unsigned int input_clock_rate_;
-			int _cycles_until_event;
+			int cycles_until_event_;
-			Time _subcycles_until_event;
+			Time subcycles_until_event_;
-			Time _event_interval;
 	};
 
 }