vis.c

#include "util.h"

#define TERMKEY_EXPORT VIS_INTERNAL
#include "external/termkey.c"

#include "vis-core.h"
#include "vis-subprocess.h"

#include "util.c"

#include "buffer.c"
#include "event-basic.c"
#include "map.c"
#include "vis-options.c"
#include "sam.c"
#include "text.c"
#include "ui-terminal.c"
#include "view.c"
#include "vis-lua.c"
#include "vis-marks.c"
#include "vis-modes.c"
#include "vis-motions.c"
#include "vis-operators.c"
#include "vis-prompt.c"
#include "vis-registers.c"
#include "vis-subprocess.c"
#include "vis-text-objects.c"

VIS_INTERNAL str8
vis_current_directory(char *buffer, s64 buffer_length)
{
	str8 result = {0};
	if (getcwd(buffer, buffer_length))
		result = str8_from_c_str(buffer);
	return result;
}

VIS_INTERNAL void
vis_file_set_name_relative(File *file, str8 directory)
{
	str8 name = file->filepath;
	if (str8_is_prefix(directory, name) && directory.length != name.length)
		name = str8_skip(name, directory.length + 1);
	file->name = name;
}

VIS_INTERNAL void
vis_file_free(Vis *vis, File *file)
{
	if (file && file->refcount > 1) {
		file->refcount--;
	} else if (file) {
		if (!file->internal)
			vis_event_emit(vis, VIS_EVENT_FILE_CLOSE, file);

		if (file->prev) file->prev->next = file->next;
		if (file->next) file->next->prev = file->prev;
		if (vis->files == file)
			vis->files = file->next;

		for (u64 i = 0; i < countof(file->marks); i++)
			da_release(file->marks + i);

		text_free(file->text);
		free(file->filepath.data);
		free(file);
	}
}

typedef enum {
	VisFileNewFlag_Internal   = (1 << 0),
	VisFileNewFlag_ForceNew   = (1 << 1),
	VisFileNewFlag_NoRefcount = (1 << 2),
} VisFileNewFlags;

VIS_INTERNAL File *
vis_file_new(Vis *vis, const char *name, VisFileNewFlags flags)
{
	File *result = 0;

	str8 filepath = name ? vis_absolute_path(name) : (str8){0};
	if (filepath.length > 0 && (flags & VisFileNewFlag_ForceNew) == 0) {
		struct stat new;
		if (stat((char *)filepath.data, &new) == 0 || errno == ENOENT) {
			for (File *file = vis->files; file; file = file->next) {
				if (!file->internal && (str8_equal(file->filepath, filepath) ||
				    (file->stat.st_dev == new.st_dev && file->stat.st_ino == new.st_ino)))
				{
					result = file;
					break;
				}
			}
		}

		if (result) {
			if ((flags & VisFileNewFlag_NoRefcount) == 0)
				result->refcount++;
			free(filepath.data);
			filepath = (str8){0};
		}
	}

	if (!result) {
		Text *text = vis_text_load(vis, name, vis->load_method);
		if (!text && name && errno == ENOENT)
			text = vis_text_load(vis, 0, TEXT_LOAD_AUTO);

		if (text && (result = calloc(1, sizeof(*result)))) {
			result->fd       = -1;
			result->text     = text;
			result->stat     = text_stat(text);
			result->refcount = (flags & VisFileNewFlag_NoRefcount) ? 0 : 1;
			result->filepath = filepath;
			result->internal = (flags & VisFileNewFlag_Internal) != 0;

			result->next = vis->files;
			if (vis->files)
				vis->files->prev = result;
			vis->files = result;

			char cwd_buffer[PATH_MAX];
			vis_file_set_name_relative(result, vis_current_directory(cwd_buffer, countof(cwd_buffer)));

			if (!result->internal)
				vis_event_emit(vis, VIS_EVENT_FILE_OPEN, result);
		}

		if (!result) {
			free(filepath.data);
			text_free(text);
		}
	}

	return result;
}

void window_selection_save(Win *win)
{
	Vis *vis = win->vis;
	FilerangeList sel = view_selections_get_all(vis, &win->view);
	vis_mark_set(vis, win, VIS_MARK_SELECTION, sel);
	da_release(&sel);
	vis_jumplist_save(vis);
}

static void window_free(Win *win) {
	if (!win)
		return;
	Vis *vis = win->vis;
	for (Win *other = vis->windows; other; other = other->next) {
		if (other->parent == win)
			other->parent = NULL;
	}
	view_free(&win->view);
	for (size_t i = 0; i < LENGTH(win->modes); i++)
		map_free(win->modes[i].bindings);
	for (int i = 0; i < VIS_MARK_SET_LRU_COUNT; i++)
		da_release(win->mark_set_lru_regions + i);
	da_release(&win->saved_selections);
	free(win);
}

static void window_draw_colorcolumn(Win *win) {
	int cc = win->view.colorcolumn;
	if (cc <= 0)
		return;
	size_t lineno = 0;
	int line_cols = 0; /* Track the number of columns we've passed on each line */
	bool line_cc_set = false; /* Has the colorcolumn attribute been set for this line yet */
	int width = win->view.width;

	for (Line *l = win->view.topline; l; l = l->next) {
		if (l->lineno != lineno) {
			line_cols = 0;
			line_cc_set = false;
			if (!(lineno = l->lineno))
				break;
		}
		if (line_cc_set)
			continue;

		/* This screen line contains the cell we want to highlight */
		if (cc <= line_cols + width) {
			VisCell *cell = l->cells + cc - 1 - line_cols;
			cell->style = vis_cell_style_merge(cell->style, win->vis->ui.styles[UI_STYLE_COLOR_COLUMN]);
			line_cc_set = true;
		} else {
			line_cols += width;
		}
	}
}

static void window_draw_cursorline(Win *win) {
	Vis *vis = win->vis;
	enum UiOption options = win->options;
	if (!(options & UI_OPTION_CURSOR_LINE))
		return;
	if (vis->mode->visual || vis->win != win)
		return;
	if (win->view.selection_count > 1)
		return;

	int width = win->view.width;
	Selection *sel = view_selections_primary_get(&win->view);
	size_t lineno = sel->line->lineno;
	for (Line *l = win->view.topline; l; l = l->next) {
		if (l->lineno == lineno) {
			for (int x = 0; x < width; x++)
				l->cells[x].style = vis_cell_style_merge(l->cells[x].style, vis->ui.styles[UI_STYLE_CURSOR_LINE]);
		} else if (l->lineno > lineno) {
			break;
		}
	}
}

static void window_draw_selection(Win *win, Selection *cur) {
	View *view = &win->view;
	Filerange sel = view_selections_get(cur);
	if (!text_range_valid(sel))
		return;
	Line *start_line; int start_col;
	Line *end_line; int end_col;
	view_coord_get(view, sel.start, &start_line, NULL, &start_col);
	view_coord_get(view, sel.end, &end_line, NULL, &end_col);
	if (!start_line && !end_line)
		return;
	if (!start_line) {
		start_line = view->topline;
		start_col = 0;
	}
	if (!end_line) {
		end_line = view->lastline;
		end_col = end_line->width;
	}
	for (Line *l = start_line; l != end_line->next; l = l->next) {
		int col = (l == start_line) ? start_col : 0;
		int end = (l == end_line) ? end_col : l->width;
		while (col < end) {
			VisCell *cell = l->cells + col++;
			cell->style = vis_cell_style_merge(cell->style, win->vis->ui.styles[UI_STYLE_SELECTION]);
		}
	}
}

static void window_draw_cursor_matching(Win *win, Selection *cur) {
	if (win->vis->mode->visual)
		return;
	Line *line_match; int col_match;
	size_t pos = view_cursors_pos(cur);
	Filerange limits = VIEW_VIEWPORT_GET(win->view);
	size_t pos_match = text_bracket_match_symbol(win->file->text, pos, "(){}[]\"'`", limits);
	if (pos == pos_match)
		return;
	if (!view_coord_get(&win->view, pos_match, &line_match, NULL, &col_match))
		return;
	line_match->cells[col_match].style = vis_cell_style_merge(line_match->cells[col_match].style,
	                                                          win->vis->ui.styles[UI_STYLE_SELECTION]);
}

static void window_draw_cursor(Win *win, Selection *cur) {
	if (win->vis->win != win)
		return;
	Line *line = cur->line;
	if (line) {
		Selection *primary = view_selections_primary_get(&win->view);
		u16 style_id = primary == cur ? UI_STYLE_CURSOR_PRIMARY : UI_STYLE_CURSOR;
		VisCell *cell = line->cells + cur->col;
		cell->style = vis_cell_style_merge(cell->style, win->vis->ui.styles[style_id]);
		window_draw_cursor_matching(win, cur);
	}
}

static void window_draw_selections(Win *win) {
	Filerange viewport = VIEW_VIEWPORT_GET(win->view);
	Selection *sel = view_selections_primary_get(&win->view);
	for (Selection *s = view_selections_prev(sel); s; s = view_selections_prev(s)) {
		window_draw_selection(win, s);
		size_t pos = view_cursors_pos(s);
		if (pos < viewport.start)
			break;
		window_draw_cursor(win, s);
	}
	window_draw_selection(win, sel);
	window_draw_cursor(win, sel);
	for (Selection *s = view_selections_next(sel); s; s = view_selections_next(s)) {
		window_draw_selection(win, s);
		size_t pos = view_cursors_pos(s);
		if (pos > viewport.end)
			break;
		window_draw_cursor(win, s);
	}
}

VIS_INTERNAL void
window_draw_eof(Win *win)
{
	View *view = &win->view;
	VisCell cell = {.width = 1};
	cell.style = vis_cell_style_merge(win->vis->ui.styles[UI_STYLE_DEFAULT], win->vis->ui.styles[UI_STYLE_EOF]);
	cell.data_length = Min(view->symbols[SYNTAX_SYMBOL_EOF].length, countof(cell.data));
	memory_copy(cell.data, view->symbols[SYNTAX_SYMBOL_EOF].data, cell.data_length);
	for (Line *l = view->lastline->next; l; l = l->next)
		l->cells[0] = cell;
}

void vis_window_draw(Win *win) {
	if (!view_update(&win->view))
		return;
	Vis *vis = win->vis;
	vis_event_emit(vis, VIS_EVENT_WIN_HIGHLIGHT, win);

	window_draw_colorcolumn(win);
	window_draw_cursorline(win);
	if (!vis->win || vis->win == win || vis->win->parent == win)
		window_draw_selections(win);
	window_draw_eof(win);

	if (win->options & UI_OPTION_STATUSBAR)
		vis_event_emit(vis, VIS_EVENT_WIN_STATUS, win);
}

void vis_window_invalidate(Win *win) {
	for (Win *w = win->vis->windows; w; w = w->next) {
		if (w->file == win->file)
			view_draw(&w->view);
	}
}

VIS_EXPORT void
vis_window_focus(Vis *vis, Win *new)
{
	if (vis->win) vis->win->view.need_update = true;
	new->view.need_update = true;
	vis->win = new;
}

Win *window_new_file(Vis *vis, File *file, enum UiOption options) {
	Win *win = calloc(1, sizeof(Win));
	if (!win)
		return NULL;
	win->vis = vis;
	win->file = file;
	if (!view_init(win, file->text)) {
		free(win);
		return NULL;
	}

	if (vis->windows)
		vis->windows->prev = win;
	win->next = vis->windows;
	vis->windows = win;

	if (!ui_window_init(&vis->ui, win, options)) {
		window_free(win);
		return NULL;
	}

	file->refcount++;
	win_options_set(win, win->options);

	vis_window_focus(vis, win);

	for (size_t i = 0; i < LENGTH(win->modes); i++)
		win->modes[i].parent = &vis_modes[i];
	vis_event_emit(vis, VIS_EVENT_WIN_OPEN, win);
	return win;
}

VIS_EXPORT bool
vis_window_file_reload(Vis *vis, Win *win)
{
	bool result = false;
	str8 path = win->file->filepath;
	if (path.length > 0) {
		File *file = vis_file_new(vis, (char *)path.data, VisFileNewFlag_ForceNew);
		result = file != 0;
		if (result) {
			vis_file_free(vis, win->file);
			win->file = file;
			view_reload(&win->view, file->text);
		}
	}
	return result;
}

VIS_EXPORT bool
vis_window_file_change(Vis *vis, Win *win, const char *filename)
{
	File *file = vis_file_new(vis, filename, 0);
	if (file) {
		vis_file_free(vis, win->file);
		win->file = file;
		view_reload(&win->view, file->text);
	}
	return file != 0;
}

bool vis_window_split(Win *original) {
	original->vis->ui.doupdate = false;
	Win *win = window_new_file(original->vis, original->file, UI_OPTION_STATUSBAR);
	if (!win)
		return false;
	for (size_t i = 0; i < LENGTH(win->modes); i++) {
		if (original->modes[i].bindings)
			win->modes[i].bindings = map_new();
		if (win->modes[i].bindings)
			vis_map_copy(win->modes[i].bindings, original->modes[i].bindings);
	}
	win->file = original->file;
	win_options_set(win, original->options);
	view_cursors_to(win->view.selection, view_cursor_get(&original->view));
	win->vis->ui.doupdate = true;
	return true;
}

void vis_window_next(Vis *vis) {
	Win *sel = vis->win;
	if (!sel)
		return;
	vis_window_focus(vis, sel->next ? sel->next : vis->windows);
}

void vis_window_prev(Vis *vis) {
	Win *sel = vis->win;
	if (!sel)
		return;
	sel = sel->prev;
	if (!sel)
		for (sel = vis->windows; sel->next; sel = sel->next);
	vis_window_focus(vis, sel);
}

void vis_draw(Vis *vis) {
	for (Win *win = vis->windows; win; win = win->next)
		view_draw(&win->view);
}

VIS_INTERNAL void
vis_redraw(Vis *vis)
{
	ui_term_backend_clear(&vis->ui);
	for (Win *win = vis->windows; win; win = win->next)
		win->view.need_update = true;
	ui_draw(vis);
}

VIS_EXPORT bool
vis_window_new(Vis *vis, const char *filename)
{
	File *file = vis_file_new(vis, filename, VisFileNewFlag_NoRefcount);
	if (file) {
		if (!window_new_file(vis, file, UI_OPTION_STATUSBAR|UI_OPTION_SYMBOL_EOF)) {
			vis_file_free(vis, file);
			file = 0;
		}
		vis->ui.doupdate = true;
	}
	return file != 0;
}

bool vis_window_new_fd(Vis *vis, int fd) {
	if (fd == -1)
		return false;
	if (!vis_window_new(vis, NULL))
		return false;
	vis->win->file->fd = fd;
	return true;
}

bool vis_window_closable(Win *win) {
	if (!win || !text_modified(win->file->text))
		return true;
	return win->file->refcount > 1;
}

void vis_window_swap(Win *a, Win *b) {
	if (a == b || !a || !b)
		return;
	Vis *vis = a->vis;
	Win *tmp = a->next;
	a->next = b->next;
	b->next = tmp;
	if (a->next)
		a->next->prev = a;
	if (b->next)
		b->next->prev = b;
	tmp = a->prev;
	a->prev = b->prev;
	b->prev = tmp;
	if (a->prev)
		a->prev->next = a;
	if (b->prev)
		b->prev->next = b;
	if (vis->windows == a)
		vis->windows = b;
	else if (vis->windows == b)
		vis->windows = a;
	if (vis->win == a)
		vis_window_focus(vis, b);
	else if (vis->win == b)
		vis_window_focus(vis, a);
}

void vis_window_close(Win *win) {
	if (!win)
		return;
	Vis *vis = win->vis;
	vis_event_emit(vis, VIS_EVENT_WIN_CLOSE, win);
	vis_file_free(vis, win->file);
	if (win->prev)
		win->prev->next = win->next;
	if (win->next)
		win->next->prev = win->prev;
	if (vis->windows == win)
		vis->windows = win->next;
	if (vis->win == win)
		vis->win = win->parent ? win->parent : (win->next ? win->next : win->prev);
	if (win == vis->message_window)
		vis->message_window = NULL;
	window_free(win);
	if (vis->win)
		vis_window_focus(vis, vis->win);
	vis_draw(vis);
}

bool vis_init(Vis *vis)
{
	zero_struct(vis);

	if (setjmp(vis->oom_jmp_buf)) {
		/* NOTE: if we run out of memory here we haven't opened any real
		 * files yet so it is safe to just cleanup and return. */
		vis_cleanup(vis);
		return false;
	}

	vis->exit_status  = -1;
	vis->escape_delay = 50;
	if (!ui_init(&vis->ui))
		return false;
	vis->change_colors = true;
	for (size_t i = 0; i < LENGTH(vis->registers); i++)
		da_push(vis, vis->registers + i);
	vis->registers[VIS_REG_BLACKHOLE].type = REGISTER_BLACKHOLE;
	vis->registers[VIS_REG_CLIPBOARD].type = REGISTER_CLIPBOARD;
	vis->registers[VIS_REG_PRIMARY].type = REGISTER_CLIPBOARD;
	vis->registers[VIS_REG_NUMBER].type = REGISTER_NUMBER;
	action_reset(&vis->action);
	vis->input_queue = (Buffer){0};
	if (!(vis->prompt_file = vis_file_new(vis, 0, VisFileNewFlag_Internal)))
		goto err;
	if (!(vis->error_file = vis_file_new(vis, 0, VisFileNewFlag_Internal)))
		goto err;
	if (!(vis->actions = map_new()))
		goto err;
	if (!(vis->keymap = map_new()))
		goto err;
	if (!vis_sam_init(vis))
		goto err;
	struct passwd *pw;
	char *shell = getenv("SHELL");
	if ((!shell || !*shell) && (pw = getpwuid(getuid())))
		shell = pw->pw_shell;
	if (!shell || !*shell)
		shell = "/bin/sh";
	if (!(vis->shell = strdup(shell)))
		goto err;
	vis->mode_prev = vis->mode = &vis_modes[VIS_MODE_NORMAL];
	vis_modes[VIS_MODE_INSERT].input  = vis_event_mode_insert_input;
	vis_modes[VIS_MODE_REPLACE].input = vis_event_mode_replace_input;
	return true;
err:
	vis_cleanup(vis);
	return false;
}

void vis_cleanup(Vis *vis)
{
	if (!vis)
		return;
	while (vis->windows)
		vis_window_close(vis->windows);
	vis_process_waitall(vis);

	// NOTE: it is possible for a plugin to call a lua function
	// such as vis:message() in QUIT which requires the existence
	// of vis' internal files. This must be emitted prior to
	// the release of those files.
	vis_event_emit(vis, VIS_EVENT_QUIT);

	vis_file_free(vis, vis->prompt_file);
	vis_file_free(vis, vis->error_file);

	for (int i = 0; i < LENGTH(vis->registers); i++) {
		for (VisDACount j = 0; j < vis->registers[i].count; j++)
			buffer_release(vis->registers[i].data + j);
		da_release(vis->registers + i);
	}
	ui_terminal_free(&vis->ui);
	if (vis->usercmds) {
		str8 name = {0};
		while (vis_map_first(vis->usercmds, &name) && vis_command_unregister(vis, name.data, name.length));
	}
	map_free(vis->usercmds);
	map_free(vis->cmds);
	if (vis->options) {
		str8 name = {0};
		while (vis_map_first(vis->options, &name) && vis_option_unregister(vis, name.data, name.length));
	}
	map_free(vis->options);
	map_free(vis->actions);
	map_free(vis->keymap);
	buffer_release(&vis->input_queue);
	for (int i = 0; i < VIS_MODE_INVALID; i++)
		map_free(vis_modes[i].bindings);
	da_release(&vis->operators);
	da_release(&vis->motions);
	da_release(&vis->textobjects);
	while (vis->bindings.count)
		vis_binding_free(vis, vis->bindings.data[0]);
	da_release(&vis->bindings);
	for (VisDACount i = 0; i < vis->actions_user.count; i++)
		keyaction_free(vis->actions_user.data[i]);
	da_release(&vis->actions_user);
	free(vis->shell);
}

void vis_insert(Vis *vis, size_t pos, const char *data, size_t len) {
	Win *win = vis->win;
	if (!win)
		return;
	text_insert(vis, win->file->text, pos, data, len);
	vis_window_invalidate(win);
}

void vis_insert_key(Vis *vis, const char *data, size_t len) {
	Win *win = vis->win;
	if (!win)
		return;
	for (Selection *s = view_selections(&win->view); s; s = view_selections_next(s)) {
		size_t pos = view_cursors_pos(s);
		if (pos != EPOS) {
			vis_insert(vis, pos, data, len);
			view_cursors_scroll_to(s, pos + len);
		}
	}
}

void vis_replace(Vis *vis, size_t pos, const char *data, size_t len) {
	Win *win = vis->win;
	if (!win)
		return;
	Text *txt = win->file->text;
	Iterator it = text_iterator_get(txt, pos);
	int chars = text_char_count(data, len);
	for (char c; chars-- > 0 && text_iterator_byte_get(&it, &c) && c != '\n'; )
		text_iterator_char_next(&it, NULL);

	text_delete(txt, pos, it.pos - pos);
	vis_insert(vis, pos, data, len);
}

void vis_replace_key(Vis *vis, const char *data, size_t len) {
	Win *win = vis->win;
	if (!win)
		return;
	for (Selection *s = view_selections(&win->view); s; s = view_selections_next(s)) {
		size_t pos = view_cursors_pos(s);
		vis_replace(vis, pos, data, len);
		view_cursors_scroll_to(s, pos + len);
	}
}

bool vis_action_register(Vis *vis, const KeyAction *action) {
	return vis_map_put(vis->actions, str8_from_c_str(action->name), action);
}

bool vis_keymap_add(Vis *vis, const char *key, const char *mapping) {
	return vis_map_put(vis->keymap, str8_from_c_str(key), mapping);
}

void vis_keymap_disable(Vis *vis) {
	vis->keymap_disabled = true;
}

void vis_do(Vis *vis) {
	Win *win = vis->win;
	if (!win)
		return;
	File *file = win->file;
	Text *txt = file->text;
	View *view = &win->view;
	Action *a = &vis->action;

	int count = MAX(a->count, 1);
	if (a->op == &vis_operators[VIS_OP_MODESWITCH])
		count = 1; /* count should apply to inserted text not motion */
	bool repeatable = a->op && !vis->macro_operator && !vis->win->parent;
	bool multiple_cursors = view->selection_count > 1;

	bool linewise = !(a->type & CHARWISE) && (
		a->type & LINEWISE || (a->movement && a->movement->type & LINEWISE) ||
		vis->mode == &vis_modes[VIS_MODE_VISUAL_LINE]);

	Register *reg = a->reg;
	size_t reg_slot = multiple_cursors ? EPOS : 0;
	size_t last_reg_slot = reg_slot;
	if (!reg)
		reg = &vis->registers[file->internal ? VIS_REG_PROMPT : VIS_REG_DEFAULT];
	if (a->op == &vis_operators[VIS_OP_PUT_AFTER] && multiple_cursors && vis_register_count(vis, reg) == 1)
		reg_slot = 0;

	if (vis->mode->visual && a->op)
		window_selection_save(win);

	for (Selection *sel = view_selections(view), *next; sel; sel = next) {
		if (vis->interrupted)
			break;

		next = view_selections_next(sel);

		size_t pos = view_cursors_pos(sel);
		if (pos == EPOS) {
			if (!view_selections_dispose(sel))
				view_cursors_to(sel, 0);
			continue;
		}

		OperatorContext c = {
			.count = count,
			.pos = pos,
			.newpos = EPOS,
			.range = text_range_empty(),
			.reg = reg,
			.reg_slot = reg_slot == EPOS ? (size_t)view_selections_number(sel) : reg_slot,
			.linewise = linewise,
			.arg = &a->arg,
			.context = a->op ? a->op->context : NULL,
		};

		last_reg_slot = c.reg_slot;

		bool err = false;
		if (a->movement) {
			size_t start = pos;
			for (int i = 0; i < count; i++) {
				size_t pos_prev = pos;
				if (a->movement->txt)
					pos = a->movement->txt(txt, pos);
				else if (a->movement->cur)
					pos = a->movement->cur(sel);
				else if (a->movement->file)
					pos = a->movement->file(vis, file, sel);
				else if (a->movement->vis)
					pos = a->movement->vis(vis, txt, pos);
				else if (a->movement->view)
					pos = a->movement->view(vis, view);
				else if (a->movement->win)
					pos = a->movement->win(vis, win, pos);
				else if (a->movement->user)
					pos = a->movement->user(vis, win, a->movement->data, pos);
				if (pos == EPOS || a->movement->type & IDEMPOTENT || pos == pos_prev) {
					err = a->movement->type & COUNT_EXACT;
					break;
				}
			}

			if (err) {
				repeatable = false;
				continue; // break?
			}

			if (pos == EPOS) {
				c.range.start = start;
				c.range.end = start;
				pos = start;
			} else {
				c.range = text_range_new(start, pos);
				c.newpos = pos;
			}

			if (!a->op) {
				if (a->movement->type & CHARWISE)
					view_cursors_scroll_to(sel, pos);
				else
					view_cursors_to(sel, pos);
				if (vis->mode->visual)
					c.range = view_selections_get(sel);
			} else if (a->movement->type & INCLUSIVE && c.range.end > start) {
				c.range.end = text_char_next(txt, c.range.end);
			} else if (linewise && (a->movement->type & LINEWISE_INCLUSIVE)) {
				c.range.end = text_char_next(txt, c.range.end);
			}
		} else if (a->textobj) {
			if (vis->mode->visual)
				c.range = view_selections_get(sel);
			else
				c.range.start = c.range.end = pos;
			for (int i = 0; i < count; i++) {
				Filerange r = text_range_empty();
				if (a->textobj->txt)
					r = a->textobj->txt(txt, pos);
				else if (a->textobj->vis)
					r = a->textobj->vis(vis, txt, pos);
				else if (a->textobj->user)
					r = a->textobj->user(vis, win, a->textobj->data, pos);
				if (!text_range_valid(r))
					break;
				if (a->textobj->type & TEXTOBJECT_DELIMITED_OUTER) {
					r.start--;
					r.end++;
				} else if (linewise && (a->textobj->type & TEXTOBJECT_DELIMITED_INNER)) {
					r.start = text_line_next(txt, r.start);
					r.end = text_line_prev(txt, r.end);
				}

				if (vis->mode->visual || (i > 0 && !(a->textobj->type & TEXTOBJECT_NON_CONTIGUOUS)))
					c.range = text_range_union(c.range, r);
				else
					c.range = r;

				if (i < count - 1) {
					if (a->textobj->type & TEXTOBJECT_EXTEND_BACKWARD) {
						pos = c.range.start;
						if ((a->textobj->type & TEXTOBJECT_DELIMITED_INNER) && pos > 0)
							pos--;
					} else {
						pos = c.range.end;
						if (a->textobj->type & TEXTOBJECT_DELIMITED_INNER)
							pos++;
					}
				}
			}
		} else if (vis->mode->visual) {
			c.range = view_selections_get(sel);
			if (!text_range_valid(c.range))
				c.range.start = c.range.end = pos;
		}

		if (linewise && vis->mode != &vis_modes[VIS_MODE_VISUAL])
			c.range = text_range_linewise(txt, c.range);
		if (vis->mode->visual) {
			view_selections_set(sel, c.range);
			sel->anchored = true;
		}

		if (a->op) {
			size_t pos = a->op->func(vis, txt, &c);
			if (pos == EPOS) {
				view_selections_dispose(sel);
			} else if (pos <= text_size(txt)) {
				view_selection_clear(sel);
				view_cursors_to(sel, pos);
			}
		}
	}

	view_selections_normalize(view);
	if (a->movement && (a->movement->type & JUMP))
		vis_jumplist_save(vis);

	if (a->op) {

		if (a->op == &vis_operators[VIS_OP_YANK] ||
		    a->op == &vis_operators[VIS_OP_DELETE] ||
		    a->op == &vis_operators[VIS_OP_CHANGE] ||
		    a->op == &vis_operators[VIS_OP_REPLACE]) {
			register_resize(reg, last_reg_slot+1);
		}

		/* we do not support visual repeat, still do something reasonable */
		if (vis->mode->visual && !a->movement && !a->textobj)
			a->movement = &vis_motions[VIS_MOVE_NOP];

		/* operator implementations must not change the mode,
		 * they might get called multiple times (once for every cursor)
		 */
		if (a->op == &vis_operators[VIS_OP_CHANGE]) {
			vis_mode_switch(vis, VIS_MODE_INSERT);
		} else if (a->op == &vis_operators[VIS_OP_MODESWITCH]) {
			vis_mode_switch(vis, a->mode);
		} else if (vis->mode == &vis_modes[VIS_MODE_OPERATOR_PENDING]) {
			mode_set(vis, vis->mode_prev);
		} else if (vis->mode->visual) {
			vis_mode_switch(vis, VIS_MODE_NORMAL);
		}

		if (vis->mode == &vis_modes[VIS_MODE_NORMAL])
			vis_file_snapshot(vis, file);
		vis_draw(vis);
	}

	if (a != &vis->action_prev) {
		if (repeatable) {
			if (!a->macro)
				a->macro = vis->macro_operator;
			vis->action_prev = *a;
		}
		action_reset(a);
	}
}

void action_reset(Action *a) {
	zero_struct(a);
	a->count = VIS_COUNT_UNKNOWN;
}

void vis_cancel(Vis *vis) {
	action_reset(&vis->action);
}

void vis_die(Vis *vis, const char *msg, ...) {
	va_list ap;
	va_start(ap, msg);
	ui_die(&vis->ui, msg, ap);
	va_end(ap);
}

const char *vis_keys_next(Vis *vis, const char *keys) {
	if (!keys || !*keys)
		return NULL;
	TermKeyKey key;
	TermKey *termkey = &vis->ui.termkey;
	const char *next = NULL;
	/* first try to parse a special key of the form <Key> */
	if (*keys == '<' && keys[1] && (next = termkey_strpkey(termkey, keys+1, &key, TERMKEY_FORMAT_VIM)) && *next == '>')
		return next+1;
	if (strncmp(keys, "<vis-", 5) == 0) {
		const char *start = keys + 1, *end = start;
		while (*end && *end != '>')
			end++;
		if (end > start && end - start - 1 < VIS_KEY_LENGTH_MAX && *end == '>') {
			char key[VIS_KEY_LENGTH_MAX];
			memcpy(key, start, end - start);
			key[end - start] = '\0';
			if (vis_map_get(vis->actions, str8_from_c_str(key)))
				return end + 1;
		}
	}
	if (ISUTF8(*keys))
		keys++;
	while (!ISUTF8(*keys))
		keys++;
	return keys;
}

long vis_keys_codepoint(Vis *vis, const char *keys) {
	long codepoint = -1;
	const char *next;
	TermKeyKey key;
	TermKey *termkey = &vis->ui.termkey;

	if (!keys[0])
		return -1;
	if (keys[0] == '<' && !keys[1])
		return '<';

	if (keys[0] == '<' && (next = termkey_strpkey(termkey, keys+1, &key, TERMKEY_FORMAT_VIM)) && *next == '>')
		codepoint = (key.type == TERMKEY_TYPE_UNICODE) ? key.code.codepoint : -1;
	else if ((next = termkey_strpkey(termkey, keys, &key, TERMKEY_FORMAT_VIM)))
		codepoint = (key.type == TERMKEY_TYPE_UNICODE) ? key.code.codepoint : -1;

	if (codepoint != -1) {
		if (key.modifiers == TERMKEY_KEYMOD_CTRL)
			codepoint &= 0x1f;
		return codepoint;
	}

	if (!next || key.type != TERMKEY_TYPE_KEYSYM)
		return -1;

	const int keysym[] = {
		TERMKEY_SYM_ENTER, '\n',
		TERMKEY_SYM_TAB, '\t',
		TERMKEY_SYM_BACKSPACE, '\b',
		TERMKEY_SYM_ESCAPE, 0x1b,
		TERMKEY_SYM_DELETE, 0x7f,
		0,
	};

	for (const int *k = keysym; k[0]; k += 2) {
		if (key.code.sym == k[0])
			return k[1];
	}

	return -1;
}

bool vis_keys_utf8(Vis *vis, const char *keys, char utf8[4+1])
{
	uint32_t cp = vis_keys_codepoint(vis, keys);
	bool result = cp != (uint32_t)-1;
	if (result) {
		size_t len = utf8_encode((unsigned char *)utf8, cp);
		utf8[len] = 0;
	}
	return result;
}

typedef struct {
	Vis *vis;
	size_t len;         // length of the prefix
	int count;          // how many bindings can complete this prefix
	bool angle_bracket; // does the prefix end with '<'
} PrefixCompletion;

static bool isprefix(const char *key, void *value, void *data) {
	PrefixCompletion *completion = data;
	if (!completion->angle_bracket) {
		completion->count++;
	} else {
		const char *start = key + completion->len;
		const char *end = vis_keys_next(completion->vis, start);
		if (end && start + 1 == end)
			completion->count++;
	}
	return completion->count == 1;
}

VIS_INTERNAL void
vis_keys_process(Vis *vis, s64 pos)
{
	Buffer *buf = &vis->input_queue;
	// TODO(rnp): none of this function should need 0 termination
	char *keys = (char *)buffer_content0(buf) + pos, *start = keys, *cur = keys, *end = keys, *binding_end = keys;;
	bool prefix = false;
	KeyBinding *binding = NULL;

	while (cur && *cur) {

		if (!(end = (char*)vis_keys_next(vis, cur))) {
			buffer_remove(buf, keys - buf->data, strlen(keys));
			// TODO(rnp): hack: see above
			vis_buffer_terminate(buf);
			return;
		}

		char tmp = *end;
		*end = '\0';
		prefix = false;

		for (Mode *global_mode = vis->mode; global_mode && !prefix; global_mode = global_mode->parent) {
			for (int global = 0; global < 2 && !prefix; global++) {
				Mode *mode = (global || !vis->win) ?
					     global_mode :
				             &vis->win->modes[global_mode->id];
				if (!mode->bindings)
					continue;
				/* keep track of longest matching binding */
				str8 start8 = str8_from_c_str(start);
				KeyBinding *match = vis_map_get(mode->bindings, start8);
				if (match && end > binding_end) {
					binding = match;
					binding_end = end;
				}

				const Map *pmap = vis_map_prefix(mode->bindings, start8);
				PrefixCompletion completions = {
					.vis = vis,
					.len = cur - start,
					.count = 0,
					.angle_bracket = !strcmp(cur, "<"),
				};
				map_iterate(pmap, isprefix, &completions);

				prefix = (!match && completions.count > 0) ||
				         ( match && completions.count > 1);
			}
		}

		*end = tmp;

		if (prefix) {
			/* input so far is ambiguous, wait for more */
			cur = end;
			end = start;
		} else if (binding) { /* exact match */
			if (binding->action) {
				size_t len = binding_end - start;
				strcpy(vis->key_prev, vis->key_current);
				strncpy(vis->key_current, start, len);
				vis->key_current[len] = '\0';
				end = (char*)binding->action->func(vis, binding_end, &binding->action->arg);
				if (!end) {
					end = start;
					break;
				}
				start = cur = end;
			} else if (binding->alias) {
				s64 length = str8_from_c_str(binding->alias).length;
				buffer_remove(buf, start - buf->data, binding_end - start);
				// TODO(rnp): hack
				vis_buffer_terminate(buf);
				vis_buffer_insert(buf, start - buf->data, binding->alias, length);
				// TODO(rnp): hack
				vis_buffer_terminate(buf);
				cur = end = start;
			}
			binding = NULL;
			binding_end = start;
		} else { /* no keybinding */
			KeyAction *action = NULL;
			if (start[0] == '<' && end[-1] == '>') {
				/* test for special editor key command */
				char tmp = end[-1];
				end[-1] = '\0';
				action = vis_map_get(vis->actions, str8_from_c_str(start + 1));
				end[-1] = tmp;
				if (action) {
					size_t len = end - start;
					strcpy(vis->key_prev, vis->key_current);
					strncpy(vis->key_current, start, len);
					vis->key_current[len] = '\0';
					end = (char*)action->func(vis, end, &action->arg);
					if (!end) {
						end = start;
						break;
					}
				}
			}
			if (!action && vis->mode->input) {
				end = (char*)vis_keys_next(vis, start);
				vis->mode->input(vis, start, end - start);
			}
			start = cur = end;
		}
	}

	buffer_remove(buf, keys - buf->data, end - keys);
	vis_buffer_terminate(buf);
}

VIS_INTERNAL void
vis_keys_push(Vis *vis, str8 input, s64 pos, bool record)
{
	if (input.length > 0) {
		if (record && vis->recording)
			buffer_append(vis->recording, input.data, input.length);
		if (vis->macro_operator)
			buffer_append(vis->macro_operator, input.data, input.length);
		if (buffer_append(&vis->input_queue, input.data, input.length))
			vis_keys_process(vis, pos);
	}
}

VIS_INTERNAL void
macro_replay_internal(Vis *vis, Macro *macro)
{
	s64 pos = vis->input_queue.length;
	for (char *key = (char *)buffer_content0(macro), *next; key; key = next) {
		next = (char *)vis_keys_next(vis, key);

		str8 input = {.data = (u8 *)key, .length = next - key};
		if (!next) input.length = macro->length > 0 ? macro->length - (key - macro->data) : 0;

		vis_keys_push(vis, input, pos, false);
	}
}

static void macro_replay(Vis *vis, const Macro *macro)
{
	const Macro *replaying = vis->replaying;
	vis->replaying = macro;
	macro_replay_internal(vis, (Macro *)macro);
	vis->replaying = replaying;
}

void vis_keys_feed(Vis *vis, const char *input) {
	if (!input)
		return;
	// TODO(rnp): performance: this dynamically allocates 1024 bytes everytime this function is called
	Macro macro = {0};
	if (!vis_buffer_append0(&macro, input))
		return;
	/* use internal function, to keep Lua based tests which use undo points working */
	macro_replay_internal(vis, &macro);
	buffer_release(&macro);
}

static const char *getkey(Vis *vis) {
	TermKeyKey key = { 0 };
	if (!vis_ui_getkey(vis, &key))
		return 0;
	vis_ui_info_hide(&vis->ui);
	bool use_keymap = vis->mode->id != VIS_MODE_INSERT &&
	                  vis->mode->id != VIS_MODE_REPLACE &&
	                  !vis->keymap_disabled;
	vis->keymap_disabled = false;
	if (key.type == TERMKEY_TYPE_UNICODE && use_keymap) {
		const char *mapped = vis_map_get(vis->keymap, str8_from_c_str((char *)key.utf8));
		if (mapped) {
			size_t len = strlen(mapped)+1;
			if (len <= sizeof(key.utf8))
				memcpy(key.utf8, mapped, len);
		}
	}

	TermKey *termkey = &vis->ui.termkey;
	if (key.type == TERMKEY_TYPE_UNKNOWN_CSI) {
		long args[18];
		size_t nargs;
		unsigned long cmd;
		if (termkey_interpret_csi(termkey, &key, &args[2], &nargs, &cmd) == TERMKEY_RES_KEY) {
			args[0] = (long)cmd;
			args[1] = nargs;
			vis_event_emit(vis, VIS_EVENT_TERM_CSI, args);
		}
		return getkey(vis);
	}
	termkey_strfkey(termkey, vis->key, sizeof(vis->key), &key, TERMKEY_FORMAT_VIM);
	return vis->key;
}

bool vis_signal_handler(Vis *vis, int signum, const siginfo_t *siginfo, const void *context) {
	switch (signum) {
	case SIGBUS:
		for (File *file = vis->files; file; file = file->next) {
			if (text_mmaped(file->text, siginfo->si_addr))
				file->truncated = true;
		}
		vis->sigbus = true;
		if (vis->running)
			siglongjmp(vis->sigbus_jmpbuf, 1);
		return true;
	case SIGINT:
		vis->interrupted = true;
		return true;
	case SIGCONT:
		vis->resume = true;
		/* fall through */
	case SIGWINCH:
		vis->need_resize = true;
		return true;
	case SIGTERM:
	case SIGHUP:
		vis->terminate = true;
		return true;
	}
	return false;
}

int vis_run(Vis *vis) {
	if (!vis->windows)
		return EXIT_SUCCESS;
	if (vis->exit_status != -1)
		return vis->exit_status;
	vis->running = true;

	if (setjmp(vis->oom_jmp_buf)) {
		/* TODO: if we run out of memory here we may have files with unsaved changes.
		 * ideally we need to try and save temporary versions somewhere for later recovery */
		vis_cleanup(vis);
		vis_die(vis, "vis: out of memory\n");
	}

	vis_event_emit(vis, VIS_EVENT_START);

	struct timespec idle = { .tv_nsec = 0 }, *timeout = NULL;

	sigset_t emptyset;
	sigemptyset(&emptyset);
	vis_draw(vis);
	vis->exit_status = EXIT_SUCCESS;

	sigsetjmp(vis->sigbus_jmpbuf, 1);

	while (vis->running) {
		fd_set fds;
		FD_ZERO(&fds);
		FD_SET(STDIN_FILENO, &fds);

		if (vis->sigbus) {
			char *name = NULL;
			for (Win *next, *win = vis->windows; win; win = next) {
				next = win->next;
				if (win->file->truncated) {
					free(name);
					name = strndup((char *)win->file->filepath.data, win->file->filepath.length);
					vis_window_close(win);
				}
			}
			if (!vis->windows)
				vis_die(vis, "WARNING: file `%s' truncated!\n", name ? name : "-");
			else
				vis_info_show(vis, "WARNING: file `%s' truncated!\n", name ? name : "-");
			vis->sigbus = false;
			free(name);
		}

		if (vis->terminate)
			vis_die(vis, "Killed by SIGTERM\n");
		if (vis->interrupted) {
			vis->interrupted = false;
			vis_keys_push(vis, str8("<C-c>"), 0, true);
			continue;
		}

		if (vis->resume) {
			ui_terminal_resume(&vis->ui);
			vis->resume = false;
		}

		if (vis->need_resize) {
			ui_resize(&vis->ui);
			vis->need_resize = false;
		}

		ui_draw(vis);
		idle.tv_sec = vis->mode->idle_timeout;
		int r = pselect(vis_process_before_tick(&fds) + 1, &fds, NULL, NULL,
		                timeout, &emptyset);
		if (r == -1 && errno == EINTR)
			continue;

		if (r < 0) {
			/* TODO save all pending changes to a ~suffixed file */
			vis_die(vis, "Error in mainloop: %s\n", strerror(errno));
		}
		vis_process_tick(vis, &fds);

		if (!FD_ISSET(STDIN_FILENO, &fds)) {
			if (vis->mode->idle)
				vis->mode->idle(vis);
			timeout = NULL;
			continue;
		}

		termkey_advisereadable(&vis->ui.termkey);
		const char *key;

		while ((key = getkey(vis)))
			vis_keys_push(vis, str8_from_c_str(key), 0, true);

		if (vis->mode->idle)
			timeout = &idle;
	}
	return vis->exit_status;
}

Macro *macro_get(Vis *vis, enum VisRegister id)
{
	if (id == VIS_MACRO_LAST_RECORDED)
		return vis->last_recording;
	if (VIS_REG_A <= id && id <= VIS_REG_Z)
		id -= VIS_REG_A;
	if (id < LENGTH(vis->registers))
		return vis->registers[id].data;
	return NULL;
}

void macro_operator_record(Vis *vis) {
	if (vis->macro_operator)
		return;
	vis->macro_operator = macro_get(vis, VIS_MACRO_OPERATOR);
	vis->macro_operator->length = 0;
}

void macro_operator_stop(Vis *vis) {
	if (!vis->macro_operator)
		return;
	Macro *dot = macro_get(vis, VIS_REG_DOT);
	buffer_put(dot, vis->macro_operator->data, vis->macro_operator->length);
	vis->action_prev.macro = dot;
	vis->macro_operator = NULL;
}

bool vis_macro_record(Vis *vis, enum VisRegister id) {
	Macro *macro = macro_get(vis, id);
	if (vis->recording || !macro)
		return false;
	if (!(VIS_REG_A <= id && id <= VIS_REG_Z))
		macro->length = 0;
	vis->recording = macro;
	return true;
}

bool vis_macro_record_stop(Vis *vis) {
	if (!vis->recording)
		return false;
	/* XXX: hack to remove last recorded key, otherwise upon replay
	 * we would start another recording */
	if (vis->recording->length > 1)
		vis->recording->length--;
	vis->last_recording = vis->recording;
	vis->recording = NULL;
	return true;
}

bool vis_macro_recording(Vis *vis) {
	return vis->recording;
}

bool vis_macro_replay(Vis *vis, enum VisRegister id) {
	if (id == VIS_REG_SEARCH)
		return vis_motion(vis, VIS_MOVE_SEARCH_REPEAT_FORWARD);
	if (id == VIS_REG_COMMAND) {
		const char *cmd = register_get(vis, &vis->registers[id], NULL);
		return vis_cmd(vis, cmd);
	}

	Macro *macro = macro_get(vis, id);
	if (!macro || macro == vis->recording)
		return false;
	int count = VIS_COUNT_DEFAULT(vis->action.count, 1);
	vis_cancel(vis);
	for (int i = 0; i < count; i++)
		macro_replay(vis, macro);
	Win *win = vis->win;
	if (win)
		vis_file_snapshot(vis, win->file);
	return true;
}

void vis_repeat(Vis *vis) {
	const Macro *macro = vis->action_prev.macro;
	int count = vis->action.count;
	if (count != VIS_COUNT_UNKNOWN)
		vis->action_prev.count = count;
	else
		count = vis->action_prev.count;
	vis->action = vis->action_prev;
	vis_mode_switch(vis, VIS_MODE_OPERATOR_PENDING);
	vis_do(vis);
	if (macro) {
		Mode *mode = vis->mode;
		Action action_prev = vis->action_prev;
		if (count < 1 || action_prev.op == &vis_operators[VIS_OP_CHANGE])
			count = 1;
		if (vis->action_prev.op == &vis_operators[VIS_OP_MODESWITCH])
			vis->action_prev.count = 1;
		for (int i = 0; i < count; i++) {
			if (vis->interrupted)
				break;
			mode_set(vis, mode);
			macro_replay(vis, macro);
		}
		vis->action_prev = action_prev;
	}
	vis_cancel(vis);
	Win *win = vis->win;
	if (win)
		vis_file_snapshot(vis, win->file);
}

VisCountIterator vis_count_iterator_get(Vis *vis, int def) {
	return (VisCountIterator) {
		.vis = vis,
		.iteration = 0,
		.count = VIS_COUNT_DEFAULT(vis->action.count, def),
	};
}

VisCountIterator vis_count_iterator_init(Vis *vis, int count) {
	return (VisCountIterator) {
		.vis = vis,
		.iteration = 0,
		.count = count,
	};
}

bool vis_count_iterator_next(VisCountIterator *it) {
	if (it->vis->interrupted)
		return false;
	return it->iteration++ < it->count;
}

void vis_exit(Vis *vis, int status) {
	vis->running = false;
	vis->exit_status = status;
}

void vis_insert_tab(Vis *vis) {
	Win *win = vis->win;
	if (!win)
		return;
	if (!win->expandtab) {
		vis_insert_key(vis, "\t", 1);
		return;
	}
	char spaces[9];
	int tabwidth = MIN(vis->win->view.tabwidth, LENGTH(spaces) - 1);
	for (Selection *s = view_selections(&win->view); s; s = view_selections_next(s)) {
		size_t pos = view_cursors_pos(s);
		int width = text_line_width_get(win->file->text, pos);
		int count = tabwidth - (width % tabwidth);
		for (int i = 0; i < count; i++)
			spaces[i] = ' ';
		spaces[count] = '\0';
		vis_insert(vis, pos, spaces, count);
		view_cursors_scroll_to(s, pos + count);
	}
}

size_t vis_text_insert_nl(Vis *vis, Text *txt, size_t pos) {
	size_t indent_len = 0;
	char byte, *indent = NULL;
	/* insert second newline at end of file, except if there is already one */
	bool eof = pos == text_size(txt);
	bool nl2 = eof && !(pos > 0 && text_byte_get(txt, pos-1, &byte) && byte == '\n');

	if (vis->autoindent) {
		/* copy leading white space of current line */
		size_t begin = text_line_begin(txt, pos);
		size_t start = text_line_start(txt, begin);
		size_t end = text_line_end(txt, start);
		if (start > pos)
			start = pos;
		indent_len = start >= begin ? start-begin : 0;
		if (start == end) {
			pos = begin;
		} else {
			indent = malloc(indent_len+1);
			if (indent)
				indent_len = text_bytes_get(txt, begin, indent_len, indent);
		}
	}

	text_insert(vis, txt, pos, "\n", 1);
	if (eof) {
		if (nl2)
			text_insert(vis, txt, text_size(txt), "\n", 1);
		else
			pos--; /* place cursor before, not after nl */
	}
	pos++;

	if (indent)
		text_insert(vis, txt, pos, indent, indent_len);
	free(indent);
	return pos + indent_len;
}

void vis_insert_nl(Vis *vis) {
	Win *win = vis->win;
	if (!win)
		return;
	Text *txt = win->file->text;
	for (Selection *s = view_selections(&win->view); s; s = view_selections_next(s)) {
		size_t pos = view_cursors_pos(s);
		size_t newpos = vis_text_insert_nl(vis, txt, pos);
		/* This is a bit of a hack to fix cursor positioning when
		 * inserting a new line at the start of the view port.
		 * It has the effect of resetting the mark used by the view
		 * code to keep track of the start of the visible region.
		 */
		view_cursors_to(s, pos);
		view_cursors_to(s, newpos);
	}
	vis_window_invalidate(win);
}

Regex *vis_regex(Vis *vis, const char *pattern) {
	if (!pattern && !(pattern = register_get(vis, &vis->registers[VIS_REG_SEARCH], NULL)))
		return NULL;
	Regex *regex = text_regex_new();
	if (!regex)
		return NULL;
	int cflags = REG_EXTENDED|REG_NEWLINE|(REG_ICASE*vis->ignorecase);
	if (text_regex_compile(regex, pattern, cflags) != 0) {
		text_regex_free(regex);
		return NULL;
	}
	register_put0(vis, &vis->registers[VIS_REG_SEARCH], pattern);
	return regex;
}

static int _vis_pipe(Vis *vis, File *file, Filerange range, const char* buf, const char *argv[],
	void *stdout_context, ssize_t (*read_stdout)(void *stdout_context, char *data, size_t len),
	void *stderr_context, ssize_t (*read_stderr)(void *stderr_context, char *data, size_t len),
	bool fullscreen) {

	/* if an invalid range was given, stdin (i.e. key board input) is passed
	 * through the external command. */
	Text *text = file != NULL ? file->text : NULL;
	int pin[2], pout[2], perr[2], status = -1;
	bool interactive = buf == NULL && !text_range_valid(range);
	Filerange rout = (interactive  || buf != NULL) ? text_range_new(0, 0) : range;

	if (pipe(pin) == -1)
		return -1;
	if (pipe(pout) == -1) {
		close(pin[0]);
		close(pin[1]);
		return -1;
	}

	if (pipe(perr) == -1) {
		close(pin[0]);
		close(pin[1]);
		close(pout[0]);
		close(pout[1]);
		return -1;
	}

	ui_terminal_save(&vis->ui, fullscreen);
	pid_t pid = fork();

	if (pid == -1) {
		close(pin[0]);
		close(pin[1]);
		close(pout[0]);
		close(pout[1]);
		close(perr[0]);
		close(perr[1]);
		vis_info_show(vis, "fork failure: %s", strerror(errno));
		return -1;
	} else if (pid == 0) { /* child i.e filter */
		sigset_t sigterm_mask;
		sigemptyset(&sigterm_mask);
		sigaddset(&sigterm_mask, SIGTERM);
		if (sigprocmask(SIG_UNBLOCK, &sigterm_mask, NULL) == -1) {
			fprintf(stderr, "failed to reset signal mask");
			exit(EXIT_FAILURE);
		}

		int null = open("/dev/null", O_RDWR);
		if (null == -1) {
			fprintf(stderr, "failed to open /dev/null");
			exit(EXIT_FAILURE);
		}

		if (!interactive) {
			/* If we have nothing to write, let stdin point to
			 * /dev/null instead of a pipe which is immediately
			 * closed. Some programs behave differently when used
			 * in a pipeline.
			 */
			if (text_range_valid(range) && text_range_size(range) == 0)
				dup2(null, STDIN_FILENO);
			else
				dup2(pin[0], STDIN_FILENO);
		}

		close(pin[0]);
		close(pin[1]);
		if (interactive) {
			dup2(STDERR_FILENO, STDOUT_FILENO);
			/* For some reason the first byte written by the
			 * interactive application is not being displayed.
			 * It probably has something to do with the terminal
			 * state change. By writing a dummy byte ourself we
			 * ensure that the complete output is visible.
			 */
			while(write(STDOUT_FILENO, " ", 1) == -1 && errno == EINTR);
		} else if (read_stdout) {
			dup2(pout[1], STDOUT_FILENO);
		} else {
			dup2(null, STDOUT_FILENO);
		}
		close(pout[1]);
		close(pout[0]);
		if (!interactive) {
			if (read_stderr)
				dup2(perr[1], STDERR_FILENO);
			else
				dup2(null, STDERR_FILENO);
		}
		close(perr[0]);
		close(perr[1]);
		close(null);

		if (file) {
			str8 name;
			path_split(file->filepath, 0, &name);
			setenv("vis_filepath", file->filepath.data ? (char *)file->filepath.data : "", 1);
			setenv("vis_filename", name.length > 0     ? (char *)name.data           : "", 1);
		}

		if (!argv[1])
			execlp(vis->shell, vis->shell, "-c", argv[0], (char*)NULL);
		else
			execvp(argv[0], (char* const*)argv);
		fprintf(stderr, "exec failure: %s", strerror(errno));
		exit(EXIT_FAILURE);
	}

	vis->interrupted = false;

	close(pin[0]);
	close(pout[1]);
	close(perr[1]);

	if (fcntl(pout[0], F_SETFL, O_NONBLOCK) == -1 ||
	    fcntl(perr[0], F_SETFL, O_NONBLOCK) == -1)
		goto err;

	fd_set rfds, wfds;

	str8 string_in = pin[1] != -1 ? str8_from_c_str(buf) : (str8){0};
	do {
		if (vis->interrupted) {
			kill(0, SIGTERM);
			break;
		}

		FD_ZERO(&rfds);
		FD_ZERO(&wfds);
		if (pin[1] != -1)
			FD_SET(pin[1], &wfds);
		if (pout[0] != -1)
			FD_SET(pout[0], &rfds);
		if (perr[0] != -1)
			FD_SET(perr[0], &rfds);

		if (select(FD_SETSIZE, &rfds, &wfds, NULL, NULL) == -1) {
			if (errno == EINTR)
				continue;
			vis_info_show(vis, "Select failure");
			break;
		}

		if (pin[1] != -1 && FD_ISSET(pin[1], &wfds)) {
			Filerange junk = rout;
			bool done_writing = false;
			s64  written      = 0;
			if (text_range_size(rout) > 0) {
				if (junk.end > junk.start + PIPE_BUF)
					junk.end = junk.start + PIPE_BUF;
				written = text_write_range(text, junk, pin[1]);
				if (written > 0) {
					rout.start   += written;
					done_writing  = text_range_size(rout) == 0;
				}
			} else if (string_in.length > 0) {
				s64  length = Min(string_in.length, PIPE_BUF);
				bool done   = os_write_file((FileHandle){pin[1]}, string_in.data, length);
				if (done) {
					string_in = str8_cut_head(string_in, length);
					written   = length;
				}
				done_writing = string_in.length == 0;
			}

			if (written <= 0) {
				if (written == -1)
					vis_info_show(vis, "Error writing to external command");
				done_writing = true;
			}

			if (done_writing) {
				close(pin[1]);
				pin[1] = -1;
			}
		}

		if (pout[0] != -1 && FD_ISSET(pout[0], &rfds)) {
			char buf[BUFSIZ];
			ssize_t len = read(pout[0], buf, sizeof buf);
			if (len > 0) {
				if (read_stdout)
					(*read_stdout)(stdout_context, buf, len);
			} else if (len == 0) {
				close(pout[0]);
				pout[0] = -1;
			} else if (errno != EINTR && errno != EWOULDBLOCK) {
				vis_info_show(vis, "Error reading from filter stdout");
				close(pout[0]);
				pout[0] = -1;
			}
		}

		if (perr[0] != -1 && FD_ISSET(perr[0], &rfds)) {
			char buf[BUFSIZ];
			ssize_t len = read(perr[0], buf, sizeof buf);
			if (len > 0) {
				if (read_stderr)
					(*read_stderr)(stderr_context, buf, len);
			} else if (len == 0) {
				close(perr[0]);
				perr[0] = -1;
			} else if (errno != EINTR && errno != EWOULDBLOCK) {
				vis_info_show(vis, "Error reading from filter stderr");
				close(perr[0]);
				perr[0] = -1;
			}
		}

	} while (pin[1] != -1 || pout[0] != -1 || perr[0] != -1);

err:
	if (pin[1] != -1)
		close(pin[1]);
	if (pout[0] != -1)
		close(pout[0]);
	if (perr[0] != -1)
		close(perr[0]);

	for (;;) {
		if (vis->interrupted)
			kill(0, SIGTERM);
		pid_t died = waitpid(pid, &status, 0);
		if ((died == -1 && errno == ECHILD) || pid == died)
			break;
	}

	/* clear any pending SIGTERM */
	struct sigaction sigterm_ignore, sigterm_old;
	sigterm_ignore.sa_handler = SIG_IGN;
	sigterm_ignore.sa_flags = 0;
	sigemptyset(&sigterm_ignore.sa_mask);

	sigaction(SIGTERM, &sigterm_ignore, &sigterm_old);
	sigaction(SIGTERM, &sigterm_old, NULL);

	vis->interrupted = false;
	ui_terminal_restore(&vis->ui);

	if (WIFEXITED(status))
		return WEXITSTATUS(status);

	return -1;
}

int vis_pipe(Vis *vis, File *file, Filerange range, const char *argv[],
	void *stdout_context, ssize_t (*read_stdout)(void *stdout_context, char *data, size_t len),
	void *stderr_context, ssize_t (*read_stderr)(void *stderr_context, char *data, size_t len),
	bool fullscreen) {
	return _vis_pipe(vis, file, range, NULL, argv, stdout_context, read_stdout, stderr_context, read_stderr, fullscreen);
}

int vis_pipe_buf(Vis *vis, const char* buf, const char *argv[],
	void *stdout_context, ssize_t (*read_stdout)(void *stdout_context, char *data, size_t len),
	void *stderr_context, ssize_t (*read_stderr)(void *stderr_context, char *data, size_t len),
	bool fullscreen)
{
	return _vis_pipe(vis, 0, text_range_empty(), buf, argv, stdout_context, read_stdout,
	                 stderr_context, read_stderr, fullscreen);
}

static int _vis_pipe_collect(Vis *vis, File *file, Filerange range, const char* buf,
                             const char *argv[],char **out, char **err, bool fullscreen)
{
	Buffer bufout = {0}, buferr = {0};
	int status = _vis_pipe(vis, file, range, buf, argv,
	                      &bufout, out ? read_into_buffer : NULL,
	                      &buferr, err ? read_into_buffer : NULL,
	                      fullscreen);
	vis_buffer_terminate(&bufout);
	vis_buffer_terminate(&buferr);
	if (out) *out = bufout.data;
	if (err) *err = buferr.data;
	return status;
}

int vis_pipe_collect(Vis *vis, File *file, Filerange range, const char *argv[], char **out, char **err, bool fullscreen)
{
	return _vis_pipe_collect(vis, file, range, NULL, argv, out, err, fullscreen);
}

int vis_pipe_buf_collect(Vis *vis, const char* buf, const char *argv[], char **out, char **err, bool fullscreen)
{
	return _vis_pipe_collect(vis, 0, text_range_empty(), buf, argv, out, err, fullscreen);
}

bool vis_cmd(Vis *vis, const char *cmdline) {
	if (!cmdline)
		return true;
	while (*cmdline == ':')
		cmdline++;
	char *line = strdup(cmdline);
	if (!line)
		return false;

	size_t len = strlen(line);
	while (len > 0 && isspace((unsigned char)line[len-1]))
		len--;
	line[len] = '\0';

	enum SamError err = sam_cmd(vis, line);
	if (err != SAM_ERR_OK)
		vis_info_show(vis, "%s", sam_error(err));
	free(line);
	return err == SAM_ERR_OK;
}

void vis_file_snapshot(Vis *vis, File *file) {
	if (!vis->replaying)
		text_snapshot(file->text);
}

Text *vis_text(Vis *vis) {
	Win *win = vis->win;
	return win ? win->file->text : NULL;
}

View *vis_view(Vis *vis) {
	Win *win = vis->win;
	return win ? &win->view : NULL;
}

VIS_EXPORT bool
vis_change_directory(Vis *vis, u8 *directory_name, s64 length)
{
	str8 directory = {.data = directory_name, .length = length};
	u8 path[PATH_MAX];

	if (length <= 0) {
		// NOTE(rnp): guaranteed 0 terminated
		directory = str8_from_c_str(getenv("HOME"));
	} else if (length < (s64)countof(path) - 1) {
		memcpy(path, directory_name, length);
		directory.data = path;
		path[length] = 0;
	} else {
		directory.length = 0;
	}

	bool result = directory.length > 0 && chdir((char *)directory.data) == 0;
	if (result) {
		// NOTE(rnp): resolve relative components
		str8 wd = vis_current_directory((char *)path, countof(path));
		for (File *file = vis->files; file; file = file->next)
			if (!file->internal)
				vis_file_set_name_relative(file, wd);
	}

	return result;
}