bluelib/term/sys/linux/tty.c

#include "../../tty.h"

#include <blue/term/tty.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>

#define ANSI_BOLD_ON          "1"
#define ANSI_BOLD_OFF         "22"
#define ANSI_ITALIC_ON        "3"
#define ANSI_ITALIC_OFF       "23"
#define ANSI_UNDERLINE_ON     "4"
#define ANSI_UNDERLINE_OFF    "24"

#define ANSI_DEFAULTCOLOUR_FG "39"
#define ANSI_DEFAULTCOLOUR_BG "49"

#define ANSI_256COLOUR_FG     "38;5"
#define ANSI_256COLOUR_BG     "48;5"

#define ANSI_TRUECOLOUR_FG    "38;2"
#define ANSI_TRUECOLOUR_BG    "48;2"

enum tty_flags {
	B_TTY_INIT = 0x01u,
	B_TTY_INTERACTIVE = 0x02u,
};

struct b_tty {
	FILE *t_in, *t_out;
	enum tty_flags t_flags;
	struct termios t_ios_raw, t_ios_default;
	struct b_tty_vmode t_vmode;
	unsigned char t_mcount;
	struct tty_format_buf t_format_buf;
};

static struct b_tty std = {0};
static struct b_tty err = {0};

static const char *ansi_colour16_fg[] = {
	[B_TTY_COLOUR16_BLACK] = "30",
	[B_TTY_COLOUR16_RED] = "31",
	[B_TTY_COLOUR16_GREEN] = "32",
	[B_TTY_COLOUR16_YELLOW] = "33",
	[B_TTY_COLOUR16_BLUE] = "34",
	[B_TTY_COLOUR16_MAGENTA] = "35",
	[B_TTY_COLOUR16_CYAN] = "36",
	[B_TTY_COLOUR16_WHITE] = "37",
	[B_TTY_COLOUR16_BRIGHT_BLACK] = "90",
	[B_TTY_COLOUR16_BRIGHT_RED] = "91",
	[B_TTY_COLOUR16_BRIGHT_GREEN] = "92",
	[B_TTY_COLOUR16_BRIGHT_YELLOW] = "93",
	[B_TTY_COLOUR16_BRIGHT_BLUE] = "94",
	[B_TTY_COLOUR16_BRIGHT_MAGENTA] = "95",
	[B_TTY_COLOUR16_BRIGHT_CYAN] = "96",
	[B_TTY_COLOUR16_BRIGHT_WHITE] = "97",
};

static const char *ansi_colour16_bg[] = {
	[B_TTY_COLOUR16_BLACK] = "40",
	[B_TTY_COLOUR16_RED] = "41",
	[B_TTY_COLOUR16_GREEN] = "42",
	[B_TTY_COLOUR16_YELLOW] = "43",
	[B_TTY_COLOUR16_BLUE] = "44",
	[B_TTY_COLOUR16_MAGENTA] = "45",
	[B_TTY_COLOUR16_CYAN] = "46",
	[B_TTY_COLOUR16_WHITE] = "47",
	[B_TTY_COLOUR16_BRIGHT_BLACK] = "100",
	[B_TTY_COLOUR16_BRIGHT_RED] = "101",
	[B_TTY_COLOUR16_BRIGHT_GREEN] = "102",
	[B_TTY_COLOUR16_BRIGHT_YELLOW] = "103",
	[B_TTY_COLOUR16_BRIGHT_BLUE] = "104",
	[B_TTY_COLOUR16_BRIGHT_MAGENTA] = "105",
	[B_TTY_COLOUR16_BRIGHT_CYAN] = "106",
	[B_TTY_COLOUR16_BRIGHT_WHITE] = "107",
};

static void init_tty(struct b_tty *tty, FILE *in, FILE *out)
{
	tty->t_in = in;
	tty->t_out = out;

	int fd = -1;
	if (in) {
		fd = fileno(in);
	} else if (out) {
		fd = fileno(out);
	}

	if (fd == -1) {
		return;
	}

	if (isatty(fd)) {
		tty->t_flags |= B_TTY_INTERACTIVE;
	}

	tcgetattr(fd, &tty->t_ios_default);
	memcpy(&tty->t_ios_raw, &tty->t_ios_default, sizeof tty->t_ios_raw);

	tty->t_ios_raw.c_iflag &= ~(ICRNL | IXON);
	tty->t_ios_raw.c_oflag &= ~(OPOST);
	tty->t_ios_raw.c_lflag &= ~(ECHO | ICANON | IEXTEN);

	tty->t_flags |= B_TTY_INIT;
}

struct b_tty *z__b_tty_get_std(void)
{
	if (!(std.t_flags & B_TTY_INIT)) {
		init_tty(&std, stdin, stdout);
	}

	return &std;
}

struct b_tty *z__b_tty_get_err(void)
{
	if (!(err.t_flags & B_TTY_INIT)) {
		init_tty(&err, NULL, stderr);
	}

	return &err;
}

struct tty_format_buf *z__b_tty_get_format_buf(struct b_tty *tty)
{
	return &tty->t_format_buf;
}

void z__b_tty_putc(struct b_tty *tty, char c)
{
	fputc(c, tty->t_out);
}

bool b_tty_is_interactive(const struct b_tty *tty)
{
	return (tty->t_flags & B_TTY_INTERACTIVE) == B_TTY_INTERACTIVE;
}

static void set_raw(struct b_tty *tty)
{
	int fd = -1;
	if (tty->t_in) {
		fd = fileno(tty->t_in);
	} else if (tty->t_out) {
		fd = fileno(tty->t_out);
	}

	if (fd == -1) {
		return;
	}

	tcsetattr(fd, TCSAFLUSH, &tty->t_ios_raw);
}

static void set_canon(struct b_tty *tty)
{
	int fd = -1;
	if (tty->t_in) {
		fd = fileno(tty->t_in);
	} else if (tty->t_out) {
		fd = fileno(tty->t_out);
	}

	if (fd == -1) {
		return;
	}

	tcsetattr(fd, TCSAFLUSH, &tty->t_ios_default);
}

void b_tty_set_mode(struct b_tty *tty, enum b_tty_mode mode)
{
	switch (mode) {
	case B_TTY_CANONICAL:
		set_canon(tty);
		break;
	case B_TTY_RAW:
		set_raw(tty);
		break;
	default:
		break;
	}
}

void b_tty_reset_vmode(struct b_tty *tty)
{
	if (tty->t_vmode.v_fg.c_mode == B_TTY_COLOUR_NONE
	    && tty->t_vmode.v_bg.c_mode == B_TTY_COLOUR_NONE
	    && tty->t_vmode.v_attrib == B_TTY_ATTRIB_NORMAL) {
		return;
	}

	fprintf(tty->t_out, "\033[0m");

	memset(&tty->t_vmode, 0x0, sizeof tty->t_vmode);

	tty->t_vmode.v_fg.c_mode = B_TTY_COLOUR_NONE;
	tty->t_vmode.v_bg.c_mode = B_TTY_COLOUR_NONE;
	tty->t_vmode.v_attrib = B_TTY_ATTRIB_NORMAL;
}

static int compare_colour(
	const struct b_tty_colour *a, const struct b_tty_colour *b)
{
	if (a->c_mode != b->c_mode) {
		return -1;
	}

	switch (a->c_mode) {
	case B_TTY_COLOUR_16:
		if (a->c_16.value != b->c_16.value) {
			return -1;
		}
		break;
	case B_TTY_COLOUR_256:
		if (a->c_256.value != b->c_256.value) {
			return -1;
		}
		break;
	case B_TTY_COLOUR_TRUE:
		if (a->c_true.r != b->c_true.r) {
			return -1;
		}

		if (a->c_true.g != b->c_true.g) {
			return -1;
		}

		if (a->c_true.b != b->c_true.b) {
			return -1;
		}
		break;
	default:
		break;
	}

	return 0;
}

static int compare_vmode(const struct b_tty_vmode *a, const struct b_tty_vmode *b)
{
	if (a->v_attrib != b->v_attrib) {
		return -1;
	}

	if (compare_colour(&a->v_fg, &b->v_fg) != 0) {
		return -1;
	}

	if (compare_colour(&a->v_bg, &b->v_bg) != 0) {
		return -1;
	}

	return 0;
}

static void put_ansi_attrib(struct b_tty *tty, const char *s)
{
	if (tty->t_mcount > 0) {
		fputs(";", tty->t_out);
	}

	fputs(s, tty->t_out);
	tty->t_mcount++;
}

static void set_attrib(
	struct b_tty *tty, enum b_tty_attrib old, enum b_tty_attrib new)
{
	if (old == new) {
		return;
	}

	/* Bold ON */
	if (!(old & B_TTY_ATTRIB_BOLD) && new &B_TTY_ATTRIB_BOLD) {
		put_ansi_attrib(tty, ANSI_BOLD_ON);
	}

	/* Bold OFF */
	if (old & B_TTY_ATTRIB_BOLD && !(new &B_TTY_ATTRIB_BOLD)) {
		put_ansi_attrib(tty, ANSI_BOLD_OFF);
	}

	/* Underline ON */
	if (!(old & B_TTY_ATTRIB_UNDERLINE) && new &B_TTY_ATTRIB_UNDERLINE) {
		put_ansi_attrib(tty, ANSI_UNDERLINE_ON);
	}

	/* Underline OFF */
	if (old & B_TTY_ATTRIB_UNDERLINE && !(new &B_TTY_ATTRIB_UNDERLINE)) {
		put_ansi_attrib(tty, ANSI_UNDERLINE_OFF);
	}

	/* Italic ON */
	if (!(old & B_TTY_ATTRIB_ITALIC) && new &B_TTY_ATTRIB_ITALIC) {
		put_ansi_attrib(tty, ANSI_ITALIC_ON);
	}

	/* Italic OFF */
	if (old & B_TTY_ATTRIB_ITALIC && !(new &B_TTY_ATTRIB_ITALIC)) {
		put_ansi_attrib(tty, ANSI_ITALIC_OFF);
	}
}

static void set_fg(
	struct b_tty *tty, const struct b_tty_colour *old,
	const struct b_tty_colour *new)
{
	if (compare_colour(old, new) == 0) {
		return;
	}

	char buf[8];

	switch (new->c_mode) {
	case B_TTY_COLOUR_NONE:
		put_ansi_attrib(tty, ANSI_DEFAULTCOLOUR_FG);
		break;
	case B_TTY_COLOUR_16:
		put_ansi_attrib(tty, ansi_colour16_fg[new->c_16.value]);
		break;
	case B_TTY_COLOUR_256:
		put_ansi_attrib(tty, ANSI_256COLOUR_FG);
		snprintf(buf, sizeof buf, "%u", new->c_256.value);
		put_ansi_attrib(tty, buf);
		break;
	case B_TTY_COLOUR_TRUE:
		put_ansi_attrib(tty, ANSI_TRUECOLOUR_FG);
		snprintf(buf, sizeof buf, "%u", new->c_true.r);
		put_ansi_attrib(tty, buf);
		snprintf(buf, sizeof buf, "%u", new->c_true.g);
		put_ansi_attrib(tty, buf);
		snprintf(buf, sizeof buf, "%u", new->c_true.b);
		put_ansi_attrib(tty, buf);
		break;
	default:
		break;
	}
}

static void set_bg(
	struct b_tty *tty, const struct b_tty_colour *old,
	const struct b_tty_colour *new)
{
	if (compare_colour(old, new) == 0) {
		return;
	}

	char buf[8];

	switch (new->c_mode) {
	case B_TTY_COLOUR_NONE:
		put_ansi_attrib(tty, ANSI_DEFAULTCOLOUR_BG);
		break;
	case B_TTY_COLOUR_16:
		put_ansi_attrib(tty, ansi_colour16_bg[new->c_16.value]);
		break;
	case B_TTY_COLOUR_256:
		put_ansi_attrib(tty, ANSI_256COLOUR_BG);
		snprintf(buf, sizeof buf, "%u", new->c_256.value);
		put_ansi_attrib(tty, buf);
		break;
	case B_TTY_COLOUR_TRUE:
		put_ansi_attrib(tty, ANSI_TRUECOLOUR_BG);
		snprintf(buf, sizeof buf, "%u", new->c_true.r);
		put_ansi_attrib(tty, buf);
		snprintf(buf, sizeof buf, "%u", new->c_true.g);
		put_ansi_attrib(tty, buf);
		snprintf(buf, sizeof buf, "%u", new->c_true.b);
		put_ansi_attrib(tty, buf);
		break;
	default:
		break;
	}
}

void b_tty_set_vmode(struct b_tty *tty, const struct b_tty_vmode *vmode)
{
	if (compare_vmode(&tty->t_vmode, vmode) == 0) {
		return;
	}

	tty->t_mcount = 0;

	fprintf(tty->t_out, "\033[");

	set_attrib(tty, tty->t_vmode.v_attrib, vmode->v_attrib);
	set_fg(tty, &tty->t_vmode.v_fg, &vmode->v_fg);
	set_bg(tty, &tty->t_vmode.v_bg, &vmode->v_bg);

	fprintf(tty->t_out, "m");

	memcpy(&tty->t_vmode, vmode, sizeof *vmode);
}

b_keycode b_tty_read_key(struct b_tty *tty)
{
	char c;
	int v;
	int fd = fileno(tty->t_in);

	while (1) {
		v = read(fd, &c, 1);
		if (v < 1) {
			return B_KEY_EOF;
		}

		if (c == '\r' || c == '\n') {
			return B_KEY_RETURN;
		}

		if (c == '\b' || c == 0x7F) {
			return B_KEY_BACKSPACE;
		}

		if (c >= 1 && c <= 26) {
			return B_TTY_CTRL_KEY(c + 'a' - 1);
		}

		if (c != 0x1b) {
			return c;
		}

		v = read(fd, &c, 1);
		if (v < 1) {
			return B_KEY_EOF;
		}

		if (c != '[') {
			continue;
		}

		v = read(fd, &c, 1);
		if (v < 1) {
			return B_KEY_EOF;
		}

		switch (c) {
		case 'A':
			return B_KEY_ARROW_UP;
		case 'B':
			return B_KEY_ARROW_DOWN;
		case 'C':
			return B_KEY_ARROW_RIGHT;
		case 'D':
			return B_KEY_ARROW_LEFT;
		default:
			continue;
		}
	}

	return c;
}

void b_tty_move_cursor_x(struct b_tty *tty, enum b_tty_position_base base, int pos)
{
	if (base == B_TTY_POS_CURSOR && pos < 0 && pos >= -4) {
		for (int i = 0; i > pos; i--) {
			fputc('\b', tty->t_out);
		}

		return;
	}

	if (base == B_TTY_POS_START) {
		if (pos == 0) {
			fputs("\033[G", tty->t_out);
		} else {
			fprintf(tty->t_out, "\033[%dG", pos + 1);
		}
	} else {
		if (pos > 1) {
			fprintf(tty->t_out, "\033[%dC", pos);
		} else if (pos == 1) {
			fputs("\033[C", tty->t_out);
		} else if (pos == -1) {
			fputs("\033[D", tty->t_out);
		} else if (pos < -1) {
			fprintf(tty->t_out, "\033[%dD", -pos);
		}
	}
}

void b_tty_move_cursor_y(struct b_tty *tty, enum b_tty_position_base base, int pos)
{
	if (base == B_TTY_POS_START) {
		/* we don't need this functionality right now */
		abort();
	}

	if (pos > 1) {
		fprintf(tty->t_out, "\033[%dB", pos);
	} else if (pos == 1) {
		fputs("\033[B", tty->t_out);
	} else if (pos == -1) {
		fputs("\033[A", tty->t_out);
	} else if (pos < -1) {
		fprintf(tty->t_out, "\033[%dA", -pos);
	}
}

void b_tty_clear(struct b_tty *tty, enum b_tty_clear_mode mode)
{
	const char *arg;
	if (mode & B_TTY_CLEAR_ALL) {
		arg = "2";
	} else if (mode & B_TTY_CLEAR_TO_CURSOR) {
		arg = "1";
	} else if (mode & B_TTY_CLEAR_FROM_CURSOR) {
		arg = "";
	} else {
		abort();
	}

	if (mode & B_TTY_CLEAR_SCREEN) {
		fprintf(tty->t_out, "\033[%sJ", arg);
	} else if (mode & B_TTY_CLEAR_LINE) {
		fprintf(tty->t_out, "\033[%sK", arg);
	} else {
		abort();
	}
}

enum b_status b_tty_get_dimensions(
	struct b_tty *tty, unsigned int *w, unsigned int *h)
{
	if (!(tty->t_flags & B_TTY_INTERACTIVE)) {
		return -1;
	}

	int fd = fileno(tty->t_out);
	struct winsize ws;
	if (ioctl(fd, TIOCGWINSZ, &ws) == -1) {
		return -1;
	}

	if (w) {
		*w = ws.ws_col;
	}

	if (h) {
		*h = ws.ws_row;
	}

	return 0;
}