ledit

undo.c (9769B)

---

 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <pango/pangoxft.h>
 
 #include "util.h"
 #include "memory.h"
 #include "common.h"
 #include "txtbuf.h"
 #include "cache.h"
 #include "undo.h"
 #include "assert.h"
 
 /* FIXME: more sanity checks in case text is
    inserted/deleted without adding to undo stack */
 /* FIXME: cursor positions can be a bit weird when
    undo is used across different insert sessions in
    insert mode - e.g. if some text is inserted, then
    'o' is used in normal mode to append a new line and
    type some text, the cursor position at a certain
    undo position will differ in insert mode depending
    on whether it was reached with undo or redo since
    'o' saves the position at which it was pressed,
    not the position of the last insert */
 
 enum operation {
 	UNDO_INSERT,
 	UNDO_DELETE
 };
 
 typedef struct {
 	txtbuf *text;
 	enum operation type;
 	ledit_mode mode;
 	ledit_range op_range;
 	ledit_range cursor_range;
 	int group;
 	int mode_group;
 } undo_elem;
 
 struct undo_stack {
 	size_t len, cur, cap;
 	undo_elem *stack;
 	int cur_valid;
 	int change_mode_group;
 };
 
 undo_stack *
 undo_stack_create(void) {
 	undo_stack *undo = ledit_malloc(sizeof(undo_stack));
 	undo->len = undo->cap = 0;
 	undo->cur = 0;
 	undo->cur_valid = 0;
 	undo->stack = NULL;
 	undo->change_mode_group = 0;
 	return undo;
 }
 
 void
 undo_stack_destroy(undo_stack *undo) {
 	for (size_t i = 0; i < undo->cap; i++) {
 		if (undo->stack[i].text != NULL)
 			txtbuf_destroy(undo->stack[i].text);
 	}
 	free(undo->stack);
 	free(undo);
 }
 
 /* FIXME: resize text buffers when they aren't needed anymore */
 static undo_elem *
 push_undo_elem(undo_stack *undo) {
 	if (undo->cur_valid)
 		undo->cur++;
 	else
 		undo->cur = 0;
 	undo->cur_valid = 1;
 	undo->len = add_sz(undo->cur, 1);
 	if (undo->len > undo->cap) {
 		size_t cap = ideal_array_size(undo->cap, undo->len);
 		undo->stack = ledit_reallocarray(undo->stack, cap, sizeof(undo_elem));
 		for (size_t i = undo->cap; i < cap; i++) {
 			undo->stack[i].text = NULL;
 		}
 		undo->cap = cap;
 	}
 	return &undo->stack[undo->cur];
 }
 
 static undo_elem *
 peek_undo_elem(undo_stack *undo) {
 	if (!undo->cur_valid)
 		return NULL;
 	return &undo->stack[undo->cur];
 }
 
 void
 undo_change_mode_group(undo_stack *undo) {
 	undo->change_mode_group = 1;
 }
 
 #if TEST
 void
 dump_undo_stack(FILE *file, undo_stack *undo) {
 	fprintf(
 	    file,
 	    "cur: %zu, cur_valid: %d, change_mode_group: %d, len: %zu, cap: %zu\n",
 	    undo->cur, undo->cur_valid, undo->change_mode_group, undo->len, undo->cap
 	);
 	for (size_t i = 0; i < undo->len; i++) {
 		undo_elem *e = &undo->stack[i];
 		fprintf(
 		    file,
 		    "type %d, mode %d, group %d, mode_group %d, text '%.*s', "
 		    "op_range (%zu,%zu;%zu,%zu), cursor_range (%zu,%zu;%zu,%zu)\n",
 		    e->type, e->mode, e->group, e->mode_group, (int)e->text->len, e->text->text,
 		    e->op_range.line1, e->op_range.byte1, e->op_range.line2, e->op_range.byte2,
 		    e->cursor_range.line1, e->cursor_range.byte1, e->cursor_range.line2, e->cursor_range.byte2
 		);
 	}
 }
 #endif
 
 static void
 push_undo(
     undo_stack *undo, txtbuf *text,
     ledit_range insert_range, /* maybe not the best name */
     ledit_range cursor_range,
     int start_group,
     enum operation type, ledit_mode mode) {
 	undo_elem *old = peek_undo_elem(undo);
 	int last_group = old == NULL ? 0 : old->group;
 	int last_mode_group = old == NULL ? 0 : old->mode_group;
 	undo_elem *e = push_undo_elem(undo);
 	e->group = start_group ? !last_group : last_group;
 	e->mode_group = undo->change_mode_group ? !last_mode_group : last_mode_group;
 	undo->change_mode_group = 0;
 	e->op_range = insert_range;
 	e->cursor_range = cursor_range;
 	e->mode = mode;
 	e->type = type;
 	if (e->text != NULL)
 		txtbuf_copy(e->text, text);
 	else
 		e->text = txtbuf_dup(text);
 }
 
 void
 undo_push_insert(
     undo_stack *undo, txtbuf *text,
     ledit_range insert_range, ledit_range cursor_range,
     int start_group, ledit_mode mode) {
 	push_undo(
 	    undo, text, insert_range, cursor_range,
 	    start_group, UNDO_INSERT, mode
 	);
 }
 
 void
 undo_push_delete(
     undo_stack *undo, txtbuf *text,
     ledit_range delete_range, ledit_range cursor_range,
     int start_group, ledit_mode mode) {
 	push_undo(
 	    undo, text, delete_range, cursor_range,
 	    start_group, UNDO_DELETE, mode
 	);
 }
 
 undo_status
 ledit_undo(undo_stack *undo, ledit_mode mode, void *callback_data,
     undo_insert_callback insert_cb, undo_delete_callback delete_cb,
     size_t *cur_line_ret, size_t *cur_index_ret, size_t *min_line_ret) {
 	undo_elem *e;
 	/* skip empty elements */
 	while (undo->cur_valid && undo->stack[undo->cur].text->len == 0) {
 		if (undo->cur == 0)
 			undo->cur_valid = 0;
 		else
 			undo->cur--;
 	}
 	if (!undo->cur_valid)
 		return UNDO_OLDEST_CHANGE;
 	int group = undo->stack[undo->cur].group;
 	int mode_group = undo->stack[undo->cur].mode_group;
 	size_t min_line = SIZE_MAX;
 	int mode_group_same = 0;
 	size_t cur_line = 0;
 	size_t cur_index = 0;
 	while (undo->cur_valid &&
 	       (undo->stack[undo->cur].group == group || (mode_group_same =
 	        ((mode == NORMAL ||
 	          mode == VISUAL) &&
 	         undo->stack[undo->cur].mode == INSERT &&
 	         undo->stack[undo->cur].mode_group == mode_group)))) {
 		e = &undo->stack[undo->cur];
 		/* if the mode group is the same, we need to update the group,
 		   otherwise it can happen that some iterations are performed
 		   because the mode group (but not the normal group) is the
 		   same, and then the next normal group is also undone because
 		   it has the same group id as the original group here */
 		if (mode_group_same)
 			group = e->group;
 		switch (e->type) {
 		case UNDO_INSERT:
 			/* FIXME: should the paste buffer also be modified? */
 			/* printf("delete %zu,%zu; %zu,%zu\n", e->op_range.line1, e->op_range.byte1, e->op_range.line2, e->op_range.byte2); */
 			delete_cb(
 			    callback_data,
 			    e->op_range.line1, e->op_range.byte1,
 			    e->op_range.line2, e->op_range.byte2
 			);
 			break;
 		case UNDO_DELETE:
 			/* printf("delete %zu,%zu; %zu,%zu\n", e->op_range.line1, e->op_range.byte1, e->op_range.line2, e->op_range.byte2); */
 			insert_cb(
 			    callback_data,
 			    e->op_range.line1, e->op_range.byte1,
 			    e->text->text, e->text->len
 			);
 			break;
 		default:
 			/* FIXME: show this as a message */
 			fprintf(stderr, "Error with undo. This should not happen. Fix the code please.\n");
 			break;
 		}
 		/* FIXME: make sure this is always sorted already */
 		if (e->op_range.line1 < min_line)
 			min_line = e->op_range.line1;
 		if (undo->cur == 0)
 			undo->cur_valid = 0;
 		else
 			undo->cur--;
 		cur_line = e->cursor_range.line1;
 		cur_index = e->cursor_range.byte1;
 	}
 	/* these can't be written directly in the while loop because that causes
 	   conflicts - when text is inserted/deleted on the current line of the
 	   view, the cursor is updated, but if the current line was already changed
 	   here before the end of the undo run, it's possible for multiple lines
 	   to have a cursor highlight set in the end (at least when working with
 	   multiple views) */
 	*cur_line_ret = cur_line;
 	*cur_index_ret = cur_index;
 	*min_line_ret = min_line;
 	if (mode == NORMAL || mode == VISUAL)
 		undo_change_mode_group(undo);
 	return UNDO_NORMAL;
 }
 
 undo_status
 ledit_redo(undo_stack *undo, ledit_mode mode, void *callback_data,
     undo_insert_callback insert_cb, undo_delete_callback delete_cb,
     size_t *cur_line_ret, size_t *cur_index_ret, size_t *min_line_ret) {
 	undo_elem *e;
 	if (undo->len == 0)
 		return UNDO_NEWEST_CHANGE;
 	/* skip elements where no text is changed */
 	while (undo->cur < undo->len - 1 && undo->stack[undo->cur + 1].text->len == 0) {
 		undo->cur++;
 	}
 	if (undo->cur_valid && undo->cur >= undo->len - 1)
 		return UNDO_NEWEST_CHANGE;
 	if (!undo->cur_valid) {
 		undo->cur_valid = 1;
 		undo->cur = 0;
 	} else {
 		undo->cur++;
 	}
 	int group = undo->stack[undo->cur].group;
 	int mode_group = undo->stack[undo->cur].mode_group;
 	size_t min_line = SIZE_MAX;
 	int mode_group_same = 0;
 	size_t cur_line = 0;
 	size_t cur_index = 0;
 	while (undo->cur < undo->len &&
 	       (undo->stack[undo->cur].group == group || (mode_group_same =
 	        ((mode == NORMAL ||
 	          mode == VISUAL) &&
 	         undo->stack[undo->cur].mode == INSERT &&
 	         undo->stack[undo->cur].mode_group == mode_group)))) {
 		e = &undo->stack[undo->cur];
 		if (mode_group_same)
 			group = e->group;
 		switch (e->type) {
 		case UNDO_INSERT:
 			insert_cb(
 			    callback_data,
 			    e->op_range.line1, e->op_range.byte1,
 			    e->text->text, e->text->len
 			);
 			break;
 		case UNDO_DELETE:
 			delete_cb(
 			    callback_data,
 			    e->op_range.line1, e->op_range.byte1,
 			    e->op_range.line2, e->op_range.byte2
 			);
 			break;
 		default:
 			fprintf(stderr, "Error with redo. This should not happen. Fix the code please.\n");
 			break;
 		}
 		if (e->op_range.line1 < min_line)
 			min_line = e->op_range.line1;
 		undo->cur++;
 		cur_line = e->cursor_range.line2;
 		cur_index = e->cursor_range.byte2;
 	}
 	*cur_line_ret = cur_line;
 	*cur_index_ret = cur_index;
 	/* it should theoretically never be 0 anyways, but whatever */
 	if (undo->cur > 0)
 		undo->cur--;
 	*min_line_ret = min_line;
 	if (mode == NORMAL || mode == VISUAL)
 		undo_change_mode_group(undo);
 	return UNDO_NORMAL;
 }
 
 void
 undo_change_last_cur_range(undo_stack *undo, ledit_range cur_range) {
 	undo_elem *e = peek_undo_elem(undo);
 	if (e != NULL)
 		e->cursor_range = cur_range;
 }
 
 char *
 undo_state_to_str(undo_status s) {
 	switch (s) {
 	case UNDO_NORMAL:
 		return "Performed undo/redo";
 	case UNDO_OLDEST_CHANGE:
 		return "Already at oldest change";
 	case UNDO_NEWEST_CHANGE:
 		return "Already at newest change";
 	default:
 		return "This is a bug. Tell lumidify about it.";
 	}
 }