sob

sob.c (18973B)

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <locale.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <unistd.h>
#include <termios.h>
#include <time.h>
#include <wchar.h>

#include "arg.h"
char *argv0;

#define LEN(x)    (sizeof (x) / sizeof *(x))
#define ISUTF8(c) (((c) & 0xc0) != 0x80)

struct line {
	char line[16384]; /* static line buffer */
	size_t bytesiz;   /* length in bytes */
	size_t utflen;    /* length in characters */
	size_t bytepos;   /* index position (in bytes) */
	size_t utfpos;    /* pos in characters */
	size_t colpos;    /* cursor position (in columns) */
	size_t collen;    /* total length (in columns) */
};

static void    cb_handleinput(const char *, size_t, size_t);
static void    cb_pipe_insert(const char *, size_t, size_t);
static void    cb_pipe_replaceword(const char *, size_t, size_t);

static void    line_clear(void);
static void    line_copywordcursor(char *, size_t);
static void    line_cursor_begin(void);
static void    line_cursor_end(void);
static void    line_cursor_move(size_t);
static void    line_cursor_next(void);
static void    line_cursor_prev(void);
static void    line_cursor_wordprev(void);
static void    line_cursor_wordnext(void);
static void    line_delcharprev(void);
static void    line_delcharnext(void);
static void    line_deltoend(void);
static void    line_delwordprev(void);
static void    line_delwordcursor(void);
static void    line_draw(void);
static void    line_exit(void);
static void    line_getwordpos(size_t, size_t, size_t *, size_t *, size_t *,
                               size_t *);
static void    line_getwordposprev(size_t, size_t, size_t *, size_t *);
static void    line_getwordposnext(size_t, size_t, size_t *, size_t *);
static void    line_inserttext(const char *);
static void    line_newline(void);
static void    line_out(void);
static void    line_prompt(void);
static int     line_promptlen(void);
static int     line_pipeto(char **, void (*)(const char *, size_t, size_t));
static int     line_wordpipeto(char **,
                               void (*)(const char *, size_t, size_t));

static int     pipe_rw(int, int, char *,
                         void (*)(const char *, size_t, size_t));
static int     pipe_cmd(char *[], char *,
                        void (*)(const char *, size_t, size_t));

static void    clear(void);
static void    gettermsize(void);
static void    handleinput(const unsigned char *, size_t);
static void    initialinput(void);
static void    resize(void);
static void    run(void);
static void    setup(void);
static void    sighandler(int);
static void    usage(void);

static size_t  colw(const char *, size_t);
static int     nonspace(int c);
static size_t  utf8len(const char *);
static size_t  utfprevn(const char *, size_t, size_t);
static size_t  utfnextn(const char *, size_t, size_t);
static void    utfuntilchar(size_t *, size_t *, int (*)(int), int);

static struct  termios ttystate, ttysave;

static struct  line line;
static size_t  dirtylen; /* dirty length (in columns) */
static int     cols = 79, rows = 24;
static int     termattrset = 0;
static int     isrunning = 1;
static FILE *  outfp = NULL;
static FILE *  lineoutfp = NULL;

#include "config.h"

static int
nonspace(int c)
{
	return !isspace(c);
}

static size_t
colw(const char *s, size_t max)
{
	size_t len = 0, i;
	wchar_t w;
	int r;

	for (i = 0; *s && i < max; s++, i++) {
		if (ISUTF8(*s)) {
			if ((r = mbtowc(&w, s, i + 4 > max ? max - i : 4)) == -1)
				break;
			if ((r = wcwidth(w)) == -1)
				r = 1;
			len += r;
		}
	}
	return len;
}

static size_t
utf8len(const char *s)
{
	size_t i;

	for (i = 0; *s; s++) {
		if (ISUTF8(*s))
			i++;
	}
	return i;
}

/* returns amount of bytes needed to go to previous utf char
 * p is index in bytes. */
static size_t
utfprevn(const char *s, size_t p, size_t n)
{
	size_t i;

	for (i = 1; p > 0; p--, i++) {
		if (ISUTF8(s[p - 1]) && !--n)
			return i;
	}
	return 0;
}

/* returns amount of bytes needed to go to next utf char
 * p is index in bytes. */
static size_t
utfnextn(const char *s, size_t p, size_t n)
{
	size_t i;

	for (i = 1; s[p]; p++, i++) {
		if (ISUTF8(s[p + 1]) && !--n)
			return i;
	}
	return 0;
}

/* b is byte start pos, u is utf pos, f is filter function,
 * dir is -1 or +1 for prev or next */
static void
utfuntilchar(size_t *b, size_t *u, int (*f)(int), int dir)
{
	size_t n;

	if (dir > 0) {
		while (*u < line.utflen && *b < line.bytesiz) {
			if (f(line.line[*b]))
				break;
			if ((n = utfnextn(line.line, *b, 1)) == 0)
				break;
			*b += n;
			(*u)++;
		}

	} else {
		while (*u > 0 && *b > 0) {
			if (f(line.line[*b - 1]))
				break;
			if ((n = utfprevn(line.line, *b, 1)) == 0)
				break;
			*b -= n;
			(*u)--;
		}
	}
}

static void
line_inserttext(const char *s)
{
	size_t siz, ulen, clen;

	siz = strlen(s);
	if (line.bytepos + siz + 1 > sizeof(line.line))
		return;
	clen = colw(s, siz);
	ulen = utf8len(s);
	/* append */
	if (line.bytepos == line.bytesiz) {
		memmove(&line.line[line.bytepos], s, siz);
	} else {
		/* insert */
		memmove(&line.line[line.bytepos + siz], &line.line[line.bytepos],
		        line.bytesiz - line.bytepos);
		memcpy(&line.line[line.bytepos], s, siz);
	}
	line.bytepos += siz;
	line.bytesiz += siz;
	line.line[line.bytesiz + 1] = '\0';
	line.utflen = utf8len(line.line);
	line.utfpos += ulen;
	line.colpos += clen;
	line.collen = colw(line.line, line.bytesiz);
}

/* like mksh, toggle counting of escape codes in prompt with "\x01" */
static int
line_promptlen(void)
{
	size_t i;
	int t = 0, n = 0;

	for (i = 0; prompt[i]; i++) {
		if (prompt[i] == 1)
			t = !t;
		else if (!t && ISUTF8(prompt[i]))
			n++;
	}
	return n;
}

static void
line_prompt(void)
{
	size_t i;

	for (i = 0; prompt[i]; i++) {
		if (prompt[i] != 1)
			fputc(prompt[i], outfp);
	}
}

static void
clear(void)
{
	/* clear screen, move cursor to (0, 0) */
	fprintf(outfp, "\x1b[2J\x1b[H");
	fflush(outfp);
}

static void
line_draw(void)
{
	size_t i;

	fprintf(outfp, "\x1b[?25l"); /* hide cursor */
	fprintf(outfp, "\x1b[H"); /* move cursor to (0, 0) */

	line_prompt();
	fwrite(line.line, 1, line.bytesiz, outfp);

	/* replace dirty chars with ' ' */
	if (dirtylen > line.collen) {
		for (i = line.collen; i < dirtylen; i++)
			fputc(' ', outfp);
	}
	line_cursor_move(line.colpos);
	fprintf(outfp, "\x1b[?25h"); /* show cursor */
	fflush(outfp);
}

static void
line_out(void)
{
	fprintf(lineoutfp, "%s\n", line.line);
	fflush(lineoutfp);
}

static void
line_cursor_move(size_t newpos)
{
	size_t x, y = 0;

	x = newpos + line_promptlen();

	/* linewrap */
	if (cols > 0 && x > (size_t)cols - 1) {
		y = (x - (x % cols)) / cols;
		x %= cols;
	}
	fprintf(outfp, "\x1b[%lu;%luH", (unsigned long)y + 1, (unsigned long)x + 1);
	fflush(outfp);
}

static void
line_cursor_wordprev(void)
{
	line_getwordposprev(line.bytepos, line.utfpos, &line.bytepos,
	                    &line.utfpos);
	line.colpos = colw(line.line, line.bytepos);
	line_cursor_move(line.colpos);
}

static void
line_cursor_wordnext(void)
{
	line_getwordposnext(line.bytepos, line.utfpos, &line.bytepos,
	                    &line.utfpos);
	line.colpos = colw(line.line, line.bytepos);
	line_cursor_move(line.colpos);
}

static void
line_cursor_begin(void)
{
	line.bytepos = 0;
	line.utfpos = 0;
	line.colpos = 0;
	line_cursor_move(line.colpos);
}

static void
line_cursor_prev(void)
{
	size_t n;

	if (line.utfpos <= 0)
		return;
	if ((n = utfprevn(line.line, line.bytepos, 1)) == 0)
		return;

	line.bytepos -= n;
	line.utfpos--;
	line.colpos -= colw(&line.line[line.bytepos], n);
	line_cursor_move(line.colpos);
}

static void
line_cursor_next(void)
{
	size_t n;

	if (line.utfpos >= line.utflen)
		return;

	if ((n = utfnextn(line.line, line.bytepos, 1)) == 0)
		return;
	line.colpos += colw(&line.line[line.bytepos], n);
	line.bytepos += n;
	line.utfpos++;
	line_cursor_move(line.colpos);
}

static void
line_cursor_end(void)
{
	line.bytepos = line.bytesiz;
	line.utfpos = line.utflen;
	line.colpos = line.collen;
	line_cursor_move(line.colpos);
}

static void
line_clear(void)
{
	memset(&line, 0, sizeof(line));
	line_draw();
}

static void
line_delcharnext(void)
{
	size_t siz;

	if (line.utfpos == line.utflen || line.utflen <= 0)
		return;

	if ((siz = utfnextn(line.line, line.bytepos, 1)) == 0)
		return;

	line.collen -= colw(&line.line[line.bytepos], siz);

	memmove(&line.line[line.bytepos], &line.line[line.bytepos + siz],
	        line.bytesiz - line.bytepos - siz);

	line.bytesiz -= siz;
	line.line[line.bytesiz] = '\0';
	line.utflen--;
	line_draw();
}

static void
line_delcharprev(void)
{
	size_t siz, col;

	if (line.utfpos <= 0 || line.utflen <= 0)
		return;
	if ((siz = utfprevn(line.line, line.bytepos, 1)) == 0)
		return;

	col = colw(&line.line[line.bytepos - siz], siz);

	memmove(&line.line[line.bytepos - siz], &line.line[line.bytepos],
	        line.bytesiz - line.bytepos);

	line.bytepos -= siz;
	line.bytesiz -= siz;
	line.line[line.bytesiz] = '\0';
	line.utflen--;
	line.utfpos--;
	line.colpos -= col;
	line.collen -= col;
	line_draw();
}

static void
line_deltoend(void)
{
	line.line[line.bytepos] = '\0';
	line.bytesiz = line.bytepos;
	line.utflen = utf8len(line.line);
	line.utfpos = line.utflen;
	line.collen = colw(line.line, line.bytesiz);
	line.colpos = line.collen;
	line_draw();
}

static void
line_delwordcursor(void)
{
	size_t bs, be, us, ue, siz, len;

	line_getwordpos(line.bytepos, line.utfpos, &bs, &be, &us, &ue);

	siz = be - bs;
	len = ue - us;

	memmove(&line.line[bs], &line.line[be], line.bytesiz - be);

	line.bytesiz -= siz;
	line.bytepos = bs;
	line.line[line.bytesiz] = '\0';
	line.utfpos = us;
	line.utflen -= len;
	line.collen = colw(line.line, line.bytesiz);
	line.colpos = colw(line.line, bs);
	line_draw();
}

static void
line_delwordprev(void)
{
	size_t bs, us, siz, len;

	if (line.utfpos <= 0 || line.utflen <= 0)
		return;

	line_getwordposprev(line.bytepos, line.utfpos, &bs, &us);

	siz = line.bytepos - bs;
	len = line.utfpos - us;
	line.colpos -= colw(&line.line[bs], siz);

	memmove(&line.line[bs], &line.line[line.bytepos],
	        line.bytesiz - line.bytepos);

	line.bytesiz -= siz;
	line.bytepos = bs;
	line.line[line.bytesiz] = '\0';
	line.utfpos = us;
	line.utflen -= len;
	line.collen = colw(line.line, line.bytesiz);
	line_draw();
}

static void
line_newline(void)
{
	line_out();
	memset(&line, 0, sizeof(line));
	line_draw();
}

static void
line_exit(void)
{
	fprintf(outfp, "\n");
	fflush(outfp);
	isrunning = 0;
}

static void
line_getwordpos(size_t b, size_t u, size_t *bs, size_t *be,
	size_t *us, size_t *ue)
{
	size_t tb = b, tu = u;

	utfuntilchar(&b, &u, isspace, -1);
	if (bs)
		*bs = b;
	if (us)
		*us = u;

	/* seek from original specified position */
	utfuntilchar(&tb, &tu, isspace, +1);
	if (be)
		*be = tb;
	if (ue)
		*ue = tu;
}

static void
line_getwordposprev(size_t sb, size_t su, size_t *b, size_t *u)
{
	utfuntilchar(&sb, &su, nonspace, -1);
	utfuntilchar(&sb, &su, isspace, -1);
	if (b)
		*b = sb;
	if (u)
		*u = su;
}

static void
line_getwordposnext(size_t sb, size_t su, size_t *b, size_t *u)
{
	utfuntilchar(&sb, &su, nonspace, +1);
	utfuntilchar(&sb, &su, isspace, +1);
	if (b)
		*b = sb;
	if (u)
		*u = su;
}

static void
line_copywordcursor(char *buf, size_t bufsiz)
{
	size_t bs, be, len;

	line_getwordpos(line.bytepos, line.utfpos, &bs, &be, NULL, NULL);
	len = be - bs;

	/* truncate */
	if (len + 1 > bufsiz)
		len = bufsiz - 1;
	memcpy(buf, &line.line[bs], len);
	buf[len] = '\0';
}

/* It will be tried first to write to the pipe and then read.
 * if fd_in == -1 don't read, if fd_out == -1 or writestr == NULL don't write.
 * f is the read callback() on the data (buf, read_size, total_read).
 * if f is NULL no data is read from the pipe. */
static int
pipe_rw(int fd_in, int fd_out, char *writestr,
	void (*f)(const char *, size_t, size_t))
{
	char buf[PIPE_BUF];
	struct timeval tv;
	fd_set fdr, fdw;
	size_t total = 0;
	ssize_t r;
	int maxfd, status = -1, haswritten = 0;

	if (fd_out == -1 || writestr == NULL)
		haswritten = 1;

	while (isrunning) {
		FD_ZERO(&fdr);
		FD_ZERO(&fdw);
		if (haswritten) {
			if (!f || fd_in == -1)
				break;
			FD_SET(fd_in, &fdr);
			maxfd = fd_in;
		} else {
			FD_SET(fd_out, &fdw);
			maxfd = fd_out;
		}
		memset(&tv, 0, sizeof(tv));
		tv.tv_usec = 50000; /* 50 ms */

		if ((r = select(maxfd + 1, haswritten ? &fdr : NULL,
				   haswritten ? NULL : &fdw, NULL, &tv)) == -1) {
			if (errno != EINTR)
				goto fini;
		} else if (!r) { /* timeout */
			continue;
		}
		if (fd_out != -1 && FD_ISSET(fd_out, &fdw)) {
			if (write(fd_out, writestr, strlen(writestr)) == -1) {
				if (errno == EWOULDBLOCK || errno == EAGAIN ||
				   errno == EINTR)
					continue;
				else if (errno == EPIPE)
					goto fini;
				goto fini;
			}
			if (fd_out > 2)
				close(fd_out); /* sends EOF */
			fd_out = -1;
			haswritten = 1;
		}
		if (haswritten && fd_in != -1 && FD_ISSET(fd_in, &fdr)) {
			r = read(fd_in, buf, sizeof(buf));
			if (r == -1) {
				if (errno == EWOULDBLOCK || errno == EAGAIN)
					continue;
				goto fini;
			}
			if (r > 0) {
				buf[r] = '\0';
				total += (size_t)r;
				if (f)
					f(buf, r, total);
			} else if (!r) {
				status = 0;
				goto fini;
			}
		}
	}
fini:
	if (fd_in != -1 && fd_in > 2)
		close(fd_in);
	if (fd_out != -1 && fd_out > 2)
		close(fd_out);
	return status;
}

static int
pipe_cmd(char *cmd[], char *writestr, void (*f)(const char *, size_t, size_t))
{
	struct sigaction sa;
	pid_t pid;
	int pc[2], cp[2];

	if (pipe(pc) == -1 || pipe(cp) == -1) {
		perror("pipe");
		return -1;
	}
	pid = fork();
	if (pid == -1) {
		perror("fork");
		return -1;
	} else if (pid == 0) {
		/* child */
		setenv("SOBLINE", line.line, 1);
		setenv("SOBWRITE", writestr, 1);
		close(cp[0]);
		close(pc[1]);

		if (dup2(pc[0], 0) == -1 || dup2(cp[1], 1) == -1) {
			perror("dup2");
			return -1;
		}

		if (execv(cmd[0], (char**)cmd) == -1) {
			perror("execv");
			_exit(1); /* NOTE: must be _exit */
		}
		_exit(0);
	} else {
		/* parent */
		close(pc[0]);
		close(cp[1]);

		/* ignore SIGPIPE, we handle this for write(). */
		memset(&sa, 0, sizeof(sa));
		sa.sa_flags = SA_RESTART;
		sa.sa_handler = SIG_IGN;
		sigaction(SIGPIPE, &sa, NULL);

		if (pipe_rw(cp[0], pc[1], writestr, f) == -1)
			return -1;
	}
	return 0;
}

static void
cb_handleinput(const char *buf, size_t len, size_t total)
{
	if (!len || !total)
		return;
	handleinput((unsigned char *)buf, len);
}

static void
cb_pipe_insert(const char *buf, size_t len, size_t total)
{
	if (!len || !total)
		return;
	memset(&line, 0, sizeof(line));
	handleinput((unsigned char *)buf, len);
}

static void
cb_pipe_replaceword(const char *buf, size_t len, size_t total)
{
	if (!len)
		return;
	/* first read: delete word under cursor. */
	if (len == total)
		line_delwordcursor();
	handleinput((unsigned char *)buf, len);
}

static int
line_pipeto(char **cmd, void (*f)(const char *, size_t, size_t))
{
	return pipe_cmd(cmd, line.line, f);
}

/* pipe word under cursor and replace it */
static int
line_wordpipeto(char **cmd, void (*f)(const char *, size_t, size_t))
{
	char wordbuf[BUFSIZ];

	wordbuf[0] = '\0';
	line_copywordcursor(wordbuf, sizeof(wordbuf));

	return pipe_cmd((char**)cmd, wordbuf, f);
}

static void
sighandler(int signum)
{
	switch(signum) {
	case SIGINT: /* fallthrough */
	case SIGTERM:
		line_exit();
		break;
	case SIGWINCH:
		clear();
		gettermsize();
		resize();
		line_draw();
		break;
	}
}

static void
gettermsize(void)
{
	struct winsize w;

	if (ioctl(0, TIOCGWINSZ, &w) == -1)
		return;
	cols = w.ws_col;
	rows = w.ws_row;
}

static void
resize(void)
{
	pipe_cmd((char **)resizecmd, line.line, NULL);
}

static void
handleinput(const unsigned char *input, size_t len)
{
	size_t p = 0, keylen, i;
	int ismatch = 0;
	char buf[BUFSIZ];

	dirtylen = line.collen;
	while (p < len && input[p] != '\0') {
		if (input[p] == 0x1b || iscntrl(input[p])) {
			ismatch = 0;
			for (i = 0; i < LEN(keybinds); i++) {
				keylen = strlen((char*)keybinds[i].key);
				if (len - p >= keylen &&
				   memcmp(&input[p], keybinds[i].key, keylen) == 0) {
					keybinds[i].func();
					p += keylen;
					ismatch = 1;
					break;
				}
			}
			if (!ismatch) {
				if (input[p] == 0x1b)
					return;
				p++;
			}
		} else {
			for (i = p; input[i] && input[i] > 0x1b; i++)
				;
			if (i - p < sizeof(buf)) {
				memcpy(buf, &input[p], i - p);
				buf[i - p] = '\0';
				p = i;
				line_inserttext((char*)buf);
				line_draw();
			} else {
				p++;
			}
		}
	}
}

static void
setup(void)
{
	struct sigaction sa;

	lineoutfp = stdout;
	outfp = stderr;
	setlocale(LC_ALL, "");

	/* signal handling */
	memset(&sa, 0, sizeof(sa));
	sa.sa_flags = SA_RESTART;
	sa.sa_handler = sighandler;
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);
	sigaction(SIGWINCH, &sa, NULL);
	/* reap zombie childs >=) */
	sa.sa_handler = SIG_IGN;
	sigaction(SIGCHLD, &sa, NULL);
	/* ignore SIGPIPE, we handle this for write(). */
	sa.sa_handler = SIG_IGN;
	sigaction(SIGPIPE, &sa, NULL);

	if (tcgetattr(0, &ttystate) == 0) {
		termattrset = 1;
		ttysave = ttystate;
		/* turn off canonical mode and echo */
		ttystate.c_lflag &= ~(ICANON | ECHO);
		ttystate.c_cc[VMIN] = 1;
		/* set the terminal attributes */
		tcsetattr(0, TCSANOW, &ttystate);
	} else {
		/* not a tty */
		initialinput();
		/* setup tty again because we (re)open "/dev/tty" */
		termattrset = 0;
		if (tcgetattr(0, &ttystate) == 0) {
			termattrset = 1;
			ttysave = ttystate;
			/* turn off canonical mode and echo */
			ttystate.c_lflag &= ~(ICANON | ECHO);
			ttystate.c_cc[VMIN] = 1;
			/* set the terminal attributes */
			tcsetattr(0, TCSANOW, &ttystate);
		}
	}
	/* get terminal window size */
	gettermsize();
}

static void
run(void)
{
	if (!isrunning)
		return;

	/* clear screen */
	clear();

	fcntl(0, F_SETFL, O_NONBLOCK);
	line_draw();

	pipe_rw(0, -1, NULL, cb_handleinput);

	/* cleanup: restore terminal attributes */
	if (termattrset) {
		ttystate.c_lflag = ttysave.c_lflag;
		tcsetattr(0, TCSANOW, &ttystate);
	}
}

static void
initialinput(void)
{
	int fd;

	/* read initial input from stdin */
	fcntl(0, F_SETFL, O_NONBLOCK);
	pipe_rw(0, -1, NULL, cb_handleinput);
	/* restore terminal attributes */
	if (termattrset) {
		ttystate.c_lflag = ttysave.c_lflag;
		tcsetattr(0, TCSANOW, &ttystate);
	}
	if (!isrunning)
		return;
	/* close and re-attach to stdin */
	close(0);
	if ((fd = open("/dev/tty", O_RDONLY | O_NONBLOCK)) == -1) {
		fprintf(stderr, "open: /dev/tty: %s\n", strerror(errno));
		exit(1);
	}
	if (dup2(fd, 0) == -1) {
		fprintf(stderr, "dup2: /dev/tty: %s\n", strerror(errno));
		exit(1);
	}
}

static void
usage(void)
{
	fprintf(stderr, "usage: %s [-p prompt]\n", argv0);
	exit(1);
}

int
main(int argc, char **argv)
{
	ARGBEGIN {
	case 'p':
		prompt = EARGF(usage());
		break;
	default:
		usage();
	} ARGEND;

	setup();
	run();

	return 0;
}