poe

poe.c (71633B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <locale.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) 2021-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 POE_C_GLOBALS
 #define TB_IMPL
 
 /* Order is important! */
 #include "draw.h"
 #include "poe.h"
 #include "config.h"
 #include "limit.h"
 #include "po.h"
 #include "strtonum.h"
 #include "util.h"
 #include "version.h"
 
 #define MAXCOPYBUF 8192
 
 extern const char* errors[];
 extern const char* actions[];
 extern const char* prompt_dirty;
 extern const char* prompt_edit_dirty;
 extern const char* prompt_overwrite;
 
 static int
 cancel_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 0;
 		save_msgstr(state);
 	}
 	else /* not saving */
 	{
 		state->edit_dirty = 0;
 		cancel_msgstr(state);
 	}
 	return 0;
 }
 
 static int
 cancel_close(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (!state->error && state->in_prompt)
 	{
 		state->in_prompt = 0;
 		*state->prompt	 = 0;
 	}
 	else if (state->show_help)
 		state->show_help = 0;
 	else if (state->show_edit)
 		cancel_msgstr(state);
 	else if (state->show_search)
 		cancel_search(state);
 	else
 		state->error = ERR_EXIT_KEY;
 	return 0;
 }
 
 static int
 cancel_msgstr(struct DrawState* state)
 {
 	char* temp = NULL;
 	ssize_t i;
 
 	assert(state != NULL);
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = cancel_callback;
 		return 0;
 	}
 
 	state->show_edit	 = 0;
 	state->reshow_edit	 = 0;
 	state->edit_info_focused = 0;
 
 	for (i = 0; i < state->input_rows_count; i++)
 		free_bufferline(state->input_buffer + i);
 	free(state->input_buffer);
 	state->input_buffer	= NULL;
 	state->input_rows_count = 0;
 	if (state->info_buffer)
 		for (i = 0; i < state->info_rows_count; i++)
 			free_bufferline(&state->info_buffer[i]);
 	free(state->info_buffer);
 	state->info_buffer     = NULL;
 	state->info_rows_count = 0;
 	state->fuzzy_count     = state->fuzzy_before_edit;
 	switch (state->input_changed_fuzzy)
 	{
 	case SET:
 		state->entries[state->msgid_number - 1].flags &= ~FL_FUZZY;
 		break;
 	case CLEARED:
 		state->entries[state->msgid_number - 1].flags |= FL_FUZZY;
 		break;
 	default:;
 	}
 	state->input_changed_fuzzy = UNCHANGED;
 	tb_hide_cursor();
 	return 0;
 }
 
 static int
 cancel_search(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->show_search = 0;
 	*state->search	   = 0;
 	tb_hide_cursor();
 	return 0;
 }
 
 static int
 copy_msgid_to_input(struct DrawState* state)
 {
 	struct PoEntry* current;
 	struct BufferLine* newbuf;
 	struct BufferLine* pbuffer;
 	const uint32_t* pmsgid;
 	const uint32_t* old_pmsgid;
 	uint32_t* newtext;
 	char* temp = NULL;
 	ssize_t msgid_num_lines, lines_to_init, lines_to_free, i, len, newlen;
 
 	assert(state != NULL);
 
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 0;
 	}
 
 	if (!state->in_prompt && *state->input_buffer->text)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_overwrite, LINE_DEFAULT, temp);
 		state->prompt_callback = overwrite_copy_msgid_callback;
 		return 0;
 	}
 
 	if (state->msgid_number == 1)
 	{
 		state->error = ERR_ILLEGAL_ON_FIRST;
 		return 0;
 	}
 
 	assert(state->entries != NULL);
 	current		= &state->entries[state->msgid_number - 1];
 	msgid_num_lines = u32_lines_in_string(current->msgid, 0, 0);
 	lines_to_init	= state->input_rows_count < msgid_num_lines
 		  ? msgid_num_lines - state->input_rows_count
 		  : 0;
 	lines_to_free	= state->input_rows_count > msgid_num_lines
 		  ? state->input_rows_count - msgid_num_lines
 		  : 0;
 	for (i = 0; i < lines_to_free; i++)
 		free_bufferline(
 			state->input_buffer + state->input_rows_count - i - 1);
 	newbuf = realloc(state->input_buffer,
 		msgid_num_lines * sizeof(struct BufferLine));
 	pmsgid = current->msgid;
 
 	if (!newbuf)
 		return 0;
 
 	pbuffer = NULL;
 	for (i = 0; i < lines_to_init; i++)
 	{
 		pbuffer = newbuf + msgid_num_lines - 1 - i;
 		init_bufferline(pbuffer);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 			return 0;
 		pbuffer->text = newtext;
 	}
 
 	pbuffer = newbuf;
 	while (pmsgid && *pmsgid)
 	{
 		old_pmsgid = pmsgid;
 		len	   = u32_next_line(current->msgid, &pmsgid, 0, 0);
 		u32_strncpy(pbuffer->text, old_pmsgid,
 			MIN(len + 1, LINE_DEFAULT));
 		newlen = u32_decode_tabs(state, pbuffer->text, LINE_DEFAULT);
 		pbuffer->length = newlen;
 		pbuffer++;
 	}
 
 	state->input_rows_count = msgid_num_lines;
 	state->input_buffer	= newbuf;
 	state->edit_dirty	= 1;
 
 	return 0;
 }
 
 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 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
 edit_page_down(struct DrawState* state)
 {
 	char* temp = NULL;
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.row + (EDIT_HEIGHT - 3) / 2
 			< state->info_rows_count - 1)
 			state->info_first_shown.row += (EDIT_HEIGHT - 3) / 2;
 		return 0;
 	}
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = edit_page_down_callback;
 		return 0;
 	}
 	move_list_down(state);
 	state->msgstr_index = 0;
 	return show_edit(state);
 }
 
 static int
 edit_page_down_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return edit_page_down(state);
 }
 
 static int
 edit_page_up(struct DrawState* state)
 {
 	char* temp = NULL;
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.row > (EDIT_HEIGHT - 3) / 2)
 			state->info_first_shown.row -= (EDIT_HEIGHT - 3) / 2;
 		else
 			move_start(state);
 		return 0;
 	}
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = edit_page_up_callback;
 		return 0;
 	}
 	move_list_up(state);
 	state->msgstr_index = 0;
 	return show_edit(state);
 }
 
 static int
 edit_page_up_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return edit_page_up(state);
 }
 
 static int
 erase_backwards(struct DrawState* state)
 {
 	struct BufferLine* buffer_line;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	buffer_line = &state->input_buffer[state->coord.row];
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	if (state->coord.col > 0)
 	{
 		ssize_t i = state->coord.col;
 		assert(buffer_line->text != NULL);
 		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->edit_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;
 	size_t i;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	buffer_line = &state->input_buffer[state->coord.row];
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	assert(buffer_line->text != NULL);
 	if (buffer_line->text[state->coord.col])
 	{
 		i = state->coord.col;
 		while (i < LINE_DEFAULT - 2 && buffer_line->text[i + 1])
 		{
 			buffer_line->text[i] = buffer_line->text[i + 1];
 			i++;
 		}
 		buffer_line->text[i] = 0;
 		buffer_line->length--;
 		state->edit_dirty = 1;
 	}
 	else if (state->coord.row < state->input_rows_count - 1)
 	{
 		if (join_lines(state))
 		{
 			state->error   = ERR_CANT_ALLOC;
 			state->running = 0;
 			return 1;
 		}
 	}
 	return 0;
 }
 
 static int
 erase_prev_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i, j, d;
 
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 	i     = state->coord.col;
 	len   = state->input_buffer[state->coord.row].length;
 	pline = state->input_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 < len - d; j++)
 		pline[j] = pline[j + d];
 
 	len -= d;
 	state->input_buffer[state->coord.row].length = len;
 	pline[len]				     = 0;
 	state->coord.col			     = i;
 	state->input_display_column = display_length(pline, state->coord.col);
 	if (state->input_display_column < state->input_first_shown.col)
 		state->input_first_shown.col = state->input_display_column;
 	state->edit_dirty = 1;
 	return 0;
 }
 
 static int
 erase_search_backwards(struct DrawState* state)
 {
 	size_t i;
 	assert(state != NULL);
 	if (state->search_column > 0)
 	{
 		i = state->search_column;
 		do
 		{
 			state->search[i - 1] = state->search[i];
 			i++;
 		} while (state->search[i]);
 		state->search[i - 1] = 0;
 		search_position_to(state, state->search_column - 1);
 		return next_match(state);
 	}
 	return 0;
 }
 
 static int
 erase_search_forward(struct DrawState* state)
 {
 	size_t i;
 	assert(state != NULL);
 	if (state->search[state->search_column])
 	{
 		i = state->search_column;
 		while (i < MAXSEARCH - 2 && state->search[i + 1])
 		{
 			state->search[i] = state->search[i + 1];
 			i++;
 		}
 		state->search[i] = 0;
 
 		return next_match(state);
 	}
 	return 0;
 }
 
 static int
 erase_search_prev_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i, j, d;
 
 	assert(state != NULL);
 	pline = state->search;
 	len   = u32_strlen(state->search);
 	i     = state->search_column;
 	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->search_column - i;
 
 	for (j = i; j < len - d; j++)
 		pline[j] = pline[j + d];
 
 	len -= d;
 	pline[len] = 0;
 	search_position_to(state, i);
 	return next_match(state);
 }
 
 static int
 erase_search_to_end(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->search[state->search_column] = 0;
 	move_search_end(state);
 	return next_match(state);
 }
 
 static int
 erase_search_to_start(struct DrawState* state)
 {
 	size_t i, len;
 
 	assert((state != NULL) && (state->search != NULL));
 	i   = state->search_column;
 	len = u32_strlen(state->search);
 	do
 	{
 		assert(i < MAXSEARCH);
 		state->search[i - state->search_column] = state->search[i];
 		i++;
 	} while (state->search[i]);
 	state->search[len - state->search_column] = 0;
 	move_search_start(state);
 	return next_match(state);
 }
 
 static int
 erase_to_end(struct DrawState* state)
 {
 	struct BufferLine* buffer_line = NULL;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	buffer_line = &state->input_buffer[state->coord.row];
 	assert(buffer_line->text != NULL);
 	buffer_line->text[state->coord.col] = 0;
 	buffer_line->length		    = state->coord.col;
 	move_end(state);
 	state->edit_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) && (state->input_buffer != NULL));
 	i	    = state->coord.col;
 	buffer_line = &state->input_buffer[state->coord.row];
 	len	    = buffer_line->length;
 
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	do
 	{
 		assert(i <= len);
 		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->edit_dirty = 1;
 	return 0;
 }
 
 static int
 exit_program(struct DrawState* state)
 {
 	char* temp = NULL;
 
 	assert(state != NULL);
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = quit_callback;
 	}
 	else if (state->dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = quit_callback;
 	}
 	else
 		state->running = 0;
 	state->error = ERR_NONE;
 	return 0;
 }
 
 static void
 goto_msgid(struct DrawState* state, const ssize_t msgid_number)
 {
 	ssize_t last_non_obsolete;
 
 	assert(state != NULL);
 	last_non_obsolete
 		= state->real_msgid_count - state->obsolete_at_end_count;
 	if (msgid_number > state->real_msgid_count)
 		return;
 
 	state->msgid_number = msgid_number;
 
 	if (state->msgid_number < state->first_shown_msgid)
 		state->first_shown_msgid = state->msgid_number;
 	else if (state->msgid_number
 		> state->first_shown_msgid + state->maxy - 2)
 		state->first_shown_msgid
 			= state->msgid_number - (state->maxy - 2);
 	else if (last_non_obsolete < state->msgid_number + state->maxy - 2)
 		state->first_shown_msgid = (last_non_obsolete > state->maxy - 2
 				? last_non_obsolete - (state->maxy - 2)
 				: 1);
 }
 
 static void
 handle_key_event(struct tb_event* ev, struct DrawState* state)
 {
 	const struct Key* current = NULL;
 	size_t key;
 
 	assert((state != NULL) && (ev != NULL));
 	state->error = ERR_NONE;
 	errno	     = 0;
 
 	if (state->in_prompt)
 	{
 		if (ev->ch && strchr("YyNn", ev->ch))
 		{
 			if (state->prompt_callback)
 			{
 				state->prompt_callback(state, ev);
 				state->prompt_callback = NULL;
 			}
 			state->in_prompt = 0;
 			*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
 		&& state->show_edit)
 		state->saved_column = -1;
 
 	for (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 (state->show_edit)
 	{
 		for (key = 0; key < LEN(edit_keys); key++)
 		{
 			current = &edit_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 (state->edit_info_focused)
 		{
 			state->error = ERR_DLG_FOCUS_EDIT;
 			return;
 		}
 		if (ev->ch)
 		{
 			insert_char(state, ev->ch);
 			return;
 		}
 	}
 
 	if (state->show_search)
 	{
 		for (key = 0; key < LEN(search_keys); key++)
 		{
 			current = &search_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_search_char(state, ev->ch);
 			return;
 		}
 	}
 
 	if (state->show_help)
 	{
 		for (key = 0; key < LEN(help_keys); key++)
 		{
 			current = help_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;
 				}
 		}
 
 		state->error = ERR_DLG_OPEN;
 		return;
 	}
 
 	if (state->show_search || state->show_edit)
 	{
 		state->error = ERR_DLG_OPEN_QUIT;
 		return;
 	}
 
 	for (key = 0; key < LEN(main_keys); key++)
 	{
 		current = &main_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 (state->edit_info_focused)
 		state->error = ERR_DLG_FOCUS_EDIT;
 	else if (state->show_edit || state->show_search)
 		state->error = ERR_UNKNOWN_KEY;
 	else
 		state->error = ERR_UNKNOWN_KEY_HELP;
 }
 
 static int
 hide_search(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->show_search = 0;
 	tb_hide_cursor();
 	return 0;
 }
 
 static int
 insert_char(struct DrawState* state, uint32_t ch)
 {
 	struct BufferLine* buffer_line;
 	uint32_t* temp = NULL;
 	ssize_t i, len, size;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->edit_info_focused)
 		return 1;
 
 	ENSURE_SIZE(state->input_buffer[state->coord.row].text, temp,
 		state->input_buffer[state->coord.row].size,
 		state->input_buffer[state->coord.row].length + 2,
 		state->input_buffer[state->coord.row].size + LINE_ALLOC_DELTA,
 		insert_char_alloc_error, uint32_t);
 
 	buffer_line = &state->input_buffer[state->coord.row];
 	len	    = buffer_line->length;
 	size	    = buffer_line->size;
 	i	    = len;
 
 	assert(buffer_line->text != NULL);
 	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;
 	buffer_line->length++;
 	position_to(state, state->coord.row, state->coord.col + 1);
 	buffer_line->text[buffer_line->length] = 0;
 
 	state->edit_dirty = 1;
 	return 0;
 
 insert_char_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 insert_line(struct DrawState* state)
 {
 	struct BufferLine* newbuf = NULL;
 	struct BufferLine* line	  = NULL;
 	uint32_t* newtext	  = NULL;
 	uint32_t* ptext		  = NULL;
 	ssize_t i;
 
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	assert(state != NULL);
 	newbuf = realloc(state->input_buffer,
 		(state->input_rows_count + 1) * sizeof(struct BufferLine));
 	if (!newbuf)
 		goto insert_line_alloc_error;
 	state->input_buffer = newbuf;
 	line		    = &state->input_buffer[state->input_rows_count];
 	init_bufferline(line);
 	newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 	if (!newtext)
 		goto insert_line_alloc_error;
 	line->text = newtext;
 	line->size = LINE_DEFAULT;
 	state->input_rows_count++;
 	for (i = state->input_rows_count - 1; i > state->coord.row + 1; i--)
 	{
 		U32_SAFE_COPY(state->input_buffer[i].text, ptext,
 			state->input_buffer[i].size,
 			state->input_buffer[i - 1].text,
 			state->input_buffer[i].size, insert_line_alloc_error);
 		state->input_buffer[i].length
 			= state->input_buffer[i - 1].length;
 	}
 	ENSURE_SIZE(state->input_buffer[state->coord.row + 1].text, ptext,
 		state->input_buffer[state->coord.row + 1].size, LINE_DEFAULT,
 		LINE_DEFAULT, insert_line_alloc_error, uint32_t);
 	*state->input_buffer[state->coord.row + 1].text = 0;
 	if (state->coord.col < state->input_buffer[state->coord.row].length)
 		U32_SAFE_COPY(state->input_buffer[state->coord.row + 1].text,
 			ptext, state->input_buffer[state->coord.row + 1].size,
 			state->input_buffer[state->coord.row].text
 				+ state->coord.col,
 			state->input_buffer[state->coord.row].size,
 			insert_line_alloc_error);
 	state->input_buffer[state->coord.row + 1].length
 		= state->input_buffer[state->coord.row].length
 		- state->coord.col;
 	state->input_buffer[state->coord.row].text[state->coord.col] = 0;
 	state->input_buffer[state->coord.row].length = state->coord.col;
 
 	state->saved_column = -1;
 	state->coord.row++;
 	if (state->coord.row
 		> state->input_first_shown.row + (EDIT_HEIGHT - 3) / 2)
 		state->input_first_shown.row
 			= state->coord.row - (EDIT_HEIGHT - 3) / 2;
 	move_start(state);
 	state->edit_dirty = 1;
 	return 0;
 
 insert_line_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 insert_search_char(struct DrawState* state, uint32_t ch)
 {
 	ssize_t len, i;
 	int add_null;
 	assert(state != NULL);
 	len = u32_strlen(state->search);
 	if (state->search_column + 1 < MAXSEARCH)
 	{
 		i	 = len + 1;
 		add_null = state->search[state->search_column] == 0;
 		while (i + 2 < MAXSEARCH && i > state->search_column)
 		{
 			state->search[i] = state->search[i - 1];
 			i--;
 		}
 		state->search[state->search_column++] = ch;
 		if (state->search_column == MAXSEARCH)
 			state->search_column = MAXSEARCH - 1;
 		state->search_display_column
 			= display_length(state->search, state->search_column);
 		if (state->search_display_column
 				- state->search_first_shown_column
 			> state->search_width - 4)
 		{
 			state->search_first_shown_column
 				= state->search_display_column
 				- state->search_width + 4;
 			state->search_display_column
 				= display_length(state->search,
 					state->search_column);
 		}
 		if (add_null)
 			state->search[state->search_column] = 0;
 
 		next_match(state);
 	}
 	return 0;
 }
 
 static int
 insert_search_space(struct DrawState* state)
 {
 	return insert_search_char(state, SPACE);
 }
 
 static int
 insert_search_tab(struct DrawState* state)
 {
 	return insert_search_char(state, TAB);
 }
 
 static int
 insert_space(struct DrawState* state)
 {
 	return insert_char(state, SPACE);
 }
 
 static int
 insert_tab(struct DrawState* state)
 {
 	return insert_char(state, TAB);
 }
 
 static int
 join_lines(struct DrawState* state)
 {
 	struct BufferLine* first_line = NULL;
 	struct BufferLine* next_line  = NULL;
 	uint32_t* ptext		      = NULL;
 	ssize_t i;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->coord.row + 1 == state->input_rows_count)
 		return 1;
 
 	first_line = &state->input_buffer[state->coord.row];
 	next_line  = &state->input_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,
 		join_lines_alloc_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);
 	for (i = state->coord.row + 1; i + 1 < state->input_rows_count; i++)
 	{
 		U32_SAFE_COPY(state->input_buffer[i].text, ptext,
 			state->input_buffer[i].size,
 			state->input_buffer[i + 1].text,
 			state->input_buffer[i + 1].size,
 			join_lines_alloc_error);
 		state->input_buffer[i].length
 			= state->input_buffer[i + 1].length;
 	}
 	free_bufferline(&state->input_buffer[state->input_rows_count - 1]);
 	state->input_rows_count--;
 	state->edit_dirty = 1;
 	return 0;
 
 join_lines_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info(struct DrawState* state)
 {
 	struct PoEntry* first	   = NULL;
 	struct PoEntry* current	   = NULL;
 	struct BufferLine* newbuf  = NULL;
 	struct BufferLine* pnewbuf = NULL;
 	uint32_t* newtext	   = NULL;
 	ssize_t msgid_num_lines, msgid_plural_num_lines, num_lines, i;
 
 	assert((state != NULL) && (state->entries != NULL));
 	first		= &state->entries[0];
 	current		= &state->entries[state->msgid_number - 1];
 	msgid_num_lines = u32_lines_in_string(current->msgid, 0, 0);
 	msgid_plural_num_lines
 		= u32_lines_in_string(current->msgid_plural, 0, 0);
 	num_lines = 0;
 
 	for (i = 0; i < state->info_rows_count; i++)
 		free_bufferline(&state->info_buffer[i]);
 	free(state->info_buffer);
 
 	state->info_maxlen = 0;
 
 	if (current->msgid)
 		num_lines += msgid_num_lines + 1;
 	if (current->msgid_plural)
 	{
 		num_lines += msgid_plural_num_lines + 1;
 		if (first->plural_forms)
 			num_lines += 2; /* title + plural_forms */
 	}
 	if (current->comments)
 		num_lines += current->comment_lines + 1;
 	if (current->extr_comments)
 		num_lines += current->extr_comment_lines + 1;
 	if (current->ref_comments)
 		num_lines += current->ref_comment_lines + 1;
 	newbuf = calloc(num_lines, sizeof(struct BufferLine));
 	if (!newbuf)
 		goto load_info_alloc_error;
 
 	pnewbuf = newbuf;
 	for (i = 0; i < num_lines; i++)
 	{
 		init_bufferline(pnewbuf);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 			goto load_info_alloc_error;
 		pnewbuf->text = newtext;
 		pnewbuf->size = LINE_DEFAULT;
 		pnewbuf->size = 0;
 		pnewbuf++;
 	}
 
 	state->info_rows_count = num_lines;
 
 	pnewbuf = newbuf;
 
 	if (current->msgid)
 		if (load_info_msgid(state, &pnewbuf))
 			return 1;
 
 	if (current->msgid_plural)
 		if (load_info_msgid_plural(state, &pnewbuf))
 			return 1;
 
 	if (current->comments)
 		if (load_info_comments(state, &pnewbuf))
 			return 1;
 
 	if (current->extr_comments)
 		if (load_info_extr_comments(state, &pnewbuf))
 			return 1;
 
 	if (current->ref_comments)
 		if (load_info_ref_comments(state, &pnewbuf))
 			return 1;
 
 	state->info_buffer = newbuf;
 	return 0;
 
 load_info_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info_comments(struct DrawState* state, struct BufferLine** lines)
 {
 	struct PoEntry* current = NULL;
 	uint32_t* comment	= NULL;
 	uint32_t* ptext		= NULL;
 	ssize_t len, llen, size, i;
 
 	current = &state->entries[state->msgid_number - 1];
 	ptext	= u32_u8_memccpy((*lines)->text, "Comments:", 0, LINE_DEFAULT);
 	(*lines)->length = llen
 		= ptext ? ptext - (*lines)->text : LINE_DEFAULT - 1;
 	(*lines)->size = LINE_DEFAULT;
 	if (llen > state->info_maxlen)
 		state->info_maxlen = llen;
 	(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 	(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 	(*lines)++;
 	for (i = 0; i < current->comment_lines; i++)
 	{
 		comment = current->comments[i];
 		len	= u32_strlen(comment);
 		size	= MAX(len + 2, LINE_DEFAULT); /* + NUL */
 		ENSURE_SIZE((*lines)->text, ptext, (*lines)->size, size, size,
 			load_info_comments_alloc_error, uint32_t);
 		U32_MEMCCPY((*lines)->text, comment, len + 1, ptext);
 		llen = ptext ? ptext - (*lines)->text : (*lines)->size - 1;
 		(*lines)->length = llen;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	return 0;
 
 load_info_comments_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info_extr_comments(struct DrawState* state, struct BufferLine** lines)
 {
 	struct PoEntry* current = NULL;
 	uint32_t* extr_comment	= NULL;
 	uint32_t* ptext		= NULL;
 	ssize_t len, llen, size, i;
 
 	current = &state->entries[state->msgid_number - 1];
 	ptext	= u32_u8_memccpy((*lines)->text, "Translation comments:", 0,
 		  LINE_DEFAULT);
 	(*lines)->length = llen = ptext ? ptext - (*lines)->text : LINE_DEFAULT;
 	(*lines)->size		= MAX(llen + 1, LINE_DEFAULT);
 	if (llen > state->info_maxlen)
 		state->info_maxlen = llen;
 	(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 	(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 	(*lines)++;
 	for (i = 0; i < current->extr_comment_lines; i++)
 	{
 		extr_comment = current->extr_comments[i];
 		len	     = u32_strlen(extr_comment);
 		size	     = MAX(len + 2, LINE_DEFAULT); /* + NUL */
 		ENSURE_SIZE((*lines)->text, ptext, (*lines)->size, size, size,
 			load_info_extr_comments_alloc_error, uint32_t);
 		U32_MEMCCPY((*lines)->text, extr_comment, len + 1, ptext);
 		/*len = ptext ? ptext - (*lines)->text : (*lines)->size - 1;*/
 		(*lines)->length = llen;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	return 0;
 
 load_info_extr_comments_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info_msgid(struct DrawState* state, struct BufferLine** lines)
 {
 	struct PoEntry* current	    = NULL;
 	const uint32_t* pumsgid	    = NULL;
 	const uint32_t* old_pumsgid = NULL;
 	uint32_t* ptext		    = NULL;
 	ssize_t len, llen, size;
 
 	current = &state->entries[state->msgid_number - 1];
 	ptext	= u32_u8_memccpy((*lines)->text, "msgid:", 0, LINE_DEFAULT);
 	(*lines)->length = llen = ptext ? ptext - (*lines)->text : LINE_DEFAULT;
 	if (llen > state->info_maxlen)
 		state->info_maxlen = llen;
 	(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 	(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 	(*lines)++;
 	pumsgid = current->msgid;
 	while (*pumsgid)
 	{
 		old_pumsgid = pumsgid;
 		len	    = u32_next_line(current->msgid, &pumsgid, 0, 0);
 		size	    = MAX(len + 2, LINE_DEFAULT); /* + NUL */
 		ENSURE_SIZE((*lines)->text, ptext, (*lines)->size, size, size,
 			load_info_msgid_alloc_error, uint32_t);
 		U32_MEMCCPY((*lines)->text, old_pumsgid, len + 1, ptext);
 		llen = u32_decode_tabs(state, (*lines)->text, len + 1);
 		(*lines)->length = llen;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	return 0;
 
 load_info_msgid_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info_msgid_plural(struct DrawState* state, struct BufferLine** lines)
 {
 	struct PoEntry* current	    = NULL;
 	struct PoEntry* first	    = NULL;
 	const uint32_t* old_pumsgid = NULL;
 	const uint32_t* pumsgid	    = NULL;
 	uint32_t* ptext		    = NULL;
 	ssize_t len, llen, size;
 
 	first	= &state->entries[0];
 	current = &state->entries[state->msgid_number - 1];
 	ptext = u32_u8_memccpy((*lines)->text, "msgid_plural:", 0, LINE_DEFAULT);
 	(*lines)->length = llen = ptext ? ptext - (*lines)->text : LINE_DEFAULT;
 	if (llen > state->info_maxlen)
 		state->info_maxlen = llen;
 	(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 	(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 	(*lines)++;
 	pumsgid = current->msgid_plural;
 	while (*pumsgid)
 	{
 		old_pumsgid = pumsgid;
 		len  = u32_next_line(current->msgid_plural, &pumsgid, 0, 0);
 		size = MAX(len + 2, LINE_DEFAULT);
 		ENSURE_SIZE((*lines)->text, ptext, (*lines)->size, size, size,
 			load_info_msgid_plural_alloc_error, uint32_t);
 		U32_MEMCCPY((*lines)->text, old_pumsgid, len + 1, ptext);
 		llen		 = u32_decode_tabs(state, (*lines)->text, size);
 		(*lines)->length = llen;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	if (first->plural_forms)
 	{
 		ptext = u32_u8_memccpy((*lines)->text, "Plural forms:", 0,
 			LINE_DEFAULT);
 		(*lines)->length = llen
 			= ptext ? ptext - (*lines)->text : LINE_DEFAULT - 1;
 		(*lines)->size = LINE_DEFAULT;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 		(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 		(*lines)++;
 		U32_SAFE_COPY((*lines)->text, ptext, (*lines)->size,
 			first->plural_forms, first->plural_forms_size,
 			load_info_msgid_plural_alloc_error);
 		(*lines)->length = llen
 			= ptext ? ptext - (*lines)->text : (*lines)->size - 1;
 		//(*lines)->size = MAX(llen + 1, LINE_DEFAULT);
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	return 0;
 
 load_info_msgid_plural_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_info_ref_comments(struct DrawState* state, struct BufferLine** lines)
 {
 	struct PoEntry* current = NULL;
 	uint32_t* ptext		= NULL;
 	char* ref_comment	= NULL;
 	ssize_t len, llen, size, i;
 
 	current = &state->entries[state->msgid_number - 1];
 	ptext = u32_u8_memccpy((*lines)->text, "References:", 0, LINE_DEFAULT);
 	(*lines)->length = llen = ptext ? ptext - (*lines)->text : LINE_DEFAULT;
 	(*lines)->size		= MAX(llen + 1, LINE_DEFAULT);
 	if (llen > state->info_maxlen)
 		state->info_maxlen = llen;
 	(*lines)->fg = colors[C_EDIT_MSGID_HEADING].fg;
 	(*lines)->bg = colors[C_EDIT_MSGID_HEADING].bg;
 	(*lines)++;
 	for (i = 0; i < current->ref_comment_lines; i++)
 	{
 		ref_comment = current->ref_comments[i];
 		len	    = strlen(ref_comment);
 		size	    = MAX(len + 2, LINE_DEFAULT); /* + NUL */
 		ENSURE_SIZE((*lines)->text, ptext, (*lines)->size, size, size,
 			load_info_ref_comments_alloc_error, uint32_t);
 		U32_U8_MEMCCPY((*lines)->text, ref_comment, len + 1, ptext);
 		llen = ptext ? ptext - (*lines)->text : LINE_DEFAULT;
 		(*lines)->length = llen;
 		if (llen > state->info_maxlen)
 			state->info_maxlen = llen;
 		(*lines)++;
 	}
 	return 0;
 
 load_info_ref_comments_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 load_msgstr(struct DrawState* state)
 {
 	struct PoEntry* current;
 	struct BufferLine* newbuf;
 	struct BufferLine* pnewbuf;
 	const uint32_t* old_pumsgstr = NULL;
 	const uint32_t* pumsgstr     = NULL;
 	uint32_t* newtext	     = NULL;
 	uint32_t* temp		     = NULL;
 	ssize_t num_lines, i, len, newlen, size, row;
 	int msgstr_index;
 
 	assert((state != NULL) && (state->entries != NULL));
 	current	     = &state->entries[state->msgid_number - 1];
 	newbuf	     = NULL;
 	pnewbuf	     = NULL;
 	msgstr_index = state->msgstr_index;
 	num_lines    = current->msgstr_count == 0
 		   ? 1
 		   : u32_lines_in_string(current->msgstr[msgstr_index], 0, 0);
 
 	for (row = 0; row < state->input_rows_count; row++)
 		free_bufferline(&state->input_buffer[row]);
 	free(state->input_buffer);
 
 	newbuf = calloc(num_lines, sizeof(struct BufferLine));
 	if (!newbuf)
 		goto load_msgstr_alloc_error;
 
 	pnewbuf = newbuf;
 	for (i = 0; i < num_lines; i++)
 	{
 		init_bufferline(pnewbuf);
 		assert(current->msgstr_size != NULL);
 		size	= MAX(current->msgstr_size[msgstr_index], LINE_DEFAULT);
 		newtext = calloc(size, sizeof(uint32_t));
 		if (!newtext)
 			goto load_msgstr_alloc_error;
 		pnewbuf->text	= newtext;
 		pnewbuf->size	= size;
 		pnewbuf->length = 0;
 		pnewbuf++;
 	}
 	state->input_rows_count = num_lines;
 
 	if (current->msgstr_count > 0)
 	{
 		pumsgstr = current->msgstr[msgstr_index];
 		if (!pumsgstr)
 		{
 			newbuf[0].length = 0;
 			goto load_msgstr_done;
 		}
 		pnewbuf = newbuf;
 		while (*pumsgstr)
 		{
 			old_pumsgstr = pumsgstr;
 			len  = u32_next_line(current->msgstr[msgstr_index],
 				 &pumsgstr, 0, 0);
 			size = MAX(len + 2, LINE_DEFAULT); /* + NUL */
 			ENSURE_SIZE(pnewbuf->text, temp, pnewbuf->size, size,
 				size, load_msgstr_alloc_error, uint32_t);
 			U32_MEMCCPY(pnewbuf->text, old_pumsgstr, len + 1, temp);
 			newlen = u32_decode_tabs(state, pnewbuf->text, len + 1);
 			pnewbuf->length = newlen;
 			pnewbuf++;
 		}
 	}
 	else
 		newbuf[0].length = 0;
 
 load_msgstr_done:
 	state->input_buffer = newbuf;
 	return 0;
 
 load_msgstr_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 move_down(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.row + (EDIT_HEIGHT - 3) / 2
 			< state->info_rows_count)
 			state->info_first_shown.row++;
 		return 0;
 	}
 	position_to(state, state->coord.row + 1, state->coord.col);
 	return 0;
 }
 
 static int
 move_end(struct DrawState* state)
 {
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->edit_info_focused)
 	{
 		if (state->info_maxlen < state->edit_width - 3)
 			state->info_first_shown.col = 0;
 		else
 			state->info_first_shown.col
 				= state->info_maxlen - state->edit_width + 3;
 		return 0;
 	}
 	position_to(state, state->coord.row,
 		state->input_buffer[state->coord.row].length);
 	return 0;
 }
 
 static int
 move_left(struct DrawState* state)
 {
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.col > 0)
 			state->info_first_shown.col--;
 		return 0;
 	}
 	position_to(state, state->coord.row, state->coord.col - 1);
 	return 0;
 }
 
 static int
 move_list_down(struct DrawState* state)
 {
 	assert(state != NULL);
 	goto_msgid(state, next_msgid(state, 1));
 	return 0;
 }
 
 static int
 move_list_end(struct DrawState* state)
 {
 	assert(state != NULL);
 	goto_msgid(state,
 		next_msgid(state,
 			state->real_msgid_count - state->msgid_number));
 	return 0;
 }
 
 static int
 move_list_page_down(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->error = ERR_NONE;
 	goto_msgid(state, next_msgid(state, state->maxy - 2));
 	return 0;
 }
 
 static int
 move_list_page_up(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->error = ERR_NONE;
 	goto_msgid(state, prev_msgid(state, state->maxy - 2));
 	return 0;
 }
 
 static int
 move_list_start(struct DrawState* state)
 {
 	assert(state != NULL);
 	goto_msgid(state, 1);
 	return 0;
 }
 
 static int
 move_list_up(struct DrawState* state)
 {
 	assert(state != NULL);
 	goto_msgid(state, prev_msgid(state, 1));
 	return 0;
 }
 
 static int
 move_next_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	ssize_t len;
 	int i;
 
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	i     = state->coord.col;
 	pline = state->input_buffer[state->coord.row].text;
 	len   = state->input_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_prev_word(struct DrawState* state)
 {
 	uint32_t* pline;
 	int i;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	i     = state->coord.col;
 	pline = state->input_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--;
 
 	position_to(state, state->coord.row, i);
 	return 0;
 }
 
 static int
 move_right(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.col + state->edit_width - 3
 			< state->info_maxlen + 1)
 			state->info_first_shown.col++;
 		return 0;
 	}
 	position_to(state, state->coord.row, state->coord.col + 1);
 	return 0;
 }
 
 static int
 move_search_end(struct DrawState* state)
 {
 	assert(state != NULL);
 	search_position_to(state, u32_strlen(state->search));
 	return 0;
 }
 
 static int
 move_search_left(struct DrawState* state)
 {
 	assert((state != NULL) && (state->search != NULL));
 	if (state->search_column == 0)
 		return 1;
 	search_position_to(state, state->search_column - 1);
 	return 0;
 }
 
 static int
 move_search_next_word(struct DrawState* state)
 {
 	uint32_t* pline = NULL;
 	ssize_t len;
 	int i;
 
 	assert((state != NULL) && (state->search != NULL));
 	i     = state->search_column;
 	pline = state->search;
 	len   = u32_strlen(state->search);
 	while (i < len && !u32_is_word_boundary(pline[i], 0))
 		i++;
 	while (i < len && u32_is_word_boundary(pline[i], 0))
 		i++;
 	search_position_to(state, i);
 	return 0;
 }
 
 static int
 move_search_prev_word(struct DrawState* state)
 {
 	uint32_t* pline = NULL;
 	int i;
 
 	assert((state != NULL) && (state->search != NULL));
 	i     = state->search_column;
 	pline = state->search;
 	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--;
 	search_position_to(state, i);
 	return 0;
 }
 
 static int
 move_search_right(struct DrawState* state)
 {
 	assert(state != NULL);
 	search_position_to(state, state->search_display_column + 1);
 	return 0;
 }
 
 static int
 move_search_start(struct DrawState* state)
 {
 	assert(state != NULL);
 	search_position_to(state, 0);
 	return 0;
 }
 
 static int
 move_start(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		state->info_first_shown.row = 0;
 		state->info_first_shown.col = 0;
 		return 0;
 	}
 	position_to(state, state->coord.row, 0);
 	return 0;
 }
 
 static int
 move_up(struct DrawState* state)
 {
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		if (state->info_first_shown.row > 0)
 			state->info_first_shown.row--;
 		return 0;
 	}
 	position_to(state, state->coord.row > 1 ? state->coord.row - 1 : 0,
 		state->coord.col);
 	return 0;
 }
 
 static int
 next_fuzzy(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	char* temp		= NULL;
 	ssize_t e;
 
 	assert(state != NULL);
 	if (state->msgid_count == 0)
 		return 1;
 
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = next_fuzzy_callback;
 		return 0;
 	}
 
 	for (e = state->msgid_number; e < state->msgid_count; e++)
 	{
 		current = &state->entries[e];
 		if (current->flags & FL_FUZZY)
 		{
 			goto_msgid(state, e + 1);
 			if (state->show_edit)
 			{
 				state->msgstr_index = 0;
 				show_edit(state);
 			}
 			return 0;
 		}
 	}
 	return 0;
 }
 
 static int
 next_fuzzy_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return next_fuzzy(state);
 }
 
 static int
 next_match(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	ssize_t e;
 
 	assert(state != NULL);
 	if (state->msgid_count == 0 || !state->search || !*state->search)
 		return 1;
 
 	for (e = state->msgid_number; e < state->real_msgid_count; e++)
 	{
 		current = state->entries + e;
 		if (current->obsolete)
 			continue;
 		if ((current->msgid && *current->msgid
 			    && u32_strstr(current->msgid, state->search))
 			|| (current->msgstr && *current->msgstr
 				&& **current->msgstr
 				&& u32_strstr(*current->msgstr, state->search)))
 		{
 			goto_msgid(state, e + 1);
 			return 0;
 		}
 	}
 	return 0;
 }
 
 static int
 next_plural(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	char* temp		= NULL;
 	assert((state != NULL) && (state->entries != NULL));
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = next_plural_callback;
 		return 0;
 	}
 	current = &state->entries[state->msgid_number - 1];
 	if (state->msgstr_index + 1 < current->msgstr_count)
 		state->msgstr_index++;
 	show_edit(state);
 	return 0;
 }
 
 static int
 next_plural_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return next_plural(state);
 }
 
 static int
 next_untranslated(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	char* temp		= NULL;
 	ssize_t e;
 
 	assert((state != NULL) && (state->entries != NULL));
 	if (state->msgid_count == 0)
 		return 1;
 
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = next_untranslated_callback;
 		return 0;
 	}
 
 	for (e = state->msgid_number; e < state->msgid_count; e++)
 	{
 		current = state->entries + e;
 		if (!current->msgstr || !*current->msgstr
 			|| u32_strlen(*current->msgstr) == 0)
 		{
 			goto_msgid(state, e + 1);
 			if (state->show_edit)
 			{
 				state->msgstr_index = 0;
 				show_edit(state);
 			}
 			return 0;
 		}
 	}
 	return 0;
 }
 
 static int
 next_untranslated_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return next_untranslated(state);
 }
 
 static size_t
 next_msgid(struct DrawState* state, const int delta)
 {
 	size_t ret, start, last_non_obsolete;
 	assert((state != NULL) && (state->entries != NULL));
 	ret   = state->msgid_number;
 	start = ret;
 	last_non_obsolete
 		= state->real_msgid_count - state->obsolete_at_end_count;
 	while (ret < last_non_obsolete + 1)
 	{
 		ret++;
 		if (!state->entries[ret - 1].obsolete && ret >= start + delta)
 			break;
 	}
 	return ret == last_non_obsolete + 1 ? last_non_obsolete : ret;
 }
 
 static int
 overwrite_copy_msgid_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (ev->ch == 'y')
 		copy_msgid_to_input(state);
 	state->prompt_callback = NULL;
 	return 0;
 }
 
 static int
 overwrite_paste_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (ev->ch == 'y')
 		paste_paste_buffer_to_input(state);
 	state->prompt_callback = NULL;
 	return 0;
 }
 
 static int
 paste_paste_buffer_to_input(struct DrawState* state)
 {
 	struct BufferLine* pinput = NULL;
 	struct BufferLine* newbuf = NULL;
 	struct BufferLine* ppaste = NULL;
 	uint32_t* newtext	  = NULL;
 	uint32_t* utemp		  = NULL;
 	char* temp		  = NULL;
 	ssize_t lines_to_init	  = 0;
 	ssize_t lines_to_free	  = 0;
 	ssize_t i;
 
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 
 	assert(state->input_buffer != NULL);
 	if (!state->in_prompt && *state->input_buffer->text)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_overwrite, LINE_DEFAULT, temp);
 		state->prompt_callback = overwrite_paste_callback;
 		return 0;
 	}
 
 	if (state->msgid_number == 1)
 	{
 		state->error = ERR_ILLEGAL_ON_FIRST;
 		return 1;
 	}
 
 	if (!state->paste || !(*state->paste).text || !*(*state->paste).text)
 	{
 		/* leave one row */
 		for (i = 1; i < state->input_rows_count; i++)
 			free_bufferline(state->input_buffer + i);
 		state->input_buffer = realloc(state->input_buffer,
 			sizeof(struct BufferLine));
 		if (!state->input_buffer)
 			goto paste_paste_buffer_alloc_error;
 		*(state->input_buffer->text) = 0;
 		init_coord(&state->coord, 0, 0);
 		state->input_display_column = 0;
 		init_coord(&state->input_first_shown, 0, 0);
 		state->input_rows_count = 1;
 		state->edit_dirty	= 1;
 		return 0;
 	}
 
 	lines_to_init = state->input_rows_count < state->paste_count
 		? state->paste_count - state->input_rows_count
 		: 0;
 	lines_to_free = state->input_rows_count > state->paste_count
 		? state->input_rows_count - state->paste_count
 		: 0;
 
 	for (i = 0; i < lines_to_free; i++)
 		free_bufferline(
 			state->input_buffer + state->input_rows_count - i - 1);
 	newbuf = realloc(state->input_buffer,
 		state->paste_count * sizeof(struct BufferLine));
 	ppaste = state->paste;
 
 	if (!newbuf)
 		goto paste_paste_buffer_alloc_error;
 
 	for (i = 0; i < lines_to_init; i++)
 	{
 		pinput = newbuf + state->paste_count - 1 - i;
 		init_bufferline(pinput);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 			goto paste_paste_buffer_alloc_error;
 		pinput->text = newtext;
 	}
 
 	if (ppaste)
 		for (i = 0; i < state->paste_count; i++)
 		{
 			pinput = newbuf + i;
 			U32_MEMCCPY(pinput->text, ppaste->text,
 				MIN(ppaste->length + 1, LINE_DEFAULT), utemp);
 			pinput->length = ppaste->length;
 			ppaste++;
 		}
 
 	state->input_rows_count = state->paste_count;
 	state->input_buffer	= newbuf;
 	state->edit_dirty	= 1;
 	return 0;
 
 paste_paste_buffer_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 /*
  * 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;
 
 	assert((state != NULL) && (state->input_buffer != NULL));
 	if (row != state->coord.row)
 	{
 		state->coord.row = row;
 		if ((state->coord.row + 1) > state->input_rows_count)
 			state->coord.row = state->input_rows_count - 1;
 		if (state->coord.row < state->input_first_shown.row)
 			state->input_first_shown.row = state->coord.row;
 		if (state->input_first_shown.row + (EDIT_HEIGHT - 3) / 2
 			< state->coord.row)
 			state->input_first_shown.row
 				= state->coord.row - (EDIT_HEIGHT - 3) / 2;
 		if (state->saved_column == -1)
 		{
 			state->saved_column = state->input_display_column;
 			state->coord.col    = column;
 		}
 		else
 			state->coord.col = buffer_length(
 				state->input_buffer[state->coord.row].text,
 				state->saved_column);
 		if (state->coord.col < 0)
 			state->coord.col = 0;
 		else if (state->coord.col
 			> (int)state->input_buffer[state->coord.row].length)
 			state->coord.col
 				= state->input_buffer[state->coord.row].length;
 		dlen = display_length(state->input_buffer[state->coord.row].text,
 			state->coord.col);
 		if (dlen < state->saved_column)
 			state->input_display_column = dlen;
 		else
 			state->input_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->input_first_shown.row > 0
 					&& state->input_first_shown.row
 						> state->coord.row)
 					state->input_first_shown.row--;
 				state->coord.col
 					= state->input_buffer[state->coord.row]
 						  .length;
 			}
 			else
 				state->coord.col = 0;
 		}
 		else if (state->coord.col
 			> state->input_buffer[state->coord.row].length)
 		{
 			if ((state->coord.row + 1) < state->input_rows_count)
 			{
 				state->coord.row++;
 				if (state->input_first_shown.row
 							+ (state->maxy - 2)
 						< state->coord.row
 					&& state->input_first_shown.row + 1
 						< state->input_rows_count)
 					state->input_first_shown.row++;
 				state->coord.col = 0;
 			}
 			else
 				state->coord.col
 					= state->input_buffer[state->coord.row]
 						  .length;
 		}
 		state->input_display_column
 			= display_length(state->input_buffer[state->coord.row]
 						 .text,
 				state->coord.col);
 		state->saved_column = state->input_display_column;
 	}
 	if (state->input_first_shown.col > state->input_display_column)
 		state->input_first_shown.col = state->input_display_column;
 	if (state->input_first_shown.col + state->edit_width - 4
 		< state->input_display_column)
 	{
 		int index_first;
 		int fsc = state->input_first_shown.col;
 		index_first
 			= buffer_length(state->input_buffer[state->coord.row]
 						.text,
 				fsc);
 		while (fsc + state->edit_width < state->input_display_column + 4)
 		{
 			index_first++;
 			fsc = display_length(state->input_buffer[state->coord.row]
 						     .text,
 				index_first);
 		}
 		state->input_first_shown.col = fsc;
 	}
 }
 
 static int
 prev_match(struct DrawState* state)
 {
 	struct PoEntry* current = NULL;
 	ssize_t e;
 
 	assert(state != NULL);
 	if (state->msgid_count == 0 || !state->search || !*state->search)
 		return 1;
 	for (e = state->msgid_number - 1; e > 0; e--)
 	{
 		current = state->entries + e - 1;
 		if ((current->msgid && *current->msgid
 			    && u32_strstr(current->msgid, state->search))
 			|| (current->msgstr && *current->msgstr
 				&& **current->msgstr
 				&& u32_strstr(*current->msgstr, state->search)))
 		{
 			goto_msgid(state, e);
 			return 0;
 		}
 	}
 	return 0;
 }
 
 static size_t
 prev_msgid(struct DrawState* state, const int delta)
 {
 	ssize_t ret   = state->msgid_number;
 	ssize_t start = ret;
 
 	assert((state != NULL) && (state->entries != NULL));
 	if (start < delta)
 		return state->real_msgid_count ? 1 : 0;
 	while (ret > 1)
 	{
 		ret--;
 		if (!state->entries[ret - 1].obsolete && ret <= start - delta)
 			break;
 	}
 	return ret;
 }
 
 static int
 prev_plural(struct DrawState* state)
 {
 	char* temp = NULL;
 	assert(state != NULL);
 	if (state->edit_info_focused)
 	{
 		state->error = ERR_DLG_FOCUS_EDIT;
 		return 1;
 	}
 	if (state->edit_dirty)
 	{
 		state->in_prompt = 1;
 		MEMCCPY(state->prompt, prompt_edit_dirty, LINE_DEFAULT, temp);
 		state->prompt_callback = prev_plural_callback;
 		return 0;
 	}
 	if (state->msgstr_index > 0)
 		state->msgstr_index--;
 	show_edit(state);
 	return 0;
 }
 
 static int
 prev_plural_callback(struct DrawState* state, struct tb_event* ev)
 {
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 1;
 		save_msgstr(state);
 	}
 	else
 		state->edit_dirty = 0;
 	return prev_plural(state);
 }
 
 int
 print_error(const int code, const char* msg, ...)
 {
 	char* buf = NULL;
 	va_list args;
 	long bufsize;
 	assert((msg != NULL) && (limits != NULL));
 	bufsize = limits[L_LINE_MAX] ? limits[L_LINE_MAX]
 				     : PRINT_BUF_MAX_FALLBACK;
 	buf	= malloc(bufsize);
 	if (!buf)
 		return ERR_CANT_ALLOC;
 	va_start(args, msg);
 	if (vsnprintf(buf, bufsize, msg, args) >= bufsize)
 		buf[bufsize - 1] = 0;
 	va_end(args);
 	fprintf(stderr, "%s: %s\n", PROGRAM_NAME, buf);
 	free(buf);
 	return code;
 }
 
 static int
 quit_callback(struct DrawState* state, struct tb_event* ev)
 {
 	int result = 0;
 	assert((state != NULL) && (ev != NULL));
 	if (strchr("Yy", ev->ch))
 	{
 		state->reshow_edit = 0;
 		if (state->edit_dirty)
 			save_msgstr(state);
 		result = write_file(state);
 	}
 	state->prompt_callback = NULL;
 	state->running	       = 0;
 	return result;
 }
 
 int
 redraw_status(struct DrawState* state)
 {
 	int result = 0;
 	assert(state != NULL);
 	if (state->recalculate_size)
 	{
 		recalculate_size(state);
 		state->recalculate_size = 0;
 	}
 	result = draw_status(state);
 	tb_present();
 	return result;
 }
 
 static int
 save_msgstr(struct DrawState* state)
 {
 	struct BufferLine* pinput_buffer;
 	struct PoEntry* current = NULL;
 	uint32_t* to_save	= NULL;
 	uint32_t* temp		= NULL;
 	uint32_t* temp2		= NULL;
 	size_t to_save_size	= 0;
 	ssize_t i;
 
 	assert(state != NULL);
 	if (state->reshow_edit)
 		state->reshow_edit = 0;
 	else
 		state->show_edit = 0;
 	state->edit_info_focused = 0;
 
 	if (state->input_buffer)
 	{
 		to_save_size = state->input_rows_count * MAXMSGLINE;
 		to_save	     = calloc(to_save_size, sizeof(uint32_t));
 		if (!to_save)
 		{
 			state->error = ERR_CANT_ALLOC;
 			return 1;
 		}
 		pinput_buffer = NULL;
 		for (i = 0; i < state->input_rows_count; i++)
 		{
 			pinput_buffer = &state->input_buffer[i];
 			if (i == 0)
 				U32_MEMCCPY(to_save, pinput_buffer->text,
 					to_save_size * sizeof(uint32_t), temp);
 			else if (temp)
 			{
 				U32_U8_MEMCCPY((temp - 1), "\\n",
 					to_save_size * sizeof(uint32_t), temp2);
 				if (temp2)
 					U32_MEMCCPY((temp2 - 1),
 						pinput_buffer->text,
 						to_save_size * sizeof(uint32_t),
 						temp);
 			}
 			free_bufferline(pinput_buffer);
 		}
 	}
 	free(state->input_buffer);
 	state->input_buffer	= NULL;
 	state->input_rows_count = 0;
 	assert(state->info_buffer != NULL);
 	for (i = 0; i < state->info_rows_count; i++)
 		free_bufferline(&state->info_buffer[i]);
 	free(state->info_buffer);
 	state->dirty	       = 1;
 	state->edit_dirty      = 0;
 	state->info_rows_count = 0;
 	state->info_buffer     = NULL;
 	if (u32_encode_tabs(state, to_save, to_save_size * sizeof(uint32_t)) < 0)
 		goto save_msgstr_error;
 	current = &state->entries[state->msgid_number - 1];
 	if (u32_match_msgid_ending(state, current->msgid, to_save,
 		    to_save_size * sizeof(uint32_t))
 		< 0)
 		goto save_msgstr_error;
 	if (*current->msgstr[state->msgstr_index] && (!to_save || !*to_save))
 		state->untranslated_count++;
 	else if (!*current->msgstr[state->msgstr_index] && to_save && *to_save)
 		state->untranslated_count--;
 
 	u32_set_msgstr(state, current, to_save, state->msgstr_index, 0);
 	update_warning(current->msgid, to_save, &current->warning);
 	state->input_changed_fuzzy = UNCHANGED;
 
 save_msgstr_error:
 	if (state->error == ERR_CANT_ALLOC)
 		goto save_msgstr_alloc_error;
 
 	tb_hide_cursor();
 	free(to_save);
 	return !!state->error;
 
 save_msgstr_alloc_error:
 	return 1;
 }
 
 static int
 search_position_to(struct DrawState* state, const int column)
 {
 	ssize_t len;
 
 	assert((state != NULL) && (state->search != NULL));
 	len		     = u32_strlen(state->search);
 	state->search_column = column;
 
 	if (state->search_column > len)
 		state->search_column = len;
 	state->search_display_column
 		= display_length(state->search, state->search_column);
 	if (state->search_first_shown_column > state->search_display_column)
 		state->search_first_shown_column = state->search_display_column;
 	if (state->search_first_shown_column + (state->search_width - 4)
 		< state->search_column)
 		state->search_first_shown_column = state->search_display_column
 			- (state->search_width - 4);
 	return 0;
 }
 
 static int
 show_edit(struct DrawState* state)
 {
 	assert((state != NULL) && (state->entries != NULL));
 	if (state->msgstr_index + 1
 		> state->entries[state->msgid_number - 1].msgstr_count)
 		state->msgstr_index = 0;
 
 	if (load_msgstr(state) || load_info(state))
 	{
 		state->running = 0;
 		return 1;
 	}
 
 	state->fuzzy_before_edit   = state->fuzzy_count;
 	state->input_changed_fuzzy = UNCHANGED;
 	state->show_edit	   = 1;
 	state->coord.row	   = 0;
 	init_coord(&state->input_first_shown, 0, 0);
 	init_coord(&state->info_first_shown, 0, 0);
 	move_start(state);
 	state->error = ERR_NONE;
 	return 0;
 }
 
 static int
 show_help(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->show_help = 1;
 	state->error	 = ERR_NONE;
 	return 0;
 }
 
 static int
 show_search(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->show_search		 = 1;
 	state->search_column		 = 0;
 	state->search_display_column	 = 0;
 	state->search_first_shown_column = 0;
 	if (!state->search)
 		state->search = calloc(MAXSEARCH, sizeof(uint32_t));
 	*state->search = 0;
 	tb_set_cursor((state->maxx - state->search_width + 2) / 2,
 		state->maxy - 1 - SEARCH_HEIGHT + 1);
 	return 0;
 }
 
 static int
 toggle_fuzzy(struct DrawState* state)
 {
 	assert((state != NULL) && (state->entries != NULL));
 	if (state->msgid_number == 1)
 	{
 		state->error = ERR_ILLEGAL_ON_FIRST;
 		return 0;
 	}
 	if (state->msgid_count > 0)
 	{
 		state->entries[state->msgid_number - 1].flags ^= FL_FUZZY;
 		if (state->entries[state->msgid_number - 1].flags & FL_FUZZY)
 		{
 			state->fuzzy_count++;
 			if (state->input_changed_fuzzy == CLEARED)
 				state->input_changed_fuzzy = UNCHANGED;
 			else
 				state->input_changed_fuzzy = SET;
 		}
 		else
 		{
 			state->fuzzy_count--;
 			if (state->input_changed_fuzzy == SET)
 				state->input_changed_fuzzy = UNCHANGED;
 			else
 				state->input_changed_fuzzy = CLEARED;
 		}
 		state->edit_dirty = 1;
 	}
 	return 0;
 }
 
 static int
 toggle_info_focused(struct DrawState* state)
 {
 	assert(state != NULL);
 	state->edit_info_focused = !state->edit_info_focused;
 	return 0;
 }
 
 static int
 yank_input_to_paste_buffer(struct DrawState* state)
 {
 	struct BufferLine* ppaste = NULL;
 	struct BufferLine* newbuf = NULL;
 	struct BufferLine* pinput = NULL;
 	uint32_t* newtext	  = NULL;
 	uint32_t* temp		  = NULL;
 	ssize_t lines_to_init	  = 0;
 	ssize_t lines_to_free	  = 0;
 	ssize_t i;
 
 	assert(state != NULL);
 	if (state->edit_info_focused)
 		return 1;
 
 	if (state->msgid_number == 1)
 	{
 		state->error = ERR_ILLEGAL_ON_FIRST;
 		return 0;
 	}
 
 	if (!state->input_buffer || !(*state->input_buffer).text
 		|| !*(*state->input_buffer).text)
 	{
 		for (i = 0; i < state->paste_count; i++)
 			free_bufferline(state->paste + i);
 		free(state->paste);
 		state->paste	   = NULL;
 		state->paste_count = 0;
 		return 0;
 	}
 
 	lines_to_init = state->paste_count < state->input_rows_count
 		? state->input_rows_count - state->paste_count
 		: 0;
 	lines_to_free = state->paste_count > state->input_rows_count
 		? state->paste_count - state->input_rows_count
 		: 0;
 
 	for (i = 0; i < lines_to_free; i++)
 		free_bufferline(state->paste + state->paste_count - i - 1);
 	if (!state->paste)
 		newbuf = calloc(state->input_rows_count,
 			sizeof(struct BufferLine));
 	else
 		newbuf = realloc(state->paste,
 			state->input_rows_count * sizeof(struct BufferLine));
 	if (!newbuf)
 		goto yank_input_alloc_error;
 
 	pinput = state->input_buffer;
 	for (i = 0; i < lines_to_init; i++)
 	{
 		ppaste = newbuf + state->input_rows_count - 1 - i;
 		init_bufferline(ppaste);
 		newtext = calloc(LINE_DEFAULT, sizeof(uint32_t));
 		if (!newtext)
 			goto yank_input_alloc_error;
 		ppaste->text = newtext;
 		ppaste->size = LINE_DEFAULT;
 	}
 
 	if (pinput)
 		for (i = 0; i < state->input_rows_count; i++)
 		{
 			ppaste = &newbuf[i];
 			U32_SAFE_COPY(ppaste->text, temp, ppaste->size,
 				pinput->text, pinput->size,
 				yank_input_alloc_error);
 			ppaste->length = pinput->length;
 			pinput++;
 		}
 
 	state->paste_count = state->input_rows_count;
 	state->paste	   = newbuf;
 	return 0;
 
 yank_input_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return 1;
 }
 
 static int
 write_file(struct DrawState* state)
 {
 	int result;
 	assert(state != NULL);
 	result = save_file(state);
 	if (result)
 	{
 		state->running = 0;
 		return result;
 	}
 	state->error	  = ERR_NONE;
 	state->edit_dirty = 0;
 	state->dirty	  = 0;
 	return 0;
 }
 
 int
 main(int argc, char** argv)
 {
 	struct DrawState state;
 	struct tb_event ev;
 	struct stat st;
 	char prompt[LINE_DEFAULT];
 	char* dir		   = NULL;
 	char* filename		   = NULL;
 	char* pdir		   = NULL;
 	char* rfn		   = NULL;
 	const char* saved_tb_error = NULL;
 	char* temp		   = NULL;
 	char* wd		   = NULL;
 	ssize_t filename_size	   = 0;
 	long col		   = 1;
 	long lineno		   = 1;
 	int dir_access;
 	int dir_access_errno;
 	int errornum;
 	int optind = 1;
 	int result;
 	int saved_errno = 0;
 	int tbires;
 
 	*prompt = 0;
 
 #ifdef __OpenBSD__
 	if (pledge("stdio tty unveil rpath wpath cpath fattr", NULL) < 0)
 	{
 		perror(PROGRAM_NAME ": pledge");
 		exit(errno);
 	}
 #endif
 
 	/* Necessary in order for termbox to function properly
 	 * See: https://github.com/termbox/termbox2/issues/73
 	 */
 	setlocale(LC_ALL, "");
 
 main_options_loop:
 	if (optind >= argc)
 		return print_error(CUSTOM_ERROR_START + ERR_NO_CL_ARG,
 			errors[ERR_NO_CL_ARG]);
 
 	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]"
 		       " [-L | --dont-break-literals]"
 		       " [-W | --no-wrap] [-w <cols> | --wrap-width=<cols>]"
 		       " filename.po\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:\n");
 		printf("  backup_fail:\t\t\t%s\n",
 			backup_fail ? "set" : "unset");
 		if (backup_suffix)
 			printf("  backup_suffix:\t\t\"%s\"\n", backup_suffix);
 		else
 			printf("  backup_suffix:\t\tunset\n");
 		printf("  break_literals:\t\t%s\n",
 			break_literals ? "set" : "unset");
 		printf("  create_backups:\t\t%s\n",
 			create_backups ? "set" : "unset");
 		printf("  literal_break_threshold:\t%d\n",
 			literal_break_threshold);
 		printf("  match_msgstr_ending:\t\t%s\n",
 			match_msgstr_ending ? "set" : "unset");
 		if (plural_string)
 			printf("  plural_string:\t\t\"%s\"\n", plural_string);
 		else
 			printf("  plural_string:\t\tunset\n");
 		printf("  warn_count_dots:\t\t%s\n",
 			warn_count_dots ? "set" : "unset");
 		printf("  wrap_width:\t\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], "-L")
 		|| !strcmp(argv[optind], "--dont-break-literals"))
 	{
 		break_literals = 0;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (!strcmp(argv[optind], "-W")
 		|| !strcmp(argv[optind], "--no-wrap"))
 	{
 		wrap_width = 0;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (!strcmp(argv[optind], "-w")
 		|| !strcmp(argv[optind], "--wrap-width="))
 	{
 		optind++;
 		wrap_width = strtonumber(argv[optind], 0, INT_MAX, &errornum);
 		if (errornum != STN_NONE)
 		{
 			if (*argv[optind] == '-')
 				state.error = ERR_NO_CL_ARG_PARAM;
 			else
 				state.error = ERR_BAD_CL_ARG;
 			goto main_done;
 		}
 		if (wrap_width < 0)
 			wrap_width = 0;
 		optind++;
 		goto main_options_loop;
 	}
 	else if (starts_with(argv[optind], "--")
 		|| starts_with(argv[optind], "-"))
 	{
 		state.error = ERR_BAD_CL_ARG;
 		goto main_done;
 	}
 
 	/*
 	 * 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[optind] 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(CUSTOM_ERROR_START + ERR_NO_CL_ARG,
 			errors[ERR_NO_CL_ARG]);
 	}
 
 	init_drawstate(&state, filename, prompt);
 
 #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(dir, "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;
 		}
 	}
 	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 a symlink, otherwise file + suffix */
 	MEMCCPY(state.backup_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 (dir_access == -1)
 		{
 			errno = dir_access_errno;
 			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, &lineno, &col))
 		goto main_done;
 
 	state.msgid_number	= state.msgid_count > 0 ? 1 : 0;
 	state.first_shown_msgid = state.msgid_number;
 
 init_termbox:
 	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_CLEAR].fg, colors[C_CLEAR].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);
 
 	switch (state.error)
 	{
 	case ERR_NOTREG_FILE:
 		print_error(1, errors[state.error], state.filename);
 		break;
 	case ERR_NO_CL_ARG_PARAM:
 		print_error(1, errors[state.error], argv[optind - 1]);
 		break;
 	case ERR_BAD_CL_ARG:
 		print_error(1, errors[state.error], argv[optind]);
 		break;
 	case ERR_SYNTAX:
 		print_error(1, errors[state.error], state.filename, lineno, col);
 		break;
 	case ERR_NONE:
 		break;
 	default:
 		print_error(1, errors[state.error]);
 	}
 
 	return saved_errno
 		? saved_errno
 		: (state.error ? CUSTOM_ERROR_START + state.error : 0);
 }