Simplify timing logic

Merge the pause_start and now variables to reduce complexity.

1 files changed, 27 insertions, 49 deletions

diff --git a/main.ha b/main.ha
index 093e440..fe1c91a 100644
--- a/main.ha
+++ b/main.ha
@@ -34,9 +34,10 @@ type state = struct {
 	subtitles: []subtitle,
 
 	start: time::instant,
+	now: time::instant,
 	length: time::duration,
 	elapsed: time::duration,
-	pause_start: (time::instant | void),
+	paused: bool,
 
 	term: *vt::term,
 };
@@ -83,10 +84,11 @@ export fn main() void = {
 		free(text.args);
 	};
 
+	let now = time::now(time::clock::REALTIME);
 	let state = state {
-		start = time::now(time::clock::REALTIME),
+		start = now,
+		now = now,
 		term = vt::open(),
-		pause_start = void,
 		subtitles = subtitles,
 		...
 	};
@@ -99,23 +101,19 @@ export fn main() void = {
 		};
 	};
 
-	match (run(state)) {
+	match (run(&state)) {
 	case void => void;
 	case let err: vt::error =>
-		vt::close(state.term);
-		fmt::fatal("Error:", vt::strerror(err));
+		fmt::errorln("Error:", vt::strerror(err))!;
 	};
 };
 
-fn run(state: state) (void | vt::error) = {
+fn run(state: *state) (void | vt::error) = {
 	for (true) {
-		match (state.pause_start) {
-		case void =>
-			let now = time::now(time::clock::REALTIME);
-			state.elapsed = time::diff(state.start, now);
-		case let inst: time::instant =>
-			state.elapsed = time::diff(state.start, inst);
+		if (!state.paused) {
+			state.now = time::now(time::clock::REALTIME);
 		};
+		state.elapsed = time::diff(state.start, state.now);
 		if (state.elapsed > state.length) break;
 
 		vt::clear(state.term)?;
@@ -124,7 +122,7 @@ fn run(state: state) (void | vt::error) = {
 			state.elapsed / time::HOUR,
 			state.elapsed / time::MINUTE % 60,
 			state.elapsed / time::SECOND % 60,
-			if (state.pause_start is time::instant) " (PAUSED)" else "",
+			if (state.paused) " (PAUSED)" else "",
 		);
 		defer free(time_text);
 		vt::print(state.term, time_text)?;
@@ -149,7 +147,7 @@ fn run(state: state) (void | vt::error) = {
 		if (timeout > next_second) {
 			timeout = next_second;
 		};
-		if (state.pause_start is time::instant) {
+		if (state.paused) {
 			timeout = poll::INDEF;
 		};
 
@@ -158,12 +156,7 @@ fn run(state: state) (void | vt::error) = {
 			events = poll::event::POLLIN | poll::event::POLLHUP,
 			...
 		}];
-		match (poll::poll(pollfds, timeout)) {
-		case let x: uint =>
-			if (x == 0) continue;
-		case let err: poll::error =>
-			fmt::errorln("Error polling for user input:", poll::strerror(err))!;
-		};
+		if (poll::poll(pollfds, timeout)? == 0) continue;
 
 		let ev = match (vt::pollevent(state.term)?) {
 		case void =>
@@ -182,21 +175,21 @@ fn run(state: state) (void | vt::error) = {
 			case 'c' =>
 				if (ev.mods & vt::modflag::CTRL != 0) break;
 			case 'j' =>
-				fast_backward(&state, time::SECOND * 10);
+				fast_forward(state, -time::SECOND * 10);
 			case 'l' =>
-				fast_forward(&state, time::SECOND * 10);
+				fast_forward(state, time::SECOND * 10);
 			case 'k' =>
-				pause(&state);
+				pause(state);
 			case ' ' =>
-				pause(&state);
+				pause(state);
 			case => void;
 			};
 		case let key: vt::specialkey =>
 			switch (key) {
 			case vt::specialkey::LEFT =>
-				fast_backward(&state, time::SECOND * 5);
+				fast_forward(state, -time::SECOND * 5);
 			case vt::specialkey::RIGHT =>
-				fast_forward(&state, time::SECOND * 5);
+				fast_forward(state, time::SECOND * 5);
 			};
 		case vt::functionkey => void;
 		};
@@ -205,33 +198,18 @@ fn run(state: state) (void | vt::error) = {
 
 fn fast_forward(state: *state, dur: time::duration) void = {
 	state.start = time::add(state.start, -dur);
-};
-
-fn fast_backward(state: *state, dur: time::duration) void = {
-	let now = time::now(time::clock::REALTIME);
-	state.start = time::add(state.start, dur);
-	match (state.pause_start) {
-	case void =>
-		if (time::diff(state.start, now) < 0) {
-			state.start = now;
-		};
-	case let inst: time::instant =>
-		if (time::diff(state.start, inst) < 0) {
-			state.start = inst;
-		};
+	if (time::diff(state.start, state.now) < 0) {
+		state.start = state.now;
 	};
-	
 };
 
 fn pause(state: *state) void = {
-	let now = time::now(time::clock::REALTIME);
-	match (state.pause_start) {
-	case void =>
-		state.pause_start = now;
-	case let inst: time::instant =>
-		state.pause_start = void;
-		state.start = time::add(state.start, time::diff(inst, now));
+	if (state.paused) {
+		let now = time::now(time::clock::REALTIME);
+		state.start = time::add(state.start, time::diff(state.now, now));
+		state.now = now;
 	};
+	state.paused = !state.paused;
 };
 
 type parser_state = enum {