Neaten.

ClockReceiver/ClockReceiver.hpp

@@ -157,9 +157,9 @@ public:
 			length_ = 0;
 			return result;
 		} else {
-			static constexpr int ShiftRight = Denominator - DestinationClocks::Denominator;
-			static constexpr IntType ResidueMask = (1 << ShiftRight) - 1;
-			const auto result = reduce<DestinationClocks>();
+			static constexpr int Shift = Denominator - DestinationClocks::Denominator;
+			static constexpr IntType ResidueMask = (1 << Shift) - 1;
+			const auto result = DestinationClocks(length_ >> Shift);
 			length_ &= ResidueMask;
 			return result;
 		}

ClockReceiver/JustInTime.hpp

@@ -186,10 +186,7 @@ public:
 				const auto duration = time_since_update_.template flush<TargetTimeScale>();
 				object_.run_for(duration);
 			} else {
-				// Get the result of clock dividing; flush that to the other time scale potentially to generate
-				// extra residue and retain that back in the original counter.
 				const auto target_duration = time_since_update_.template divide<TargetTimeScale>(divider);
-				time_since_update_ += target_duration;
 				if(target_duration > TargetTimeScale(0)) {
 					object_.run_for(target_duration);
 				}

Components/6560/6560.hpp

@@ -475,7 +475,7 @@ private:
 
 	Cycles cycles_since_speaker_update_;
 	void update_audio() {
-		speaker_.run_for(audio_queue_, Cycles(cycles_since_speaker_update_.divide<Cycles>(Cycles(4))));
+		speaker_.run_for(audio_queue_, cycles_since_speaker_update_.divide<Cycles>(4));
 	}
 
 	// register state

InstructionSets/M50740/Executor.cpp

@@ -52,7 +52,7 @@ void Executor::run_for(const Cycles cycles) {
 	// The incoming clock is divided by four; the local cycles_ count
 	// ensures that fractional parts are kept track of.
 	cycles_ += cycles;
-	CachingExecutor::run_for(cycles_.divide<Cycles>(Cycles(4)).as<int>());
+	CachingExecutor::run_for(cycles_.divide(4).as<int>());
 }
 
 void Executor::reset() {

Machines/Acorn/Archimedes/Archimedes.cpp

@@ -399,7 +399,7 @@ private:
 		static constexpr int TickFrequency = ClockRate / 50;	// i.e. 480,000
 		Cycles subtractor = cursor_action_subcycle_;
 		cursor_action_subcycle_ += cycles;
-		auto segments = cursor_action_subcycle_.divide<Cycles>(TickFrequency).as<int>();
+		auto segments = cursor_action_subcycle_.divide(TickFrequency).as<int>();
 		while(segments--) {
 			//
 			// Run up until end of next window.

Machines/Acorn/BBCMicro/BBCMicro.cpp

@@ -172,7 +172,7 @@ public:
 
 private:
 	void post_time() {
-		speaker_.run_for(audio_queue_, time_since_update_.divide<Cycles>(2));
+		speaker_.run_for(audio_queue_, time_since_update_.divide(2));
 	}
 
 	Concurrency::AsyncTaskQueue<false> audio_queue_;

Machines/Acorn/Electron/Electron.cpp

@@ -688,7 +688,7 @@ private:
 
 	// MARK: - Work deferral updates.
 	inline void update_audio() {
-		speaker_.run_for(audio_queue_, cycles_since_audio_update_.divide<Cycles>(SoundGenerator::clock_rate_divider));
+		speaker_.run_for(audio_queue_, cycles_since_audio_update_.divide(SoundGenerator::clock_rate_divider));
 	}
 
 	inline void signal_interrupt(uint8_t interrupt) {

Machines/Acorn/Tube/Tube6502.hpp

@@ -32,7 +32,7 @@ public:
 	// Multiply by 3/2 to turn that into the tube 6502's usual 3Mhz bus.
 	void run_for(const Cycles cycles) {
 		cycles_modulo_ += cycles * 3;
-		m6502_.run_for(cycles_modulo_.divide<Cycles>(2));
+		m6502_.run_for(cycles_modulo_.divide(2));
 	}
 
 	template <CPU::MOS6502Mk2::BusOperation operation, typename AddressT>

Machines/Amiga/Chipset.cpp

@@ -777,11 +777,11 @@ template <bool stop_on_cpu> Chipset::Changes Chipset::run(HalfCycles length) {
 	// Advance the keyboard's serial output, at
 	// close enough to 1,000,000 ticks/second.
 	keyboard_divider_ += changes.duration;
-	keyboard_.run_for(keyboard_divider_.divide<HalfCycles>(14));
+	keyboard_.run_for(keyboard_divider_.divide(14));
 
 	// The CIAs are on the E clock.
 	cia_divider_ += changes.duration;
-	const HalfCycles e_clocks = cia_divider_.divide<HalfCycles>(20);
+	const HalfCycles e_clocks = cia_divider_.divide(20);
 	if(e_clocks > HalfCycles(0)) {
 		cia_a.run_for(e_clocks);
 		cia_b.run_for(e_clocks);

Machines/AmstradCPC/AmstradCPC.cpp

@@ -140,7 +140,7 @@ public:
 
 	/// Enqueues an update-to-now into the AY's deferred queue.
 	inline void update() {
-		const auto cycles = cycles_since_update_.divide<Cycles>(HalfCycles(4));
+		const auto cycles = cycles_since_update_.divide<Cycles>(4);
 		speaker_.run_for(audio_queue_, cycles);
 	}
 
@@ -882,7 +882,7 @@ public:
 			// will do as it's safe to conclude that nobody else has touched video RAM
 			// during that whole window.
 			crtc_counter_ += cycle.length;
-			const Cycles crtc_cycles = crtc_counter_.divide<Cycles>(HalfCycles(4));
+			const Cycles crtc_cycles = crtc_counter_.divide<Cycles>(4);
 			if(crtc_cycles > Cycles(0)) crtc_.run_for(crtc_cycles);
 
 			// Check whether that prompted a change in the interrupt line. If so then date

Machines/Apple/AppleIIgs/AppleIIgs.cpp

@@ -873,7 +873,7 @@ public:
 
 		// Propagate time far and wide.
 		cycles_since_clock_tick_ += duration;
-		auto ticks = cycles_since_clock_tick_.divide<Cycles>(CLOCK_RATE).get();
+		auto ticks = cycles_since_clock_tick_.divide(CLOCK_RATE).get();
 		while(ticks--) {
 			clock_.update();
 			video_.last_valid()->notify_clock_tick();	// The video controller marshalls the one-second interrupt.
@@ -972,7 +972,7 @@ private:
 	Cycles cycles_until_audio_event_;
 	static constexpr int audio_divider = 16;
 	void update_audio() {
-		const auto divided_cycles = cycles_since_audio_update_.divide<Cycles>(audio_divider);
+		const auto divided_cycles = cycles_since_audio_update_.divide(audio_divider);
 		sound_glu_.run_for(divided_cycles);
 		speaker_.run_for(audio_queue_, divided_cycles);
 	}

Machines/Apple/Macintosh/Macintosh.cpp

@@ -565,7 +565,7 @@ private:
 		// Possibly route vsync.
 		if(time_since_video_update_ < time_until_video_event_) {
 			via_clock_ += duration;
-			via_.run_for(via_clock_.divide<HalfCycles>(10));
+			via_.run_for(via_clock_.divide(10));
 		} else {
 			auto via_time_base = time_since_video_update_ - duration;
 			auto via_cycles_outstanding = duration;
@@ -575,7 +575,7 @@ private:
 				via_cycles_outstanding -= via_cycles;
 
 				via_clock_ += via_cycles;
-				via_.run_for(via_clock_.divide<HalfCycles>(10));
+				via_.run_for(via_clock_.divide(10));
 
 				video_.run_for(time_until_video_event_);
 				time_since_video_update_ -= time_until_video_event_;
@@ -585,14 +585,14 @@ private:
 			}
 
 			via_clock_ += via_cycles_outstanding;
-			via_.run_for(via_clock_.divide<HalfCycles>(10));
+			via_.run_for(via_clock_.divide(10));
 		}
 
 		// The keyboard also has a clock, albeit a very slow one — 100,000 cycles/second.
 		// Its clock and data lines are connected to the VIA.
 		keyboard_clock_ += duration;
 		if(keyboard_clock_ >= KEYBOARD_CLOCK_RATE) {
-			const auto keyboard_ticks = keyboard_clock_.divide<HalfCycles>(KEYBOARD_CLOCK_RATE);
+			const auto keyboard_ticks = keyboard_clock_.divide(KEYBOARD_CLOCK_RATE);
 			keyboard_.run_for(keyboard_ticks);
 			via_.template set_control_line_input<MOS::MOS6522::Port::B, MOS::MOS6522::Line::Two>(keyboard_.get_data());
 			via_.template set_control_line_input<MOS::MOS6522::Port::B, MOS::MOS6522::Line::One>(keyboard_.get_clock());
@@ -601,7 +601,7 @@ private:
 		// Feed mouse inputs within at most 1250 cycles of each other.
 		if(mouse_.has_steps()) {
 			time_since_mouse_update_ += duration;
-			const auto mouse_ticks = time_since_mouse_update_.divide<HalfCycles>(2500);
+			const auto mouse_ticks = time_since_mouse_update_.divide(2500);
 			if(mouse_ticks > HalfCycles(0)) {
 				mouse_.prepare_step();
 				scc_.set_dcd(0, mouse_.get_channel(1) & 1);
@@ -614,7 +614,7 @@ private:
 
 		// Consider updating the real-time clock.
 		real_time_clock_ += duration;
-		auto ticks = real_time_clock_.divide<Cycles>(HalfCycles(CLOCK_RATE)).get();
+		auto ticks = real_time_clock_.divide<Cycles>(CLOCK_RATE).get();
 		while(ticks--) {
 			clock_.update();
 			// TODO: leave a delay between toggling the input rather than using this coupled hack.

Machines/Atari/2600/Bus.hpp

@@ -49,7 +49,7 @@ protected:
 	// speaker backlog accumlation counter
 	Cycles cycles_since_speaker_update_;
 	inline void update_audio() {
-		speaker_.run_for(audio_queue_, cycles_since_speaker_update_.divide<Cycles>(CPUTicksPerAudioTick * 3));
+		speaker_.run_for(audio_queue_, cycles_since_speaker_update_.divide(CPUTicksPerAudioTick * 3));
 	}
 
 	// video backlog accumulation counter

Machines/Atari/2600/Cartridges/Pitfall2.hpp

@@ -103,7 +103,7 @@ private:
 
 	inline uint8_t update_audio() {
 		const unsigned int clock_divisor = 57;
-		auto cycles_to_run_for = cycles_since_audio_update_.divide<Cycles>(clock_divisor).as<int>();
+		auto cycles_to_run_for = cycles_since_audio_update_.divide(clock_divisor).as<int>();
 
 		int table_position = 0;
 		for(int c = 0; c < 3; c++) {

Machines/Atari/ST/AtariST.cpp

@@ -468,7 +468,7 @@ private:
 		// Don't even count time for the keyboard unless it has requested it.
 		if(keyboard_needs_clock_) {
 			cycles_since_ikbd_update_ += length;
-			ikbd_.run_for(cycles_since_ikbd_update_.divide<HalfCycles>(512));
+			ikbd_.run_for(cycles_since_ikbd_update_.divide(512));
 		}
 
 		// Flush anything that needs real-time updating.
@@ -498,7 +498,7 @@ private:
 	}
 
 	void update_audio() {
-		speaker_.run_for(audio_queue_, cycles_since_audio_update_.divide<Cycles>(HalfCycles(4)));
+		speaker_.run_for(audio_queue_, cycles_since_audio_update_.divide<Cycles>(4));
 	}
 
 	CPU::MC68000::Processor<ConcreteMachine, true, true> mc68000_;

Machines/ColecoVision/ColecoVision.cpp

@@ -381,7 +381,7 @@ private:
 	inline void update_audio() {
 		speaker_.run_for(
 			audio_queue_,
-			time_since_sn76489_update_.divide<Cycles>(HalfCycles(sn76489_divider))
+			time_since_sn76489_update_.divide<Cycles>(sn76489_divider)
 		);
 	}
 

Machines/Commodore/Plus4/Plus4.cpp

@@ -269,7 +269,7 @@ public:
 
 			if(c1541_) {
 				c1541_cycles_ += length * Cycles(1'000'000);
-				c1541_->run_for(c1541_cycles_.divide<Cycles>(media_divider_));
+				c1541_->run_for(c1541_cycles_.divide(media_divider_));
 			}
 
 			time_since_audio_update_ += length;
@@ -699,7 +699,7 @@ private:
 
 	void advance_timers_and_tape(const Cycles length) {
 		timers_subcycles_ += length;
-		const auto timers_cycles = timers_subcycles_.divide<Cycles>(video_.timer_cycle_length());
+		const auto timers_cycles = timers_subcycles_.divide(video_.timer_cycle_length());
 		timers_.tick(timers_cycles.as<int>());
 
 		tape_handler_.run_for(length);

Machines/Commodore/Plus4/Video.hpp

@@ -223,7 +223,7 @@ public:
 		// That gives close enough to 456 pixel clocks per line in both systems so the TED just rolls with that.
 
 		subcycles_ += cycles * 2;
-		auto ticks_remaining = subcycles_.divide<Cycles>(is_ntsc_ ? Cycles(4) : Cycles(5)).as<int>();
+		auto ticks_remaining = subcycles_.divide(is_ntsc_ ? 4 : 5).as<int>();
 		while(ticks_remaining) {
 			//
 			// Check for events: (i) deferred; ...

Machines/Enterprise/Dave.cpp

@@ -276,7 +276,7 @@ void TimedInterruptSource::update_channel(const int c, const bool is_linked, con
 void TimedInterruptSource::run_for(const Cycles duration) {
 	// Determine total number of ticks.
 	run_length_ += duration;
-	const Cycles cycles = run_length_.divide<Cycles>(global_divider_);
+	const Cycles cycles = run_length_.divide(global_divider_);
 	if(cycles == Cycles(0)) {
 		return;
 	}

Machines/Enterprise/Enterprise.cpp

@@ -843,7 +843,7 @@ private:
 	inline void update_audio() {
 		speaker_.run_for(
 			audio_queue_,
-			time_since_audio_update_.divide<Cycles>(HalfCycles(dave_divider))
+			time_since_audio_update_.divide<Cycles>(dave_divider)
 		);
 	}
 

Machines/MSX/MSX.cpp

@@ -850,7 +850,7 @@ private:
 	void update_audio() {
 		speaker_.speaker.run_for(
 			speaker_.audio_queue,
-			time_since_ay_update_.divide<Cycles>(HalfCycles(2))
+			time_since_ay_update_.divide<Cycles>(2)
 		);
 	}
 

Machines/MasterSystem/MasterSystem.cpp

@@ -461,7 +461,7 @@ private:
 	inline void update_audio() {
 		speaker_.run_for(
 			audio_queue_,
-			time_since_sn76489_update_.divide<Cycles>(HalfCycles(audio_divider))
+			time_since_sn76489_update_.divide<Cycles>(audio_divider)
 		);
 	}
 

Machines/Sinclair/ZX8081/ZX8081.cpp

@@ -486,7 +486,7 @@ private:
 		return GI::AY38910::Utility::read(ay_);
 	}
 	inline void update_audio() {
-		speaker_.run_for(audio_queue_, time_since_ay_update_.divide<Cycles>(HalfCycles(2)));
+		speaker_.run_for(audio_queue_, time_since_ay_update_.divide<Cycles>(2));
 	}
 };