ledit

buffer.c (33596B)

---

 /* FIXME: maybe use separate unicode grapheme library so all functions
    that need grapheme boundaries can be included here instead of in the views */
 
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
 #include <pango/pangoxft.h>
 #include <X11/extensions/Xdbe.h>
 
 #include "util.h"
 #include "undo.h"
 #include "cache.h"
 #include "memory.h"
 #include "common.h"
 #include "txtbuf.h"
 #include "window.h"
 #include "buffer.h"
 #include "assert.h"
 #include "pango-compat.h"
 
 /*
  * Important notes:
  * - Lines must be null-terminated for some things to work (e.g. text search),
  *   but the '\0' is not included in 'len'.
  * - When the line is not normalized, the '\0' is not always included! This
  *   should maybe be changed for consistency, but for now, the resizing just
  *   always makes sure to add one so there's enough space when the text is
  *   normalized. This is a bit ugly, but oh well.
 */
 
 /*
  * Note: "line gap buffer" refers to the gap buffer containing
  * all lines, not to the gap buffer of the text in one line.
  */
 
 /*
  * Move the gap of the line gap buffer to 'index'.
  */
 static void move_line_gap(ledit_buffer *buffer, size_t index);
 
 /*
  * Resize the line so it can hold at least 'min_size' bytes and move the gap
  * to byte position 'index'.
  */
 static void resize_and_move_text_gap(ledit_line *line, size_t min_size, size_t index);
 
 /*
  * Resize the line gap buffer so it can hold at least 'min_size' lines and
  * move the gap to line at position 'index'.
  */
 static void resize_and_move_line_gap(ledit_buffer *buffer, size_t min_size, size_t index);
 
 /*
  * Similar to strchr, but the length of the text is given separately
  */
 static char *strchr_len(char *text, char c, size_t len);
 
 /*
  * Initialize a line with default values for its struct members.
  */
 static void init_line(ledit_buffer *buffer, ledit_line *line);
 
 /*
  * Insert 'src_len' bytes from 'src_line' starting at byte position 'src_index'
  * into line 'dst_line' at byte position 'dst_index'.
  * 'dst_line' must not be the same as 'src_line'.
  * If 'text_ret' is not NULL, the copied text is additionally copied into 'text_ret'.
  * This function does not update the views or normalize the lines, so it should
  * only be used for efficiency purposes when performing multiple operations.
  */
 static void buffer_insert_text_from_line_base(
     ledit_buffer *buffer,
     size_t dst_line, size_t dst_index,
     size_t src_line, size_t src_index, size_t src_len,
     txtbuf *text_ret
 );
 
 /*
  * Insert text 'text' with length 'len' at line 'line_index' and byte position 'index'.
  * The text must not contain newlines.
  * This function does not update the views or normalize the lines, so it should
  * only be used for efficiency purposes when performing multiple operations.
  */
 static void buffer_insert_text_base(
     ledit_buffer *buffer,
     size_t line_index, size_t index,
     char *text, size_t len
 );
 
 /* Insert text 'text' with length 'len' at line 'line_index' and byte position 'index.
  * The text may contain newlines.
  * If end_line_ret is not NULL, the line index at the end of the insertion is
  * written into it.
  * If end_byte_ret is not NULL, the byte position at the end of the insertion is
  * written into it.
  * This function does not update the views or normalize the lines, so it should
  * only be used for efficiency purposes when performing multiple operations.
  */
 static void buffer_insert_text_with_newlines_base(
     ledit_buffer *buffer,
     size_t line_index, size_t index,
     char *text, size_t len,
     size_t *end_line_ret, size_t *end_char_ret
 );
 
 /*
  * Same as buffer_insert_text_with_newlines_base, but the views are updated afterwards.
  */
 static void buffer_insert_text_with_newlines(
     ledit_buffer *buffer,
     size_t line_index, size_t index,
     char *text, size_t len,
     size_t *end_line_ret, size_t *end_char_ret
 );
 
 /*
  * Append line after line at 'line_index'.
  * if 'break_text' is not 0, the text on line 'line_index' starting at
  * byte index 'text_index' is moved to the newly appended line.
  * The views are notified that a line has been appended, but not told to update
  * their line heights and offsets.
  */
 static void buffer_append_line_base(ledit_buffer *buffer, size_t line_index, size_t text_index, int break_text);
 
 /*
  * Delete lines between 'index1' and 'index2' (inclusive).
  * The views are notified of the deletion but not told to
  * update their line heights and offsets.
  */
 static void buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1, size_t index2);
 
 /*
  * Delete the section of line 'line' starting at byte 'start' with length 'length'
  * and notify the views.
  * Note that this does not tell the views to recalculate their line heights and offsets.
  */
 static void buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, size_t start, size_t length);
 
 /*
  * Copy text range into given buffer.
  * - dst is null-terminated
  * - dst must be large enough to contain the text and NUL (only use this together with buffer_textlen)
  * - the range must be sorted already
  */
 static void buffer_copy_text(ledit_buffer *buffer, char *dst, int line1, int byte1, int line2, int byte2);
 
 static void marklist_destroy(ledit_buffer_marklist *marklist);
 static ledit_buffer_marklist *marklist_create(void);
 
 static void
 marklist_destroy(ledit_buffer_marklist *marklist) {
 	for (size_t i = 0; i < marklist->len; i++) {
 		free(marklist->marks[i].text);
 	}
 	free(marklist->marks);
 	free(marklist);
 }
 
 void
 buffer_insert_mark(ledit_buffer *buffer, char *mark, size_t len, size_t line, size_t byte) {
 	ledit_buffer_marklist *marklist = buffer->marklist;
 	for (size_t i = 0; i < marklist->len; i++) {
 		if (!strncmp(mark, marklist->marks[i].text, len)) {
 			marklist->marks[i].line = line;
 			marklist->marks[i].byte = byte;
 			return;
 		}
 	}
 	if (marklist->len == marklist->alloc) {
 		size_t new_alloc = ideal_array_size(marklist->alloc, add_sz(marklist->len, 1));
 		marklist->marks = ledit_reallocarray(
 		    marklist->marks, new_alloc, sizeof(ledit_buffer_mark)
 		);
 		marklist->alloc = new_alloc;
 	}
 	ledit_buffer_mark *m = &marklist->marks[marklist->len];
 	m->text = ledit_strndup(mark, len);
 	m->line = line;
 	m->byte = byte;
 	marklist->len++;
 }
 
 /* FIXME: check that byte is actually at grapheme boundary
    (difficult because that can't currently be done by the buffer) */
 int
 buffer_get_mark(ledit_buffer *buffer, char *mark, size_t len, size_t *line_ret, size_t *byte_ret) {
 	ledit_buffer_marklist *marklist = buffer->marklist;
 	int ret = 1;
 	for (size_t i = 0; i < marklist->len; i++) {
 		if (!strncmp(mark, marklist->marks[i].text, len)) {
 			ledit_line *ll;
 			ledit_buffer_mark *m = &marklist->marks[i];
 			if (m->line >= buffer->lines_num) {
 				*line_ret = buffer->lines_num - 1;
 				ll = buffer_get_line(buffer, *line_ret);
 				*byte_ret = ll->len;
 			} else {
 				*line_ret = m->line;
 				ll = buffer_get_line(buffer, m->line);
 				if (m->byte >= ll->len)
 					*byte_ret = ll->len;
 				else
 					*byte_ret = m->byte;
 			}
 			ret = 0;
 			break;
 		}
 	}
 	return ret;
 }
 
 static ledit_buffer_marklist *
 marklist_create(void) {
 	ledit_buffer_marklist *marklist = ledit_malloc(sizeof(ledit_buffer_marklist));
 	marklist->len = marklist->alloc = 0;
 	marklist->marks = NULL;
 	return marklist;
 }
 
 ledit_buffer *
 buffer_create(ledit_common *common, ledit_clipboard *clipboard) {
 	ledit_buffer *buffer = ledit_malloc(sizeof(ledit_buffer));
 	buffer->common = common;
 	buffer->clipboard = clipboard;
 	buffer->undo = undo_stack_create();
 	buffer->marklist = marklist_create();
 
 	buffer->filename = NULL;
 	memset(&buffer->file_mtime, 0, sizeof(buffer->file_mtime));
 	buffer->lines = NULL;
 	buffer->lines_num = 0;
 	buffer->lines_cap = 0;
 	buffer->lines_gap = 0;
 	buffer->views = NULL;
 	buffer->views_num = 0;
 	buffer->hard_line_based = 1;
 	buffer->modified = 0;
 
 	/* add one empty line to buffer */
 	resize_and_move_line_gap(buffer, 1, 0);
 	buffer->lines_num++;
 	buffer->lines_gap++;
 	ledit_line *ll = buffer_get_line(buffer, 0);
 	init_line(buffer, ll);
 
 	return buffer;
 }
 
 void
 buffer_lock_all_views_except(ledit_buffer *buffer, ledit_view *view, char *lock_text) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		if (buffer->views[i] != view) {
 			view_lock(buffer->views[i], lock_text);
 		}
 	}
 }
 
 void
 buffer_unlock_all_views(ledit_buffer *buffer) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_unlock(buffer->views[i]);
 	}
 }
 
 void
 buffer_set_hard_line_based(ledit_buffer *buffer, int hl) {
 	buffer->hard_line_based = hl;
 }
 
 /* FIXME: lock view if others are locked! */
 void
 buffer_add_view(ledit_buffer *buffer, ledit_mode mode, size_t line, size_t pos, long scroll_offset) {
 	size_t new_num = add_sz(buffer->views_num, 1);
 	buffer->views = ledit_reallocarray(buffer->views, new_num, sizeof(ledit_view *));
 	buffer->views[buffer->views_num] = view_create(buffer, mode, line, pos);
 	view_scroll(buffer->views[buffer->views_num], scroll_offset);
 	buffer->views_num = new_num;
 }
 
 /* FIXME: error checking */
 void
 buffer_remove_view(ledit_buffer *buffer, ledit_view *view) {
 	size_t i = 0;
 	int found = 0;
 	for (; i < buffer->views_num; i++) {
 		if (buffer->views[i] == view) {
 			found = 1;
 			break;
 		}
 	}
 	if (found) {
 		view_destroy(buffer->views[i]);
 		memmove(
 		    buffer->views + i,
 		    buffer->views + i + 1,
 		    (buffer->views_num - i - 1) * sizeof(ledit_view *)
 		);
 		--buffer->views_num;
 		/* FIXME: use generic "vector" library to avoid problems like this */
 		if (buffer->views_num == 0) {
 			free(buffer->views);
 			buffer->views = NULL;
 		} else {
 			buffer->views = ledit_reallocarray(buffer->views, buffer->views_num, sizeof(ledit_view *));
 		}
 	}
 }
 
 void
 buffer_recalc_all_views_from_line(ledit_buffer *buffer, size_t line) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_recalc_from_line(buffer->views[i], line);
 	}
 }
 
 /* WARNING: errstr must be copied as soon as possible! */
 int
 buffer_load_file(ledit_buffer *buffer, char *filename, size_t line, char **errstr) {
 	long len;
 	int off = 0;
 	ledit_line *ll;
 	char *file_contents;
 	FILE *file;
 
 	/* FIXME: https://wiki.sei.cmu.edu/confluence/display/c/FIO19-C.+Do+not+use+fseek()+and+ftell()+to+compute+the+size+of+a+regular+file */
 	file = fopen(filename, "r");
 	if (!file) goto error;
 	if (fseek(file, 0, SEEK_END)) goto errorclose;
 	len = ftell(file);
 	if (len < 0) goto errorclose;
 	if (fseek(file, 0, SEEK_SET)) goto errorclose;
 	size_t lenz = add_sz((size_t)len, 2);
 
 	ll = buffer_get_line(buffer, line);
 	/* FIXME: insert in chunks instead of allocating huge buffer */
 	file_contents = ledit_malloc(lenz);
 	/* mimic nvi (or at least the openbsd version) - if the line
 	   is empty, insert directly, otherwise insert after the line */
 	if (ll->len > 0) {
 		off = 1;
 		file_contents[0] = '\n';
 	}
 	clearerr(file);
 	fread(file_contents + off, 1, (size_t)len, file);
 	if (ferror(file)) goto errorclose;
 	file_contents[len + off] = '\0';
 	/* don't generate extra newline at end */
 	if (len + off > 0 && file_contents[len + off - 1] == '\n') {
 		file_contents[len + off - 1] = '\0';
 		len--;
 	}
 	if (fclose(file)) goto error;
 
 	buffer_insert_text_with_newlines(
 	    buffer, line, ll->len, file_contents, len + off, NULL, NULL
 	);
 	free(file_contents);
 	buffer->modified = 0;
 	return 0;
 error:
 	if (errstr)
 		*errstr = strerror(errno);
 	return 1;
 errorclose:
 	if (errstr)
 		*errstr = strerror(errno);
 	fclose(file);
 	return 1;
 }
 
 int
 buffer_write_to_file(ledit_buffer *buffer, FILE *file, char **errstr) {
 	ledit_line *ll;
 	clearerr(file);
 	for (size_t i = 0; i < buffer->lines_num; i++) {
 		ll = buffer_get_line(buffer, i);
 		buffer_normalize_line(ll);
 		if (fprintf(file, "%s\n", ll->text) < 0) goto errorclose;
 	}
 	if (fclose(file)) goto error;
 	buffer->modified = 0;
 	return 0;
 error:
 	if (errstr)
 		*errstr = strerror(errno);
 	return 1;
 errorclose:
 	if (errstr)
 		*errstr = strerror(errno);
 	fclose(file);
 	return 1;
 }
 
 int
 buffer_write_to_fd(ledit_buffer *buffer, int fd, char **errstr) {
 	FILE *file = fdopen(fd, "w");
 	if (!file) goto error;
 	return buffer_write_to_file(buffer, file, errstr);
 error:
 	if (errstr)
 		*errstr = strerror(errno);
 	/* catching errors on the close wouldn't
 	   really make much sense anymore */
 	close(fd);
 	return 1;
 }
 
 /* FIXME: allow to write only certain lines */
 int
 buffer_write_to_filename(ledit_buffer *buffer, char *filename, char **errstr) {
 	FILE *file = fopen(filename, "w");
 	if (!file) goto error;
 	return buffer_write_to_file(buffer, file, errstr);
 error:
 	if (errstr)
 		*errstr = strerror(errno);
 	return 1;
 }
 
 void
 buffer_destroy(ledit_buffer *buffer) {
 	ledit_line *l;
 	for (size_t i = 0; i < buffer->lines_num; i++) {
 		l = buffer_get_line(buffer, i);
 		free(l->text);
 	}
 	undo_stack_destroy(buffer->undo);
 	free(buffer->lines);
 	if (buffer->filename)
 		free(buffer->filename);
 	marklist_destroy(buffer->marklist);
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_destroy(buffer->views[i]);
 	}
 	free(buffer->views);
 	free(buffer);
 }
 
 void
 buffer_normalize_line(ledit_line *line) {
 	if (line->gap < line->len) {
 		memmove(
 		    line->text + line->gap,
 		    line->text + line->gap + line->cap - line->len,
 		    line->len - line->gap
 		);
 		line->gap = line->len;
 	}
 	/* this should never happen because the functions always
 	   make sure to allocate one more for the '\0' */
 	ledit_assert(line->len < line->cap);
 	line->text[line->len] = '\0';
 }
 
 /* FIXME: To simplify this a bit, maybe just copy text to txtbuf first and
    then insert it in one go instead of having this complex logic */
 /* FIXME: check if there can be bugs when a newline is inserted in some way
    other than pasting or pressing enter */
 
 static void
 buffer_insert_text_from_line_base(
     ledit_buffer *buffer,
     size_t dst_line, size_t dst_index,
     size_t src_line, size_t src_index, size_t src_len,
     txtbuf *text_ret) {
 	ledit_assert(dst_line != src_line);
 	ledit_line *ll = buffer_get_line(buffer, src_line);
 	ledit_assert(add_sz(src_index, src_len) <= ll->len);
 	if (text_ret != NULL) {
 		txtbuf_resize(text_ret, src_len);
 		text_ret->len = src_len;
 	}
 	if (src_index >= ll->gap) {
 		/* all text to insert is after gap */
 		buffer_insert_text_base(
 		    buffer, dst_line, dst_index,
 		    ll->text + src_index + ll->cap - ll->len, src_len
 		);
 		if (text_ret != NULL) {
 			memcpy(
 			    text_ret->text,
 			    ll->text + src_index + ll->cap - ll->len,
 			    src_len
 			);
 		}
 	} else if (ll->gap - src_index >= src_len) {
 		/* all text to insert is before gap */
 		buffer_insert_text_base(
 		    buffer, dst_line, dst_index,
 		    ll->text + src_index, src_len
 		);
 		if (text_ret != NULL) {
 			memcpy(
 			    text_ret->text,
 			    ll->text + src_index,
 			    src_len
 			);
 		}
 	} else {
 		/* insert part of text before gap */
 		buffer_insert_text_base(
 		    buffer, dst_line, dst_index,
 		    ll->text + src_index, ll->gap - src_index
 		);
 		/* insert part of text after gap */
 		buffer_insert_text_base(
 		    buffer, dst_line, dst_index + ll->gap - src_index,
 		    ll->text + ll->gap + ll->cap - ll->len,
 		    src_len - ll->gap + src_index
 		);
 		if (text_ret != NULL) {
 			memcpy(
 			    text_ret->text,
 			    ll->text + src_index,
 			    ll->gap - src_index
 			);
 			memcpy(
 			    text_ret + ll->gap - src_index,
 			    ll->text + ll->gap + ll->cap - ll->len,
 			    src_len - ll->gap + src_index
 			);
 		}
 
 	}
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_notify_insert_text(buffer->views[i], dst_line, dst_index, src_len);
 	}
 }
 
 static void
 move_line_gap(ledit_buffer *buffer, size_t index) {
 	move_gap(
 	    buffer->lines, sizeof(ledit_line), index,
 	    buffer->lines_gap, buffer->lines_cap, buffer->lines_num,
 	    &buffer->lines_gap
 	);
 }
 
 /* FIXME: add "final" versions of the functions that include the
    normalization, i.e. if they have to move the gap anyways, they
    just move it to the end */
 
 static void
 resize_and_move_text_gap(ledit_line *line, size_t min_size, size_t index) {
 	/* yes, I know sizeof(char) == 1 anyways */
 	line->text = resize_and_move_gap(
 	    line->text, sizeof(char),
 	    line->gap, line->cap, line->len,
 	    min_size, index,
 	    &line->gap, &line->cap
 	);
 }
 
 static void
 resize_and_move_line_gap(ledit_buffer *buffer, size_t min_size, size_t index) {
 	buffer->lines = resize_and_move_gap(
 	    buffer->lines, sizeof(ledit_line),
 	    buffer->lines_gap, buffer->lines_cap, buffer->lines_num,
 	    min_size, index,
 	    &buffer->lines_gap, &buffer->lines_cap
 	);
 }
 
 static void
 buffer_insert_text_base(ledit_buffer *buffer, size_t line_index, size_t index, char *text, size_t len) {
 	ledit_line *line = buffer_get_line(buffer, line_index);
 	ledit_assert(index <= line->len);
 	/* \0 is not included in line->len */
 	resize_and_move_text_gap(line, add_sz3(line->len, len, 1), index);
 	/* the gap is now located at 'index' and at least large enough to hold the new text */
 	memmove(line->text + index, text, len);
 	line->gap += len;
 	line->len += len;
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_notify_insert_text(buffer->views[i], line_index, index, len);
 	}
 }
 
 /* FIXME: this isn't optimized like the standard version, but whatever */
 static char *
 strchr_len(char *text, char c, size_t len) {
 	for (size_t i = 0; i < len; i++) {
 		if (text[i] == c)
 			return text + i;
 	}
 	return NULL;
 }
 
 /* FIXME: make these functions that call recalc* also be final as described above */
 static void
 buffer_insert_text_with_newlines(
     ledit_buffer *buffer,
     size_t line_index, size_t index,
     char *text, size_t len,
     size_t *end_line_ret, size_t *end_byte_ret) {
 	size_t end;
 	buffer_insert_text_with_newlines_base(
 	    buffer, line_index, index, text, len,
 	    &end, end_byte_ret
 	);
 	if (end_line_ret)
 		*end_line_ret = end;
 	if (line_index == end)
 		buffer_recalc_line(buffer, line_index);
 	else
 		buffer_recalc_from_line(buffer, line_index);
 }
 
 /* FIXME: also look for \r */
 static void
 buffer_insert_text_with_newlines_base(
     ledit_buffer *buffer,
     size_t line_index, size_t index,
     char *text, size_t len,
     size_t *end_line_ret, size_t *end_byte_ret) {
 	size_t rem_len = len;
 	char *cur, *last = text;
 	size_t cur_line = line_index;
 	size_t cur_index = index;
 	/* FIXME: strchr_len isn't really needed when the lines are normalized anyways */
 	while ((cur = strchr_len(last, '\n', rem_len)) != NULL) {
 		/* FIXME: this is probably inefficient, but I don't have time to
 		   think about it right now */
 		buffer_append_line_base(buffer, cur_line, cur_index, 1);
 		buffer_insert_text_base(buffer, cur_line, cur_index, last, cur - last);
 		cur_index = 0;
 		cur_line++;
 		rem_len -= cur - last + 1;
 		last = cur + 1;
 	}
 	/* FIXME: check how legal this casting between pointers and size_t's is */
 	buffer_insert_text_base(buffer, cur_line, cur_index, last, text + len - last);
 	if (end_line_ret)
 		*end_line_ret = cur_line;
 	if (end_byte_ret)
 		*end_byte_ret = cur_index + text + len - last;
 }
 
 static void
 init_line(ledit_buffer *buffer, ledit_line *line) {
 	line->parent_buffer = buffer;
 	line->gap = 0;
 	line->cap = 2; /* arbitrary */
 	line->text = ledit_malloc(line->cap);
 	line->text[0] = '\0';
 	line->len = 0;
 }
 
 static void
 buffer_append_line_base(ledit_buffer *buffer, size_t line_index, size_t text_index, int break_text) {
 	size_t new_len = add_sz(buffer->lines_num, 1);
 	size_t insert_index = add_sz(line_index, 1);
 	resize_and_move_line_gap(buffer, new_len, insert_index);
 	buffer->lines_num++;
 	buffer->lines_gap++;
 	ledit_line *new_l = buffer_get_line(buffer, line_index + 1);
 	init_line(buffer, new_l);
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_notify_append_line(buffer->views[i], line_index);
 	}
 	if (break_text) {
 		ledit_line *l = buffer_get_line(buffer, line_index);
 		buffer_insert_text_from_line_base(
 		    buffer, line_index + 1, 0,
 		    line_index, text_index, l->len - text_index, NULL
 		);
 		buffer_delete_line_section_base(
 		    buffer, line_index,
 		    text_index, l->len - text_index
 		);
 	}
 }
 
 /* IMPORTANT: buffer_recalc_from_line needs to be called sometime after this! */
 static void
 buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1, size_t index2) {
 	ledit_line *l;
 	ledit_assert(index2 >= index1);
 	/* it isn't allowed to delete all lines */
 	ledit_assert(index2 - index1 != buffer->lines_num);
 	for (size_t i = index1; i <= index2; i++) {
 		l = buffer_get_line(buffer, i);
 		free(l->text);
 	}
 	move_line_gap(buffer, index1);
 	buffer->lines_num -= index2 - index1 + 1;
 	/* possibly decrease size of array - this needs to be after
 	   actually deleting the lines so the length is already less */
 	size_t min_size = ideal_array_size(buffer->lines_cap, buffer->lines_num);
 	if (min_size != buffer->lines_cap)
 		resize_and_move_line_gap(buffer, buffer->lines_num, buffer->lines_gap);
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_notify_delete_lines(buffer->views[i], index1, index2);
 	}
 }
 
 ledit_line *
 buffer_get_line(ledit_buffer *buffer, size_t index) {
 	ledit_assert(index < buffer->lines_num);
 	return index < buffer->lines_gap ?
 	       &buffer->lines[index] :
 	       &buffer->lines[index + buffer->lines_cap - buffer->lines_num];
 }
 
 void
 buffer_recalc_line(ledit_buffer *buffer, size_t line) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_recalc_line(buffer->views[i], line);
 	}
 }
 
 void
 buffer_recalc_from_line(ledit_buffer *buffer, size_t line) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_recalc_from_line(buffer->views[i], line);
 	}
 }
 
 void
 buffer_recalc_all_lines(ledit_buffer *buffer) {
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_recalc_all_lines(buffer->views[i]);
 	}
 }
 
 size_t
 buffer_textlen(ledit_buffer *buffer, size_t line1, size_t byte1, size_t line2, size_t byte2) {
 	ledit_assert(line1 < line2 || (line1 == line2 && byte1 <= byte2));
 	size_t len = 0;
 	ledit_line *ll = buffer_get_line(buffer, line1);
 	ledit_line *ll2 = buffer_get_line(buffer, line2);
 	ledit_assert(byte1 <= ll->len);
 	ledit_assert(byte2 <= ll2->len);
 	if (line1 == line2) {
 		len = byte2 - byte1;
 	} else {
 		/* + 1 for newline */
 		len = add_sz3(ll->len - byte1, byte2, 1);
 		for (size_t i = line1 + 1; i < line2; i++) {
 			ll = buffer_get_line(buffer, i);
 			/* ll->len + 1 should be valid anyways
 			   because there *should* always be
 			   space for '\0' at the end, i.e. ll->cap
 			   should be at least ll->len + 1 */
 			/* FIXME: also, this overflow checking is
 			   probably completely useless (it definitely
 			   is really ugly) */
 			len += add_sz(ll->len, 1);
 		}
 	}
 	return len;
 }
 
 /* FIXME: Only copy new text in selection when expanding it */
 /* FIXME: Work directly with gap buffer instead of normalizing first
    -> I guess it doesn't matter right now because copying text is
       only done when it is re-rendered (and thus normalized because
       of pango's requirements). If a more efficient rendering
       backend is added, it would be good to optimize this, though. */
 static void
 buffer_copy_text(ledit_buffer *buffer, char *dst, int line1, int byte1, int line2, int byte2) {
 	ledit_assert(line1 < line2 || (line1 == line2 && byte1 <= byte2));
 	ledit_line *ll1 = buffer_get_line(buffer, line1);
 	ledit_line *ll2 = buffer_get_line(buffer, line2);
 	buffer_normalize_line(ll1);
 	if (line1 == line2) {
 		memcpy(dst, ll1->text + byte1, byte2 - byte1);
 		dst[byte2 - byte1] = '\0';
 	} else {
 		size_t cur_pos = 0;
 		memcpy(dst, ll1->text + byte1, ll1->len - byte1);
 		cur_pos += ll1->len - byte1;
 		dst[cur_pos] = '\n';
 		cur_pos++;
 		for (int i = line1 + 1; i < line2; i++) {
 			ledit_line *ll = buffer_get_line(buffer, i);
 			buffer_normalize_line(ll);
 			memcpy(dst + cur_pos, ll->text, ll->len);
 			cur_pos += ll->len;
 			dst[cur_pos] = '\n';
 			cur_pos++;
 		}
 		buffer_normalize_line(ll2);
 		memcpy(dst + cur_pos, ll2->text, byte2);
 		cur_pos += byte2;
 		dst[cur_pos] = '\0';
 	}
 }
 
 void
 buffer_copy_text_to_txtbuf(
     ledit_buffer *buffer,
     txtbuf *buf,
     size_t line1, size_t byte1,
     size_t line2, size_t byte2) {
 	ledit_assert(line1 < line2 || (line1 == line2 && byte1 <= byte2));
 	size_t len = buffer_textlen(buffer, line1, byte1, line2, byte2);
 	txtbuf_resize(buf, len);
 	buffer_copy_text(buffer, buf->text, line1, byte1, line2, byte2);
 	buf->len = len;
 }
 
 /* get char with logical index i from line */
 #define LINE_CHAR(line, i) ((i) < (line)->gap ? (line)->text[i] : (line)->text[i + (line)->cap - (line)->len])
 
 size_t
 line_prev_utf8(ledit_line *line, size_t index) {
 	if (index == 0)
 		return 0;
 	size_t i = index - 1;
 	/* find valid utf8 char - this probably needs to be improved */
 	while (i > 0 && ((LINE_CHAR(line, i) & 0xC0) == 0x80))
 		i--;
 	return i;
 }
 
 size_t
 line_next_utf8(ledit_line *line, size_t index) {
 	if (index >= line->len)
 		return line->len;
 	size_t i = index + 1;
 	while (i < line->len && ((LINE_CHAR(line, i) & 0xC0) == 0x80))
 		i++;
 	return i;
 }
 
 /* Warning: this is very inefficient! */
 /* FIXME: Any way to optimize this? */
 size_t
 line_byte_to_char(ledit_line *line, size_t byte) {
 	size_t c = 0;
 	size_t i = 0;
 	size_t b = byte > line->len ? line->len : byte; /* maybe not necessary */
 	while (i < b) {
 		c++;
 		i = line_next_utf8(line, i);
 	}
 	return c;
 }
 
 /* FIXME: It might make more sense to add a flag to view_{next,prev}_char_pos
    since this is essentially the same, just without the check for is_cursor_position */
 void
 buffer_next_char_pos(
     ledit_buffer *buffer,
     size_t line, size_t byte,
     int num, int multiline,
     size_t *line_ret, size_t *byte_ret) {
 	ledit_line *ll = buffer_get_line(buffer, line);
 	size_t c = line_byte_to_char(ll, byte);
 	size_t cur_byte = byte;
 	for (int i = 0; i < num; i++) {
 		if (cur_byte >= ll->len) {
 			if (multiline && line < buffer->lines_num - 1) {
 				line++;
 				ll = buffer_get_line(buffer, line);
 				c = 0;
 				cur_byte = 0;
 				i++;
 				continue;
 			} else {
 				break;
 			}
 		}
 		cur_byte = line_next_utf8(ll, cur_byte);
 		c++;
 	}
 	if (line_ret)
 		*line_ret = line;
 	if (byte_ret)
 		*byte_ret = cur_byte <= ll->len ? cur_byte : ll->len;
 }
 
 void
 buffer_prev_char_pos(
     ledit_buffer *buffer,
     size_t line, size_t byte,
     int num, int multiline,
     size_t *line_ret, size_t *byte_ret) {
 	ledit_line *ll = buffer_get_line(buffer, line);
 	size_t c = line_byte_to_char(ll, byte);
 	size_t cur_byte = byte;
 	for (int i = 0; i < num; i++) {
 		if (cur_byte == 0) {
 			if (multiline && line > 0) {
 				line--;
 				ll = buffer_get_line(buffer, line);
 				c = line_byte_to_char(ll, ll->len);
 				cur_byte = ll->len;
 				i++;
 				continue;
 			} else {
 				break;
 			}
 		}
 		cur_byte = line_prev_utf8(ll, cur_byte);
 		c--;
 	}
 	if (line_ret)
 		*line_ret = line;
 	if (byte_ret)
 		*byte_ret = cur_byte;
 }
 
 /* The check for length == 0 in buffer_delete_line_section_base and the check for
    empty range in delete_range_base shouldn't be needed, but I added them just in case. */
 static void
 buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, size_t start, size_t length) {
 	if (length == 0)
 		return;
 	ledit_line *l = buffer_get_line(buffer, line);
 	/* FIXME: somehow make sure this doesn't get optimized out? */
 	(void)add_sz(start, length); /* just check that no overflow */
 	ledit_assert(start + length <= l->len);
 	if (start <= l->gap && start + length >= l->gap) {
 		/* range includes gap */
 		l->gap = start;
 	} else if (start < l->gap && start + length <= l->gap) {
 		/* entire range is before gap */
 		memmove(
 		    l->text + l->cap - l->len + start + length,
 		    l->text + start + length,
 		    l->gap - start - length
 		);
 		l->gap = start;
 	} else {
 		/* entire range is after gap */
 		/* move piece between end of gap and
 		   start of range to beginning of gap */
 		memmove(
 		    l->text + l->gap,
 		    l->text + l->gap + l->cap - l->len,
 		    start - l->gap
 		);
 		l->gap += start - l->gap;
 	}
 	l->len -= length;
 	/* possibly decrease size of line */
 	size_t cap = ideal_array_size(l->cap, add_sz(l->len, 1));
 	if (cap != l->cap)
 		resize_and_move_text_gap(l, l->len + 1, l->gap);
 	for (size_t i = 0; i < buffer->views_num; i++) {
 		view_notify_delete_text(buffer->views[i], line, start, length);
 	}
 }
 
 static void
 delete_range_base(
     ledit_buffer *buffer,
     size_t line_index1, size_t byte_index1,
     size_t line_index2, size_t byte_index2,
     txtbuf *text_ret) {
 	if (line_index1 == line_index2 && byte_index1 == byte_index2)
 		return;
 	sort_range(&line_index1, &byte_index1, &line_index2, &byte_index2);
 	if (line_index1 == line_index2) {
 		if (text_ret) {
 			buffer_copy_text_to_txtbuf(
 			    buffer, text_ret,
 			    line_index1, byte_index1,
 			    line_index2, byte_index2
 			);
 		}
 		buffer_delete_line_section_base(
 		    buffer, line_index1, byte_index1, byte_index2 - byte_index1
 		);
 	} else {
 		if (text_ret) {
 			buffer_copy_text_to_txtbuf(
 			    buffer, text_ret,
 			    line_index1, byte_index1,
 			    line_index2, byte_index2
 			);
 		}
 		ledit_line *line1 = buffer_get_line(buffer, line_index1);
 		ledit_line *line2 = buffer_get_line(buffer, line_index2);
 		ledit_assert(byte_index1 <= line1->len);
 		ledit_assert(byte_index2 <= line2->len);
 		buffer_delete_line_section_base(
 		    buffer, line_index1, byte_index1, line1->len - byte_index1
 		);
 		buffer_insert_text_from_line_base(
 		    buffer,
 		    line_index1, byte_index1,
 		    line_index2, byte_index2,
 		    line2->len - byte_index2, NULL
 		);
 		buffer_delete_line_entries_base(
 		    buffer, line_index1 + 1, line_index2
 		);
 	}
 }
 
 static void
 undo_insert_helper(void *data, size_t line, size_t byte, char *text, size_t text_len) {
 	ledit_buffer *buffer = (ledit_buffer *)data;
 	buffer_insert_text_with_newlines_base(buffer, line, byte, text, text_len, NULL, NULL);
 }
 
 static void
 undo_delete_helper(void *data, size_t line1, size_t byte1, size_t line2, size_t byte2) {
 	ledit_buffer *buffer = (ledit_buffer *)data;
 	delete_range_base(buffer, line1, byte1, line2, byte2, NULL);
 }
 
 undo_status
 buffer_undo(ledit_buffer *buffer, ledit_mode mode, size_t *cur_line, size_t *cur_byte) {
 	size_t min_line;
 	undo_status s = ledit_undo(
 	    buffer->undo, mode, buffer, &undo_insert_helper,
 	    &undo_delete_helper, cur_line, cur_byte, &min_line
 	);
 	if (min_line < buffer->lines_num) {
 		buffer_recalc_all_views_from_line(
 		    buffer, min_line > 0 ? min_line - 1 : min_line
 		);
 	}
 	buffer->modified = 1;
 	return s;
 }
 
 undo_status
 buffer_redo(ledit_buffer *buffer, ledit_mode mode, size_t *cur_line, size_t *cur_byte) {
 	size_t min_line;
 	undo_status s = ledit_redo(
 	    buffer->undo, mode, buffer, &undo_insert_helper,
 	    &undo_delete_helper, cur_line, cur_byte, &min_line
 	);
 	if (min_line < buffer->lines_num) {
 		buffer_recalc_all_views_from_line(
 		    buffer, min_line > 0 ? min_line - 1 : min_line
 		);
 	}
 	buffer->modified = 1;
 	return s;
 }
 
 void
 buffer_delete_with_undo_base(
     ledit_buffer *buffer, ledit_range cur_range,
     int start_undo_group, ledit_mode mode, /* for undo */
     size_t line_index1, size_t byte_index1,
     size_t line_index2, size_t byte_index2,
     txtbuf *text_ret) {
 	/* FIXME: global txtbuf to avoid allocating each time */
 	/* actually, could just use stack variable here */
 	txtbuf *buf = text_ret != NULL ? text_ret : txtbuf_new();
 	sort_range(&line_index1, &byte_index1, &line_index2, &byte_index2);
 	delete_range_base(
 	    buffer, line_index1, byte_index1, line_index2, byte_index2, buf
 	);
 	ledit_range del_range = {
 	    .line1 = line_index1, .byte1 = byte_index1,
 	    .line2 = line_index2, .byte2 = byte_index2
 	};
 	undo_push_delete(
 	    buffer->undo, buf, del_range, cur_range, start_undo_group, mode
 	);
 	if (text_ret == NULL)
 		txtbuf_destroy(buf);
 	buffer->modified = 1;
 }
 
 void
 buffer_delete_with_undo(
     ledit_buffer *buffer, ledit_range cur_range,
     int start_undo_group, ledit_mode mode, /* for undo */
     size_t line_index1, size_t byte_index1,
     size_t line_index2, size_t byte_index2,
     txtbuf *text_ret) {
 	buffer_delete_with_undo_base(
 	    buffer, cur_range,
 	    start_undo_group, mode,
 	    line_index1, byte_index1,
 	    line_index2, byte_index2,
 	    text_ret
 	);
 	size_t min = line_index1 < line_index2 ? line_index1 : line_index2;
 	buffer_recalc_all_views_from_line(buffer, min);
 }
 
 void
 buffer_insert_with_undo_base(
     ledit_buffer *buffer,
     ledit_range cur_range, int set_range_end,
     int start_undo_group, ledit_mode mode,
     size_t line, size_t byte,
     char *text, size_t len,
     size_t *line_ret, size_t *byte_ret) {
 	txtbuf ins_buf = {.text = text, .len = len, .cap = len};
 	ledit_range ins_range;
 	ins_range.line1 = line;
 	ins_range.byte1 = byte;
 	size_t new_line, new_byte;
 	buffer_insert_text_with_newlines_base(
 	    buffer, line, byte, text, len,
 	    &new_line, &new_byte
 	);
 	if (set_range_end) {
 		cur_range.line2 = new_line;
 		cur_range.byte2 = new_byte;
 	}
 	ins_range.line2 = new_line;
 	ins_range.byte2 = new_byte;
 	undo_push_insert(
 	    buffer->undo, &ins_buf, ins_range, cur_range, start_undo_group, mode
 	);
 	if (line_ret != NULL)
 		*line_ret = new_line;
 	if (byte_ret != NULL)
 		*byte_ret = new_byte;
 	buffer->modified = 1;
 }
 
 void
 buffer_insert_with_undo(
     ledit_buffer *buffer,
     ledit_range cur_range, int set_range_end,
     int start_undo_group, ledit_mode mode,
     size_t line, size_t byte,
     char *text, size_t len,
     size_t *line_ret, size_t *byte_ret) {
 	buffer_insert_with_undo_base(
 	    buffer,
 	    cur_range, set_range_end,
 	    start_undo_group, mode,
 	    line, byte, text, len,
 	    line_ret, byte_ret
 	);
 	buffer_recalc_all_views_from_line(buffer, line);
 }