initial commit

1 files changed, 432 insertions, 0 deletions

diff --git a/ttym.c b/ttym.c
new file mode 100644
index 0000000..fa46132
--- /dev/null
+++ b/ttym.c
@@ -0,0 +1,432 @@
+/* ttym - countdown / stopwatch in a single C file.
+ * See LICENSE file for copyright and license details.
+ */
+#define _POSIX_C_SOURCE 200809L
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "config.h"
+
+/* ===== types & globals ===== */
+
+typedef struct {
+	int quiet;            /* -q: suppress completion bell */
+	int silent;           /* -s: no bell, no extras */
+} Config;
+
+static struct termios oldtios;
+static int ttyfd = -1;
+static int rawset = 0;
+static volatile sig_atomic_t interrupted = 0;
+
+/* exposed for patches that read the final elapsed seconds at exit */
+static long elapsed_s = 0;
+
+/* nonzero once stdout is confirmed a tty; gates cursor/redraw escapes */
+static int out_tty = 0;
+
+/* ===== helpers ===== */
+
+static void
+die(const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+	fputc('\n', stderr);
+	exit(1);
+}
+
+static void
+sleep_ms(int ms)
+{
+	struct timespec ts = { ms / 1000, (long)(ms % 1000) * 1000000L };
+	nanosleep(&ts, NULL);
+}
+
+static long
+now_ms(void)
+{
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	return ts.tv_sec * 1000L + ts.tv_nsec / 1000000L;
+}
+
+static int
+term_cols(void)
+{
+	struct winsize ws;
+	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0)
+		return ws.ws_col;
+	return 80;
+}
+
+static void
+on_signal(int sig)
+{
+	(void)sig;
+	interrupted = 1;
+}
+
+static void
+restore_tty(void)
+{
+	if (rawset && ttyfd >= 0)
+		tcsetattr(ttyfd, TCSANOW, &oldtios);
+	rawset = 0;
+	if (out_tty)
+		fputs("\033[?7h\033[?25h", stdout);  /* re-enable wrap, show cursor */
+	fputc('\n', stdout);
+	fflush(stdout);
+}
+
+/* ===== duration parsing =====
+ * accepts: 25m | 90s | 2h | 1h30m | 01:30:00 | 25:00
+ */
+
+static int
+parse_uint(const char *s, size_t n, long *out)
+{
+	long v = 0;
+	if (n == 0) return -1;
+	for (size_t i = 0; i < n; i++) {
+		if (!isdigit((unsigned char)s[i])) return -1;
+		v = v * 10 + (s[i] - '0');
+		if (v > 1000000) return -1;
+	}
+	*out = v;
+	return 0;
+}
+
+static long
+parse_duration(const char *s)
+{
+	size_t len = strlen(s);
+	if (len == 0) return -1;
+
+	if (strchr(s, ':')) {
+		/* Split on ':' into 2 or 3 fields, then parse each with
+		 * parse_uint. That rejects empty fields, signs and
+		 * whitespace, and bounds every component -- so unlike a
+		 * raw sscanf("%ld") this cannot overflow on huge input.
+		 */
+		const char *fld[3];
+		size_t flen[3];
+		int nf = 0;
+		size_t fstart = 0;
+		for (size_t i = 0; i <= len; i++) {
+			if (i != len && s[i] != ':') continue;
+			if (nf == 3) return -1;
+			fld[nf] = s + fstart;
+			flen[nf] = i - fstart;
+			nf++;
+			fstart = i + 1;
+		}
+		long v[3] = { 0, 0, 0 };
+		for (int k = 0; k < nf; k++)
+			if (parse_uint(fld[k], flen[k], &v[k]) < 0)
+				return -1;
+		long total;
+		if (nf == 3) {
+			if (v[1] >= 60 || v[2] >= 60) return -1;
+			total = v[0] * 3600 + v[1] * 60 + v[2];
+		} else if (nf == 2) {
+			if (v[1] >= 60) return -1;
+			total = v[0] * 60 + v[1];
+		} else {
+			return -1;
+		}
+		return total > 0 ? total : -1;
+	}
+
+	long total = 0;
+	size_t i = 0, start = 0;
+	int have_any = 0;
+	while (i < len) {
+		if (isdigit((unsigned char)s[i])) { i++; continue; }
+		if (s[i] != 'h' && s[i] != 'm' && s[i] != 's') return -1;
+		long v;
+		if (parse_uint(s + start, i - start, &v) < 0) return -1;
+		switch (s[i]) {
+		case 'h': total += v * 3600; break;
+		case 'm': total += v * 60;   break;
+		case 's': total += v;        break;
+		}
+		have_any = 1;
+		i++;
+		start = i;
+	}
+	if (!have_any || start != len) return -1;
+	return total > 0 ? total : -1;
+}
+
+/* ===== formatting ===== */
+
+static void
+fmt_clock(long s, char *buf, size_t bufsz)
+{
+	long h = s / 3600; s %= 3600;
+	long m = s / 60;  long sec = s % 60;
+	if (h > 0) snprintf(buf, bufsz, "%02ld:%02ld:%02ld", h, m, sec);
+	else       snprintf(buf, bufsz, "%02ld:%02ld", m, sec);
+}
+
+/* ===== drawing ===== */
+
+static void
+draw_countdown(long total, long elapsed_ms, int paused, int barw)
+{
+	if (total <= 0) return;
+	long total_ms = total * 1000L;
+	if (elapsed_ms < 0) elapsed_ms = 0;
+	if (elapsed_ms > total_ms) elapsed_ms = total_ms;
+	long es = elapsed_ms / 1000;
+	long remaining = total - es;
+	long pct = (elapsed_ms * 100) / total_ms;
+	int fill = (int)((long)barw * elapsed_ms / total_ms);
+	if (fill > barw) fill = barw;
+	int empty = barw - fill;
+
+	char rem[24], el[24];
+	fmt_clock(remaining, rem, sizeof(rem));
+	fmt_clock(es, el, sizeof(el));
+
+	const char *color  = paused ? "\033[36m" : "\033[33m";
+	const char *status = paused ? "PAUSED " : "       ";
+
+	printf("\r%sT-%s\033[0m \033[2m+%s\033[0m [", color, rem, el);
+	for (int i = 0; i < fill;  i++) fputs(BAR_FILL,  stdout);
+	for (int i = 0; i < empty; i++) fputs(BAR_EMPTY, stdout);
+	printf("] %3ld%% %s", pct, status);
+	fflush(stdout);
+}
+
+static void
+draw_stopwatch(long elapsed_ms, int paused)
+{
+	long es = elapsed_ms / 1000;
+	char el[24];
+	fmt_clock(es, el, sizeof(el));
+	const char *color  = paused ? "\033[36m" : "\033[32m";
+	const char *status = paused ? "PAUSED " : "       ";
+	printf("\r%sT+%s\033[0m %s                          ",
+	       color, el, status);
+	fflush(stdout);
+}
+
+/* ===== usage =====
+ * Patches MUST update this in lockstep with new flags so -h always
+ * reflects the build.
+ */
+
+static void
+usage(FILE *f)
+{
+	fprintf(f,
+"usage:\n"
+"  timer [FLAGS] DURATION    countdown\n"
+"  timer [FLAGS]             stopwatch\n"
+"\n"
+"DURATION:  25m | 90s | 2h | 1h30m | 01:30:00 | 25:00\n"
+"FLAGS:\n"
+"  -q              no sound\n"
+"  -s              silent\n"
+"  --              end of options\n"
+"  -h              help\n"
+"\n"
+"controls:  [space] pause/resume   [q | Ctrl+C] quit\n");
+}
+
+/* ===== run loop ===== */
+
+static int
+run(long total, int stopwatch, const Config *cfg)
+{
+	out_tty = isatty(STDOUT_FILENO);
+	int cols = term_cols();
+	int barw = cols - 40;
+	if (barw < 10) barw = 10;
+
+	ttyfd = open("/dev/tty", O_RDONLY);
+	if (ttyfd >= 0 && isatty(ttyfd)) {
+		if (tcgetattr(ttyfd, &oldtios) == 0) {
+			struct termios raw = oldtios;
+			raw.c_lflag &= ~(ICANON | ECHO);
+			raw.c_cc[VMIN] = 0;
+			raw.c_cc[VTIME] = 0;
+			if (tcsetattr(ttyfd, TCSANOW, &raw) == 0)
+				rawset = 1;
+		}
+	}
+
+	atexit(restore_tty);
+	struct sigaction sa = {0};
+	sa.sa_handler = on_signal;
+	sigaction(SIGINT,  &sa, NULL);
+	sigaction(SIGTERM, &sa, NULL);
+
+	if (out_tty)
+		fputs("\033[?25l\033[?7l", stdout);
+
+	long start_ms    = now_ms();
+	long pause_accum = 0;
+	long pause_start = 0;
+	int  paused      = 0;
+	int  user_quit   = 0;
+
+	for (;;) {
+		if (interrupted) { user_quit = 1; break; }
+
+		long now = now_ms();
+		long elapsed_ms = paused
+			? pause_start - start_ms - pause_accum
+			: now - start_ms - pause_accum;
+		if (elapsed_ms < 0) elapsed_ms = 0;
+
+		if (stopwatch) {
+			if (out_tty)
+				draw_stopwatch(elapsed_ms, paused);
+		} else {
+			if (out_tty)
+				draw_countdown(total, elapsed_ms, paused, barw);
+			if (!paused && elapsed_ms >= total * 1000L) break;
+		}
+
+		long frame_end = now_ms() + 100;
+		for (;;) {
+			if (interrupted) break;
+			long rem_frame = frame_end - now_ms();
+			if (rem_frame <= 0) break;
+			if (ttyfd < 0) { sleep_ms((int)rem_frame); break; }
+
+			struct pollfd pfd = { .fd = ttyfd, .events = POLLIN };
+			int pr = poll(&pfd, 1, (int)rem_frame);
+			if (pr > 0 && (pfd.revents & POLLIN)) {
+				char c;
+				ssize_t n = read(ttyfd, &c, 1);
+				if (n == 1) {
+					if (c == ' ') {
+						if (paused) {
+							pause_accum += now_ms() - pause_start;
+							paused = 0;
+						} else {
+							pause_start = now_ms();
+							paused = 1;
+						}
+					} else if (c == 'q' || c == 'Q') {
+						user_quit = 1;
+						goto done;
+					}
+				}
+			} else if (pr == 0) {
+				break;
+			} else {
+				sleep_ms((int)rem_frame);
+				break;
+			}
+		}
+	}
+done:
+
+	{
+		long final_now = now_ms();
+		long final_ms = paused
+			? pause_start - start_ms - pause_accum
+			: final_now  - start_ms - pause_accum;
+		if (final_ms < 0) final_ms = 0;
+		elapsed_s = final_ms / 1000;
+	}
+
+	if (stopwatch) {
+		char el[24];
+		fmt_clock(elapsed_s, el, sizeof(el));
+		if (out_tty)
+			printf("\r\033[32mSTOP %s%*s\033[0m\n", el, 30, "");
+		else
+			printf("STOP %s\n", el);
+	} else if (user_quit) {
+		char el[24];
+		fmt_clock(elapsed_s, el, sizeof(el));
+		if (out_tty)
+			printf("\r\033[33mQUIT at %s%*s\033[0m\n", el, 30, "");
+		else
+			printf("QUIT at %s\n", el);
+	} else {
+		char tb[24];
+		fmt_clock(total, tb, sizeof(tb));
+		if (out_tty)
+			printf("\r\033[32mDONE %s 100%%%*s\033[0m\n", tb, 20, "");
+		else
+			printf("DONE %s 100%%\n", tb);
+		if (!cfg->silent && !cfg->quiet && out_tty) {
+			fputc('\a', stdout);
+			fflush(stdout);
+			sleep_ms(50);
+		}
+	}
+
+	(void)cfg;
+	return user_quit ? 130 : 0;
+}
+
+/* ===== main ===== */
+
+int
+main(int argc, char **argv)
+{
+	Config cfg = {0};
+
+	/* Pre-strip long-form flags before getopt. Stop at "--". */
+	int new_argc = 0;
+	char **new_argv = malloc(sizeof(char *) * (argc + 1));
+	if (!new_argv) die("oom");
+	int past_dd = 0;
+	for (int i = 0; i < argc; i++) {
+		if (!past_dd && !strcmp(argv[i], "--")) {
+			past_dd = 1;
+			new_argv[new_argc++] = argv[i];
+			continue;
+		}
+		new_argv[new_argc++] = argv[i];
+	}
+	new_argv[new_argc] = NULL;
+
+	int opt;
+	while ((opt = getopt(new_argc, new_argv, "qsh")) != -1) {
+		switch (opt) {
+		case 'q': cfg.quiet  = 1; break;
+		case 's': cfg.silent = 1; break;
+		case 'h': usage(stdout); free(new_argv); return 0;
+		default:  usage(stderr); free(new_argv); return 1;
+		}
+	}
+	int rem_argc = new_argc - optind;
+	char **rem_argv = new_argv + optind;
+
+	int stopwatch = (rem_argc < 1);
+	long total = 0;
+	if (!stopwatch) {
+		total = parse_duration(rem_argv[0]);
+		if (total < 0) {
+			fprintf(stderr, "bad duration: %s\n", rem_argv[0]);
+			free(new_argv);
+			return 1;
+		}
+	}
+
+	int rc = run(total, stopwatch, &cfg);
+	free(new_argv);
+	return rc;
+}