editor.c

/* es-mveety line editor
 * this has been broadly cribbed from linenoise (https://github.com/antirez/linenoise)
 * basically this is just a little dumber, less featureful, and more integrated
 * into es.
 */

#include "stdenv.h"
#ifdef STANDALONE
#ifdef __linux__
#define _XOPEN_SOURCE 800
#endif
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <assert.h>
#include <unistd.h>
#include <stdint.h>
#else
#include "es.h"
#include "gc.h"
#endif
#include "editor.h"
#include <locale.h>
#include <wchar.h>

#ifndef EditorDebug
#define EditorDebug 0
#endif

#ifdef dprint
#undef dprint
#endif

#if EditorDebug == 1
#define dprint(args...)                \
	do {                               \
		if(state->dfd > 0) {           \
			dprintf(state->dfd, args); \
		}                              \
	} while(0)
#else
#define dprint(args...) noop()
#endif

#define bufferassert() assert(state->bufpos <= state->bufend)

typedef struct {
	char *str;
	size_t len;
	size_t size;
} OutBuf;

const Position ErrPos = (Position){-1, -1};

#ifdef STANDALONE

#define nil ((void *)0)

#define strneq(s, t, n) (strncmp(s, t, n) == 0)
#define hasprefix(s, p) strneq(s, p, (sizeof(p) - 1))

#ifndef unreachable
#define unreachable() \
	do {              \
		assert(0);    \
	} while(0)
#endif

#if __has_attribute(__fallthrough__)
#define fallthrough __attribute__((__fallthrough__))
#else
#define fallthrough \
	do {            \
	} while(0) /* fallthrough */
#endif

void
noop(void)
{
	return;
}

void *
ealloc(size_t n)
{
	void *ptr;

	ptr = malloc(n);
	assert(ptr);
	memset(ptr, 0, n);
	return ptr;
}

void *
erealloc(void *p, size_t n)
{
	void *ptr;

	if(!p)
		return ealloc(n);
	ptr = realloc(p, n);
	assert(ptr);
	return ptr;
}

void
efree(void *ptr)
{
	free(ptr);
}

char *
estrdup(char *str)
{
	char *res = nil;

	res = strdup(str);
	assert(res);
	return res;
}

char *
estrndup(char *str, size_t len)
{
	char *res = nil;

	res = strndup(str, len);
	assert(res);
	return res;
}

Result
result(void *ptr, int status)
{
	return (Result){
		.ptr = ptr,
		.status = status,
	};
}

void *
ok(Result r)
{
	assert(r.status == 0);
	return r.ptr;
}

int
status(Result r)
{
	return r.status;
}

void *
used(void *ptr)
{
	return ptr;
}

int
editor_istracked(void *ptr)
{
	used(ptr);
	return 0;
}

int
eisatty(int fd)
{
	return isatty(fd);
}

#else

int
editor_istracked(void *ptr)
{
	if(istracked(ptr) == TRUE)
		return 1;
	return 0;
}

#endif

HistoryEntry *get_history_next(EditorState *state);
HistoryEntry *get_history_last(EditorState *state);
void create_default_mapping(Keymap *map);

char *
getterm(void)
{
	char *env_term;

	env_term = getenv("TERM");
	if(!env_term)
		return estrdup("unknown");
	return estrdup(env_term);
}

void
outbuf_append(OutBuf *obuf, char *str, int len)
{
	if(obuf->str == nil)
		obuf->str = ealloc(len + 2);
	if(obuf->len + len + 1 > obuf->size) {
		obuf->str = erealloc(obuf->str, obuf->size + len + 1);
		obuf->size += len + 1;
	}
	memcpy(&obuf->str[obuf->len], str, len);
	obuf->len += len;
}

typedef struct {
	Brace *brace;
	enum { NoBrace, OpenBrace, CloseBrace } type;
} BraceState;

BraceState
findbrace(char c, EditorState *state)
{
	size_t i = 0;

	for(i = 0; i < state->nbraces; i++) {
		if(state->braces[i].open == c)
			return (BraceState){.brace = &state->braces[i], .type = OpenBrace};
		if(state->braces[i].close == c)
			return (BraceState){.brace = &state->braces[i], .type = CloseBrace};
	}

	return (BraceState){.brace = nil, .type = NoBrace};
}

int64_t
find_matching_paren(EditorState *state)
{
	int64_t i = 0;
	int reg = 0;
	char c = 0;
	BraceState bs;

	if(state->braces == nil || state->nbraces == 0)
		return -1;

	if(state->bufpos == state->bufend && state->bufpos > 0)
		c = state->buffer[state->bufpos - 1];
	else
		c = state->buffer[state->bufpos];

	switch((bs = findbrace(c, state)).type) {
	default:
		unreachable();
		break;
	case NoBrace:
		assert(bs.brace == nil);
		return -1;
	case OpenBrace:
		if(state->bufpos == state->bufend)
			return -1;
		for(i = state->bufpos; i <= (int64_t)state->bufend; i++) {
			if(reg < 0)
				return -1;
			if(state->buffer[i] == bs.brace->open) {
				reg++;
				continue;
			}
			if(state->buffer[i] == bs.brace->close) {
				reg--;
				if(reg == 0)
					return i;
			}
		}
		return -1;
	case CloseBrace:
		for(i = state->bufpos; i >= 0; i--) {
			if(reg < 0)
				return -1;
			if(state->buffer[i] == bs.brace->close) {
				reg++;
				continue;
			}
			if(state->buffer[i] == bs.brace->open) {
				reg--;
				if(reg == 0)
					return i;
			}
		}
		return -1;
	}
	return -1;
}

void
outbuf_append_printable(EditorState *state, OutBuf *obuf, char *str, int len, int all,
						int nohighlight)
{
	int64_t i = 0;
	int64_t pos = 0;
	int64_t incr = 1;
	int64_t highlight = -1;
	int64_t highlight2 = -1;
	int64_t highlightsz = 0;
	size_t hlfmtlen = 0;
	size_t full_len = 0;
	size_t curfmt_start = 0;
	size_t curfmt_end = 0;
	size_t fmtlen = 0;

	if(nohighlight == 0) {
		if(state->match_braces && !state->done_reading)
			highlight = find_matching_paren(state);

		if(state->highlight_formatting == nil)
			highlight = -1;
		if(highlight >= 0) {
			hlfmtlen = strlen(state->highlight_formatting);
			highlightsz = hlfmtlen + 4;
		}

		if(highlight >= 0 && state->bufpos == state->bufend) {
			highlight2 = state->bufpos - 1;
			highlightsz += highlightsz;
		}

		dprint("highlight1 = %ld\n", highlight);
		dprint("highlight2 = %ld\n", highlight2);
		dprint("highlightsz = %ld\n", highlightsz);
	}

	if(obuf->str == nil) {
		obuf->str = ealloc(len + highlightsz + 2);
		obuf->size = len + highlightsz + 2;
	}

	full_len = highlightsz + len + 1;
	dprint("prefmt full_len = %lu\n", full_len);
	for(i = 0; i < len; i++) {
		if(str[i] == '\x01') {
			if(i + 1 < len)
				curfmt_start = i + 1;
			continue;
		}
		if(str[i] == '\x02')
			fmtlen += i - curfmt_start;
	}
	dprint("fmtlen = %lu\n", fmtlen);
	full_len += fmtlen * 2;
	dprint("postfmt full_len = %lu\n", full_len);

	dprint("pre sizecheck: obuf->len = %lu, obuf->size = %lu\n", obuf->len, obuf->size);
	if(obuf->len + full_len > obuf->size) {
		obuf->str = erealloc(obuf->str, obuf->size + full_len);
		obuf->size += full_len;
	}
	dprint("post sizecheck: obuf->len = %lu, obuf->size = %lu\n", obuf->len, obuf->size);

	for(i = 0, pos = 0, curfmt_start = 0, curfmt_end = 0; i < len; i++) {
		if(str[i] == '\x01') {
			incr = 0;
			if(i + 1 < len)
				curfmt_start = i + 1;
			continue;
		} else if(str[i] == '\x02') {
			incr = 1;
			curfmt_end = i;
			continue;
		}
		if(incr == 1 && (pos == highlight || pos == highlight2)) {
			dprint("adding highlight at %ld (pos = %ld)\n", i, pos);
			memcpy(&obuf->str[obuf->len], state->highlight_formatting, hlfmtlen);
			obuf->len += hlfmtlen;
		}
		if(all)
			obuf->str[obuf->len++] = str[i];
		else {
			if(str[i] >= ' ' && str[i] <= '~') {
				obuf->str[obuf->len++] = str[i];
			} else if(str[i] & 0b10000000) {
				obuf->str[obuf->len++] = str[i];
			} else {
				dprint("got unprintable char in buffer: %x\n", str[i]);
			}
		}
		if(incr == 1 && (pos == highlight || pos == highlight2)) {
			obuf->str[obuf->len++] = '\x1b';
			obuf->str[obuf->len++] = '[';
			obuf->str[obuf->len++] = '0';
			obuf->str[obuf->len++] = 'm';
			if(curfmt_end > 0 && curfmt_start != 0 && curfmt_end > curfmt_start) {
				dprint("resetting formatting: curfmt_start = %lu, curfmt_end = %lu\n", curfmt_start,
					   curfmt_end);
				dprint("obuf->len = %lu\n", obuf->len);
				memcpy(&obuf->str[obuf->len], &str[curfmt_start], curfmt_end - curfmt_start);
				obuf->len += curfmt_end - curfmt_start;
			}
		}
		pos += incr;
	}
}

void
outbuf_clean(OutBuf *obuf)
{
	memset(obuf->str, 0, obuf->len + 1);
	obuf->len = 0;
}

int
reconfigure_terminal(EditorState *state)
{
	struct termios raw;

	raw = state->old_termios;
	raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
	raw.c_oflag &= ~OPOST;
	raw.c_cflag |= CS8;
	raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
	raw.c_cc[VMIN] = 1;
	raw.c_cc[VTIME] = 0;

	if(tcsetattr(state->ifd, TCSANOW, &raw) < 0) {
		tcsetattr(state->ifd, TCSANOW, &state->old_termios);
		return -1;
	}
	state->rawmode = 1;
	return 0;
}

int
rawmode_on(EditorState *state)
{
	struct termios raw;

	if(state->rawmode)
		return 1;
	if(tcgetattr(state->ifd, &state->old_termios) < 0)
		return -1;

	raw = state->old_termios;
	raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
	raw.c_oflag &= ~OPOST;
	raw.c_cflag |= CS8;
	raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
	raw.c_cc[VMIN] = 1;
	raw.c_cc[VTIME] = 0;

	if(tcsetattr(state->ifd, TCSAFLUSH, &raw) < 0) {
		tcsetattr(state->ifd, TCSAFLUSH, &state->old_termios);
		return -1;
	}
	state->rawmode = 1;
	return 0;
}

int
rawmode_off(EditorState *state)
{
	if(!state->rawmode)
		return -2;
	if(tcsetattr(state->ifd, TCSAFLUSH, &state->old_termios) < 0)
		return -1;
	state->rawmode = 0;
	return 0;
}

int
isavty(EditorState *state)
{
	char *ttypath = nil;

	ttypath = ttyname(state->ifd);
	if(!ttypath)
		return 0;
	if(hasprefix(ttypath, PTY_PREFIX))
		return 1;
	return 0;
}

Position
getposition(EditorState *state)
{
	char buf[32];
	int cols, rows;
	size_t i = 0;

	// NOTE: this is a hack for FreeBSD vt(4)
	// it seems to be the case that vt(4) does not respond
	// to \x1b[6n, causing es to freeze on start up. A workaround
	// for this is to just return ErrPos when the tty does not
	// start with /dev/pts.
	// I think this really only hits FreeBSD and only during early init.
	// the other case where getposition is used is normally covered
	// by ioctl.

#if defined(__FreeBSD__)
	if(!isavty(state))
		return ErrPos;
#endif

	if(write(state->ofd, "\x1b[6n", 4) != 4)
		return ErrPos;

	for(i = 0; i < sizeof(buf) - 1; i++) {
		if(read(state->ifd, &buf[i], 1) != 1)
			return ErrPos;
		if(buf[i] == 'R')
			break;
	}

	buf[i] = 0;
	if(buf[0] != KeyEscape || buf[1] != '[')
		return ErrPos;
	if(sscanf(&buf[2], "%d;%d", &rows, &cols) != 2)
		return ErrPos;
	return (Position){cols, rows};
}

int
setposition_lines(EditorState *state, Position pos)
{
	char buf[32];

	snprintf(&buf[0], sizeof(buf), "\x1b[%dH", pos.lines);
	if(write(state->ofd, buf, strnlen(buf, sizeof(buf))) < 0)
		return -1;
	return 0;
}

int
setposition_cols(EditorState *state, Position pos)
{
	char buf[32];

	snprintf(&buf[0], sizeof(buf), "\x1b[;%dH", pos.cols);
	if(write(state->ofd, buf, strnlen(buf, sizeof(buf))) < 0)
		return -1;
	return 0;
}

int
setposition(EditorState *state, Position pos)
{
	char buf[32];

	snprintf(&buf[0], sizeof(buf), "\x1b[%d;%dH", pos.lines, pos.cols);
	if(write(state->ofd, buf, strnlen(buf, sizeof(buf))) < 0)
		return -1;
	return 0;
}

Position
gettermsize(EditorState *state)
{
	struct winsize ws;
	Position saved_pos;
	Position res;

	/* this stuff only works if this is really a for real tty */
	if(!isatty(state->ofd) || !isatty(state->ifd))
		return (Position){80, 24};
	if(ioctl(state->ofd, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
		saved_pos = getposition(state);
		if(saved_pos.cols == -1 && saved_pos.lines == -1)
			return ErrPos;

		if(write(state->ofd, "\1b[999C", 6) != 6)
			return ErrPos;
		res = getposition(state);
		setposition(state, saved_pos);
		return res;
	}
	return (Position){ws.ws_col, ws.ws_row};
}

int
supported_term(char *term)
{
	if(hasprefix(term, "xterm"))
		return 1;
	if(hasprefix(term, "screen"))
		return 1;
	if(hasprefix(term, "rxvt"))
		return 1;
	if(hasprefix(term, "linux"))
		return 1;
	if(hasprefix(term, "tmux"))
		return 1;
	if(hasprefix(term, "putty"))
		return 1;
	if(hasprefix(term, "dtterm"))
		return 1;
	if(hasprefix(term, "st"))
		return 1;
	if(hasprefix(term, "vt1"))
		return 1;
	if(hasprefix(term, "vt2"))
		return 1;
	if(hasprefix(term, "vt3"))
		return 1;
	if(hasprefix(term, "vt4"))
		return 1;
	if(hasprefix(term, "vt5"))
		return 1;
	if(hasprefix(term, "wsvt25"))
		return 1;
	if(hasprefix(term, "alacritty"))
		return 1;
	return 0;
}

void
basic_editor_initialization(EditorState *state, int ifd, int ofd)
{
	/* this sets things up for the fallback editor */
	state->ifd = ifd;
	state->ofd = ofd;
	state->prompt1 = nil;
	state->prompt2 = nil;
	state->buffer = ealloc(EDITINITIALBUFSZ);
	state->bufsz = EDITINITIALBUFSZ;
	state->initialized = 1;
	state->indriver = DriverFallback;
	state->term = estrdup("fallback");
}

int /* only do this once! */
initialize_editor(EditorState *state, int ifd, int ofd)
{
	char *term = nil;

	memset(state, 0, sizeof(EditorState));
	state->ifd = ifd;
	state->ofd = ofd;
	state->prompt1 = nil;
	state->initialized = 0;

	if(!eisatty(ifd) || !eisatty(ofd)) {
		basic_editor_initialization(state, ifd, ofd);
		return -1;
	}
	term = getterm();
	if(!supported_term(term)) {
		basic_editor_initialization(state, ifd, ofd);
		efree(term);
		return -2;
	}
	*state = (EditorState){
		.ifd = ifd,
		.ofd = ofd,
		.dfd = -1,
		.term = term,
		.buffer = ealloc(EDITINITIALBUFSZ),
		.bufsz = EDITINITIALBUFSZ,
		.bufpos = 0,
		.fixed_bufpos = 0,
		.bufend = 0,
		.lastbufpos = 0,
		.position = (Position){.lines = 1, .cols = 0},
		.last_end = (Position){.lines = 1, .cols = 0},
		.initialized = 1,
		.history = nil,
		.histbuf = nil,
		.inhistory = 0,
		.cur = nil,
		.completions = nil,
		.completionsi = 0,
		.completionssz = 0,
		.completions_hook = nil,
		.completebuf = nil,
		.lastcomplen = 0,
		.wordbreaks = " \t\n",
		.prefixes = nil,
		.in_completion = 0,
		.pos = (Wordpos){.start = 0, .end = 0 },
		.outbuf = ealloc(sizeof(OutBuf)),
		.sort_completions = 0,
		.remove_duplicates = 0,
		.clear_screen = 0,
		.done_reading = 0,
		.match_braces = 1,
		.braces = nil,
		.nbraces = 0,
		.word_start = FirstLetter,
		.noreset = 0,
		.highlight_formatting = nil,
		.syntax_highlight_hook = nil,
		.indriver = DriverVT100,
		.outdriver = DriverVT100,
		.keymap = ealloc(sizeof(Keymap)),
	};
	memset(state->outbuf, 0, sizeof(OutBuf));
	rawmode_on(state);
	state->size = gettermsize(state);
	rawmode_off(state);
	create_default_mapping(state->keymap);
	setlocale(LC_ALL, "");
	return 0;
}

void
editor_debugging(EditorState *state, int dfd)
{
	state->dfd = dfd;
}

void
free_editor(EditorState *state)
{
	HistoryEntry *cur;
	OutBuf *buf;

	if(!state->initialized)
		return;

	if(state->term)
		efree(state->term);
	efree(state->buffer);
	if(state->prompt1)
		efree(state->prompt1);
	if(state->prompt2)
		efree(state->prompt2);
	state->prompt1sz = 0;
	state->prompt2sz = 0;
	state->initialized = 0;

	if(state->outbuf) {
		buf = state->outbuf;
		if(buf->str)
			efree(buf->str);
		efree(state->outbuf);
	}

	cur = state->history;
	if(cur) {
		while(cur->next != nil) {
			if(cur->prev) {
				efree(cur->prev->str);
				efree(cur->prev);
			}
			cur = cur->next;
		}
		if(cur->prev) {
			efree(cur->prev->str);
			efree(cur->prev);
		}
		efree(cur->str);
		efree(cur);
	}
	if(state->keymap)
		efree(state->keymap);
	if(state->braces)
		efree(state->braces);
	if(state->highlight_formatting)
		efree(state->highlight_formatting);
}

int
reset_editor(EditorState *state)
{
	Position curpos;
	char newline[] = "\r\n";

	if(!state->initialized)
		return -1;

	if(state->noreset) {
		state->noreset = 0;
		state->size = gettermsize(state);
		if(state->inhistory) {
			assert(state->histbuf);
			efree(state->histbuf);
			state->histbufsz = 0;
			state->cur = nil;
			state->inhistory = 0;
		}
		completion_reset(state);
		return 0;
	}

	curpos = getposition(state);
	dprint("firstpos = (Position){.lines = %d, .cols = %d}\n", curpos.lines, curpos.cols);
	if(curpos.cols > 1) {
		dprint("in the middle of a line, resetting and adding a newline\n");
		write(state->ofd, newline, 2);
	}
	memset(state->buffer, 0, state->bufsz);
	state->bufpos = 0;
	state->fixed_bufpos = 0;
	state->bufend = 0;
	state->lastbufpos = 0;
	state->position = (Position){.lines = 1, .cols = 0};
	state->last_end = (Position){.lines = 1, .cols = 0};
	state->size = gettermsize(state);
	if(state->inhistory) {
		assert(state->histbuf);
		efree(state->histbuf);
		state->histbufsz = 0;
		state->cur = nil;
		state->inhistory = 0;
	}
	completion_reset(state);
	state->pos = (Wordpos){0, 0};
	state->done_reading = 0;
	return 0;
}

int
register_braces(EditorState *state, char open, char close)
{
	if(!state->initialized)
		return -1;

	state->braces = erealloc(state->braces, (state->nbraces + 1) * sizeof(Brace));
	state->braces[state->nbraces] = (Brace){.open = open, .close = close};
	state->nbraces++;

	return 0;
}

size_t
marked_strlen(char *str)
{
	size_t i = 0;
	size_t len = 0;
	enum { Count, DontCount } state = Count;

	for(i = 0, len = 0; str[i] != 0; i++) {
		switch(state) {
		default:
			unreachable();
			break;
		case Count:
			if(str[i] == '\x01')
				state = DontCount;
			else
				len++;
			break;
		case DontCount:
			if(str[i] == '\x02')
				state = Count;
			break;
		}
	}
	return len;
}

size_t
old_utf8_strnlen(EditorState *state, char *str, size_t lim)
{
	size_t i = 0;
	size_t sz = 0;
	wchar_t buf;
	int st;
	int width;

	for(i = 0; i < lim;) {
		width = mbtowc(&buf, &str[i], 4);
		if(width < 0) {
			i++;
			continue;
		}
		i += width;
		st = wcwidth(buf);
		if(st < 0)
			continue;
		sz += st;
	}
	return sz;
}

size_t
new_utf8_strnlen(EditorState *state, char *str, size_t lim)
{
	wchar_t *wstr = nil;
	char *sstr = nil;
	size_t nwchars = 0;
	int cols = 0;

	sstr = estrndup(str, lim);
	wstr = ealloc(sizeof(wchar_t) * (lim + 2));
	errno = 0;
	nwchars = mbstowcs(wstr, sstr, lim);
	if(nwchars == (size_t)-1) {
		if(errno == EILSEQ)
			dprintf(2, "got invalid multibyte sequence\n");
		else if(errno == EINVAL)
			dprintf(2, "conversion state is invalid\n");
		unreachable();
	}
	cols = wcswidth(wstr, nwchars);
	if(cols == -1) {
		dprintf(2, "non-printing char found?\n");
		unreachable();
	}
	efree(wstr);
	efree(sstr);
	return (size_t)cols;
}

size_t
utf8_strnlen(EditorState *state, char *str, size_t lim)
{
	return old_utf8_strnlen(state, str, lim);
}

size_t
utf8_marked_strlen(char *str)
{
	size_t i = 0;
	size_t len = 0;
	enum { Count, DontCount } state = Count;
	wchar_t buf = 0;
	int st = 0;
	int width;

	for(i = 0, len = 0; str[i] != 0;) {
		switch(state) {
		default:
			unreachable();
			break;
		case Count:
			if(str[i] == '\x01') {
				state = DontCount;
				continue;
			}
			width = mbtowc(&buf, &str[i], 4);
			if(width < 0) {
				i++;
				continue;
			}
			i += width;
			st = wcwidth(buf);
			if(st < 0)
				continue;
			len += st;
			break;
		case DontCount:
			if(str[i] == '\x02')
				state = Count;
			i++;
			break;
		}
	}

	return len;
}

void
set_prompt1(EditorState *state, char *str)
{
	dprint("setting prompt1 to \"%s\"\n", str);
	if(state->prompt1) {
		efree(state->prompt1);
		state->prompt1sz = 0;
	}
	if(str == nil)
		return;
	state->prompt1 = estrdup(str);
	state->prompt1sz = marked_strlen(str);
}

void
set_prompt2(EditorState *state, char *str)
{
	if(!state->initialized)
		return;
	dprint("setting prompt2 to \"%s\"\n", str);
	if(state->prompt2) {
		efree(state->prompt2);
		state->prompt2sz = 0;
	}
	if(str == nil)
		return;
	state->prompt2 = estrdup(str);
	state->prompt2sz = marked_strlen(str);
}

void
set_complete_hook(EditorState *state, char **(*hook)(char *, int, int))
{
	if(!state->initialized)
		return;
	completion_reset(state);
	state->completions_hook = hook;
}

void
set_highlight_formatting(EditorState *state, char *formatting)
{
	if(!state->initialized)
		return;
	if(state->highlight_formatting)
		efree(state->highlight_formatting);
	state->highlight_formatting = nil;
	if(formatting == nil)
		return;
	state->highlight_formatting = estrdup(formatting);
}

void
set_syntax_highlight_hook(EditorState *state, char *(*hook)(char *, size_t))
{
	if(!state->initialized)
		return;
	state->syntax_highlight_hook = hook;
}

void /* I really think this could use work */
vt100_refresh(EditorState *state)
{
	OutBuf *buf = nil;
	char snbuf[64];
	size_t snsz;
	int promptn = state->which_prompt;
#if EditorDebug == 1
	size_t promptsz = promptn == 0 ? state->prompt1sz : state->prompt2sz;
#endif
	char *prompt = promptn == 0 ? state->prompt1 : state->prompt2;
	size_t i;
	/*Position real_position;*/
	Position rel_end;
	Position rel_next_end;
	Position rel_cur_pos;
	Position rel_next_pos;
	size_t utf8_promptsz = 0;
	size_t utf8_bufpos = 0;
	size_t utf8_bufend = 0;
	char *highlighted_buffer = nil;

	bufferassert();
	buf = state->outbuf;
	/* we need to work out where the line originally started */
	utf8_promptsz = utf8_marked_strlen(prompt);
	utf8_bufpos = utf8_strnlen(state, state->buffer, state->bufpos);
	utf8_bufend = utf8_strnlen(state, state->buffer, state->bufend);
	/* real_position = getposition(state); */
	rel_end = state->last_end;
	rel_next_end = (Position){
		.lines = (utf8_bufend + utf8_promptsz + state->size.cols) / state->size.cols,
		.cols = (utf8_bufend + utf8_promptsz) % state->size.cols,
	};
	rel_cur_pos = state->position;
	rel_next_pos = (Position){
		.lines = (utf8_bufpos + utf8_promptsz + state->size.cols) / state->size.cols,
		.cols = (utf8_bufpos + utf8_promptsz) % state->size.cols,
	};
	dprint("----------\n");
	dprint("buf->size = %lu, buf->len = %lu\n", buf->size, buf->len);
	dprint("state->size = {.lines = %d, .cols = %d}\n", state->size.lines, state->size.cols);
	dprint("state->bufend = %lu, state->bufpos = %lu\n", state->bufend, state->bufpos);
	dprint("utf8_bufpos = %lu, utf8_bufend = %lu\n", utf8_bufpos, utf8_bufend);
	dprint("promptsz = %lu, utf8_promptsz = %lu\n", promptsz, utf8_promptsz);
	dprint("strlen(prompt) = %lu\n", strlen(prompt));
	dprint("rel_end = {.lines = %d, .cols = %d}\n", rel_end.lines, rel_end.cols);
	dprint("rel_next_end = {.lines = %d, .cols = %d}\n", rel_next_end.lines, rel_next_end.cols);
	dprint("rel_cur_pos = {.lines = %d, .cols = %d}\n", rel_cur_pos.lines, rel_cur_pos.cols);
	dprint("rel_next_pos = {.lines = %d, .cols = %d}\n", rel_next_pos.lines, rel_next_pos.cols);
	/*dprint("real_position = {.lines = %d, .cols = %d}\n", real_position.lines,
			real_position.cols);*/
	dprint("state->buffer = \"%s\"\n", state->buffer);

	if(state->clear_screen) {
		snsz = snprintf(&snbuf[0], sizeof(snbuf), "\x1b[H\x1b[2J");
		outbuf_append(buf, &snbuf[0], snsz);
		state->clear_screen = 0;
	} else {
		/* go to end */

		if(rel_end.lines - rel_cur_pos.lines > 0)
			snsz =
				snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[%dB", rel_end.lines - rel_cur_pos.lines);
		else
			snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r");
		outbuf_append(buf, &snbuf[0], snsz);

		if(state->bufpos <= state->lastbufpos) {
			for(i = 0; i < (size_t)(rel_end.lines - 1); i++) {
				snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[0K\x1b[1A");
				outbuf_append(buf, &snbuf[0], snsz);
			}

			snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[0K");
			outbuf_append(buf, &snbuf[0], snsz);
		} else {
			for(i = 0; i < (size_t)(rel_end.lines - 1); i++) {
				snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[1A");
				outbuf_append(buf, &snbuf[0], snsz);
			}
		}
	}

	outbuf_append_printable(state, buf, prompt, strlen(prompt), 1, 1);
	if(state->syntax_highlight_hook) {
		dprint("calling syntax highlighting hook\n");
		highlighted_buffer = state->syntax_highlight_hook(state->buffer, state->bufend);
		if(highlighted_buffer) {
			outbuf_append_printable(state, buf, highlighted_buffer, strlen(highlighted_buffer), 1,
									0);
			efree(highlighted_buffer);
		}
	} else
		outbuf_append_printable(state, buf, state->buffer, state->bufend, 0, 0);

	if(rel_next_end.lines - 1 > 0) {
		if(rel_next_end.cols > 0)
			snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[%dA", rel_next_end.lines - 1);
		else
			snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\n\x1b[%dA", rel_next_end.lines - 1);
	} else
		snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r");
	outbuf_append(buf, &snbuf[0], snsz);

	if(rel_next_pos.lines - 1 > 0) {
		snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[%dB", rel_next_pos.lines - 1);
		outbuf_append(buf, &snbuf[0], snsz);
	}

	if(rel_next_pos.cols > 0) {
		snsz = snprintf(&snbuf[0], sizeof(snbuf), "\r\x1b[%dC", rel_next_pos.cols);
		outbuf_append(buf, &snbuf[0], snsz);
	}

	write(state->ofd, buf->str, buf->len);
	state->position = rel_next_pos;
	state->last_end = rel_next_end;

	dprint("buf->size = %lu, buf->len = %lu\n", buf->size, buf->len);
	outbuf_clean(buf);
	state->lastbufpos = state->bufpos;
}

void
refresh(EditorState *state)
{
	switch(state->outdriver) {
	default:
		unreachable();
	case DriverVT100:
		vt100_refresh(state);
		break;
	}
}

void
update_size(EditorState *state)
{
	dprint("size update: old: state->size = {.lines = %d, .cols = %d}\n", state->size.lines,
		   state->size.cols);
	state->size = gettermsize(state);
	dprint("size update: new: state->size = {.lines = %d, .cols = %d}\n", state->size.lines,
		   state->size.cols);
	refresh(state);
}

void
grow_buffer(EditorState *state, size_t sz)
{
	bufferassert();
	state->bufsz += sz;
	state->buffer = erealloc(state->buffer, state->bufsz);
}

EditorContext *
save_editor_context(EditorState *state)
{
	EditorContext *ctx = nil;

	ctx = ealloc(sizeof(EditorContext));
	ctx->bufpos = state->bufpos;
	ctx->bufsize = state->bufend;
	if(state->bufend > 0)
		ctx->bufdata = estrndup(state->buffer, state->bufend + 1);

	dprint("saving editor context: pos = %lu, size = %lu\n", ctx->bufpos, ctx->bufsize);
	return ctx;
}

EditorContext *
restore_editor_context(EditorState *state, EditorContext *ctx)
{
	dprint("restoring editor context: pos = %lu, size = %lu\n", ctx->bufpos, ctx->bufsize);
	if(state->bufsz < ctx->bufsize)
		grow_buffer(state, ctx->bufsize + 5);
	memset(state->buffer, 0, state->bufsz);
	if(ctx->bufsize > 0) {
		memcpy(state->buffer, ctx->bufdata, ctx->bufsize);
		efree(ctx->bufdata);
	}
	state->bufend = ctx->bufsize;
	state->bufpos = ctx->bufpos;
	state->noreset = 1;

	efree(ctx);

	return nil;
}

/* motions and editing */
int
isawordbreak(EditorState *state, size_t wordbreakssz, char c)
{
	size_t i = 0;

	assert(state->wordbreaks);
	for(i = 0; i < wordbreakssz; i++) {
		if(c == '\0')
			return 1; /* we'll call nil a wordbreak */
		if(c == state->wordbreaks[i])
			return 1;
	}
	return 0;
}

int
isaprefix(EditorState *state, char c)
{
	size_t i = 0;
	size_t prefixssz = 0;

	if(!state->prefixes)
		return 0;
	prefixssz = strlen(state->prefixes);
	for(i = 0; i < prefixssz; i++)
		if(state->prefixes[i] == c)
			return 1;
	return 0;
}

Wordpos
get_word_position(EditorState *state)
{
	Wordpos res = {0, 0};
	size_t i;
	size_t wordbreakssz;

	assert(state->wordbreaks);
	wordbreakssz = strlen(state->wordbreaks);
	if(state->bufend == 0)
		return res;
	res.end = state->bufpos;
	for(i = state->bufpos; i < state->bufend; i++)
		if(isawordbreak(state, wordbreakssz, state->buffer[i]))
			break;
	res.end = i;
	for(i = res.end; i >= 1; i--)
		if(isawordbreak(state, wordbreakssz, state->buffer[i - 1])) {
			res.start = i;
			if(i > 0 && isaprefix(state, state->buffer[i - 1]))
				res.start -= 1;
			assert(res.start <= res.end);
			return res;
		}
	res.start = 0;
	assert(res.start <= res.end);
	return res;
}

void
insert_char(EditorState *state, char c)
{
	assert(state->bufpos <= state->bufend);
	if(state->bufend == (state->bufsz - 5))
		grow_buffer(state, state->bufsz);

	if(state->bufpos == state->bufend) {
		state->buffer[state->bufpos] = c;
		state->bufpos++;
		state->bufend++;
		return;
	}
	memmove(&state->buffer[state->bufpos + 1], &state->buffer[state->bufpos],
			state->bufend - state->bufpos);
	state->buffer[state->bufpos] = c;
	state->bufpos++;
	state->bufend++;
	return;
}

void
insert_n_char(EditorState *state, char *str, size_t len)
{
	size_t i = 0;

	for(i = 0; i < len; i++)
		insert_char(state, str[i]);
}

size_t
charsize(EditorState *state)
{
	size_t sz = 0;

	do {
		sz++;
	} while((state->buffer[state->bufpos - sz] & 0b11000000) == 0b10000000 &&
			(state->bufpos - sz) > 0);
	return sz;
}

void
backspace_char(EditorState *state)
{
	size_t charsz = 0;
	size_t i = 0;

	if(state->bufpos == 0)
		return;
	bufferassert();
	charsz = charsize(state);
	if(state->bufpos == state->bufend) {
		for(i = 0; i < charsz; i++) {
			state->bufpos--;
			state->bufend--;
			state->buffer[state->bufpos] = 0;
		}
		return;
	}
	state->bufpos -= charsz;
	state->bufend -= charsz;
	memmove(&state->buffer[state->bufpos], &state->buffer[state->bufpos + charsz],
			state->bufend - state->bufpos);
	memset(&state->buffer[state->bufend], 0, charsz);
	return;
}

void
delete_char(EditorState *state)
{
	size_t charsz = 0;

	bufferassert();
	if(state->bufpos == state->bufend)
		return;
	charsz = charsize(state);
	state->bufend -= charsz;
	memmove(&state->buffer[state->bufpos], &state->buffer[state->bufpos + charsz],
			state->bufend - state->bufpos);
	memset(&state->buffer[state->bufend], 0, charsz);
	return;
}

void
delete_word(EditorState *state)
{
	Wordpos wordpos;
	size_t first_end = 0;
	size_t old_bufend = 0;

	bufferassert();

	wordpos = get_word_position(state);
	dprint("start wordpos = {.start = %lu, .end = %lu}\n", wordpos.start, wordpos.end);
	if(wordpos.end - wordpos.start == 0) {
		first_end = wordpos.end;
		while(wordpos.end - wordpos.start == 0 && state->bufpos > 0) {
			state->bufpos--;
			wordpos = get_word_position(state);
		}
		wordpos.end = first_end;
	}
	dprint("end wordpos = {.start = %lu, .end = %lu}\n", wordpos.start, wordpos.end);

	memset(&state->buffer[wordpos.start], 0, wordpos.end - wordpos.start);
	memmove(&state->buffer[wordpos.start], &state->buffer[wordpos.end],
			state->bufend - wordpos.end);
	old_bufend = state->bufend;
	state->bufend -= wordpos.end - wordpos.start;
	if(state->bufend < old_bufend)
		memset(&state->buffer[state->bufend], 0, old_bufend - state->bufend);
	state->bufpos = wordpos.start;
}

void
delete_to_start(EditorState *state)
{
	size_t old_bufpos = 0;
	size_t old_bufend = 0;

	bufferassert();
	if(state->bufend == 0)
		return;
	if(state->bufpos == 0)
		return;

	old_bufpos = state->bufpos;
	old_bufend = state->bufend;

	memmove(&state->buffer[0], &state->buffer[state->bufpos], state->bufend - state->bufpos);
	state->bufpos = 0;
	state->bufend = state->bufend - old_bufpos;
	memset(&state->buffer[state->bufend], 0, old_bufend - state->bufend);
	bufferassert();
}

void
delete_to_end(EditorState *state)
{
	bufferassert();
	if(state->bufend == 0)
		return;
	if(state->bufpos == 0) {
		memset(state->buffer, 0, state->bufend);
		state->bufend = 0;
		return;
	}

	memset(&state->buffer[state->bufpos], 0, state->bufend - state->bufpos);
	state->bufend = state->bufpos;
}

void
cursor_move_left(EditorState *state)
{
	bufferassert();
	if(state->bufpos == 0)
		return;
	do {
		state->bufpos--;
	} while((state->buffer[state->bufpos] & 0b11000000) == 0b10000000 && state->bufpos > 0);
}

void
cursor_move_right(EditorState *state)
{
	bufferassert();
	if(state->bufpos == state->bufend)
		return;
	do {
		state->bufpos++;
	} while((state->buffer[state->bufpos] & 0b11000000) == 0b10000000 &&
			state->bufpos < state->bufend);
}

void
cursor_home(EditorState *state)
{
	bufferassert();
	if(state->bufpos != 0)
		state->bufpos = 0;
}

void
cursor_end(EditorState *state)
{
	bufferassert();
	if(state->bufpos < state->bufend)
		state->bufpos = state->bufend;
}

void
clear_screen(EditorState *state)
{
	bufferassert();
	state->clear_screen = 1;
}

void
cursor_move_word_left(EditorState *state)
{
	Wordpos nextword;
	size_t first_end;

	bufferassert();
	if(state->bufpos == 0)
		return;

	nextword = get_word_position(state);
	dprint("start nextword = {.start = %lu, .end = %lu}\n", nextword.start, nextword.end);
	if(nextword.start == state->bufpos) {
		state->bufpos--;
		nextword = get_word_position(state);
		dprint("start nextword = {.start = %lu, .end = %lu}\n", nextword.start, nextword.end);
	}
	if(nextword.end - nextword.start == 0) {
		first_end = nextword.end;
		while(nextword.end - nextword.start == 0 && state->bufpos > 0) {
			state->bufpos--;
			nextword = get_word_position(state);
		}
		nextword.end = first_end;
	}
	dprint("end nextword = {.start = %lu, .end = %lu}\n", nextword.start, nextword.end);

	switch(state->word_start) {
	default:
		unreachable();
	case FirstLetter:
		state->bufpos = nextword.start;
		break;
	case FirstBreak:
		if(nextword.start == 0) {
			state->bufpos = 0;
			return;
		}
		if(isawordbreak(state, strlen(state->wordbreaks), state->buffer[nextword.start - 1]))
			state->bufpos = nextword.start - 1;
		else
			state->bufpos = nextword.start;
		break;
	case LastBreak:
		if(nextword.start == 0) {
			state->bufpos = 0;
			return;
		}
		nextword.start--;
		while(nextword.start > 0 &&
			  isawordbreak(state, strlen(state->wordbreaks), state->buffer[nextword.start]))
			nextword.start--;
		if(isawordbreak(state, strlen(state->wordbreaks), state->buffer[nextword.start + 1]))
			nextword.start++;
		state->bufpos = nextword.start;
		break;
	}
}

void
cursor_move_word_right(EditorState *state)
{
	size_t i;

	bufferassert();
	if(state->bufpos == state->bufend)
		return;

	dprint("finding start of first word...");
	for(i = state->bufpos;
		i < state->bufend && isawordbreak(state, strlen(state->wordbreaks), state->buffer[i]); i++)
		;
	;
	dprint("found at %lu\nfinding end of word...", i);
	for(; i < state->bufend && !isawordbreak(state, strlen(state->wordbreaks), state->buffer[i]);
		i++)
		;
	;
	dprint("found at %lu\n", i);

	if(i > state->bufend)
		i = state->bufend;
	state->bufpos = i;
}

void
jump_to_matching_paren(EditorState *state)
{
	int64_t nextparen = -1;

	nextparen = find_matching_paren(state);
	if(nextparen < 0) {
		dprint("found no matching paren\n");
		return;
	}
	dprint("found matching paren at %ld\n", nextparen);
	dprint("old state->bufpos = %lu\n", state->bufpos);
	state->bufpos = nextparen;
	if(state->bufpos > state->bufend)
		state->bufpos = state->bufend;
	dprint("new state->bufpos = %lu\n", state->bufpos);
}

/* history */

void
history_add(EditorState *state, char *str)
{
	HistoryEntry *new_entry = nil;

	new_entry = ealloc(sizeof(HistoryEntry));

	new_entry->str = estrdup(str);
	new_entry->len = strlen(str);
	new_entry->next = state->history;
	if(new_entry->next)
		new_entry->next->prev = new_entry;
	new_entry->prev = nil;
	state->history = new_entry;
}

void
history_clear(EditorState *state)
{
	HistoryEntry *cur;

	cur = state->history;
	if(cur) {
		while(cur->next != nil) {
			if(cur->prev) {
				efree(cur->prev->str);
				efree(cur->prev);
			}
			cur = cur->next;
		}
		if(cur->prev) {
			efree(cur->prev->str);
			efree(cur->prev);
		}
		efree(cur->str);
		efree(cur);
	}
	state->cur = nil;
	state->history = nil;
}

HistoryEntry *
get_history_next(EditorState *state)
{
	if(state->history == nil)
		return nil;
	if(state->cur == nil) {
		state->cur = state->history;
		return state->cur;
	}
	state->cur = state->cur->next;
	return state->cur;
}

HistoryEntry *
get_history_prev(EditorState *state)
{
	if(state->history == nil)
		return nil;
	if(state->cur == nil)
		return nil;
	state->cur = state->cur->prev;
	return state->cur;
}

void
do_history_replace(EditorState *state, HistoryEntry *ent)
{
	bufferassert();
	if(state->inhistory) {
		assert(state->histbuf);
		memset(state->buffer, 0, state->bufend);
		if(ent == nil) {
			memcpy(state->buffer, state->histbuf, state->histbufsz);
			state->bufend = state->histbufsz;
			efree(state->histbuf);
			state->inhistory = 0;
		} else {
			if(ent->len >= state->bufsz)
				grow_buffer(state, state->bufsz);
			memcpy(state->buffer, ent->str, ent->len);
			state->bufend = ent->len;
		}
		state->bufpos = state->bufend;
	} else {
		if(ent == nil)
			return;
		state->inhistory = 1;
		state->histbuf = estrdup(state->buffer);
		state->histbufsz = strlen(state->buffer);
		memset(state->buffer, 0, state->bufend);
		if(ent->len >= state->bufsz)
			grow_buffer(state, state->bufsz);
		memcpy(state->buffer, ent->str, ent->len);
		state->bufend = ent->len;
		state->bufpos = state->bufend;
	}
	bufferassert();
}

void
history_next(EditorState *state)
{
	HistoryEntry *ent = nil;

	ent = get_history_next(state);
	do_history_replace(state, ent);
}

void
history_prev(EditorState *state)
{
	HistoryEntry *ent = nil;

	ent = get_history_prev(state);
	do_history_replace(state, ent);
}

void
history_cancel(EditorState *state)
{
	if(state->inhistory) {
		assert(state->histbuf);
		memset(state->buffer, 0, state->bufend);
		memcpy(state->buffer, state->histbuf, state->histbufsz);
		state->bufend = state->histbufsz;
		efree(state->histbuf);
		if(state->bufpos > state->bufend)
			state->bufpos = state->bufend;
		state->cur = nil;
		state->inhistory = 0;
	}
	bufferassert();
}

/* completion */

int
complete_compstr(const void *a, const void *b)
{
	const char *astr = *(const char **)a;
	const char *bstr = *(const char **)b;

	return strcmp(astr, bstr);
}

void
call_completions_hook(EditorState *state, Wordpos pos)
{
	size_t i = 0;
	char *partial = nil;
	Wordpos partial_pos;
	char **completions = nil;
	size_t completionssz = 0;
	char **completions2 = nil;
	size_t completions2sz = 0;

	if(!state->completions_hook)
		return;

	completion_reset(state);
	partial_pos = get_word_position(state);
	partial = ealloc(partial_pos.end - partial_pos.start + 2);
	memcpy(partial, &state->buffer[partial_pos.start], partial_pos.end - partial_pos.start);
	dprint("partial = %s\n", partial);
	completions = state->completions_hook(partial, pos.start, pos.end);
	efree(partial);
	if(completions == nil)
		return;
	for(i = 0; completions[i] != nil; i++) {
		assert(!editor_istracked(completions[i]));
		dprint("completions[%lu] = %p\n", i, completions[i]);
	}
	completionssz = i;
	dprint("completionssz = %lu\n", completionssz);

	if(state->sort_completions) {
		qsort(completions, completionssz, sizeof(char *), &complete_compstr);
		if(state->remove_duplicates) {
			dprint("removing duplicate completions\n");
			completions2 = ealloc(sizeof(char *) * completionssz);
			completions2[0] = completions[0];
			completions2sz = 1;
			for(i = 1; i < completionssz; i++) {
				if(completions[i] == nil)
					break;
				if(strcmp(completions[i], completions2[completions2sz - 1]) == 0) {
					efree(completions[i]);
					completions[i] = nil;
					continue;
				}
				completions2[completions2sz] = completions[i];
				completions2sz++;
			}
			dprint("completions2sz = %lu\n", completionssz);
			efree(completions);
			completions = completions2;
			completionssz = completions2sz;
		}
#if EditorDebug == 1
		for(i = 0; i < completionssz; i++) {
			dprint("sorted completions[%lu](%lu) = \"%s\"\n", i, strlen(completions[i]),
				   completions[i]);
		}
		dprint("completionssz = %lu\n", completionssz);
#endif
	}
	state->completions = completions;
	state->completionssz = completionssz;
}

char *
get_next_completion(EditorState *state, Wordpos pos)
{
	if(state->completions == nil)
		call_completions_hook(state, pos);
	if(state->completions == nil)
		return nil;

	switch(state->complete_direction) {
	default:
		unreachable();
	case None:
		state->completionsi = 0;
		dprint("complete state: None -> Forward\n");
		state->complete_direction = Forward;
		break;
	case Forward:
		dprint("complete state: Forward\n");
		state->complete_direction = Forward;
		break;
	case Backward:
		dprint("complete state: Backward -> Forward\n");
		dprint("incoming state->completionsi = %ld\n", state->completionsi);
		state->complete_direction = Forward;
		if(state->in_completion)
			state->completionsi += 2;
		else
			state->completionsi = 0;
		break;
	}

	dprint("state->completionsi = %ld\n", state->completionsi);

	if(state->completionsi >= (ssize_t)state->completionssz) {
		state->completionsi = 0;
		return nil;
	}

	return estrdup(state->completions[state->completionsi++]);
}

char *
get_prev_completion(EditorState *state, Wordpos pos)
{
	if(state->completions == nil)
		call_completions_hook(state, pos);
	if(state->completions == nil)
		return nil;

	switch(state->complete_direction) {
	default:
		unreachable();
	case None:
		state->completionsi = state->completionssz - 1;
		dprint("complete state: None -> Backward\n");
		state->complete_direction = Backward;
		break;
	case Backward:
		dprint("complete state: Backward\n");
		state->complete_direction = Backward;
		break;
	case Forward:
		dprint("complete state: Forward -> Backward\n");
		dprint("incoming state->completionsi = %ld\n", state->completionsi);
		state->complete_direction = Backward;
		if(state->in_completion)
			state->completionsi -= 2;
		else
			state->completionsi = state->completionssz - 1;
		break;
	}

	dprint("state->completionsi = %ld\n", state->completionsi);

	if(state->completionsi < 0) {
		state->completionsi = state->completionssz - 1;
		return nil;
	}

	return estrdup(state->completions[state->completionsi--]);
}

void /* maybe I should use a rope? */
do_completion(EditorState *state, char *comp, Wordpos pos)
{
	size_t complen = 0;
	size_t i = 0;
	size_t prefixlen = 0;
	size_t suffixlen = 0;

	assert(pos.end <= state->bufend);
	bufferassert();

	if(!state->in_completion) {
		if(comp == nil)
			return;
		dprint("state->in_completion = %d -> 1\n", state->in_completion);
		state->pos = pos;
		state->in_completion = 1;
		state->completebuf = estrdup(state->buffer);
		if(pos.start > 0) {
			state->comp_prefix = ealloc(pos.start + 1);
			memcpy(state->comp_prefix, state->buffer, pos.start);
		} else {
			state->comp_prefix = nil;
		}
		if(state->bufend - pos.end > 0) {
			state->comp_suffix = ealloc((state->bufend - pos.end) + 1);
			memcpy(state->comp_suffix, &state->buffer[pos.end], (state->bufend - pos.end));
		} else {
			state->comp_suffix = nil;
		}
	}

	if(comp == nil) {
		dprint("state->in_completion = %d -> 0\n", state->in_completion);
		memset(state->buffer, 0, state->bufend + 1);
		memcpy(state->buffer, state->completebuf, strlen(state->completebuf));
		state->bufend = strlen(state->completebuf);
		state->bufpos = pos.end;
		if(state->bufpos > state->bufend)
			state->bufpos = state->bufend;
		efree(state->completebuf);
		if(state->comp_prefix)
			efree(state->comp_prefix);
		if(state->comp_suffix)
			efree(state->comp_suffix);
		state->completebuf = nil;
		state->comp_prefix = nil;
		state->comp_suffix = nil;
		state->in_completion = 0;
		return;
	}

	dprint("state->completebuf = \"%s\"\n", state->completebuf);
	if(state->comp_prefix)
		dprint("state->comp_prefix = \"%s\"\n", state->comp_prefix);
	else
		dprint("state->comp_prefix = nil\n");

	if(state->comp_suffix)
		dprint("state->comp_suffix = \"%s\"\n", state->comp_suffix);
	else
		dprint("state->comp_suffix = nil\n");
	dprint("state->completionsi = %lu\n", state->completionsi);
	dprint("state->completionssz = %lu\n", state->completionssz);

	complen = strlen(comp);
	memset(state->buffer, 0, state->bufend);
	if(state->comp_prefix) {
		prefixlen = strlen(state->comp_prefix);
		if((complen + prefixlen) - 2 > state->bufsz)
			grow_buffer(state, state->bufsz);
		memcpy(state->buffer, state->comp_prefix, prefixlen);
		i += prefixlen;
	}
	memcpy(&state->buffer[i], comp, complen);
	i += complen;
	if(state->comp_suffix) {
		suffixlen = strlen(state->comp_suffix);
		if((complen + prefixlen + suffixlen) - 2 > state->bufsz)
			grow_buffer(state, state->bufsz);
		memcpy(&state->buffer[i], state->comp_suffix, suffixlen);
		i += suffixlen;
	}

	state->bufpos = prefixlen + complen;
	state->bufend = i;
	if(state->bufpos > state->bufend)
		state->bufpos = state->bufend;
	state->lastcomplen = complen;
}

void
completion_reset(EditorState *state)
{
	size_t i;

	if(state->completionssz > 0) {
		for(i = 0; i < state->completionssz; i++) {
			assert(!editor_istracked(state->completions[i]));
			if(state->completions[i] == nil)
				continue;
			efree(state->completions[i]);
			state->completions[i] = nil;
		}
		efree(state->completions);
		state->completions = nil;
		state->completionssz = 0;
	}
	if(state->completebuf) {
		efree(state->completebuf);
		state->completebuf = nil;
	}
	state->completionsi = 0;
	state->lastcomplen = 0;
	if(state->comp_prefix) {
		efree(state->comp_prefix);
		state->comp_prefix = nil;
	}
	if(state->comp_suffix) {
		efree(state->comp_suffix);
		state->comp_suffix = nil;
	}
	state->complete_direction = None;
	dprint("state->in_completion = %d -> 0\n", state->in_completion);
	state->in_completion = 0;
}

void
completion_maybe_reset(EditorState *state)
{
	if(state->bufpos < state->pos.start || state->bufpos > (state->pos.start + state->lastcomplen))
		completion_reset(state);
}

void
completion_next(EditorState *state)
{
	char *comp = nil;

	if(!state->in_completion)
		state->pos = get_word_position(state);
	comp = get_next_completion(state, state->pos);
	dprint("complete start = %lu, end = %lu\n", state->pos.start, state->pos.end);
	if(comp != nil)
		dprint("completion string = \"%s\"\n", comp);
	else
		dprint("completion string = nil\n");
	do_completion(state, comp, state->pos);
	if(comp)
		efree(comp);
}

void
completion_prev(EditorState *state)
{
	char *comp = nil;

	if(!state->in_completion)
		state->pos = get_word_position(state);
	comp = get_prev_completion(state, state->pos);
	dprint("complete start = %lu, end = %lu\n", state->pos.start, state->pos.end);
	if(comp != nil)
		dprint("completion string = \"%s\"\n", comp);
	else
		dprint("completion string = nil\n");
	do_completion(state, comp, state->pos);
	if(comp)
		efree(comp);
}

/* keymapping */

char *
pass_key(EditorState *state, int key, void *aux)
{
	used(aux);

	if(key <= KeyDelete)
		insert_char(state, (char)key);
	return nil;
}

int
bindmapping(EditorState *state, int key, Mapping mapping)
{
	if(!state->initialized)
		return -1;

	if(key < ExtKeyOffset && key > KeyMax)
		return -1;
	if(key >= ExtKeyOffset && key > ExtKeyMax)
		return -1;

	if(key >= ExtKeyOffset) {
		state->keymap->ext_keys[key - ExtKeyOffset] = mapping;
		return 0;
	}

	if(key < KeyMax) {
		state->keymap->base_keys[key] = mapping;
		return 0;
	}
	return -1;
}

Result
runmapping(EditorState *state, int key)
{
	Mapping *map;
	char *res;

	if(key > KeyNull && key < KeyMax)
		map = &state->keymap->base_keys[key];
	else if(key >= ExtKeyOffset && key < ExtKeyMax)
		map = &state->keymap->ext_keys[key - ExtKeyOffset];
	else
		return result(nil, -1);

	switch(map->reset_completion) {
	case 1:
		completion_reset(state);
		break;
	case 2:
		completion_maybe_reset(state);
		break;
	}
	if(map->breakkey)
		return result(nil, -3);
	if(map->end_of_file)
		return result(nil, -4);
	if(map->eof_if_empty && state->bufend == 0)
		return result(nil, -4);
	if(map->input_finished)
		return result(nil, -5);

	if(map->base_hook == nil) {
		if(map->hook == nil)
			return result(nil, -2);

		res = map->hook(state, key, map->aux);
		return result(res, 0);
	} else {
		map->base_hook(state);
		return result(nil, 0);
	}
}

void
create_default_mapping(Keymap *map)
{
	int i = 0;

	memset(&map->base_keys[0], 0, sizeof(Mapping) * BaseKeys);
	memset(&map->ext_keys[0], 0, sizeof(Mapping) * ExtendedKeys);

	map->base_keys[KeyEnter] = (Mapping){
		.hook = nil,
		.base_hook = nil,
		.input_finished = 1,
	};

	for(i = KeySpace; i < BaseKeys; i++)
		map->base_keys[i] = (Mapping){
			.hook = &pass_key,
			.base_hook = nil,
			.reset_completion = 1,
		};

	map->base_keys[KeyCtrlC] = (Mapping){
		.hook = nil,
		.base_hook = nil,
		.breakkey = 1,
	};
	map->base_keys[KeyCtrlD] = (Mapping){
		.hook = nil,
		.base_hook = &delete_char,
		.reset_completion = 1,
		.eof_if_empty = 1,
	};
	map->base_keys[KeyBackspace] = (Mapping){
		.hook = nil,
		.base_hook = &backspace_char,
		.reset_completion = 1,
	};
	map->base_keys[KeyCtrlH] = (Mapping){
		.hook = nil,
		.base_hook = &backspace_char,
		.reset_completion = 1,
	};
	map->base_keys[KeyTab] = (Mapping){
		.hook = nil,
		.base_hook = &completion_next,
	};
	map->base_keys[KeyCtrlA] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_home,
		.reset_completion = 2,
	};
	map->base_keys[KeyCtrlE] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_end,
		.reset_completion = 2,
	};
	map->base_keys[KeyCtrlW] = (Mapping){
		.hook = nil,
		.base_hook = &delete_word,
		.reset_completion = 1,
	};
	map->base_keys[KeyCtrlU] = (Mapping){
		.hook = nil,
		.base_hook = &delete_to_start,
		.reset_completion = 1,
	};
	map->base_keys[KeyCtrlK] = (Mapping){
		.hook = nil,
		.base_hook = &delete_to_end,
		.reset_completion = 1,
	};
	map->base_keys[KeyCtrlL] = (Mapping){
		.hook = nil,
		.base_hook = &clear_screen,
	};

	map->ext_keys[KeyArrowUp - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &history_next,
		.reset_completion = 1,
	};
	map->ext_keys[KeyArrowDown - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &history_prev,
		.reset_completion = 1,
	};
	map->ext_keys[KeyArrowLeft - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_move_left,
		.reset_completion = 2,
	};
	map->ext_keys[KeyArrowRight - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_move_right,
		.reset_completion = 2,
	};
	map->ext_keys[KeyHome - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_home,
		.reset_completion = 2,
	};
	map->ext_keys[KeyEnd - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_end,
		.reset_completion = 2,
	};
	map->ext_keys[KeyExtDelete - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &delete_char,
		.reset_completion = 1,
	};
	map->ext_keys[KeyShiftTab - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &completion_prev,
		.reset_completion = 0,
	};
	map->ext_keys[KeyAltb - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_move_word_left,
		.reset_completion = 2,
	};
	map->ext_keys[KeyAltf - ExtKeyOffset] = (Mapping){
		.hook = nil,
		.base_hook = &cursor_move_word_right,
		.reset_completion = 2,
	};
}

// clang-format off
char *keynames[] = {
	[KeyNull] = "(null)",
	[KeyCtrlA] = "CtrlA",
	[KeyCtrlB] = "CtrlB",
	[KeyCtrlC] = "CtrlC",
	[KeyCtrlD] = "CtrlD",
	[KeyCtrlE] = "CtrlE",
	[KeyCtrlF] = "CtrlF",
	[KeyCtrlG] = "CtrlG",
	[KeyCtrlH] = "CtrlH",
	[KeyTab] = "Tab",
	[KeyCtrlJ] = "CtrlJ",
	[KeyCtrlK] = "CtrlK",
	[KeyCtrlL] = "CtrlL",
	[KeyEnter] = "Enter",
	[KeyCtrlN] = "CtrlN",
	[KeyCtrlO] = "CtrlO",
	[KeyCtrlP] = "CtrlP",
	[KeyCtrlQ] = "CtrlQ",
	[KeyCtrlR] = "CtrlR",
	[KeyCtrlS] = "CtrlS",
	[KeyCtrlT] = "CtrlT",
	[KeyCtrlU] = "CtrlU",
	[KeyCtrlV] = "CtrlV",
	[KeyCtrlW] = "CtrlW",
	[KeyCtrlX] = "CtrlX",
	[KeyCtrlY] = "CtrlY",
	[KeyCtrlZ] = "CtrlZ",
	[KeySpace] = "Space",
	[KeyEscape] = "Escape",
	[KeyBackspace] = "Backspace",

	[KeyExclaimation] = "Exclaimation",
	[KeyDoubleQuote] = "DoubleQuote",
	[KeyNumberSign] = "NumberSign",
	[KeyDollar] = "Dollar",
	[KeyPercent] = "Percent",
	[KeyAmpersand] = "Ampersand",
	[KeySingleQuote] = "SingleQuote",
	[KeyOpenParen] = "OpenParen",
	[KeyCloseParen] = "CloseParen",
	[KeyAsterisk] = "Asterisk",
	[KeyPlus] = "Plus",
	[KeyComma] = "Comma",
	[KeyHyphen] = "Hyphen",
	[KeyPeriod] = "Period",
	[KeySlash] = "Slash",
	[Key0] = "0",
	[Key1] = "1",
	[Key2] = "2",
	[Key3] = "3",
	[Key4] = "4",
	[Key5] = "5",
	[Key6] = "6",
	[Key7] = "7",
	[Key8] = "8",
	[Key9] = "9",
	[KeyColon] = "Colon",
	[KeySemicolon] = "Semicolon",
	[KeyLessThan] = "LessThan",
	[KeyEquals] = "Equals",
	[KeyGreaterThan] = "GreaterThan",
	[KeyQuestion] = "Question",
	[KeyAt] = "At",
	[KeyA] = "A",
	[KeyB] = "B",
	[KeyC] = "C",
	[KeyD] = "D",
	[KeyE] = "E",
	[KeyF] = "F",
	[KeyG] = "G",
	[KeyH] = "H",
	[KeyI] = "I",
	[KeyJ] = "J",
	[KeyK] = "K",
	[KeyL] = "L",
	[KeyM] = "M",
	[KeyN] = "N",
	[KeyO] = "O",
	[KeyP] = "P",
	[KeyQ] = "Q",
	[KeyR] = "R",
	[KeyS] = "S",
	[KeyT] = "T",
	[KeyU] = "U",
	[KeyV] = "V",
	[KeyW] = "W",
	[KeyX] = "X",
	[KeyY] = "Y",
	[KeyZ] = "Z",
	[KeyOpenBracket] = "OpenBracket",
	[KeyBackslash] = "Backslash",
	[KeyCloseBracket] = "CloseBracket",
	[KeyCaret] = "Caret",
	[KeyUnderscore] = "Underscore",
	[KeyGrave] = "Grave",
	[Keya] = "a",
	[Keyb] = "b",
	[Keyc] = "c",
	[Keyd] = "d",
	[Keye] = "e",
	[Keyf] = "f",
	[Keyg] = "g",
	[Keyh] = "h",
	[Keyi] = "i",
	[Keyj] = "j",
	[Keyk] = "k",
	[Keyl] = "l",
	[Keym] = "m",
	[Keyn] = "n",
	[Keyo] = "o",
	[Keyp] = "p",
	[Keyq] = "q",
	[Keyr] = "r",
	[Keys] = "s",
	[Keyt] = "t",
	[Keyu] = "u",
	[Keyv] = "v",
	[Keyw] = "w",
	[Keyx] = "x",
	[Keyy] = "y",
	[Keyz] = "z",
	[KeyOpenBrace] = "OpenBrace",
	[KeyPipe] = "Pipe",
	[KeyCloseBrace] = "CloseBrace",
	[KeyTilde] = "Tilde",
};

char *extkeynames[] = {
	[0] = "ArrowLeft",
	[1] = "ArrowRight",
	[2] = "ArrowUp",
	[3] = "ArrowDown",
	[4] = "PageUp",
	[5] = "PageDown",
	[6] = "Home",
	[7] = "End",
	[8] = "Insert",
	[9] = "ExtDelete",
	[10] = "PF1",
	[11] = "PF2",
	[12] = "PF3",
	[13] = "PF4",
	[14] = "PF5",
	[15] = "PF6",
	[16] = "PF7",
	[17] = "PF8",
	[18] = "PF9",
	[19] = "PF10",
	[20] = "PF11",
	[21] = "PF12",
	[22] = "ShiftTab",
	[23] = "Alta",
	[24] = "Altb",
	[25] = "Altc",
	[26] = "Altd",
	[27] = "Alte",
	[28] = "Altf",
	[29] = "Altg",
	[30] = "Alth",
	[31] = "Alti",
	[32] = "Altj",
	[33] = "Altk",
	[34] = "Altl",
	[35] = "Altm",
	[36] = "Altn",
	[37] = "Alto",
	[38] = "Altp",
	[39] = "Altq",
	[40] = "Altr",
	[41] = "Alts",
	[42] = "Altt",
	[43] = "Altu",
	[44] = "Altv",
	[45] = "Altw",
	[46] = "Altx",
	[47] = "Alty",
	[48] = "Altz",
	[49] = "AltE",
	[50] = "AltF",
	[51] = "AltG",
	[52] = "AltH",
	[53] = "AltI",
	[54] = "AltJ",
	[55] = "AltK",
	[56] = "AltL",
	[57] = "AltM",
	[58] = "AltN",
	[59] = "AltO",
	[60] = "AltP",
	[61] = "AltQ",
	[62] = "AltR",
	[63] = "AltS",
	[64] = "AltT",
	[65] = "AltU",
	[66] = "AltV",
	[67] = "AltW",
	[68] = "AltX",
	[69] = "AltY",
	[70] = "AltZ",
	[71] = "CtrlLeft",
	[72] = "CtrlRight",
	[73] = "CtrlUp",
	[74] = "CtrlDown",
	[75] = "AltLeft",
	[76] = "AltRight",
	[77] = "AltUp",
	[78] = "AltDown",
};
// clang-format on

char *
key2name(int key)
{
	if(key >= KeyNull && key <= KeyEscape)
		return keynames[key];

	if(key >= KeySpace && key < KeyMax)
		return keynames[key];

	if(key >= ExtKeyOffset && key < ExtKeyMax)
		return extkeynames[key - ExtKeyOffset];

	return "Unknown";
}

int
name2key(char *name)
{
	int i;

	for(i = KeyCtrlA; i < KeyMax; i++)
		if(i < KeyInvalidFS || i > KeyInvalidUS)
			if(strcmp(name, keynames[i]) == 0)
				return i;

	for(i = ExtKeyOffset; i < ExtKeyMax; i++)
		if(strcmp(name, extkeynames[i - ExtKeyOffset]) == 0)
			return i;

	return -1;
}

char *
getcurrentline(EditorState *state)
{
	return estrndup(state->buffer, state->bufend + 1);
}

/* the big kahuna */

char *
fallback_editor(EditorState *state)
{
	/* this at a minimum needs initialize_editor to have been called
	 * basically you should never call this yourself. let line_editor
	 * do that for you.
	 */

	char *res = nil;
	size_t i = 0;

	/* in case this is called directly */
	if(!state->initialized)
		unreachable();

	if(state->prompt1)
		write(state->ofd, state->prompt1, strlen(state->prompt1));
	memset(state->buffer, 0, state->bufsz);
	read(state->ifd, state->buffer, EDITINITIALBUFSZ - 2);
	for(i = 0; i < EDITINITIALBUFSZ; i++)
		if(state->buffer[i] == '\n') {
			state->buffer[i] = '\0';
			break;
		}
	res = estrdup(state->buffer);
	return res;
}

char * /* budget readline */
vt100_basic_editor(EditorState *state)
{
	char c;
	char *res;
	char seq[6];
	enum { StateRead, StateDone } readstate = StateRead;
	size_t readn = 0;

	rawmode_on(state);
	if(reset_editor(state) < 0)
		goto fail;

	while(readstate == StateRead) {
		refresh(state);
		dprint("read1...");
		if(read(state->ifd, &c, 1) < 0)
			goto fail;
top:
		switch(c) {
		default:
			if(c >= ' ' && c <= '~') {
				insert_char(state, c);
			} else if((c & 0b11000000) == 0b11000000) {
				/* utf-8 stuff */
				seq[0] = c;
				if((c & 0b11100000) == 0b11000000)
					readn = 1;
				else if((c & 0b11110000) == 0b11100000)
					readn = 2;
				else if((c & 0b11111000) == 0b11110000)
					readn = 3;
				else
					unreachable();
				dprint("utf8 read %lu...", readn);
				read(state->ifd, &seq[1], readn);
				insert_n_char(state, &seq[0], readn + 1);
			} else if((c & 0b11000000) == 0b10000000) {
				/* something got screwed up with utf-8
				 * just skip until we get something sensible
				 */
				continue;
			}
			completion_reset(state);
			break;
		case KeyEnter:
			readstate = StateDone;
			break;
		case KeyCtrlC:
			goto fail;
			break;
		case KeyCtrlH:
		case KeyBackspace:
			backspace_char(state);
			completion_reset(state);
			break;
		case KeyTab:
			completion_next(state);
			break;
		case KeyCtrlA:
			cursor_home(state);
			completion_maybe_reset(state);
			break;
		case KeyCtrlE:
			cursor_end(state);
			completion_maybe_reset(state);
			break;
		case KeyCtrlW:
			delete_word(state);
			completion_reset(state);
			break;
		case KeyEscape:
			dprint("escape read...");
			if(read(state->ifd, &seq[0], 1) < 0)
				break;
			if(seq[0] == '[') {
				completion_maybe_reset(state);
				dprint("escape [ read...");
				if(read(state->ifd, &seq[1], 1) < 0)
					break;
				switch(seq[1]) {
				default:
					break;
				case 'A':
					history_next(state);
					break;
				case 'B':
					history_prev(state);
					break;
				case 'C':
					cursor_move_right(state);
					break;
				case 'D':
					cursor_move_left(state);
					break;
				}
			} else {
				c = seq[0];
				goto top;
			}
			break;
		}
	}
	refresh(state);

	if(state->bufend == 0)
		goto fail;

	write(state->ofd, "\r\n", 2);
	rawmode_off(state);
	res = estrndup(state->buffer, state->bufend + 1);
	return res;

fail:
	write(state->ofd, "\r\n", 2);
	rawmode_off(state);
	return nil;
}

char *
basic_editor(EditorState *state)
{
	if(!state->initialized)
		unreachable();

	switch(state->indriver) {
	default:
		unreachable();
	case DriverFallback:
		return fallback_editor(state);
	case DriverVT100:
	case DriverKitty:
		return vt100_basic_editor(state);
	}
}

/*
 * line_editor is the terminal keycode -> internal keycode converter
 * It will insert everything printable, and passes everything else to the keymap.
 * I am toying with a 'bring your own read' version of this similar to linenoise
 * for integration with kqueue/select/etc. I don't think that will be at all
 * valuable for es, but if this has life outside of here it might be of value.
 */
Result
vt100_line_editor(EditorState *state)
{
	uint8_t c;
	char seq[6];
	enum { StateRead, StateDone, StateCancel } readstate = StateRead;
	int key = 0;
	Result r;
	char *str;
	size_t readn = 0;

	rawmode_on(state);
	if(reset_editor(state) < 0)
		goto fail;

	while(readstate == StateRead) {
		assert(readstate == StateRead);
		dprint("=== top of editor input loop ===\n");
		key = 0;
		memset(&seq[0], 0, sizeof(seq));
		refresh(state);
		reconfigure_terminal(state);
		dprint("read 1...");
		if(read(state->ifd, &c, 1) < 0)
			goto fail;
		if(c >= KeySpace && c < BaseKeys) {
			key = c;
		} else if((c & 0b11000000) == 0b11000000) {
			/* utf-8 stuff */
			seq[0] = c;
			if((c & 0b11100000) == 0b11000000)
				readn = 1;
			else if((c & 0b11110000) == 0b11100000)
				readn = 2;
			else if((c & 0b11111000) == 0b11110000)
				readn = 3;
			else
				unreachable();

			dprint("utf8 read %lu...", readn);
			read(state->ifd, &seq[1], readn);
			dprint("\n");
			completion_reset(state);
			insert_n_char(state, &seq[0], readn + 1);
			continue;
		} else if((c & 0b11000000) == 0b10000000) {
			/* something got screwed up with utf-8
			 * just skip until we get something sensible
			 */
			continue;
		} else if(c == KeyEnter) {
			key = KeyEnter;
		} else if(c == KeyEscape) {
			dprint("escape read...");
			if(read(state->ifd, &seq[0], 1) < 0)
				continue;
			if(seq[0] == '[') {
				dprint("[ read...");
				if(read(state->ifd, &seq[1], 1) < 0)
					continue;
				switch(seq[1]) {
				default:
					dprint("\ngot unknown code %c%c\n", seq[0], seq[1]);
					continue;
				case 'A':
					key = KeyArrowUp;
					break;
				case 'B':
					key = KeyArrowDown;
					break;
				case 'C':
					key = KeyArrowRight;
					break;
				case 'D':
					key = KeyArrowLeft;
					break;
				case 'H':
					key = KeyHome;
					break;
				case 'F':
					key = KeyEnd;
					break;
				case 'M':
				case 'P':
					key = KeyExtDelete;
					break;
				case '@':
				case 'L':
					key = KeyInsert;
					break;
				case 'Z':
					key = KeyShiftTab;
					break;
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					dprint("number read...");
					if(read(state->ifd, &seq[2], 1) < 0)
						continue;
					if(seq[2] == '~') {
						switch(seq[1]) {
						default:
							dprint("\ngot unknown code %c%c%c\n", seq[0], seq[1], seq[2]);
							continue;
						case '5':
							key = KeyPageUp;
							break;
						case '6':
							key = KeyPageDown;
							break;
						case '4':
							key = KeyEnd;
							break;
						case '3':
							key = KeyExtDelete;
							break;
						case '2':
							key = KeyInsert;
							break;
						case '1':
							key = KeyHome;
							break;
						}
					} else if(seq[2] >= '0' && seq[2] <= '9') {
						/* this is like wtf? I found this experimentally. It is at least
						 * true in konsole 25.08.1 on FreeBSD 14.3. subject to change?
						 */
						dprint("PF key read...");
						if(read(state->ifd, &seq[3], 1) < 0)
							continue;
						if(seq[3] != '~') {
							dprint("\ngot unknown code %c%c%c%c\n", seq[0], seq[1], seq[2], seq[3]);
							continue;
						}
						if(seq[1] == '1') {
							switch(seq[2]) {
							default:
								if(state->dfd > 0)
									dprint("\ngot unknown code %c%c%c%c\n", seq[0], seq[1], seq[2],
										   seq[3]);
								continue;
							case '1':
								key = KeyPF1;
								break;
							case '2':
								key = KeyPF2;
								break;
							case '3':
								key = KeyPF3;
								break;
							case '4':
								key = KeyPF4;
								break;
							case '5':
								key = KeyPF5;
								break;
							case '7':
								key = KeyPF6;
								break;
							case '8':
								key = KeyPF7;
								break;
							case '9':
								key = KeyPF8;
								break;
							}
						} else if(seq[1] == '2') {
							switch(seq[2]) {
							default:
								dprint("\ngot unknown code %c%c%c%c\n", seq[0], seq[1], seq[2],
									   seq[3]);
								continue;
							case '0':
								key = KeyPF9;
								break;
							case '1':
								key = KeyPF10;
								break;
							case '3':
								key = KeyPF11;
								break;
							case '4':
								key = KeyPF12;
								break;
							}
						} else {
							dprint("\ngot unknown code %c%c%c%c\n", seq[0], seq[1], seq[2], seq[3]);
							continue;
						}
					} else if(seq[2] == ';' && seq[1] == '1') { // Ctrl+Arrow
						dprint("(Ctrl/Alt)+Arrow read 1...");
						if(read(state->ifd, &seq[3], 1) < 0)
							continue;
						if(seq[3] == '5' || seq[3] == '3') {
							dprint("(Ctrl/Alt)+Arrow read 2...");
							if(read(state->ifd, &seq[4], 1) < 0)
								continue;
							switch(seq[4]) {
							default:
								dprint("\ngot unknown code %c%c%c%c%c\n", seq[0], seq[1], seq[2],
									   seq[3], seq[4]);
								continue;
							case 'A':
								if(seq[3] == '5')
									key = KeyCtrlUp;
								else if(seq[3] == '3')
									key = KeyAltUp;
								else
									unreachable();
								break;
							case 'B':
								if(seq[3] == '5')
									key = KeyCtrlDown;
								else if(seq[3] == '3')
									key = KeyAltDown;
								else
									unreachable();
								break;
							case 'C':
								if(seq[3] == '5')
									key = KeyCtrlRight;
								else if(seq[3] == '3')
									key = KeyAltRight;
								else
									unreachable();
								break;
							case 'D':
								if(seq[3] == '5')
									key = KeyCtrlLeft;
								else if(seq[3] == '3')
									key = KeyAltLeft;
								else
									unreachable();
								break;
							}
						} else {
							dprint("\ngot unknown code %c%c%c%c\n", seq[0], seq[1], seq[2], seq[3]);
							continue;
						}
					}
					break;
				}
			} else if(seq[0] == 'O') {
				dprint("O read...");
				if(read(state->ifd, &seq[1], 1) < 0)
					continue;
				switch(seq[1]) {
				default:
					dprint("\ngot unknown code %c%c\n", seq[0], seq[1]);
					continue;
				case ' ': /* sun application space */
					break;
				case 'A':
					key = KeyArrowUp;
					break;
				case 'B':
					key = KeyArrowDown;
					break;
				case 'C':
					key = KeyArrowRight;
					break;
				case 'D':
					key = KeyArrowLeft;
					break;
				case 'I':
					key = KeyTab;
					break;
				case 'M':
					key = KeyEnter;
					break;
				case 'P':
					key = KeyPF1;
					break;
				case 'Q':
					key = KeyPF2;
					break;
				case 'R':
					key = KeyPF3;
					break;
				case 'S':
					key = KeyPF4;
					break;
				case 'H':
					key = KeyHome;
					break;
				case 'F':
					key = KeyEnd;
					break;
				}
			} else if(seq[0] >= 'A' && seq[0] <= 'Z') {
				switch(seq[0]) {
				case 'A':
					key = KeyArrowUp;
					break;
				case 'B':
					key = KeyArrowDown;
					break;
				case 'C':
					key = KeyArrowRight;
					break;
				case 'D':
					key = KeyArrowLeft;
					break;
				default:
					key = (seq[0] - 'E') + KeyAltE;
					break;
				}
			} else if(seq[0] >= 'a' && seq[0] <= 'z') {
				key = (seq[0] - 'a') + KeyAlta;
			} else {
				dprint("\ngot code %c\n", seq[0]);
				continue;
			}
		} else {
			key = c;
		}

		dprint("\ngot key %s\n", key2name(key));
		state->fixed_bufpos = 0;
		r = runmapping(state, key);
		switch(status(r)) {
		default:
			unreachable();
			break;
		case -5:
			readstate = StateDone;
			break;
		case -4:
			goto fail;
			break;
		case -2:
			dprint("got unmapped key %s\n", key2name(key));
			break;
		case -1:
			if(state->dfd > 0)
				dprint("got invalid key %d\n", key);
			break;
		case -3:
			readstate = StateCancel;
			dprint("cancel input\n");
			break;
		case 0:
			if(r.ptr != nil) {
				str = r.ptr;
				memset(state->buffer, 0, state->bufend);
				memcpy(state->buffer, str, strlen(str));
				state->bufend = strlen(str);
				if(!state->fixed_bufpos)
					state->bufpos = state->bufend;
				efree(str);
			}
			break;
		}
	}

	state->done_reading = 1;
	state->bufpos = state->bufend;
	refresh(state);
	write(state->ofd, "\r\n", 2);
	rawmode_off(state);

	if(readstate == StateCancel)
		return result(nil, -1);
	if(state->bufend == 0)
		return result(estrdup(""), 0);
	return result(estrndup(state->buffer, state->bufend + 1), 0);

fail:
	write(state->ofd, "\r\n", 2);
	rawmode_off(state);
	return result(nil, -2);
}

Result
line_editor(EditorState *state)
{
	if(!state->initialized)
		unreachable();

	switch(state->indriver) {
	default:
		unreachable();
	case DriverFallback:
		return result(fallback_editor(state), 0);
	case DriverVT100:
	case DriverKitty:
		return vt100_line_editor(state);
	}
}