--- /dev/null
+/* $OpenBSD: undo.c,v 1.50 2010/06/30 19:12:54 oga Exp $ */
+/*
+ * This file is in the public domain
+ */
+
+#include "def.h"
+#include "kbd.h"
+
+#define MAX_FREE_RECORDS 32
+
+/*
+ * Local variables
+ */
+static struct undoq undo_free;
+static int undo_free_num;
+static int boundary_flag = TRUE;
+static int undo_enable_flag = TRUE;
+
+/*
+ * Local functions
+ */
+static int find_dot(struct line *, int);
+static int find_lo(int, struct line **, int *, int *);
+static struct undo_rec *new_undo_record(void);
+static int drop_oldest_undo_record(void);
+
+/*
+ * find_dot, find_lo()
+ *
+ * Find an absolute dot in the buffer from a line/offset pair, and vice-versa.
+ *
+ * Since lines can be deleted while they are referenced by undo record, we
+ * need to have an absolute dot to have something reliable.
+ */
+static int
+find_dot(struct line *lp, int off)
+{
+ int count = 0;
+ struct line *p;
+
+ for (p = curbp->b_headp; p != lp; p = lforw(p)) {
+ if (count != 0) {
+ if (p == curbp->b_headp) {
+ ewprintf("Error: Undo stuff called with a"
+ "nonexistent line");
+ return (FALSE);
+ }
+ }
+ count += llength(p) + 1;
+ }
+ count += off;
+
+ return (count);
+}
+
+static int
+find_lo(int pos, struct line **olp, int *offset, int *lnum)
+{
+ struct line *p;
+ int lineno;
+
+ p = curbp->b_headp;
+ lineno = 0;
+ while (pos > llength(p)) {
+ pos -= llength(p) + 1;
+ if ((p = lforw(p)) == curbp->b_headp) {
+ *olp = NULL;
+ *offset = 0;
+ return (FALSE);
+ }
+ lineno++;
+ }
+ *olp = p;
+ *offset = pos;
+ *lnum = lineno;
+
+ return (TRUE);
+}
+
+static struct undo_rec *
+new_undo_record(void)
+{
+ struct undo_rec *rec;
+
+ rec = TAILQ_FIRST(&undo_free);
+ if (rec != NULL) {
+ /* Remove it from the free-list */
+ TAILQ_REMOVE(&undo_free, rec, next);
+ undo_free_num--;
+ } else {
+ if ((rec = malloc(sizeof(*rec))) == NULL)
+ panic("Out of memory in undo code (record)");
+ }
+ memset(rec, 0, sizeof(struct undo_rec));
+
+ return (rec);
+}
+
+void
+free_undo_record(struct undo_rec *rec)
+{
+ static int initialised = 0;
+
+ /*
+ * On the first run, do initialisation of the free list.
+ */
+ if (initialised == 0) {
+ TAILQ_INIT(&undo_free);
+ initialised = 1;
+ }
+ if (rec->content != NULL) {
+ free(rec->content);
+ rec->content = NULL;
+ }
+ if (undo_free_num >= MAX_FREE_RECORDS) {
+ free(rec);
+ return;
+ }
+ undo_free_num++;
+
+ TAILQ_INSERT_HEAD(&undo_free, rec, next);
+}
+
+/*
+ * Drop the oldest undo record in our list. Return 1 if we could remove it,
+ * 0 if the undo list was empty.
+ */
+static int
+drop_oldest_undo_record(void)
+{
+ struct undo_rec *rec;
+
+ rec = TAILQ_LAST(&curbp->b_undo, undoq);
+ if (rec != NULL) {
+ undo_free_num--;
+ TAILQ_REMOVE(&curbp->b_undo, rec, next);
+ free_undo_record(rec);
+ return (1);
+ }
+ return (0);
+}
+
+static int
+lastrectype(void)
+{
+ struct undo_rec *rec;
+
+ if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL)
+ return (rec->type);
+ return (0);
+}
+
+/*
+ * Returns TRUE if undo is enabled, FALSE otherwise.
+ */
+int
+undo_enabled(void)
+{
+ return (undo_enable_flag);
+}
+
+/*
+ * undo_enable: toggle undo_enable.
+ * Returns the previous value of the flag.
+ */
+int
+undo_enable(int f, int n)
+{
+ int pon = undo_enable_flag;
+
+ if (f & (FFARG | FFRAND))
+ undo_enable_flag = n > 0;
+ else
+ undo_enable_flag = !undo_enable_flag;
+
+ if (!(f & FFRAND))
+ ewprintf("Undo %sabled", undo_enable_flag ? "en" : "dis");
+
+ return (pon);
+}
+
+/*
+ * If undo is enabled, then:
+ * Toggle undo boundary recording.
+ * If called with an argument, (n > 0) => enable. Otherwise disable.
+ * In either case, add an undo boundary
+ * If undo is disabled, this function has no effect.
+ */
+int
+undo_boundary_enable(int f, int n)
+{
+ int bon = boundary_flag;
+
+ if (!undo_enable_flag)
+ return (FALSE);
+
+ undo_add_boundary(FFRAND, 1);
+
+ if (f & (FFARG | FFRAND))
+ boundary_flag = n > 0;
+ else
+ boundary_flag = !boundary_flag;
+
+ if (!(f & FFRAND))
+ ewprintf("Undo boundaries %sabled",
+ boundary_flag ? "en" : "dis");
+
+ return (bon);
+}
+
+/*
+ * Record an undo boundary, unless boundary_flag == FALSE.
+ * Does nothing if previous undo entry is already a boundary or 'modified' flag.
+ */
+int
+undo_add_boundary(int f, int n)
+{
+ struct undo_rec *rec;
+ int last;
+
+ if (boundary_flag == FALSE)
+ return (FALSE);
+
+ last = lastrectype();
+ if (last == BOUNDARY || last == MODIFIED)
+ return (TRUE);
+
+ rec = new_undo_record();
+ rec->type = BOUNDARY;
+
+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
+
+ return (TRUE);
+}
+
+/*
+ * Record an undo "modified" boundary
+ */
+void
+undo_add_modified(void)
+{
+ struct undo_rec *rec;
+
+ rec = new_undo_record();
+ rec->type = MODIFIED;
+
+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
+
+ return;
+}
+
+int
+undo_add_insert(struct line *lp, int offset, int size)
+{
+ struct region reg;
+ struct undo_rec *rec;
+ int pos;
+
+ if (!undo_enable_flag)
+ return (TRUE);
+ reg.r_linep = lp;
+ reg.r_offset = offset;
+ reg.r_size = size;
+
+ pos = find_dot(lp, offset);
+
+ /*
+ * We try to reuse the last undo record to `compress' things.
+ */
+ rec = TAILQ_FIRST(&curbp->b_undo);
+ if (rec != NULL && rec->type == INSERT) {
+ if (rec->pos + rec->region.r_size == pos) {
+ rec->region.r_size += reg.r_size;
+ return (TRUE);
+ }
+ }
+
+ /*
+ * We couldn't reuse the last undo record, so prepare a new one.
+ */
+ rec = new_undo_record();
+ rec->pos = pos;
+ rec->type = INSERT;
+ memmove(&rec->region, ®, sizeof(struct region));
+ rec->content = NULL;
+
+ undo_add_boundary(FFRAND, 1);
+
+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
+
+ return (TRUE);
+}
+
+/*
+ * This of course must be done _before_ the actual deletion is done.
+ */
+int
+undo_add_delete(struct line *lp, int offset, int size, int isreg)
+{
+ struct region reg;
+ struct undo_rec *rec;
+ int pos;
+
+ if (!undo_enable_flag)
+ return (TRUE);
+
+ reg.r_linep = lp;
+ reg.r_offset = offset;
+ reg.r_size = size;
+
+ pos = find_dot(lp, offset);
+
+ if (offset == llength(lp)) /* if it's a newline... */
+ undo_add_boundary(FFRAND, 1);
+ else if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL) {
+ /*
+ * Separate this command from the previous one if we're not
+ * just before the previous record...
+ */
+ if (!isreg && rec->type == DELETE) {
+ if (rec->pos - rec->region.r_size != pos)
+ undo_add_boundary(FFRAND, 1);
+ }
+ }
+ rec = new_undo_record();
+ rec->pos = pos;
+ if (isreg)
+ rec->type = DELREG;
+ else
+ rec->type = DELETE;
+ memmove(&rec->region, ®, sizeof(struct region));
+ do {
+ rec->content = malloc(reg.r_size + 1);
+ } while ((rec->content == NULL) && drop_oldest_undo_record());
+
+ if (rec->content == NULL)
+ panic("Out of memory");
+
+ region_get_data(®, rec->content, reg.r_size);
+
+ if (isreg || lastrectype() != DELETE)
+ undo_add_boundary(FFRAND, 1);
+
+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
+
+ return (TRUE);
+}
+
+/*
+ * This of course must be called before the change takes place.
+ */
+int
+undo_add_change(struct line *lp, int offset, int size)
+{
+ if (!undo_enable_flag)
+ return (TRUE);
+ undo_add_boundary(FFRAND, 1);
+ boundary_flag = FALSE;
+ undo_add_delete(lp, offset, size, 0);
+ undo_add_insert(lp, offset, size);
+ boundary_flag = TRUE;
+ undo_add_boundary(FFRAND, 1);
+
+ return (TRUE);
+}
+
+/*
+ * Show the undo records for the current buffer in a new buffer.
+ */
+/* ARGSUSED */
+int
+undo_dump(int f, int n)
+{
+ struct undo_rec *rec;
+ struct buffer *bp;
+ struct mgwin *wp;
+ char buf[4096], tmp[1024];
+ int num;
+
+ /*
+ * Prepare the buffer for insertion.
+ */
+ if ((bp = bfind("*undo*", TRUE)) == NULL)
+ return (FALSE);
+ bp->b_flag |= BFREADONLY;
+ bclear(bp);
+ popbuf(bp, WNONE);
+
+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+ if (wp->w_bufp == bp) {
+ wp->w_dotp = bp->b_headp;
+ wp->w_doto = 0;
+ }
+ }
+
+ num = 0;
+ TAILQ_FOREACH(rec, &curbp->b_undo, next) {
+ num++;
+ snprintf(buf, sizeof(buf),
+ "%d:\t %s at %d ", num,
+ (rec->type == DELETE) ? "DELETE":
+ (rec->type == DELREG) ? "DELREGION":
+ (rec->type == INSERT) ? "INSERT":
+ (rec->type == BOUNDARY) ? "----" :
+ (rec->type == MODIFIED) ? "MODIFIED": "UNKNOWN",
+ rec->pos);
+
+ if (rec->content) {
+ (void)strlcat(buf, "\"", sizeof(buf));
+ snprintf(tmp, sizeof(tmp), "%.*s", rec->region.r_size,
+ rec->content);
+ (void)strlcat(buf, tmp, sizeof(buf));
+ (void)strlcat(buf, "\"", sizeof(buf));
+ }
+ snprintf(tmp, sizeof(tmp), " [%d]", rec->region.r_size);
+ if (strlcat(buf, tmp, sizeof(buf)) >= sizeof(buf)) {
+ ewprintf("Undo record too large. Aborted.");
+ return (FALSE);
+ }
+ addlinef(bp, "%s", buf);
+ }
+ return (TRUE);
+}
+
+/*
+ * After the user did action1, then action2, then action3:
+ *
+ * [action3] <--- Undoptr
+ * [action2]
+ * [action1]
+ * ------
+ * [undo]
+ *
+ * After undo:
+ *
+ * [undo of action3]
+ * [action2] <--- Undoptr
+ * [action1]
+ * ------
+ * [undo]
+ *
+ * After another undo:
+ *
+ *
+ * [undo of action2]
+ * [undo of action3]
+ * [action1] <--- Undoptr
+ * ------
+ * [undo]
+ *
+ * Note that the "undo of actionX" have no special meaning. Only when
+ * we undo a deletion, the insertion will be recorded just as if it
+ * was typed on the keyboard. Resulting in the inverse operation being
+ * saved in the list.
+ *
+ * If undoptr reaches the bottom of the list, or if we moved between
+ * two undo actions, we make it point back at the topmost record. This is
+ * how we handle redoing.
+ */
+/* ARGSUSED */
+int
+undo(int f, int n)
+{
+ struct undo_rec *ptr, *nptr;
+ int done, rval;
+ struct line *lp;
+ int offset, save, dot;
+ static int nulled = FALSE;
+ int lineno;
+
+ if (n < 0)
+ return (FALSE);
+
+ dot = find_dot(curwp->w_dotp, curwp->w_doto);
+
+ ptr = curbp->b_undoptr;
+
+ /* first invocation, make ptr point back to the top of the list */
+ if ((ptr == NULL && nulled == TRUE) || rptcount == 0) {
+ ptr = TAILQ_FIRST(&curbp->b_undo);
+ nulled = TRUE;
+ }
+
+ rval = TRUE;
+ while (n--) {
+ /* if we have a spurious boundary, free it and move on.... */
+ while (ptr && ptr->type == BOUNDARY) {
+ nptr = TAILQ_NEXT(ptr, next);
+ TAILQ_REMOVE(&curbp->b_undo, ptr, next);
+ free_undo_record(ptr);
+ ptr = nptr;
+ }
+ /*
+ * Ptr is NULL, but on the next run, it will point to the
+ * top again, redoing all stuff done in the buffer since
+ * its creation.
+ */
+ if (ptr == NULL) {
+ ewprintf("No further undo information");
+ rval = FALSE;
+ nulled = TRUE;
+ break;
+ }
+ nulled = FALSE;
+
+ /*
+ * Loop while we don't get a boundary specifying we've
+ * finished the current action...
+ */
+
+ undo_add_boundary(FFRAND, 1);
+
+ save = boundary_flag;
+ boundary_flag = FALSE;
+
+ done = 0;
+ do {
+ /*
+ * Move to where this has to apply
+ *
+ * Boundaries (and the modified flag) are put as
+ * position 0 (to save lookup time in find_dot)
+ * so we must not move there...
+ */
+ if (ptr->type != BOUNDARY && ptr->type != MODIFIED) {
+ if (find_lo(ptr->pos, &lp,
+ &offset, &lineno) == FALSE) {
+ ewprintf("Internal error in Undo!");
+ rval = FALSE;
+ break;
+ }
+ curwp->w_dotp = lp;
+ curwp->w_doto = offset;
+ curwp->w_markline = curwp->w_dotline;
+ curwp->w_dotline = lineno;
+ }
+
+ /*
+ * Do operation^-1
+ */
+ switch (ptr->type) {
+ case INSERT:
+ ldelete(ptr->region.r_size, KNONE);
+ break;
+ case DELETE:
+ lp = curwp->w_dotp;
+ offset = curwp->w_doto;
+ region_put_data(ptr->content,
+ ptr->region.r_size);
+ curwp->w_dotp = lp;
+ curwp->w_doto = offset;
+ break;
+ case DELREG:
+ region_put_data(ptr->content,
+ ptr->region.r_size);
+ break;
+ case BOUNDARY:
+ done = 1;
+ break;
+ case MODIFIED:
+ curbp->b_flag &= ~BFCHG;
+ break;
+ default:
+ break;
+ }
+
+ /* And move to next record */
+ ptr = TAILQ_NEXT(ptr, next);
+ } while (ptr != NULL && !done);
+
+ boundary_flag = save;
+ undo_add_boundary(FFRAND, 1);
+
+ ewprintf("Undo!");
+ }
+ /*
+ * Record where we are. (we have to save our new position at the end
+ * since we change the dot when undoing....)
+ */
+ curbp->b_undoptr = ptr;
+
+ curbp->b_undopos = find_dot(curwp->w_dotp, curwp->w_doto);
+
+ return (rval);
+}
projects / pd_readline / blobdiff