Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/undo.c	Lines:	0	232	0.0 %
Date:	2017-11-07	Branches:	0	140	0.0 %


/* $OpenBSD: undo.c,v 1.58 2016/09/05 08:10:58 lum Exp $ */
/*
 * This file is in the public domain
 */

#include <sys/queue.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#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) {
				dobeep();
				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;
	}
	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, *trec;

	TAILQ_FOREACH_SAFE(rec, &curbp->b_undo, next, trec)
		if (rec->type == MODIFIED) {
			TAILQ_REMOVE(&curbp->b_undo, rec, next);
			free_undo_record(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);

	memset(&reg, 0, sizeof(reg));
	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, &reg, 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);

	memset(&reg, 0, sizeof(reg));
	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, &reg, 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(&reg, 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);
	if ((wp = popbuf(bp, WNONE)) == NULL)
		return (FALSE);

	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)) {
			dobeep();
			ewprintf("Undo record too large. Aborted.");
			return (FALSE);
		}
		addlinef(bp, "%s", buf);
	}
	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
		if (wp->w_bufp == bp) {
			wp->w_dotline = num+1;
			wp->w_rflag |= WFFULL;
		}
	}
	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;
	static int	 nulled = FALSE;
	int		 lineno;

	if (n < 0)
		return (FALSE);

	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) {
			dobeep();
			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) {
					dobeep();
					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!");
	}

	curbp->b_undoptr = ptr;

	return (rval);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: undo.c,v 1.58 2016/09/05 08:10:58 lum Exp $ */
2			/*
3			* This file is in the public domain
4			*/
5
6			#include <sys/queue.h>
7			#include <signal.h>
8			#include <stdio.h>
9			#include <stdlib.h>
10			#include <string.h>
11
12			#include "def.h"
13			#include "kbd.h"
14
15			#define MAX_FREE_RECORDS 32
16
17			/*
18			* Local variables
19			*/
20			static struct undoq undo_free;
21			static int undo_free_num;
22			static int boundary_flag = TRUE;
23			static int undo_enable_flag = TRUE;
24
25			/*
26			* Local functions
27			*/
28			static int find_dot(struct line *, int);
29			static int find_lo(int, struct line *, int , int *);
30			static struct undo_rec *new_undo_record(void);
31			static int drop_oldest_undo_record(void);
32
33			/*
34			* find_dot, find_lo()
35			*
36			* Find an absolute dot in the buffer from a line/offset pair, and vice-versa.
37			*
38			* Since lines can be deleted while they are referenced by undo record, we
39			* need to have an absolute dot to have something reliable.
40			*/
41			static int
42			find_dot(struct line *lp, int off)
43			{
44			int count = 0;
45			struct line *p;
46
47			for (p = curbp->b_headp; p != lp; p = lforw(p)) {
48			if (count != 0) {
49			if (p == curbp->b_headp) {
50			dobeep();
51			ewprintf("Error: Undo stuff called with a"
52			"nonexistent line");
53			return (FALSE);
54			}
55			}
56			count += llength(p) + 1;
57			}
58			count += off;
59
60			return (count);
61			}
62
63			static int
64			find_lo(int pos, struct line *olp, int offset, int *lnum)
65			{
66			struct line *p;
67			int lineno;
68
69			p = curbp->b_headp;
70			lineno = 0;
71			while (pos > llength(p)) {
72			pos -= llength(p) + 1;
73			if ((p = lforw(p)) == curbp->b_headp) {
74			*olp = NULL;
75			*offset = 0;
76			return (FALSE);
77			}
78			lineno++;
79			}
80			*olp = p;
81			*offset = pos;
82			*lnum = lineno;
83
84			return (TRUE);
85			}
86
87			static struct undo_rec *
88			new_undo_record(void)
89			{
90			struct undo_rec *rec;
91
92			rec = TAILQ_FIRST(&undo_free);
93			if (rec != NULL) {
94			/* Remove it from the free-list */
95			TAILQ_REMOVE(&undo_free, rec, next);
96			undo_free_num--;
97			} else {
98			if ((rec = malloc(sizeof(*rec))) == NULL)
99			panic("Out of memory in undo code (record)");
100			}
101			memset(rec, 0, sizeof(struct undo_rec));
102
103			return (rec);
104			}
105
106			void
107			free_undo_record(struct undo_rec *rec)
108			{
109			static int initialised = 0;
110
111			/*
112			* On the first run, do initialisation of the free list.
113			*/
114			if (initialised == 0) {
115			TAILQ_INIT(&undo_free);
116			initialised = 1;
117			}
118			free(rec->content);
119			rec->content = NULL;
120			if (undo_free_num >= MAX_FREE_RECORDS) {
121			free(rec);
122			return;
123			}
124			undo_free_num++;
125
126			TAILQ_INSERT_HEAD(&undo_free, rec, next);
127			}
128
129			/*
130			* Drop the oldest undo record in our list. Return 1 if we could remove it,
131			* 0 if the undo list was empty.
132			*/
133			static int
134			drop_oldest_undo_record(void)
135			{
136			struct undo_rec *rec;
137
138			rec = TAILQ_LAST(&curbp->b_undo, undoq);
139			if (rec != NULL) {
140			undo_free_num--;
141			TAILQ_REMOVE(&curbp->b_undo, rec, next);
142			free_undo_record(rec);
143			return (1);
144			}
145			return (0);
146			}
147
148			static int
149			lastrectype(void)
150			{
151			struct undo_rec *rec;
152
153			if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL)
154			return (rec->type);
155			return (0);
156			}
157
158			/*
159			* Returns TRUE if undo is enabled, FALSE otherwise.
160			*/
161			int
162			undo_enabled(void)
163			{
164			return (undo_enable_flag);
165			}
166
167			/*
168			* undo_enable: toggle undo_enable.
169			* Returns the previous value of the flag.
170			*/
171			int
172			undo_enable(int f, int n)
173			{
174			int pon = undo_enable_flag;
175
176			if (f & (FFARG \| FFRAND))
177			undo_enable_flag = n > 0;
178			else
179			undo_enable_flag = !undo_enable_flag;
180
181			if (!(f & FFRAND))
182			ewprintf("Undo %sabled", undo_enable_flag ? "en" : "dis");
183
184			return (pon);
185			}
186
187			/*
188			* If undo is enabled, then:
189			* Toggle undo boundary recording.
190			* If called with an argument, (n > 0) => enable. Otherwise disable.
191			* In either case, add an undo boundary
192			* If undo is disabled, this function has no effect.
193			*/
194			int
195			undo_boundary_enable(int f, int n)
196			{
197			int bon = boundary_flag;
198
199			if (!undo_enable_flag)
200			return (FALSE);
201
202			undo_add_boundary(FFRAND, 1);
203
204			if (f & (FFARG \| FFRAND))
205			boundary_flag = n > 0;
206			else
207			boundary_flag = !boundary_flag;
208
209			if (!(f & FFRAND))
210			ewprintf("Undo boundaries %sabled",
211			boundary_flag ? "en" : "dis");
212
213			return (bon);
214			}
215
216			/*
217			* Record an undo boundary, unless boundary_flag == FALSE.
218			* Does nothing if previous undo entry is already a boundary or 'modified' flag.
219			*/
220			int
221			undo_add_boundary(int f, int n)
222			{
223			struct undo_rec *rec;
224			int last;
225
226			if (boundary_flag == FALSE)
227			return (FALSE);
228
229			last = lastrectype();
230			if (last == BOUNDARY \|\| last == MODIFIED)
231			return (TRUE);
232
233			rec = new_undo_record();
234			rec->type = BOUNDARY;
235
236			TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
237
238			return (TRUE);
239			}
240
241			/*
242			* Record an undo "modified" boundary
243			*/
244			void
245			undo_add_modified(void)
246			{
247			struct undo_rec rec, trec;
248
249			TAILQ_FOREACH_SAFE(rec, &curbp->b_undo, next, trec)
250			if (rec->type == MODIFIED) {
251			TAILQ_REMOVE(&curbp->b_undo, rec, next);
252			free_undo_record(rec);
253			}
254
255			rec = new_undo_record();
256			rec->type = MODIFIED;
257
258			TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
259
260			return;
261			}
262
263			int
264			undo_add_insert(struct line *lp, int offset, int size)
265			{
266			struct region reg;
267			struct undo_rec *rec;
268			int pos;
269
270			if (!undo_enable_flag)
271			return (TRUE);
272
273			memset(&reg, 0, sizeof(reg));
274			reg.r_linep = lp;
275			reg.r_offset = offset;
276			reg.r_size = size;
277
278			pos = find_dot(lp, offset);
279
280			/*
281			* We try to reuse the last undo record to `compress' things.
282			*/
283			rec = TAILQ_FIRST(&curbp->b_undo);
284			if (rec != NULL && rec->type == INSERT) {
285			if (rec->pos + rec->region.r_size == pos) {
286			rec->region.r_size += reg.r_size;
287			return (TRUE);
288			}
289			}
290
291			/*
292			* We couldn't reuse the last undo record, so prepare a new one.
293			*/
294			rec = new_undo_record();
295			rec->pos = pos;
296			rec->type = INSERT;
297			memmove(&rec->region, &reg, sizeof(struct region));
298			rec->content = NULL;
299
300			undo_add_boundary(FFRAND, 1);
301
302			TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
303
304			return (TRUE);
305			}
306
307			/*
308			* This of course must be done _before_ the actual deletion is done.
309			*/
310			int
311			undo_add_delete(struct line *lp, int offset, int size, int isreg)
312			{
313			struct region reg;
314			struct undo_rec *rec;
315			int pos;
316
317			if (!undo_enable_flag)
318			return (TRUE);
319
320			memset(&reg, 0, sizeof(reg));
321			reg.r_linep = lp;
322			reg.r_offset = offset;
323			reg.r_size = size;
324
325			pos = find_dot(lp, offset);
326
327			if (offset == llength(lp)) /* if it's a newline... */
328			undo_add_boundary(FFRAND, 1);
329			else if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL) {
330			/*
331			* Separate this command from the previous one if we're not
332			* just before the previous record...
333			*/
334			if (!isreg && rec->type == DELETE) {
335			if (rec->pos - rec->region.r_size != pos)
336			undo_add_boundary(FFRAND, 1);
337			}
338			}
339			rec = new_undo_record();
340			rec->pos = pos;
341			if (isreg)
342			rec->type = DELREG;
343			else
344			rec->type = DELETE;
345			memmove(&rec->region, &reg, sizeof(struct region));
346			do {
347			rec->content = malloc(reg.r_size + 1);
348			} while ((rec->content == NULL) && drop_oldest_undo_record());
349
350			if (rec->content == NULL)
351			panic("Out of memory");
352
353			region_get_data(&reg, rec->content, reg.r_size);
354
355			if (isreg \|\| lastrectype() != DELETE)
356			undo_add_boundary(FFRAND, 1);
357
358			TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
359
360			return (TRUE);
361			}
362
363			/*
364			* This of course must be called before the change takes place.
365			*/
366			int
367			undo_add_change(struct line *lp, int offset, int size)
368			{
369			if (!undo_enable_flag)
370			return (TRUE);
371			undo_add_boundary(FFRAND, 1);
372			boundary_flag = FALSE;
373			undo_add_delete(lp, offset, size, 0);
374			undo_add_insert(lp, offset, size);
375			boundary_flag = TRUE;
376			undo_add_boundary(FFRAND, 1);
377
378			return (TRUE);
379			}
380
381			/*
382			* Show the undo records for the current buffer in a new buffer.
383			*/
384			/* ARGSUSED */
385			int
386			undo_dump(int f, int n)
387			{
388			struct undo_rec *rec;
389			struct buffer *bp;
390			struct mgwin *wp;
391			char buf[4096], tmp[1024];
392			int num;
393
394			/*
395			* Prepare the buffer for insertion.
396			*/
397			if ((bp = bfind("undo", TRUE)) == NULL)
398			return (FALSE);
399			bp->b_flag \|= BFREADONLY;
400			bclear(bp);
401			if ((wp = popbuf(bp, WNONE)) == NULL)
402			return (FALSE);
403
404			for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
405			if (wp->w_bufp == bp) {
406			wp->w_dotp = bp->b_headp;
407			wp->w_doto = 0;
408			}
409			}
410
411			num = 0;
412			TAILQ_FOREACH(rec, &curbp->b_undo, next) {
413			num++;
414			snprintf(buf, sizeof(buf),
415			"%d:\t %s at %d ", num,
416			(rec->type == DELETE) ? "DELETE":
417			(rec->type == DELREG) ? "DELREGION":
418			(rec->type == INSERT) ? "INSERT":
419			(rec->type == BOUNDARY) ? "----" :
420			(rec->type == MODIFIED) ? "MODIFIED": "UNKNOWN",
421			rec->pos);
422
423			if (rec->content) {
424			(void)strlcat(buf, "\"", sizeof(buf));
425			snprintf(tmp, sizeof(tmp), "%.*s", rec->region.r_size,
426			rec->content);
427			(void)strlcat(buf, tmp, sizeof(buf));
428			(void)strlcat(buf, "\"", sizeof(buf));
429			}
430			snprintf(tmp, sizeof(tmp), " [%d]", rec->region.r_size);
431			if (strlcat(buf, tmp, sizeof(buf)) >= sizeof(buf)) {
432			dobeep();
433			ewprintf("Undo record too large. Aborted.");
434			return (FALSE);
435			}
436			addlinef(bp, "%s", buf);
437			}
438			for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
439			if (wp->w_bufp == bp) {
440			wp->w_dotline = num+1;
441			wp->w_rflag \|= WFFULL;
442			}
443			}
444			return (TRUE);
445			}
446
447			/*
448			* After the user did action1, then action2, then action3:
449			*
450			* [action3] <--- Undoptr
451			* [action2]
452			* [action1]
453			* ------
454			* [undo]
455			*
456			* After undo:
457			*
458			* [undo of action3]
459			* [action2] <--- Undoptr
460			* [action1]
461			* ------
462			* [undo]
463			*
464			* After another undo:
465			*
466			*
467			* [undo of action2]
468			* [undo of action3]
469			* [action1] <--- Undoptr
470			* ------
471			* [undo]
472			*
473			* Note that the "undo of actionX" have no special meaning. Only when
474			* we undo a deletion, the insertion will be recorded just as if it
475			* was typed on the keyboard. Resulting in the inverse operation being
476			* saved in the list.
477			*
478			* If undoptr reaches the bottom of the list, or if we moved between
479			* two undo actions, we make it point back at the topmost record. This is
480			* how we handle redoing.
481			*/
482			/* ARGSUSED */
483			int
484			undo(int f, int n)
485			{
486			struct undo_rec ptr, nptr;
487			int done, rval;
488			struct line *lp;
489			int offset, save;
490			static int nulled = FALSE;
491			int lineno;
492
493			if (n < 0)
494			return (FALSE);
495
496			ptr = curbp->b_undoptr;
497
498			/* first invocation, make ptr point back to the top of the list */
499			if ((ptr == NULL && nulled == TRUE) \|\| rptcount == 0) {
500			ptr = TAILQ_FIRST(&curbp->b_undo);
501			nulled = TRUE;
502			}
503
504			rval = TRUE;
505			while (n--) {
506			/* if we have a spurious boundary, free it and move on.... */
507			while (ptr && ptr->type == BOUNDARY) {
508			nptr = TAILQ_NEXT(ptr, next);
509			TAILQ_REMOVE(&curbp->b_undo, ptr, next);
510			free_undo_record(ptr);
511			ptr = nptr;
512			}
513			/*
514			* Ptr is NULL, but on the next run, it will point to the
515			* top again, redoing all stuff done in the buffer since
516			* its creation.
517			*/
518			if (ptr == NULL) {
519			dobeep();
520			ewprintf("No further undo information");
521			rval = FALSE;
522			nulled = TRUE;
523			break;
524			}
525			nulled = FALSE;
526
527			/*
528			* Loop while we don't get a boundary specifying we've
529			* finished the current action...
530			*/
531
532			undo_add_boundary(FFRAND, 1);
533
534			save = boundary_flag;
535			boundary_flag = FALSE;
536
537			done = 0;
538			do {
539			/*
540			* Move to where this has to apply
541			*
542			* Boundaries (and the modified flag) are put as
543			* position 0 (to save lookup time in find_dot)
544			* so we must not move there...
545			*/
546			if (ptr->type != BOUNDARY && ptr->type != MODIFIED) {
547			if (find_lo(ptr->pos, &lp,
548			&offset, &lineno) == FALSE) {
549			dobeep();
550			ewprintf("Internal error in Undo!");
551			rval = FALSE;
552			break;
553			}
554			curwp->w_dotp = lp;
555			curwp->w_doto = offset;
556			curwp->w_markline = curwp->w_dotline;
557			curwp->w_dotline = lineno;
558			}
559
560			/*
561			* Do operation^-1
562			*/
563			switch (ptr->type) {
564			case INSERT:
565			ldelete(ptr->region.r_size, KNONE);
566			break;
567			case DELETE:
568			lp = curwp->w_dotp;
569			offset = curwp->w_doto;
570			region_put_data(ptr->content,
571			ptr->region.r_size);
572			curwp->w_dotp = lp;
573			curwp->w_doto = offset;
574			break;
575			case DELREG:
576			region_put_data(ptr->content,
577			ptr->region.r_size);
578			break;
579			case BOUNDARY:
580			done = 1;
581			break;
582			case MODIFIED:
583			curbp->b_flag &= ~BFCHG;
584			break;
585			default:
586			break;
587			}
588
589			/* And move to next record */
590			ptr = TAILQ_NEXT(ptr, next);
591			} while (ptr != NULL && !done);
592
593			boundary_flag = save;
594			undo_add_boundary(FFRAND, 1);
595
596			ewprintf("Undo!");
597			}
598
599			curbp->b_undoptr = ptr;
600
601			return (rval);
602			}