sled

sled.c (75685B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2022-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <locale.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #define COPYRIGHT                                                             \
 	("  This program is licensed under the terms of GNU GPL v3"           \
 	 " or (at your option)\n"                                             \
 	 "  any later version. Copyright (C) 2022-2026  Strahinya Radich.\n"  \
 	 "  See the file LICENSE for exact copyright and license "            \
 	 "details.\n"                                                         \
 	 "  File termbox.h is based on termbox2 TUI library, (c) 2021"        \
 	 " termbox developers,\n"                                             \
 	 "  which is released under the terms of Expat license, see the file" \
 	 "  LICENSE.termbox.\n")
 
 #define SLED_C_GLOBALS
 #define TB_IMPL
 
 #include "draw.h"
 #include "sled.h"
 #include "config.h"
 #include "limit.h"
 #include "util.h"
 #include "version.h"
 
 #define SEL_NOT_EMPTY(state)                          \
 	((state->sel_start.row != state->sel_end.row) \
 		|| (state->sel_start.col != state->sel_end.col))
 
 extern const char* errors[];
 extern const char* actions[];
 extern const char* mode_labels[];
 extern const char* go_to_dialog_title;
 extern const char* prompt_dirty;
 extern const char* prompt_overwrite;
 extern const char* prompt_reread_dirty;
 extern const char* replace_dialog_title;
 extern const char* search_dialog_title;
 
 static int
 cancel_close(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (!state->error && !IN(state->mode, M_PROMPT)
 		&& !IN(state->mode, M_HELP))
 	{
 		if (SEL_NOT_EMPTY(state))
 			clear_selection(state);
 		else
 			state->error = ERR_EXIT_KEY;
 	}
 	else
 	{
 		state->error   = ERR_NONE;
 		*state->prompt = 0;
 		CLEAR(state->mode, M_PROMPT | M_HELP);
 	}
 
 	return 0;
 }
 
 static int
 clear_selection(struct DrawState* state)
 {
 	assert(state != NULL);
 	CLEAR(state->mode, M_SELECTION);
 	init_coord(&state->sel_start, 0, 0);
 	init_coord(&state->sel_end, 0, 0);
 	return 0;
 }
 
 #define MAXCOPYBUF 8192
 
 static int
 cp(const char* from, const char* to)
 {
 	struct stat st;
 	struct timespec times[2];
 	char buf[MAXCOPYBUF];
 	int fromfd, tofd;
 	int nread    = 0;
 	int nwritten = 0;
 	int result;
 	int saved_errno;
 
 	assert((from != NULL) && (to != NULL));
 
 	tofd   = 0;
 	fromfd = open(from, O_RDONLY);
 	if (fromfd < 0)
 		return 1;
 	if (fstat(fromfd, &st) < 0)
 	{
 		result = 1;
 		goto cp_cleanup;
 	}
 
 	tofd = open(to, O_WRONLY | O_CREAT | O_TRUNC, st.st_mode);
 	if (tofd < 0)
 		return 1;
 	if (fchmod(tofd, st.st_mode) < 0)
 	{
 		result = 1;
 		goto cp_cleanup;
 	}
 	times[0] = st.st_atim;
 	times[1] = st.st_mtim;
 
 	result = 0;
 	while ((nread = read(fromfd, buf, MAXCOPYBUF)) > 0)
 	{
 		nwritten = write(tofd, buf, nread);
 		if (nwritten < nread)
 		{
 			result = 1;
 			goto cp_cleanup;
 		}
 	}
 
 	if (nread < 0)
 	{
 		result = 1;
 		goto cp_cleanup;
 	}
 
 	errno = 0;
 	if (futimens(tofd, times) < 0)
 		result = 1;
 
 cp_cleanup:
 	saved_errno = errno;
 	if (tofd)
 		close(tofd);
 	close(fromfd);
 	errno = saved_errno;
 	return result;
 }
 
 static int
 create_file(struct DrawState* state)
 {
 	struct BufferLine* newchunk = NULL;
 	uint32_t* newtext	    = NULL;
 
 	assert(state != NULL);
 	newchunk = calloc(ALLOC_DELTA, sizeof(struct BufferLine));
 	if (!newchunk)
 	{
 		state->running = 0;
 		return 1;
 	}
 	for (ssize_t row = 0; row < ALLOC_DELTA; row++)
 	{
 		init_bufferline(newchunk + row);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 		{
 			state->running = 0;
 			return 1;
 		}
 		newchunk[row].size = LINE_DEFAULT;
 		newchunk[row].text = newtext;
 	}
 	state->buffer	   = newchunk;
 	state->buffer_size = ALLOC_DELTA;
 	state->rows_count  = 1;
 	recalculate_line_numbers(state);
 	state->coord.row = 0;
 	state->dirty	 = 1;
 
 	return 0;
 }
 
 static int
 cut_to_paste(struct DrawState* state)
 {
 	assert(state != NULL);
 	simple_yank(state);
 	erase_selection(state);
 	position_to_selection_start(state);
 	clear_selection(state);
 	return 0;
 }
 
 static char*
 dirname(char* dir, char* path, const ssize_t dir_size)
 {
 	char* p = NULL;
 
 	assert((dir != NULL) && (path != NULL) && (dir_size > 0));
 	if (!*path)
 		return NULL;
 
 	MEMCCPY(dir, path, dir_size, p);
 
 	if (p > dir + 2 && *(p - 2) == '/')
 		*p = 0;
 	if (p > dir + 1)
 		p--;
 
 	while (p != dir && *p != '/')
 	{
 		p--;
 		if (p != dir && *p == '/')
 		{
 			*p = 0;
 			return dir;
 		}
 		else if (p == dir && *p == '/')
 			return dir;
 	}
 	dir[0] = '.';
 	dir[1] = 0;
 	return dir;
 }
 
 static int
 do_search_replace(struct DrawState* state)
 {
 	uint32_t* buf	 = NULL;
 	uint32_t* temp	 = NULL;
 	uint32_t* before = NULL;
 	uint32_t* found	 = NULL;
 	uint32_t* after	 = NULL;
 	/* minimum size is LINE_DEFAULT to avoid 0-allocation */
 	ssize_t bufsize	   = LINE_DEFAULT; /* size in uint32_t units */
 	ssize_t buflen	   = 0;
 	ssize_t old_buflen = 0;
 	ssize_t search_len;
 	ssize_t input_len;
 	ssize_t after_len = 0;
 	int start_row	  = 0;
 	int end_row;
 
 	assert((state != NULL) && (state->search != NULL)
 		&& (state->input != NULL));
 	search_len = u32_strlen(state->search);
 	input_len  = u32_strlen(state->input);
 	end_row	   = state->rows_count;
 
 	if (SEL_NOT_EMPTY(state))
 		get_selection(&start_row, NULL, &end_row, NULL, state);
 
 	for (int row = start_row; row < end_row; row++)
 		if (state->buffer[row].size > bufsize)
 			bufsize = state->buffer[row].size;
 
 	buf = calloc(bufsize, sizeof(uint32_t));
 	if (!buf)
 		goto do_search_replace_alloc_error;
 
 	for (int row = start_row; row < end_row; row++)
 	{
 		before = state->buffer[row].text;
 		found  = (uint32_t*)u32_strstr(before, state->search);
 
 		if (!found)
 			continue;
 
 		state->dirty = 1;
 		*buf	     = 0;
 		*found	     = 0;
 		buflen	     = u32_strlen(before);
 		ENSURE_SIZE(buf, temp, bufsize, buflen + 1, buflen + 1,
 			do_search_replace_alloc_error, uint32_t);
 		U32_MEMCCPY(buf, before, bufsize, temp);
 		after	     = found + search_len;
 		*(after - 1) = 0;
 		while (found)
 		{
 			old_buflen = buflen;
 			buflen += input_len;
 			ENSURE_SIZE(buf, temp, bufsize, buflen + 1, buflen + 1,
 				do_search_replace_alloc_error, uint32_t);
 			U32_MEMCCPY((buf + old_buflen), state->input,
 				input_len + 1, temp);
 			before = after;
 			found  = (uint32_t*)u32_strstr(before, state->search);
 			if (found) /* new found, after before */
 				*found = 0;
 			after_len  = u32_strlen(after);
 			old_buflen = buflen;
 			buflen += after_len;
 			ENSURE_SIZE(buf, temp, bufsize, buflen + 1, buflen + 1,
 				do_search_replace_alloc_error, uint32_t);
 			U32_MEMCCPY((buf + old_buflen), after, after_len + 1,
 				temp);
 			if (found) /* new found, after before */
 			{
 				after	     = found + search_len;
 				*(after - 1) = 0;
 			}
 		}
 		U32_SAFE_COPY(state->buffer[row].text, temp,
 			state->buffer[row].size, buf, bufsize,
 			do_search_replace_alloc_error);
 		state->buffer[row].length = buflen;
 	}
 	free(buf);
 	return 0;
 
 do_search_replace_alloc_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 enter_command_mode(struct DrawState* state)
 {
 	assert(state != NULL);
 	SET(state->mode, M_COMMAND);
 	return 0;
 }
 
 static int
 enter_insert_mode(struct DrawState* state)
 {
 	assert(state != NULL);
 	CLEAR(state->mode, M_COMMAND);
 	return 0;
 }
 
 static int
 erase_backwards(struct DrawState* state)
 {
 	struct BufferLine* buffer_line;
 
 	assert(state != NULL);
 	buffer_line = &state->buffer[state->coord.row];
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 		return 0;
 	}
 
 	if (state->coord.col > 0)
 	{
 		ssize_t i = state->coord.col;
 		while (i <= buffer_line->length)
 		{
 			buffer_line->text[i - 1] = buffer_line->text[i];
 			i++;
 		}
 		buffer_line->text[i - 1] = 0;
 		buffer_line->length--;
 		position_to(state, state->coord.row, state->coord.col - 1);
 		state->dirty = 1;
 	}
 	else if (state->coord.row > 0)
 	{
 		move_up(state);
 		move_end(state);
 		erase_forward(state);
 	}
 	return 0;
 }
 
 static int
 erase_forward(struct DrawState* state)
 {
 	struct BufferLine* buffer_line;
 
 	assert(state != NULL);
 	buffer_line = &state->buffer[state->coord.row];
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 		return 0;
 	}
 
 	if (buffer_line->text[state->coord.col])
 	{
 		ssize_t i = state->coord.col;
 		while (i + 2 < buffer_line->size && buffer_line->text[i + 1])
 		{
 			buffer_line->text[i] = buffer_line->text[i + 1];
 			i++;
 		}
 		buffer_line->text[i] = 0;
 		buffer_line->length--;
 		state->dirty = 1;
 	}
 	else if ((state->coord.row + 1) < state->rows_count)
 		simple_join_lines(state);
 	return 0;
 }
 
 static int
 erase_line(struct DrawState* state)
 {
 	struct BufferLine* current = NULL;
 	struct BufferLine* next	   = NULL;
 	uint32_t* ptext		   = NULL;
 
 	assert(state != NULL);
 	if (state->rows_count == 1)
 	{
 		*state->buffer[0].text	= 0;
 		state->buffer[0].length = 0;
 		return 0;
 	}
 	for (ssize_t row = state->coord.row; row < state->rows_count - 1; row++)
 	{
 		current = state->buffer + row;
 		next	= state->buffer + row + 1;
 		U32_SAFE_COPY(current->text, ptext, current->size, next->text,
 			next->size, erase_line_error);
 		current->length = next->length;
 	}
 	free_bufferline(&state->buffer[state->rows_count - 1]);
 	if ((state->coord.row + 1) == state->rows_count)
 		state->coord.row--;
 	position_to(state, state->coord.row, 0);
 	state->rows_count--;
 	state->dirty = 1;
 	recalculate_line_numbers(state);
 	return 0;
 
 erase_line_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 erase_prev_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i, j, d;
 
 	assert((state != NULL) && (state->buffer != NULL)
 		&& (state->buffer[state->coord.row].text != NULL));
 	i     = state->coord.col;
 	len   = state->buffer[state->coord.row].length;
 	pline = state->buffer[state->coord.row].text;
 
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 
 	d = state->coord.col - i;
 
 	for (j = i; j + d < len; j++)
 		pline[j] = pline[j + d];
 
 	len -= d;
 	state->buffer[state->coord.row].length = len;
 	pline[len]			       = 0;
 	state->coord.col		       = i;
 	state->display_column = display_length(pline, state->coord.col);
 	if (state->display_column < state->first_shown.col)
 		state->first_shown.col = state->display_column;
 	state->dirty = 1;
 	return 0;
 }
 
 static int
 erase_selection(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (SEL_NOT_EMPTY(state))
 	{
 		uint32_t* buf  = NULL;
 		uint32_t* temp = NULL;
 		/* Selection start row/col */
 		int ssr = 0;
 		int ssc = 0;
 		/* Selection end row/col */
 		int ser	    = 0;
 		int sec	    = 0;
 		int ser_len = 0;
 		ssize_t bufsize;
 
 		get_selection(&ssr, &ssc, &ser, &sec, state);
 
 		assert(ser < state->buffer_size);
 		ser_len = state->buffer[ser].length;
 		bufsize = ssc + ser_len - sec + 1;
 		buf	= calloc(bufsize, sizeof(uint32_t));
 		if (!buf)
 			exit(print_error(ENOMEM, "Memory allocation failed"));
 
 		U32_MEMCCPY(buf, state->buffer[ser].text + sec, bufsize, temp);
 		ENSURE_SIZE(state->buffer[ssr].text, temp,
 			state->buffer[ssr].size, bufsize, bufsize,
 			erase_selection_alloc_error, uint32_t);
 		U32_MEMCCPY((state->buffer[ssr].text + ssc), buf, bufsize, temp);
 
 		state->buffer[ssr].size = MAX(bufsize, state->buffer[ssr].size);
 		state->buffer[ssr].length = ssc + ser_len - sec;
 
 		if (ssr == ser)
 			goto erase_selection_same_line;
 		for (ssize_t row = 0; ser + row + 1 < state->rows_count; row++)
 		{
 			ENSURE_SIZE(state->buffer[ssr + row + 1].text, temp,
 				state->buffer[ssr + row + 1].size,
 				state->buffer[ser + row + 1].size,
 				state->buffer[ser + row + 1].size,
 				erase_selection_alloc_error, uint32_t);
 			U32_MEMCCPY(state->buffer[ssr + row + 1].text,
 				state->buffer[ser + row + 1].text,
 				state->buffer[ser + row + 1].size, temp);
 			state->buffer[ssr + row + 1].size
 				= MAX(state->buffer[ssr + row + 1].size,
 					state->buffer[ser + row + 1].size);
 			state->buffer[ssr + row + 1].length
 				= state->buffer[ser + row + 1].length;
 		}
 		for (ssize_t row = state->rows_count - (ser - ssr);
 			row < state->rows_count; row++)
 		{
 			*state->buffer[row].text  = 0;
 			state->buffer[row].length = 0;
 		}
 		state->rows_count -= ser - ssr;
 		recalculate_line_numbers(state);
 
 	erase_selection_same_line:
 		free(buf);
 		state->dirty = 1;
 	}
 	return 0;
 
 erase_selection_alloc_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 erase_to_end(struct DrawState* state)
 {
 	struct BufferLine* buffer_line;
 
 	assert(state != NULL);
 	buffer_line = &state->buffer[state->coord.row];
 	assert((buffer_line != NULL) && (buffer_line->text != NULL));
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 		return 0;
 	}
 
 	buffer_line->text[state->coord.col] = 0;
 	buffer_line->length		    = state->coord.col;
 	move_end(state);
 	state->dirty = 1;
 	return 0;
 }
 
 static int
 erase_to_start(struct DrawState* state)
 {
 	struct BufferLine* buffer_line;
 	ssize_t i;
 	ssize_t len;
 
 	assert(state != NULL);
 	i	    = state->coord.col;
 	buffer_line = &state->buffer[state->coord.row];
 	assert((buffer_line != NULL) && (buffer_line->text != NULL));
 	len = buffer_line->length;
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 		return 0;
 	}
 
 	do
 	{
 		assert(i < buffer_line->length);
 		buffer_line->text[i - state->coord.col] = buffer_line->text[i];
 		i++;
 	} while (buffer_line->text[i]);
 	buffer_line->text[len - state->coord.col] = 0;
 	buffer_line->length			  = len - state->coord.col;
 	move_start(state);
 	state->dirty = 1;
 	return 0;
 }
 
 static int
 exit_program(struct DrawState* state)
 {
 	char* temp = NULL;
 
 	assert(state != NULL);
 	if (state->dirty)
 	{
 		SET(state->mode, M_PROMPT);
 		MEMCCPY(state->prompt, prompt_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = quit_callback;
 	}
 	else
 		state->running = 0;
 	state->error = ERR_NONE;
 	return 0;
 }
 
 void
 get_selection(int* ssr, int* ssc, int* ser, int* sec,
 	const struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->sel_start.row == state->sel_end.row)
 	{
 		if (state->sel_start.col <= state->sel_end.col)
 		{
 			if (ssc)
 				*ssc = state->sel_start.col;
 			if (sec)
 				*sec = state->sel_end.col;
 		}
 		else /* Swap */
 		{
 			if (ssc)
 				*ssc = state->sel_end.col;
 			if (sec)
 				*sec = state->sel_start.col;
 		}
 
 		if (ssr)
 			*ssr = state->sel_start.row;
 		if (ser)
 			*ser = state->sel_end.row;
 	}
 	else if (state->sel_start.row < state->sel_end.row)
 	{
 		if (ssr)
 			*ssr = state->sel_start.row;
 		if (ser)
 			*ser = state->sel_end.row;
 		if (ssc)
 			*ssc = state->sel_start.col;
 		if (sec)
 			*sec = state->sel_end.col;
 	}
 	else /* Swap */
 	{
 		if (ssr)
 			*ssr = state->sel_end.row;
 		if (ser)
 			*ser = state->sel_start.row;
 		if (ssc)
 			*ssc = state->sel_end.col;
 		if (sec)
 			*sec = state->sel_start.col;
 	}
 }
 
 static int
 go_to_line_callback(struct DrawState* state)
 {
 	ssize_t lineno = 0;
 	ssize_t len    = 0;
 	char* u8_input = NULL;
 
 	assert(state != NULL);
 	if (*state->input)
 	{
 		len	 = u32_strlen(state->input);
 		u8_input = calloc(len + 1, UTF8REPMAX);
 		if (!u8_input)
 		{
 			state->running = 0;
 			return 1;
 		}
 		unicode_string_to_u8(u8_input, state->input, len + 1);
 		errno  = 0;
 		lineno = strtoul(u8_input, NULL, 10);
 		if (errno)
 			state->error = ERR_INVALID_NUM;
 		if (!state->error)
 		{
 			if (lineno > state->rows_count - 1)
 				lineno = state->rows_count;
 			else if (lineno < 1)
 				lineno = 1;
 			position_to(state, lineno - 1, state->coord.col);
 			*state->input = 0;
 		}
 		free(u8_input);
 	}
 	if (!state->error)
 		state->input_callback = NULL;
 	return 0;
 }
 
 static void
 handle_key_event(struct tb_event* ev, struct DrawState* state)
 {
 	const struct Key* current = NULL;
 
 	assert((state != NULL) && (ev != NULL));
 	state->error = ERR_NONE;
 	errno	     = 0;
 
 	if (IN(state->mode, M_PROMPT))
 	{
 		if (ev->ch && strchr("YyNn", ev->ch))
 		{
 			if (state->prompt_callback)
 				state->prompt_callback(state, ev);
 			CLEAR(state->mode, M_PROMPT);
 			*state->prompt = 0;
 		}
 		else if (ev->key == TB_KEY_ESC)
 			cancel_close(state);
 		return;
 	}
 
 	/* Remember to also edit the following condition if you
 	 * reassign motion keys */
 	if (ev->key != TB_KEY_ARROW_DOWN && ev->key != TB_KEY_ARROW_UP
 		&& ev->key != TB_KEY_PGDN && ev->key != TB_KEY_PGUP
 		&& ev->key != TB_KEY_CTRL_B && ev->key != TB_KEY_CTRL_F
 		&& !(IN(state->mode, M_COMMAND) && strchr("jkgGHLM", ev->ch)))
 		state->saved_column = -1;
 
 	if (IN(state->mode, M_INPUT))
 	{
 		for (size_t key = 0; key < LEN(input_dialog_keys); key++)
 		{
 			current = input_dialog_keys + key;
 			if (((current->ev.mod == ev->mod)
 				    && (current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback)
 				{
 					current->callback(state);
 					return;
 				}
 		}
 		if (ev->ch)
 		{
 			if ((IN(state->mode, M_INPUT_NUM)
 				    && strchr("0123456789", (const char)ev->ch))
 				|| !IN(state->mode, M_INPUT_NUM))
 				input_insert_char(state, ev->ch);
 			else
 				state->error = ERR_INPUT_NONNUM;
 			return;
 		}
 	}
 
 	for (size_t key = 0; key < LEN(top_level_keys); key++)
 	{
 		current = &top_level_keys[key];
 		if (((current->ev.mod == ev->mod)
 			    && (current->ev.key == ev->key) && !ev->ch)
 			|| (current->ev.ch && (current->ev.ch == ev->ch)))
 			if (current->callback)
 			{
 				current->callback(state);
 				return;
 			}
 	}
 
 	if (IN(state->mode, M_HELP))
 	{
 		state->error = ERR_DLG_OPEN;
 		return;
 	}
 
 	for (size_t key = 0; key < LEN(global_keys); key++)
 	{
 		current = &global_keys[key];
 		assert(current != NULL);
 		if (((current->ev.mod == ev->mod)
 			    && (current->ev.key == ev->key) && !ev->ch)
 			|| (current->ev.ch && (current->ev.ch == ev->ch)))
 			if (current->callback)
 			{
 				current->callback(state);
 				return;
 			}
 	}
 
 	if (IN(state->mode, M_COMMAND))
 	{
 		for (size_t key = 0; key < LEN(command_keys); key++)
 		{
 			current = &command_keys[key];
 			assert(current != NULL);
 			if (((current->ev.mod == ev->mod)
 				    && (current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback)
 				{
 					current->callback(state);
 					return;
 				}
 		}
 	}
 	else
 	{
 		for (size_t key = 0; key < LEN(insert_keys); key++)
 		{
 			current = &insert_keys[key];
 			if (((current->ev.mod == ev->mod)
 				    && (current->ev.key == ev->key) && !ev->ch)
 				|| (current->ev.ch
 					&& (current->ev.ch == ev->ch)))
 				if (current->callback)
 				{
 					current->callback(state);
 					return;
 				}
 		}
 		if (ev->ch)
 		{
 			insert_char(state, ev->ch);
 			return;
 		}
 	}
 
 	state->error = ERR_UNKNOWN_KEY;
 }
 
 static int
 input_cancel(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->error)
 	{
 		state->error = ERR_NONE;
 		return 0;
 	}
 	*state->input = 0;
 	if (state->input_update_callback)
 		state->input_update_callback(state);
 	CLEAR(state->mode, M_INPUT | M_INPUT_NUM);
 	state->input_callback	     = NULL;
 	state->input_update_callback = NULL;
 	state->chain_dialog	     = 0;
 	return 0;
 }
 
 static int
 input_enter(struct DrawState* state)
 {
 	int hide_dialog = 1;
 
 	assert(state != NULL);
 	if (state->input_callback)
 	{
 		state->input_callback(state);
 		hide_dialog = (!state->search || !*state->search
 			|| !state->chain_dialog || *state->input != 0);
 		if (hide_dialog)
 		{
 			if (!state->error)
 				CLEAR(state->mode, M_INPUT | M_INPUT_NUM);
 			state->input_callback = NULL;
 		}
 	}
 	else if (hide_dialog)
 		CLEAR(state->mode, M_INPUT | M_INPUT_NUM);
 	if (hide_dialog)
 		state->input_update_callback = NULL;
 	return 0;
 }
 
 static int
 input_erase_backwards(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->input_column > 0)
 	{
 		ssize_t i = state->input_column;
 		do
 		{
 			state->input[i - 1] = state->input[i];
 			i++;
 		} while (state->input[i]);
 		state->input[i - 1] = 0;
 		input_position_to(state, state->input_column - 1);
 		if (state->input_update_callback)
 			state->input_update_callback(state);
 	}
 	return 0;
 }
 
 static int
 input_erase_forward(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->input)
 	{
 		ssize_t i = state->input_column;
 		while (i + 2 < MAXINPUT && state->input[i + 1])
 		{
 			state->input[i] = state->input[i + 1];
 			i++;
 		}
 		state->input[i] = 0;
 		if (state->input_update_callback)
 			state->input_update_callback(state);
 	}
 	return 0;
 }
 
 static int
 input_erase_to_end(struct DrawState* state)
 {
 	uint32_t* temp = NULL;
 	assert(state != NULL);
 	state->input[state->input_column] = 0;
 	input_move_end(state);
 	U32_MEMCCPY(state->search, state->input, MAXINPUT, temp);
 	if (state->input_update_callback)
 		state->input_update_callback(state);
 	return 0;
 }
 
 static int
 input_erase_to_start(struct DrawState* state)
 {
 	ssize_t i;
 	ssize_t len;
 
 	assert(state != NULL);
 	i   = state->input_column;
 	len = u32_strlen(state->input);
 
 	do
 	{
 		assert(i < len);
 		state->input[i - state->input_column] = state->input[i];
 		i++;
 	} while (state->input[i]);
 	state->input[len - state->input_column] = 0;
 	input_move_start(state);
 	if (state->input_update_callback)
 		state->input_update_callback(state);
 	return 0;
 }
 
 static int
 input_insert_char(struct DrawState* state, uint32_t ch)
 {
 	ssize_t len;
 	assert(state != NULL);
 	len = u32_strlen(state->input);
 	if (state->input_column + 1 < MAXINPUT)
 	{
 		ssize_t i    = len + 1;
 		int add_null = state->input[state->input_column] == 0;
 		while (i + 2 < MAXINPUT && i > state->input_column)
 		{
 			state->input[i] = state->input[i - 1];
 			i--;
 		}
 		state->input[state->input_column] = ch;
 		input_position_to(state, state->input_column + 1);
 		if (add_null)
 			state->input[state->input_column] = 0;
 		if (state->input_update_callback)
 			state->input_update_callback(state);
 	}
 	return 0;
 }
 
 static int
 input_insert_space(struct DrawState* state)
 {
 	return input_insert_char(state, ' ');
 }
 
 static int
 input_insert_tab(struct DrawState* state)
 {
 	return input_insert_char(state, '\t');
 }
 
 static int
 input_move_end(struct DrawState* state)
 {
 	assert(state != NULL);
 	input_position_to(state, u32_strlen(state->input));
 	return 0;
 }
 
 static int
 input_move_left(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->input_column == 0)
 		return 0;
 	input_position_to(state, state->input_column - 1);
 	return 0;
 }
 
 static int
 input_move_next_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i;
 
 	assert((state != NULL) && (state->input != NULL));
 	i     = state->input_column;
 	pline = state->input;
 	len   = u32_strlen(state->input);
 	while (i < len && !u32_is_word_boundary(pline[i], 0))
 		i++;
 	while (i < len && u32_is_word_boundary(pline[i], 0))
 		i++;
 	input_position_to(state, i);
 	return 0;
 }
 
 static int
 input_move_prev_word(struct DrawState* state)
 {
 	int i;
 	uint32_t* pline;
 
 	assert((state != NULL) && (state->input != NULL));
 	i     = state->input_column;
 	pline = state->input;
 	assert(pline != NULL);
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	input_position_to(state, i);
 	return 0;
 }
 
 static int
 input_move_right(struct DrawState* state)
 {
 	assert(state != NULL);
 	input_position_to(state, state->input_column + 1);
 	return 0;
 }
 
 static int
 input_move_start(struct DrawState* state)
 {
 	input_position_to(state, 0);
 	return 0;
 }
 
 static void
 input_position_to(struct DrawState* state, const int column)
 {
 	ssize_t len;
 
 	assert((state != NULL) && (state->input != NULL));
 	len		    = u32_strlen(state->input);
 	state->input_column = column;
 
 	if (state->input_column > len)
 		state->input_column = len;
 	state->input_display_column
 		= display_length(state->input, state->input_column);
 	if (state->input_first_shown_column > state->input_display_column)
 		state->input_first_shown_column = state->input_display_column;
 	if (state->input_first_shown_column + (state->input_dialog_width - 4)
 		< state->input_column)
 		state->input_first_shown_column = state->input_display_column
 			- (state->input_dialog_width - 4);
 }
 
 static int
 insert_char(struct DrawState* state, uint32_t ch)
 {
 	struct BufferLine* buffer_line = NULL;
 	uint32_t* ptext		       = NULL;
 	ssize_t i, len, size;
 
 	assert((state != NULL) && (state->buffer != NULL));
 	ENSURE_SIZE(state->buffer[state->coord.row].text, ptext,
 		state->buffer[state->coord.row].size,
 		state->buffer[state->coord.row].length + 2,
 		state->buffer[state->coord.row].size + LINE_ALLOC_DELTA,
 		insert_char_error, uint32_t);
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 	}
 
 	buffer_line = &state->buffer[state->coord.row];
 	len	    = buffer_line->length;
 	size	    = buffer_line->size;
 	i	    = len;
 
 	assert(buffer_line->text != NULL);
 	if (!IN(state->mode, M_OVERWRITE))
 		while (i + 1 < size && i > state->coord.col)
 		{
 			buffer_line->text[i] = buffer_line->text[i - 1];
 			i--;
 		}
 	buffer_line->text[state->coord.col] = ch;
 	if (state->coord.col == len || !IN(state->mode, M_OVERWRITE))
 		buffer_line->length++;
 	position_to(state, state->coord.row, state->coord.col + 1);
 	buffer_line->text[buffer_line->length] = 0;
 
 	if (!enable_wrap)
 		goto insert_skip_wrap;
 
 	while (state->display_column >= wrap_width)
 	{
 		int saved_column = state->coord.col;
 		buffer_line	 = state->buffer + state->coord.row;
 		assert((buffer_line != NULL) && (buffer_line->text != NULL));
 		state->coord.col = buffer_length(buffer_line->text, wrap_width);
 		/* clang-format off */
 		while (state->coord.col > 0
 			&& !u32_is_word_boundary(
 				buffer_line->text[state->coord.col - 1], 1))
 			state->coord.col--;
 		/* clang-format on */
 		if (state->coord.col == 0)
 		{
 			state->coord.col = saved_column;
 			break;
 		}
 		simple_insert_line(state);
 		state->saved_column = -1;
 		position_to(state, state->coord.row + 1,
 			saved_column - state->coord.col);
 	}
 
 insert_skip_wrap:
 	state->dirty = 1;
 
 	return 0;
 
 insert_char_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 insert_line(struct DrawState* state)
 {
 	struct BufferLine* buffer_line = NULL;
 
 	assert(state != NULL);
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 	}
 
 	if (!enable_wrap)
 		goto insert_skip_wrap;
 
 	while (state->display_column >= wrap_width)
 	{
 		int saved_column = state->coord.col;
 		buffer_line	 = state->buffer + state->coord.row;
 		assert((buffer_line != NULL) && (buffer_line->text != NULL));
 		state->coord.col = buffer_length(buffer_line->text, wrap_width);
 		/* clang-format off */
 		while (state->coord.col > 0
 			&& !u32_is_word_boundary(
 				buffer_line->text[state->coord.col - 1], 1))
 			state->coord.col--;
 		/* clang-format on */
 		if (state->coord.col == 0)
 		{
 			state->coord.col = saved_column;
 			break;
 		}
 		simple_insert_line(state);
 		state->saved_column = -1;
 		position_to(state, state->coord.row + 1,
 			saved_column - state->coord.col);
 	}
 
 insert_skip_wrap:
 	simple_insert_line(state);
 	state->saved_column = -1;
 	position_to(state, state->coord.row + 1, 0);
 	state->dirty = 1;
 	return 0;
 }
 
 static int
 insert_space(struct DrawState* state)
 {
 	return insert_char(state, ' ');
 }
 
 static int
 insert_tab(struct DrawState* state)
 {
 	return insert_char(state, '\t');
 }
 
 static int
 join_lines(struct DrawState* state)
 {
 	struct BufferLine* current = NULL;
 	struct BufferLine* next	   = NULL;
 	uint32_t* ptext		   = NULL;
 	/* Selection start row/col */
 	int ssr = 0;
 	int ssc = 0;
 	/* Selection end row */
 	int ser	      = 0;
 	int selection = 0;
 	int saved_row;
 
 	assert(state != NULL);
 	saved_row = state->coord.row;
 	if (SEL_NOT_EMPTY(state))
 	{
 		get_selection(&ssr, &ssc, &ser, NULL, state);
 		ser--;
 		selection = 1;
 		clear_selection(state);
 	}
 	else
 	{
 		ssr = state->coord.row;
 		ssc = state->coord.col;
 		ser = state->coord.row;
 	}
 
 	if ((ssr + 1) == state->rows_count)
 		return 0;
 
 	for (int row = ssr; row <= ser; row++)
 	{
 		assert(ssr + 1 < state->buffer_size);
 		current = state->buffer + ssr;
 		next	= state->buffer + ssr + 1;
 		assert((current != NULL) && (next != NULL));
 		ENSURE_SIZE(current->text, ptext, current->size,
 			current->length + 3, current->length + LINE_ALLOC_DELTA,
 			join_lines_error, uint32_t);
 		state->coord.row = ssr;
 		if (current->length > 0
 			&& !u32_is_word_boundary(current->text[current->length
 							 - 1],
 				1)
 			&& !u32_is_word_boundary(next->text[0], 1))
 		{
 			current->text[current->length]	   = ' ';
 			current->text[current->length + 1] = 0;
 			current->length++;
 			state->coord.col = current->length - 1;
 		}
 		else
 			state->coord.col = current->length;
 		state->display_column
 			= display_length(current->text, state->coord.col);
 		simple_join_lines(state);
 	}
 
 	state->coord.row = saved_row;
 	if (selection)
 		position_to(state, ssr, ssc);
 
 	return 0;
 
 join_lines_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 load_file(struct DrawState* state)
 {
 	struct BufferLine* newchunk = NULL;
 	struct BufferLine* line	    = NULL;
 	FILE* input		    = NULL;
 	uint32_t* newtext	    = NULL;
 	uint32_t* ptext		    = NULL;
 	char* input_line	    = NULL;
 	ssize_t input_size	    = limits[L_LINE_MAX];
 	ssize_t input_len	    = 0;
 	int possible_nulbyte;
 
 	assert(state != NULL);
 	input_line = calloc(input_size, 1);
 	if (!input_line)
 		goto load_file_alloc_error;
 	newchunk = calloc(ALLOC_DELTA, sizeof(struct BufferLine));
 	if (!newchunk)
 		goto load_file_alloc_error;
 	for (ssize_t row = 0; row < ALLOC_DELTA; row++)
 	{
 		init_bufferline(newchunk + row);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 			goto load_file_alloc_error;
 		newchunk[row].size = LINE_DEFAULT;
 		newchunk[row].text = newtext;
 	}
 
 	state->buffer	   = newchunk;
 	state->buffer_size = ALLOC_DELTA;
 	state->rows_count  = 0;
 
 	input = fopen(state->filename, "rt");
 	if (!input)
 		return 1;
 
 	state->action = ACT_READING;
 	redraw_status(state);
 
 	possible_nulbyte = 0;
 	while (!feof(input))
 	{
 		char* eol     = NULL;
 		char* nulbyte = NULL;
 
 		if (!fgets(input_line, input_size, input))
 			continue;
 
 		if (possible_nulbyte)
 		{
 			/* Definitely not EOF, NUL byte confirmed */
 			state->error = ERR_BINARY;
 			fclose(input);
 			free(input_line);
 			return 1;
 		}
 
 		eol = strchr(input_line, '\n');
 		if (eol)
 			*eol = 0;
 		nulbyte = strchr(input_line, 0);
 
 		/* We don't know if the NUL byte not being equal to
 		 * (possibly NULL) eol is the result of EOF or not
 		 */
 		if (!open_binary && nulbyte && (nulbyte != eol))
 			possible_nulbyte = 1;
 
 		if (state->rows_count + 1 == state->buffer_size)
 		{
 			state->buffer_size += ALLOC_DELTA;
 			newchunk = realloc(state->buffer,
 				state->buffer_size * sizeof(struct BufferLine));
 			if (!newchunk)
 				goto load_file_alloc_error;
 			state->buffer = newchunk;
 			for (ssize_t row = state->buffer_size - ALLOC_DELTA;
 				row < state->buffer_size; row++)
 			{
 				init_bufferline(state->buffer + row);
 				newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 				if (!newtext)
 					goto load_file_alloc_error;
 				state->buffer[row].size = LINE_DEFAULT;
 				state->buffer[row].text = newtext;
 			}
 		}
 		line	  = state->buffer + state->rows_count;
 		input_len = strlen(input_line);
 		ENSURE_SIZE(line->text, ptext, line->size, input_len + 1,
 			input_len + LINE_ALLOC_DELTA, load_file_alloc_error,
 			uint32_t);
 
 		U32_U8_MEMCCPY(line->text, input_line, line->size, ptext);
 		line->length = u32_strlen(line->text);
 		state->rows_count++;
 	}
 	fclose(input);
 	state->action = ACT_IDLE;
 
 	if (state->rows_count == 0)
 		state->rows_count++;
 
 	free(input_line);
 	return 0;
 
 load_file_alloc_error:
 	return 1;
 }
 
 static int
 move_bottom(struct DrawState* state)
 {
 	position_to(state, state->rows_count > 1 ? state->rows_count - 1 : 0,
 		state->coord.col);
 	return 0;
 }
 
 static int
 move_down(struct DrawState* state)
 {
 	position_to(state, state->coord.row + 1, state->coord.col);
 	return 0;
 }
 
 static int
 move_end(struct DrawState* state)
 {
 	position_to(state, state->coord.row,
 		state->buffer[state->coord.row].length);
 	return 0;
 }
 
 static int
 move_left(struct DrawState* state)
 {
 	position_to(state, state->coord.row, state->coord.col - 1);
 	return 0;
 }
 
 static int
 move_next_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i;
 
 	assert((state != NULL) && (state->buffer != NULL));
 	i     = state->coord.col;
 	pline = state->buffer[state->coord.row].text;
 	len   = state->buffer[state->coord.row].length;
 	while (i < len && !u32_is_word_boundary(pline[i], 0))
 		i++;
 	while (i < len && u32_is_word_boundary(pline[i], 0))
 		i++;
 	position_to(state, state->coord.row, i);
 	return 0;
 }
 
 static int
 move_page_down(struct DrawState* state)
 {
 	assert(state != NULL);
 	if ((state->coord.row + state->maxy) < state->rows_count + 2)
 		position_to(state, state->coord.row + state->maxy - 2,
 			state->coord.col);
 	else
 		move_bottom(state);
 	return 0;
 }
 
 static int
 move_page_up(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->coord.row > state->maxy - 2)
 		position_to(state, state->coord.row - (state->maxy - 2),
 			state->coord.col);
 	else
 		move_top(state);
 	return 0;
 }
 
 static int
 move_prev_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	int i;
 
 	assert((state != NULL) && (state->buffer != NULL));
 	i     = state->coord.col;
 	pline = state->buffer[state->coord.row].text;
 	assert(pline != NULL);
 	if (i > 0 && u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	while (i > 0 && u32_is_word_boundary(pline[i], 0))
 		i--;
 	while (i > 0 && !u32_is_word_boundary(pline[i], 0)
 		&& !u32_is_word_boundary(pline[i - 1], 0))
 		i--;
 	position_to(state, state->coord.row, i);
 	return 0;
 }
 
 static int
 move_right(struct DrawState* state)
 {
 	position_to(state, state->coord.row, state->coord.col + 1);
 	return 0;
 }
 
 static int
 move_screen_bottom(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->rows_count + 2 < state->maxy)
 		position_to(state, state->rows_count - 1, state->coord.col);
 	else
 	{
 		if ((state->first_shown.row + state->maxy)
 			< state->rows_count + 2)
 			position_to(state,
 				state->first_shown.row + state->maxy - 2,
 				state->coord.col);
 	}
 	return 0;
 }
 
 static int
 move_screen_middle(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->rows_count + 2 < state->maxy)
 		position_to(state, state->rows_count / 2, state->coord.col);
 	else
 	{
 		int row = state->first_shown.row + (state->maxy - 2) / 2;
 		if (state->rows_count < (row + (state->maxy - 2) / 2))
 			row = state->rows_count - (state->maxy - 2) / 2;
 		position_to(state, row, state->coord.col);
 	}
 	return 0;
 }
 
 static int
 move_screen_top(struct DrawState* state)
 {
 	assert(state != NULL);
 	position_to(state, state->first_shown.row, state->coord.col);
 	return 0;
 }
 
 static int
 move_start(struct DrawState* state)
 {
 	assert(state != NULL);
 	position_to(state, state->coord.row, 0);
 	return 0;
 }
 
 static int
 move_top(struct DrawState* state)
 {
 	assert(state != NULL);
 	position_to(state, 0, state->coord.col);
 	return 0;
 }
 
 static int
 move_up(struct DrawState* state)
 {
 	assert(state != NULL);
 	position_to(state, state->coord.row > 1 ? state->coord.row - 1 : 0,
 		state->coord.col);
 	return 0;
 }
 
 static int
 next_match(struct DrawState* state)
 {
 	struct BufferLine* current = NULL;
 	const uint32_t* found	   = NULL;
 	ssize_t idelta;
 
 	assert(state != NULL);
 	if (!state->search || !*state->search)
 		return 0;
 
 	state->error = ERR_NONE;
 	for (ssize_t row = state->coord.row; row < state->rows_count; row++)
 	{
 		current = state->buffer + row;
 		found	= current->text;
 		if (row == state->coord.row)
 			found += state->coord.col + 1;
 		found = u32_strstr(found, state->search);
 		if (found)
 		{
 			idelta = found - (const uint32_t*)current->text;
 			state->saved_column
 				= display_length(current->text, idelta);
 			if (*current->text)
 			{
 				position_to(state, row, idelta);
 				return 0;
 			}
 		}
 	}
 	return 0;
 }
 
 static int
 paste_from_paste(struct DrawState* state)
 {
 	struct BufferLine* line	  = NULL;
 	struct BufferLine* newbuf = NULL;
 	struct Coord newpos;
 	uint32_t* newtext = NULL;
 	uint32_t* ptext	  = NULL;
 	uint32_t* rest	  = NULL;
 	ssize_t newsize	  = 0;
 	ssize_t rest_size = 0;
 
 	assert(state != NULL);
 	if (!state->paste_count)
 		return 0;
 
 	if (SEL_NOT_EMPTY(state))
 	{
 		erase_selection(state);
 		position_to_selection_start(state);
 		clear_selection(state);
 	}
 
 	if (state->paste_count > 1)
 	{
 		if (state->rows_count + state->paste_count > state->buffer_size)
 		{
 			ssize_t old_size = state->buffer_size;
 			while (state->rows_count + state->paste_count
 				> state->buffer_size)
 				state->buffer_size += ALLOC_DELTA;
 			newbuf = realloc(state->buffer,
 				state->buffer_size * sizeof(struct BufferLine));
 			for (ssize_t row = old_size; row < state->buffer_size;
 				row++)
 			{
 				init_bufferline(newbuf + row);
 				newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 				newbuf[row].size = LINE_DEFAULT;
 				newbuf[row].text = newtext;
 			}
 			state->buffer = newbuf;
 		}
 	}
 
 	line	= state->buffer + state->coord.row;
 	newsize = line->length + state->paste[0].length + 1;
 	newtext = calloc(newsize, sizeof(uint32_t));
 	if (!newtext)
 	{
 		state->running = 0;
 		goto paste_from_paste_cleanup;
 	}
 	U32_MEMCCPY(newtext, line->text, state->coord.col + 1, ptext);
 	U32_MEMCCPY((newtext + state->coord.col), state->paste[0].text, newsize,
 		ptext);
 
 	assign_coord(&newpos, state->coord);
 
 	if (state->paste_count == 1)
 	{
 		if (ptext)
 			U32_MEMCCPY_EXT((ptext - 1), newtext,
 				line->text + state->coord.col,
 				line->length - state->coord.col, newsize,
 				ptext);
 		U32_SAFE_COPY(line->text, ptext, line->size, newtext, newsize,
 			paste_from_paste_cleanup);
 		line->length = u32_strlen(line->text);
 		newpos.col += state->paste[0].length;
 	}
 	else
 	{
 		state->rows_count += state->paste_count - 1;
 		rest_size = line->size - state->coord.col;
 		rest	  = calloc(rest_size, sizeof(uint32_t));
 		if (!rest)
 		{
 			state->running = 0;
 			goto paste_from_paste_cleanup;
 		}
 		U32_MEMCCPY(rest, line->text + state->coord.col, rest_size,
 			ptext);
 		U32_SAFE_COPY(line->text, ptext, line->size, newtext, newsize,
 			paste_from_paste_cleanup);
 		line->length = u32_strlen(line->text);
 		for (ssize_t row = state->rows_count - state->coord.row
 				- (state->paste_count - 2) - 1;
 			row > 0; row--)
 		{
 			struct BufferLine* copied_line
 				= &state->buffer[state->coord.row + row - 1];
 
 			line = state->buffer + state->coord.row
 				+ state->paste_count - 2 + row;
 			U32_SAFE_COPY(line->text, ptext, line->size,
 				copied_line->text, copied_line->size,
 				paste_from_paste_cleanup);
 			line->length = u32_strlen(line->text);
 		}
 		line = state->buffer + state->coord.row;
 		U32_SAFE_COPY(line->text, ptext, line->size, newtext, newsize,
 			paste_from_paste_cleanup);
 		line->length = u32_strlen(line->text);
 		for (ssize_t row = 1; row < state->paste_count - 1; row++)
 		{
 			line = state->buffer + state->coord.row + row;
 			U32_SAFE_COPY(line->text, ptext, line->size,
 				state->paste[row].text, state->paste[row].size,
 				paste_from_paste_cleanup);
 			line->length = u32_strlen(line->text);
 		}
 		line = state->buffer + state->coord.row + state->paste_count
 			- 1;
 		U32_SAFE_COPY(newtext, ptext, newsize,
 			state->paste[state->paste_count - 1].text,
 			state->paste[state->paste_count - 1].size + rest_size,
 			paste_from_paste_cleanup);
 		if (ptext)
 			U32_MEMCCPY_EXT((ptext - 1), newtext, rest,
 				newsize - (ptext - newtext - 1), newsize,
 				ptext);
 		U32_SAFE_COPY(line->text, ptext, line->size, newtext, newsize,
 			paste_from_paste_cleanup);
 		line->length = u32_strlen(line->text);
 		newpos.col   = state->paste[state->paste_count - 1].length;
 		newpos.row += state->paste_count - 1;
 		state->saved_column
 			= display_length(state->paste[state->paste_count - 1]
 						 .text,
 				newpos.col);
 	}
 
 	position_to(state, newpos.row, newpos.col);
 	state->dirty = 1;
 
 paste_from_paste_cleanup:
 	free(rest);
 	free(newtext);
 	return 0;
 }
 
 /*
  * state->saved_column - display coordinate
  * row, column - buffer coordinates (not display)
  */
 static void
 position_to(struct DrawState* state, const int row, const int column)
 {
 	ssize_t dlen;
 	int old_first_shown_row;
 	int maxx;
 
 	assert(state != NULL);
 	maxx = state->maxx;
 	if (state->line_numbers)
 		maxx -= state->line_numbers_width + 2;
 	old_first_shown_row = state->first_shown.row;
 	if (row != state->coord.row)
 	{
 		state->coord.row = row;
 		if ((state->coord.row + 1) > state->rows_count)
 			state->coord.row = state->rows_count - 1;
 		if (state->first_shown.row > state->coord.row)
 			state->first_shown.row = state->coord.row;
 		if (state->first_shown.row + (state->maxy - 2)
 			< state->coord.row)
 			state->first_shown.row
 				= state->coord.row - (state->maxy - 2);
 		if (state->saved_column == -1)
 		{
 			state->saved_column = state->display_column;
 			state->coord.col    = column;
 		}
 		else
 			state->coord.col
 				= buffer_length(state->buffer[state->coord.row]
 							.text,
 					state->saved_column);
 		if (state->coord.col < 0)
 			state->coord.col = 0;
 		else if (state->coord.col
 			> (int)state->buffer[state->coord.row].length)
 			state->coord.col
 				= state->buffer[state->coord.row].length;
 		dlen = display_length(state->buffer[state->coord.row].text,
 			state->coord.col);
 		if (dlen < state->saved_column)
 			state->display_column = dlen;
 		else
 			state->display_column = state->saved_column;
 	}
 	else
 	{
 		state->coord.col = column;
 		if (state->coord.col < 0)
 		{
 			if (state->coord.row > 0)
 			{
 				state->coord.row--;
 				if (state->first_shown.row > 0
 					&& state->first_shown.row
 						> state->coord.row)
 					state->first_shown.row--;
 				state->coord.col
 					= state->buffer[state->coord.row].length;
 			}
 			else
 				state->coord.col = 0;
 		}
 		else if (state->coord.col
 			> state->buffer[state->coord.row].length)
 		{
 			if ((state->coord.row + 1) < state->rows_count)
 			{
 				state->coord.row++;
 				if (state->first_shown.row + (state->maxy - 2)
 						< state->coord.row
 					&& state->first_shown.row + 1
 						< state->rows_count)
 					state->first_shown.row++;
 				state->coord.col = 0;
 			}
 			else
 				state->coord.col
 					= state->buffer[state->coord.row].length;
 		}
 		state->display_column
 			= display_length(state->buffer[state->coord.row].text,
 				state->coord.col);
 		state->saved_column = state->display_column;
 	}
 	if (state->first_shown.col > state->display_column)
 	{
 		state->first_shown.col = state->display_column;
 	}
 	if (state->first_shown.col + maxx < state->display_column + 1)
 	{
 		int index_first;
 		int fsc = state->first_shown.col;
 		index_first
 			= buffer_length(state->buffer[state->coord.row].text,
 				fsc);
 		while (fsc + maxx < state->display_column + 1)
 		{
 			index_first++;
 			fsc = display_length(state->buffer[state->coord.row].text,
 				index_first);
 		}
 		state->first_shown.col = fsc;
 	}
 	if (old_first_shown_row != state->first_shown.row)
 		recalculate_line_numbers(state);
 
 	if (IN(state->mode, M_SELECTION))
 		assign_coord(&state->sel_end, state->coord);
 }
 
 static int
 position_to_selection_end(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (SEL_NOT_EMPTY(state))
 	{
 		int ser = 0;
 		int sec = 0;
 
 		get_selection(NULL, NULL, &ser, &sec, state);
 
 		state->saved_column
 			= display_length(state->buffer[ser].text, sec);
 		position_to(state, ser, sec);
 		state->saved_column = state->display_column;
 	}
 	return 0;
 }
 
 static int
 position_to_selection_start(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (SEL_NOT_EMPTY(state))
 	{
 		int ssr = 0;
 		int ssc = 0;
 
 		get_selection(&ssr, &ssc, NULL, NULL, state);
 
 		state->saved_column
 			= display_length(state->buffer[ssr].text, ssc);
 		position_to(state, ssr, ssc);
 		state->saved_column = state->display_column;
 	}
 	return 0;
 }
 
 static int
 prev_match(struct DrawState* state)
 {
 	struct BufferLine* current = NULL;
 	const uint32_t* found	   = NULL;
 	ssize_t idelta;
 	ssize_t row;
 
 	assert(state != NULL);
 	if (!state->search || !*state->search)
 		return 0;
 
 	state->error = ERR_NONE;
 
 	row = state->coord.row;
 	while (1)
 	{
 		const uint32_t* save_found;
 		current = state->buffer + row;
 		found	= current->text;
 		if (!found)
 			return 0;
 		if (row == state->coord.row)
 			found += state->coord.col;
 		else
 			found += current->length;
 
 	prev_match_loop:
 		save_found = found;
 		found	   = u32_strrstr(current->text, state->search, found);
 		if (found)
 		{
 			idelta = found - current->text;
 			state->saved_column
 				= display_length(current->text, idelta);
 			if (*current->text)
 			{
 				position_to(state, row, idelta);
 				return 0;
 			}
 		}
 		if (save_found == current->text)
 			goto prev_match_end;
 		found = save_found - 1;
 		goto prev_match_loop;
 	prev_match_end:
 		if (!row)
 			break;
 		row--;
 	}
 	return 0;
 }
 
 static int
 print_error(const int code, const char* msg, ...)
 {
 	char buf[LINE_DEFAULT];
 	va_list args;
 	va_start(args, msg);
 	vsnprintf(buf, LINE_DEFAULT, msg, args);
 	va_end(args);
 	fprintf(stderr, "%s: %s\n", PROGRAM_NAME, buf);
 	return code;
 }
 
 static int
 quit_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert(state != NULL);
 	if (ev->ch == 'y')
 		if (write_file(state))
 			return 1;
 	state->prompt_callback = NULL;
 	state->running	       = 0;
 	return 0;
 }
 
 static int
 reread_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert(state != NULL);
 	if (strchr("Yy", ev->ch))
 		if (reread_file(state))
 			return 1;
 	state->prompt_callback = NULL;
 	return 0;
 }
 
 static int
 reread_file(struct DrawState* state)
 {
 	assert(state != NULL);
 	free_drawstate(state);
 	init_drawstate(state, state->filename, state->prompt, 1, 1);
 
 	redraw_status(state);
 
 	if (load_file(state))
 	{
 		state->running = 0;
 		return state->error;
 	}
 
 	recalculate_line_numbers(state);
 	return 0;
 }
 
 static int
 reread_or_callback(struct DrawState* state)
 {
 	char* temp = NULL;
 
 	assert(state != NULL);
 	if (state->dirty)
 	{
 		SET(state->mode, M_PROMPT);
 		MEMCCPY(state->prompt, prompt_reread_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = reread_callback;
 	}
 	else
 		reread_file(state);
 	return 0;
 }
 
 static int
 save_file(struct DrawState* state)
 {
 	FILE* output = NULL;
 	struct stat st;
 	char* buf	= NULL;
 	char* pbuf	= NULL;
 	ssize_t bufsize = LINE_DEFAULT;
 	int result	= 0;
 	int saved_errno;
 
 	assert(state != NULL);
 	if (!(buf = calloc(bufsize, 1)))
 		goto save_file_alloc_error;
 
 	state->action = ACT_WRITING;
 	redraw_status(state);
 	errno = 0;
 
 	if (!create_backups || state->new_file)
 		goto save_skip_backup_copy;
 
 	if (!backup_fail && !state->backup_possible)
 		goto save_skip_backup_copy;
 
 	if ((unlink(state->backup_filename) < 0) && (errno != ENOENT))
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 	if (cp(state->rfn_len > 0 ? state->real_filename : state->filename,
 		    state->backup_filename))
 	{
 		if (backup_fail)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 		else
 			errno = 0; /* ignore errors */
 	}
 
 save_skip_backup_copy:
 	if (!(output = fopen(state->rfn_len > 0 ? state->real_filename
 						: state->filename,
 		      "w")))
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 
 	if (!create_backups || state->new_file)
 		goto save_skip_backup_symlink;
 
 	if (lstat(state->rfn_len > 0 ? state->real_filename : state->filename,
 		    &st)
 		< 0)
 	{
 		state->error = ERR_ERRNO_SET;
 		result	     = 1;
 		goto save_file_cleanup;
 	}
 
 	if (!backup_fail && !state->backup_possible)
 		goto save_skip_backup_symlink;
 
 	if (state->rfn_len > 0)
 	{
 		if (unlink(state->filename) == -1)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 		if (symlink(state->orig_real_filename, state->filename) == -1)
 		{
 			state->error = ERR_ERRNO_SET;
 			result	     = 1;
 			goto save_file_cleanup;
 		}
 	}
 	chmod(state->rfn_len > 0 ? state->real_filename : state->filename,
 		st.st_mode);
 
 save_skip_backup_symlink:
 	if (state->rows_count == 1 && state->buffer[0].length == 0)
 		goto save_file_cleanup;
 
 	for (ssize_t row = 0; row < state->rows_count; row++)
 	{
 		ENSURE_SIZE(buf, pbuf, bufsize,
 			UTF8REPMAX * state->buffer[row].length + 1,
 			UTF8REPMAX * state->buffer[row].length
 				+ LINE_ALLOC_DELTA,
 			save_file_alloc_error, char);
 		unicode_string_to_u8(buf, state->buffer[row].text, bufsize);
 		fprintf(output, "%s\n", buf);
 	}
 
 	state->new_file = 0;
 	goto save_file_cleanup;
 
 save_file_alloc_error:
 	if (output)
 		fclose(output);
 	return 1;
 
 save_file_cleanup:
 	saved_errno = errno;
 	if (output)
 		fclose(output);
 	free(buf);
 	state->action = ACT_IDLE;
 	errno	      = saved_errno;
 	return result;
 }
 
 static int
 search_dialog_callback(struct DrawState* state)
 {
 	assert(state != NULL);
 	next_match(state);
 	if (!state->error)
 		state->input_callback = NULL;
 	return 0;
 }
 
 static int
 search_replace_replace_dialog_callback(struct DrawState* state)
 {
 	assert(state != NULL);
 	do_search_replace(state);
 	*state->search = 0;
 	/*u32_strcpy(state->search, state->input);
 	next_match(state);*/
 	if (!state->error)
 		state->input_callback = NULL;
 	state->chain_dialog = 0;
 	return 0;
 }
 
 static int
 search_replace_search_dialog_callback(struct DrawState* state)
 {
 	assert(state != NULL);
 	/*next_match(state);*/
 	if (!state->error)
 		state->input_callback = NULL;
 	*state->input = 0;
 	show_replace(state);
 	return 0;
 }
 
 static int
 search_update_callback(struct DrawState* state)
 {
 	uint32_t* temp = NULL;
 	U32_MEMCCPY(state->search, state->input, MAXINPUT, temp);
 	return 0;
 }
 
 static int
 show_go_to_line(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->input_title    = (char*)go_to_dialog_title;
 	state->input_callback = go_to_line_callback;
 	if (!state->input)
 	{
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	SET(state->mode, M_INPUT | M_INPUT_NUM);
 	*state->input = 0;
 	state->error  = ERR_NONE;
 	input_position_to(state, 0);
 	return 0;
 }
 
 static int
 show_help(struct DrawState* state)
 {
 	assert(state != NULL);
 	SET(state->mode, M_HELP);
 	state->error = ERR_NONE;
 	return 0;
 }
 
 static int
 show_replace(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->input_title	     = (char*)replace_dialog_title;
 	state->input_callback	     = search_replace_replace_dialog_callback;
 	state->input_update_callback = NULL;
 	if (!state->input)
 	{
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	*state->input = 0;
 	SET(state->mode, M_INPUT);
 	CLEAR(state->mode, M_INPUT_NUM);
 	state->error = ERR_NONE;
 	input_position_to(state, 0);
 	return 0;
 }
 
 static int
 show_search(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (!state->search)
 	{
 		if (!(state->search = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	*state->search		     = 0;
 	state->input_title	     = (char*)search_dialog_title;
 	state->input_callback	     = search_dialog_callback;
 	state->input_update_callback = search_update_callback;
 	if (!state->input)
 	{
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	*state->input = 0;
 	SET(state->mode, M_INPUT);
 	CLEAR(state->mode, M_INPUT_NUM);
 	state->error = ERR_NONE;
 	input_position_to(state, 0);
 	return 0;
 }
 
 static int
 show_search_replace(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (!state->search)
 	{
 		if (!(state->search = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	*state->search		     = 0;
 	state->input_title	     = (char*)search_dialog_title;
 	state->input_callback	     = search_replace_search_dialog_callback;
 	state->input_update_callback = search_update_callback;
 	if (!state->input)
 	{
 		if (!(state->input = calloc(MAXINPUT, sizeof(uint32_t))))
 		{
 			state->running = 0;
 			return 1;
 		}
 	}
 	*state->input	    = 0;
 	state->chain_dialog = 1;
 	SET(state->mode, M_INPUT);
 	CLEAR(state->mode, M_INPUT_NUM);
 	state->error = ERR_NONE;
 	input_position_to(state, 0);
 	return 0;
 }
 
 static void
 simple_insert_line(struct DrawState* state)
 {
 	struct BufferLine* newchunk = NULL;
 	struct BufferLine* line	    = NULL;
 	uint32_t* ptext		    = NULL;
 
 	assert(state != NULL);
 	if (state->rows_count + 1 == state->buffer_size)
 	{
 		state->buffer_size += ALLOC_DELTA;
 		newchunk = realloc(state->buffer,
 			state->buffer_size * sizeof(struct BufferLine));
 		if (!newchunk)
 		{
 			state->running = 0;
 			return;
 		}
 		state->buffer = newchunk;
 		for (ssize_t row = state->buffer_size - ALLOC_DELTA;
 			row < state->buffer_size; row++)
 		{
 			line = state->buffer + row;
 			init_bufferline(line);
 			ENSURE_SIZE(line->text, ptext, line->size, LINE_DEFAULT,
 				LINE_DEFAULT, simple_insert_line_error,
 				uint32_t);
 		}
 	}
 	state->rows_count++;
 	for (ssize_t i = state->rows_count - 1; i > (state->coord.row + 1); i--)
 	{
 		U32_SAFE_COPY(state->buffer[i].text, ptext,
 			state->buffer[i].size, state->buffer[i - 1].text,
 			state->buffer[i - 1].size, simple_insert_line_error);
 		state->buffer[i].length = state->buffer[i - 1].length;
 	}
 	ENSURE_SIZE(state->buffer[state->coord.row + 1].text, ptext,
 		state->buffer[state->coord.row + 1].size, LINE_DEFAULT,
 		LINE_DEFAULT, simple_insert_line_error, uint32_t);
 	*state->buffer[state->coord.row + 1].text = 0;
 	if (state->coord.col < state->buffer[state->coord.row].length)
 		U32_SAFE_COPY(state->buffer[state->coord.row + 1].text, ptext,
 			state->buffer[state->coord.row + 1].size,
 			state->buffer[state->coord.row].text + state->coord.col,
 			state->buffer[state->coord.row].size,
 			simple_insert_line_error);
 
 	state->buffer[state->coord.row + 1].length
 		= state->buffer[state->coord.row].length - state->coord.col;
 
 	state->buffer[state->coord.row].text[state->coord.col] = 0;
 	state->buffer[state->coord.row].length = state->coord.col;
 
 	state->dirty = 1;
 	recalculate_line_numbers(state);
 	return;
 
 simple_insert_line_error:
 	state->running = 0;
 	return;
 }
 
 static void
 simple_join_lines(struct DrawState* state)
 {
 	struct BufferLine* first_line = NULL;
 	struct BufferLine* next_line  = NULL;
 	uint32_t* ptext		      = NULL;
 
 	assert(state != NULL);
 	if ((state->coord.row + 1) == state->rows_count)
 		return;
 
 	first_line = &state->buffer[state->coord.row];
 	next_line  = &state->buffer[state->coord.row + 1];
 	ENSURE_SIZE(first_line->text, ptext, first_line->size,
 		first_line->length + next_line->length + 1,
 		first_line->length + next_line->length + LINE_ALLOC_DELTA,
 		simple_join_lines_error, uint32_t);
 	U32_MEMCCPY((first_line->text + first_line->length), next_line->text,
 		next_line->length + 1, ptext);
 	first_line->length = u32_strlen(first_line->text);
 	/* i <- i+1 */
 	for (ssize_t i = state->coord.row + 1; i + 1 < state->rows_count; i++)
 	{
 		U32_SAFE_COPY(state->buffer[i].text, ptext,
 			state->buffer[i].size, state->buffer[i + 1].text,
 			state->buffer[i + 1].size, simple_join_lines_error);
 		state->buffer[i].length = state->buffer[i + 1].length;
 	}
 	free_bufferline(&state->buffer[state->rows_count - 1]);
 	state->rows_count--;
 	state->dirty = 1;
 	recalculate_line_numbers(state);
 	return;
 
 simple_join_lines_error:
 	state->running = 0;
 	return;
 }
 
 static void
 simple_yank(struct DrawState* state)
 {
 	struct BufferLine* newbuf = NULL;
 	uint32_t* ptext		  = NULL;
 	ssize_t initialize_start;
 	/* Selection start row/col */
 	int ssr = 0;
 	int ssc = 0;
 	/* Selection end row/col */
 	int ser = 0;
 	int sec = 0;
 
 	assert(state != NULL);
 	if (!SEL_NOT_EMPTY(state))
 	{
 		if (state->paste_count > 0)
 		{
 			state->paste_count     = 0;
 			*state->paste[0].text  = 0;
 			state->paste[0].length = 0;
 		}
 		clear_selection(state);
 		return;
 	}
 
 	get_selection(&ssr, &ssc, &ser, &sec, state);
 
 	state->paste_count = ser - ssr + 1;
 	initialize_start   = state->paste_size;
 	if (!state->paste_size)
 	{
 		while (state->paste_count > state->paste_size)
 			state->paste_size += ALLOC_DELTA;
 		newbuf = calloc(state->paste_size, sizeof(struct BufferLine));
 	}
 	else if (state->paste_count > state->paste_size)
 	{
 		while (state->paste_count > state->paste_size)
 			state->paste_size += ALLOC_DELTA;
 		newbuf = realloc(state->paste,
 			state->paste_size * sizeof(struct BufferLine));
 	}
 	else
 		newbuf = state->paste;
 	for (ssize_t row = initialize_start; row < state->paste_size; row++)
 	{
 		init_bufferline(newbuf + row);
 		ENSURE_SIZE(newbuf[row].text, ptext, newbuf[row].size,
 			LINE_DEFAULT, LINE_DEFAULT, simple_yank_alloc_error,
 			uint32_t);
 	}
 	state->paste = newbuf;
 	if (state->paste_count == 1)
 	{
 		U32_SAFE_COPY(state->paste[0].text, ptext, state->paste[0].size,
 			state->buffer[ssr].text + ssc, (sec - ssc + 1),
 			simple_yank_alloc_error);
 		state->paste[0].length = sec - ssc;
 	}
 	else
 	{
 		ssize_t first_line_len = state->buffer[ssr].length - ssc;
 
 		U32_SAFE_COPY(state->paste[0].text, ptext, state->paste[0].size,
 			state->buffer[ssr].text + ssc, first_line_len + 1,
 			simple_yank_alloc_error);
 		state->paste[0].length = first_line_len;
 
 		for (ssize_t row = 1; row < state->paste_count - 1; row++)
 		{
 			U32_SAFE_COPY(state->paste[row].text, ptext,
 				state->paste[row].size,
 				state->buffer[ssr + row].text,
 				state->buffer[ssr + row].size,
 				simple_yank_alloc_error);
 			state->paste[row].length
 				= u32_strlen(state->paste[row].text);
 		}
 
 		U32_SAFE_COPY(state->paste[state->paste_count - 1].text, ptext,
 			state->paste[state->paste_count - 1].size,
 			state->buffer[ser].text, (sec + 1),
 			simple_yank_alloc_error);
 		state->paste[state->paste_count - 1].length = sec;
 	}
 	return;
 
 simple_yank_alloc_error:
 	state->running = 0;
 	return;
 }
 
 static int
 suspend_program(struct DrawState* state)
 {
 	tb_set_clear_attrs(TB_WHITE, TB_DEFAULT);
 	tb_clear();
 	tb_set_cursor(0, 0);
 	tb_present();
 
 	kill(getpid(), SIGTSTP);
 
 	/* --- back from suspend --- */
 
 	tb_clear();
 	if (draw(state))
 		return 1;
 	tb_present();
 	return 0;
 }
 
 static int
 toggle_line_numbers(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->line_numbers = !state->line_numbers;
 	position_to(state, state->coord.row, state->coord.col);
 	return 0;
 }
 
 static int
 toggle_overwrite(struct DrawState* state)
 {
 	assert(state != NULL);
 	TOGGLE(state->mode, M_OVERWRITE);
 	CLEAR(state->mode, M_COMMAND);
 	return 0;
 }
 
 static int
 toggle_selection(struct DrawState* state)
 {
 	assert(state != NULL);
 	TOGGLE(state->mode, M_SELECTION);
 	if (IN(state->mode, M_SELECTION))
 		assign_coord(&state->sel_start, state->coord);
 	assign_coord(&state->sel_end, state->coord);
 	return 0;
 }
 
 /*
  * Not ideal (todo). In extreme cases (files generated by the testsuite, with a
  * huge block of full lines with no spaces), becomes unresponsive and has to be
  * killed. But in most "normal" cases, behaves acceptably.
  */
 static int
 wrap_para(struct DrawState* state)
 {
 	struct BufferLine* current = NULL;
 	struct BufferLine* next	   = NULL;
 	uint32_t* ptext		   = NULL;
 	int sel;
 	int start_row;
 	int end_row;
 	int cur_row;
 	int bcol;
 	int dlen;
 	int col;
 	int added_blank = 0;
 
 	assert(state != NULL);
 	if (!enable_wrap)
 		goto wrap_not_enabled;
 
 	sel = SEL_NOT_EMPTY(state);
 
 	state->action = ACT_WRAPPING;
 	redraw_status(state);
 
 	if (sel)
 		get_selection(&start_row, NULL, &end_row, NULL, state);
 	else
 	{
 		start_row = state->coord.row;
 		end_row	  = start_row;
 		for (cur_row = start_row; cur_row > 0; cur_row--)
 			if (state->buffer[cur_row - 1].length == 0
 				|| !u32_has_nonblanks(
 					state->buffer[cur_row - 1].text))
 			{
 				start_row = cur_row;
 				break;
 			}
 		if (cur_row == 0)
 			start_row = cur_row;
 		for (cur_row = state->coord.row;
 			cur_row + 1 < state->rows_count; cur_row++)
 			if (state->buffer[cur_row].length == 0
 				|| !u32_has_nonblanks(
 					state->buffer[cur_row].text))
 			{
 				end_row = cur_row - 1;
 				break;
 			}
 		if (cur_row + 1 == state->rows_count)
 			end_row = cur_row - 1;
 	}
 
 	cur_row = start_row;
 wrap_next_line:
 	state->coord.col = 0;
 	current		 = &state->buffer[cur_row];
 	next		 = &state->buffer[cur_row + 1];
 	state->coord.row = cur_row;
 
 	if (sel && (cur_row == state->sel_end.row)
 		&& (cur_row != state->sel_start.row)
 		&& (cur_row + 1 != state->rows_count))
 		goto wrap_finish;
 
 	/* If the line has less than wrap_width characters, join with next */
 	dlen = display_length(current->text, current->length);
 	while ((dlen < wrap_width) && (cur_row + 1 < state->rows_count)
 		&& (current->length > 0) && u32_has_nonblanks(next->text))
 	{
 		/* Insert space to avoid joining ending and beginning words */
 		if (current->length > 0
 			&& !u32_is_word_boundary(current->text[current->length
 							 - 1],
 				1))
 		{
 			ENSURE_SIZE(current->text, ptext, current->size,
 				current->length + 2, current->length + 2,
 				wrap_alloc_error, uint32_t);
 			current->length++;
 			current->text[current->length - 1] = (uint32_t)' ';
 			current->text[current->length]	   = 0;
 		}
 
 		if (sel)
 		{
 			if (cur_row + 1 == state->sel_end.row)
 				state->sel_end.col
 					+= state->buffer[cur_row].length;
 			if (cur_row + 1 == state->sel_start.row)
 				state->sel_end.col -= state->sel_start.col;
 			state->sel_end.row--;
 		}
 		simple_join_lines(state);
 		end_row--;
 
 		current = &state->buffer[cur_row];
 		next	= &state->buffer[cur_row + 1];
 
 		dlen = display_length(current->text, current->length);
 	}
 
 	/* If the line has wrap_width or more characters, wrap it */
 	while (dlen >= wrap_width)
 	{
 		int tdlen;
 		bcol = buffer_length(current->text, wrap_width);
 		while (bcol > 0
 			&& !u32_is_word_boundary(current->text[bcol - 1], 1))
 			bcol--;
 		if (bcol == 0)
 			break;
 		ENSURE_SIZE(current->text, ptext, current->size,
 			current->length + 1, current->length + LINE_ALLOC_DELTA,
 			wrap_alloc_error, uint32_t);
 		state->coord.col = bcol - 1;
 
 		if (sel)
 		{
 			if (cur_row == state->sel_end.row)
 				state->sel_end.col -= bcol;
 			/* TODO: Add startcol parameter to buffer_length? */
 			/*if (cur_row == state->sel_start.row)
 				state->sel_end.col += state->sel_start.col;*/
 			state->sel_end.row++;
 		}
 		simple_insert_line(state);
 		end_row++;
 
 		cur_row++;
 		state->coord.row++;
 		current = &state->buffer[cur_row];
 		next	= &state->buffer[cur_row + 1];
 
 		/* - Remove spaces between the two words at split
 		 * - current is the new current (the rest of the line
 		 *   after split) */
 		while (u32_is_word_boundary(current->text[0], 1))
 		{
 			for (col = 0; col < current->length; col++)
 				current->text[col] = current->text[col + 1];
 			assert(current->length > 0);
 			current->length--;
 			if (current->length == 0)
 				break;
 		}
 
 		if (cur_row + 1 == state->rows_count)
 			goto wrap_next_line;
 
 		/* If the rest of the line is still in block and is
 		 * < wrap_width, join it with next (the new next) */
 		tdlen = display_length(current->text, current->length);
 		if ((current->length > 0) && u32_has_nonblanks(next->text)
 			&& (tdlen < wrap_width)
 			&& !(sel && (cur_row == state->sel_end.row)))
 		{
 			/* Add space if needed to avoid joining words */
 			/* clang-format off */
 			if (!u32_is_word_boundary(
 				current->text[current->length - 1], 1))
 			{
 				/* clang-format on */
 				ENSURE_SIZE(current->text, ptext, current->size,
 					current->length + 2,
 					current->length + 2, wrap_alloc_error,
 					uint32_t);
 				current->length++;
 				current->text[current->length - 1]
 					= (uint32_t)' ';
 				current->text[current->length] = 0;
 			}
 
 			if (sel)
 			{
 				if (cur_row + 1 == state->sel_end.row)
 					state->sel_end.col
 						+= state->buffer[cur_row].length;
 				if (cur_row + 1 == state->sel_start.row)
 					state->sel_end.col
 						-= state->sel_start.col;
 				state->sel_end.row--;
 			}
 			simple_join_lines(state);
 			end_row--;
 
 			dlen = display_length(current->text,
 				sel && (cur_row == state->sel_end.row)
 					? state->sel_end.col
 					: current->length);
 			// dlen = display_length(current->text, current->length);
 			if (dlen < wrap_width)
 				goto wrap_next_line;
 
 			/* One more split needed for the rest of the line (new
 			 * current) */
 			bcol = buffer_length(current->text, wrap_width);
 			while (bcol > 0
 				&& !u32_is_word_boundary(current->text[bcol - 1],
 					1))
 				bcol--;
 			if (bcol == 0)
 				break;
 			ENSURE_SIZE(current->text, ptext, current->size,
 				current->length + 1,
 				current->length + LINE_ALLOC_DELTA,
 				wrap_alloc_error, uint32_t);
 			state->coord.col = bcol - 1;
 
 			if (sel)
 			{
 				if (cur_row == state->sel_end.row)
 					state->sel_end.col -= bcol;
 				/* TODO: Add startcol parameter to
 				 *	 buffer_length? */
 				/*if (cur_row == state->sel_start.row)
 					state->sel_end.col +=
 					state->sel_start.col;*/
 				state->sel_end.row++;
 			}
 			simple_insert_line(state);
 			end_row++;
 
 			/* Remove spaces between the two words at split */
 			while (u32_is_word_boundary(next->text[0], 1))
 			{
 				for (col = 0; col < next->length; col++)
 					next->text[col] = next->text[col + 1];
 				assert(next->length > 0);
 				next->length--;
 				if (next->length == 0)
 					break;
 			}
 		}
 
 		if (cur_row + 1 == state->rows_count)
 			goto wrap_next_line;
 
 		if (cur_row == MIN((end_row + 1), state->rows_count))
 			break;
 
 		dlen = display_length(current->text, current->length);
 	}
 	cur_row++;
 	if (added_blank)
 		goto wrap_finish;
 	if (cur_row >= state->rows_count)
 	{
 		added_blank = 1;
 		move_end(state);
 		simple_insert_line(state);
 		move_up(state);
 		goto wrap_next_line;
 	}
 	else if (cur_row < (end_row + 2 >= state->rows_count ? state->rows_count
 							     : end_row + 1))
 		goto wrap_next_line;
 
 wrap_finish:
 	if (added_blank)
 		erase_line(state);
 
 	if (sel)
 		position_to_selection_end(state);
 	else
 		position_to(state, cur_row, 0);
 
 	state->action = ACT_IDLE;
 	recalculate_line_numbers(state);
 	return 0;
 
 wrap_not_enabled:
 	state->error = ERR_NOT_IMP;
 	return 1;
 
 wrap_alloc_error:
 	state->running = 0;
 	return 1;
 }
 
 static int
 write_file(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (save_file(state))
 	{
 		state->running = 0;
 		return 1;
 	}
 
 	state->error = ERR_NONE;
 	state->dirty = 0;
 	return 0;
 }
 
 static int
 yank_to_paste(struct DrawState* state)
 {
 	simple_yank(state);
 	clear_selection(state);
 	return 0;
 }
 
 int
 main(int argc, char** argv)
 {
 	struct tb_event ev;
 	struct DrawState state;
 	struct stat st;
 	char prompt[LINE_DEFAULT];
 	char* filename		   = NULL;
 	char* wd		   = NULL;
 	char* dir		   = NULL;
 	char* pdir		   = NULL;
 	char* temp		   = NULL;
 	char* rfn		   = NULL;
 	const char* saved_tb_error = NULL;
 	ssize_t filename_size	   = 0;
 	int result		   = 0;
 	int dir_access;
 	int dir_access_errno;
 	int saved_errno;
 	int tbires;
 	int optind = 1;
 
 	*prompt = 0;
 
 #ifdef __OpenBSD__
 	if (pledge("stdio tty unveil rpath wpath cpath fattr", NULL) < 0)
 	{
 		perror(PROGRAM_NAME ": pledge");
 		exit(errno);
 	}
 #endif
 
 	setlocale(LC_ALL, "");
 
 	if (argc == 1)
 		return print_error(CUSTOM_ERROR_START + ERR_NO_CL_ARG,
 			"No filename given");
 
 main_options_loop:
 	if (optind == argc)
 		return print_error(CUSTOM_ERROR_START + ERR_NO_CL_ARG,
 			"No filename given");
 
 	if (!strcmp(argv[optind], "-h") || !strcmp(argv[optind], "--help"))
 	{
 		printf("Usage:\t%s -h | --help | -V | --full-version | "
 		       "-v | --version\n"
 		       "\t%s [-B | --no-backup] [-b | --backup] "
 		       "[-O | --no-open-binary] [-o | --open-binary] "
 		       "filename\n",
 			PROGRAM_NAME, PROGRAM_NAME);
 		return 0;
 	}
 	else if (!strcmp(argv[optind], "-v")
 		|| !strcmp(argv[optind], "--version"))
 	{
 		printf("%s %s, committed on %s\n", PROGRAM_NAME, VERSION, DATE);
 		return 0;
 	}
 	else if (!strcmp(argv[optind], "-V")
 		|| !strcmp(argv[optind], "--full-version"))
 	{
 		printf("%s %s, committed on %s\n", PROGRAM_NAME, VERSION, DATE);
 		puts(COPYRIGHT);
 		printf("Features set in config.h and on command line:\n");
 		printf("  backup_fail:\t\t%s\n", backup_fail ? "set" : "unset");
 		printf("  create_backups:\t%s\n",
 			create_backups ? "set" : "unset");
 		printf("  enable_wrap:\t\t%s\n", enable_wrap ? "set" : "unset");
 		printf("  line_numbers:\t\t%s\n",
 			line_numbers ? "set" : "unset");
 		printf("  open_binary:\t\t%s\n", open_binary ? "set" : "unset");
 		printf("  wrap_width:\t\t%d\n", wrap_width);
 		return 0;
 	}
 	else if (!strcmp(argv[optind], "-B")
 		|| !strcmp(argv[optind], "--no-backup"))
 	{
 		create_backups = 0;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (!strcmp(argv[optind], "-b")
 		|| !strcmp(argv[optind], "--backup"))
 	{
 		create_backups = 1;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (!strcmp(argv[optind], "-O")
 		|| !strcmp(argv[optind], "--no-open-binary"))
 	{
 		open_binary = 0;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (!strcmp(argv[optind], "-o")
 		|| !strcmp(argv[optind], "--open-binary"))
 	{
 		open_binary = 1;
 		optind++;
 		goto main_options_loop;
 	}
 
 	/*
 	 * Chicken and egg problem: to get fpathconf(dirfd, _PC_PATH_MAX)
 	 * we need a dir, which needs to be allocated, and to allocate it we
 	 * need to know the value returned by fpathconf(dirfd, _PC_PATH_MAX)...
 	 */
 	/* argv[1] is the filename; BTW, "filename" is a misnomer */
 	filename_size = strlen(argv[optind]) + 1;
 	if (!(dir = malloc(filename_size)))
 	{
 		perror(PROGRAM_NAME ": malloc");
 		exit(errno);
 	}
 
 	(void)dirname(dir, argv[optind], filename_size);
 	if (init_limits(dir) < 0)
 	{
 		perror(PROGRAM_NAME ": init_limits");
 		free(dir);
 		exit(errno);
 	}
 
 	filename = calloc(limits[L_PATH_MAX], 1);
 	if (!filename)
 	{
 		perror(PROGRAM_NAME ": calloc");
 		exit(errno);
 	}
 
 	*filename = 0;
 	MEMCCPY(filename, argv[optind], limits[L_PATH_MAX], temp);
 	if (!*filename)
 	{
 		free(filename);
 		free(dir);
 		return print_error(EINVAL, "No filename given");
 	}
 
 	init_drawstate(&state, filename, prompt, 0, 0);
 
 #ifdef __OpenBSD__
 	if (unveil(state.filename, "rwc") < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 	if (unveil(dir, "rwc") < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 #endif
 
 	if (!create_backups)
 		goto main_skip_backups;
 
 	if (!(wd = malloc(limits[L_PATH_MAX])))
 	{
 		perror(PROGRAM_NAME ": malloc");
 		goto main_done;
 	}
 	if (!getcwd(wd, limits[L_PATH_MAX]))
 	{
 		perror(PROGRAM_NAME ": getcwd");
 		goto main_done;
 	}
 #ifdef __OpenBSD__
 	if (unveil(wd, "rwc") < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 #endif
 
 	errno = 0;
 	if (lstat(state.filename, &st) != -1)
 	{
 		if (S_ISLNK(st.st_mode))
 		{
 			if (!(rfn = malloc(limits[L_PATH_MAX])))
 			{
 				perror(PROGRAM_NAME ": malloc");
 				goto main_done;
 			}
 
 			if (!(state.real_filename = malloc(limits[L_PATH_MAX])))
 			{
 				perror(PROGRAM_NAME ": malloc");
 				goto main_done;
 			}
 
 			state.rfn_len = readlink(state.filename, rfn,
 				limits[L_PATH_MAX]);
 			if (state.rfn_len == -1)
 				goto main_done;
 
 			rfn[state.rfn_len] = 0;
 
 			if (*rfn == '/') /* rfn is absolute */
 			{
 				MEMCCPY(state.real_filename, rfn,
 					limits[L_PATH_MAX], temp);
 				state.rfn_len = strlen(rfn);
 			}
 			else /* rfn is relative */
 			{
 				size_t rfn_dir_len;
 
 				state.orig_real_filename
 					= strndup(rfn, state.rfn_len);
 				if (!state.orig_real_filename)
 				{
 					perror(PROGRAM_NAME ": strndup");
 					goto main_done;
 				}
 
 				MEMCCPY(state.real_filename, dir,
 					limits[L_PATH_MAX], temp);
 				if (!temp)
 				{
 					errno = ENAMETOOLONG;
 					goto main_done;
 				}
 				*(temp - 1) = '/'; /* overwrite NUL */
 				rfn_dir_len = temp - state.real_filename - 1;
 				MEMCCPY_EXT(temp, state.real_filename, rfn,
 					limits[L_PATH_MAX] - rfn_dir_len, temp);
 				if (temp)
 					state.rfn_len = temp
 						- state.real_filename - 1;
 			}
 			free(rfn);
 			rfn = NULL;
 #ifdef __OpenBSD__
 			if (unveil(state.real_filename, "rwc") < 0)
 			{
 				perror(PROGRAM_NAME ": unveil");
 				goto main_done;
 			}
 #endif
 			if (stat(state.real_filename, &st) == -1)
 				goto main_done;
 		}
 	} /* We don't error out here on ENOENT to account for new files */
 	else if (errno == ENOENT)
 		state.new_file = 1;
 	else
 		goto main_done;
 
 	if (!(state.backup_filename = malloc(limits[L_PATH_MAX])))
 	{
 		perror(PROGRAM_NAME ": malloc");
 		goto main_done;
 	}
 
 	/* Backup filename is the target file + suffix if the file to
 	 * write is not a new file and is a symlink, otherwise file +
 	 * suffix */
 	MEMCCPY(state.backup_filename,
 		state.new_file ? state.filename
 			       : (state.rfn_len > 0 ? state.real_filename
 						    : state.filename),
 		limits[L_PATH_MAX], temp);
 	if (!temp) /* filename is full, turning off backups */
 		state.backup_possible = 0;
 	else
 		MEMCCPY_EXT((temp - 1), state.backup_filename, backup_suffix,
 			limits[L_PATH_MAX] + temp - state.backup_filename,
 			temp);
 #ifdef __OpenBSD__
 	if (unveil(state.backup_filename, "rwc") < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 #endif
 
 main_skip_backups:
 	if (state.rfn_len > 0)
 	{
 		if (!(pdir = realloc(dir, limits[L_PATH_MAX])))
 		{
 			perror(PROGRAM_NAME ": realloc");
 			goto main_done;
 		}
 		dir  = pdir;
 		*dir = 0;
 		(void)dirname(dir, state.real_filename, limits[L_PATH_MAX]);
 #ifdef __OpenBSD__
 		if (unveil(dir, "rwc") < 0)
 		{
 			perror(PROGRAM_NAME ": unveil");
 			goto main_done;
 		}
 #endif
 	}
 
 #ifdef __OpenBSD__
 	if (unveil_terminfo_path() < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 	/* Have to explicitly unveil /dev/tty before tb_init despite pledge(tty)
 	 * in OpenBSD 7.9+
 	 */
 	if (unveil("/dev/tty", "rw"))
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 	if (unveil(NULL, NULL) < 0)
 	{
 		perror(PROGRAM_NAME ": unveil");
 		goto main_done;
 	}
 #endif
 
 	dir_access	 = access(dir, W_OK | X_OK);
 	dir_access_errno = errno;
 
 	if (!backup_fail && state.backup_possible)
 		state.backup_possible = dir_access != -1;
 
 	result = stat(state.filename, &st);
 	if (result == -1)
 	{
 		if (errno != ENOENT || dir_access == -1)
 		{
 			errno = dir_access_errno;
 			goto main_done;
 		}
 		if (create_file(&state))
 			goto main_done;
 
 		goto init_termbox;
 	}
 
 	errno = 0;
 
 	if (!S_ISREG(st.st_mode))
 	{
 		state.error = ERR_NOTREG_FILE;
 		goto main_done;
 	}
 
 	if (access(state.filename, F_OK | R_OK | W_OK) == -1)
 		goto main_done;
 
 	if (state.rfn_len > 0
 		&& access(state.real_filename, F_OK | R_OK | W_OK) == -1)
 		goto main_done;
 
 	if (load_file(&state))
 		goto main_done;
 
 	goto init_termbox;
 
 init_termbox:
 	tbires = 0;
 	if ((tbires = tb_init()))
 	{
 		saved_tb_error = tb_strerror(tbires);
 		errno	       = ERR_TB_ERROR;
 		goto main_done;
 	}
 
 	errno		       = 0;
 	state.maxx	       = 0;
 	state.recalculate_size = 1;
 
 	while (state.running)
 	{
 		tb_set_clear_attrs(colors[C_TEXT].fg, colors[C_TEXT].bg);
 		tb_clear();
 
 		if (state.recalculate_size)
 		{
 			recalculate_size(&state);
 			state.recalculate_size = 0;
 		}
 		if (draw(&state))
 		{
 			state.running = 0;
 			goto main_done;
 		}
 		tb_present();
 		result = tb_poll_event(&ev);
 		if (result == TB_OK && ev.type == TB_EVENT_RESIZE)
 			state.recalculate_size = 1;
 		else if (result == TB_OK && ev.type == TB_EVENT_KEY)
 			handle_key_event(&ev, &state);
 	}
 
 main_done:
 	saved_errno = errno;
 
 	if (saved_tb_error)
 	{
 		tb_shutdown(1);
 		print_error(1, saved_tb_error);
 		exit(CUSTOM_ERROR_START + saved_errno);
 	}
 
 	tb_shutdown(saved_errno != ENOMEM);
 
 	if (saved_errno)
 		perror(PROGRAM_NAME);
 
 	if (state.error == ERR_NOTREG_FILE)
 		print_error(1, errors[state.error], state.filename);
 	else if (state.error)
 		print_error(1, errors[state.error]);
 	/*free_drawstate(&state);
 	free(wd);
 	free(dir);
 	free(rfn);*/
 	return saved_errno
 		? saved_errno
 		: (state.error ? CUSTOM_ERROR_START + state.error : 0);
 }