
/*
 * Undo facility
 *
 * The routines in this file comprise a general undo facility for use
 * throughout the rest of the editor. The routine u_save() is called
 * before each edit operation to save the current contents of the lines
 * to be editted. Later, u_undo() can be called to return those lines
 * to their original state. The routine u_clear() should be called
 * whenever a new file is going to be editted to clear the undo buffer.
 *
 * $Log:	undo.c,v $
 * Revision 1.4  88/08/26  08:45:56  tony
 * Misc. changes to make lint happy.
 * 
 * Revision 1.3  88/08/17  07:38:14  tony
 * Made u_save() more robust by checking for null parameters. It's up to
 * the caller to notice the problem before it causes trouble elsewhere.
 * 
 * Revision 1.2  88/07/09  20:39:11  tony
 * Added routines to implement the 'U' command.
 * 
 * Revision 1.1  88/03/20  21:10:53  tony
 * Initial revision
 * 
 */

#include "stevie.h"

/*
 * The next two variables mark the boundaries of the changed section
 * of the file. Lines BETWEEN the lower and upper bounds are changed
 * and originally contained the lines pointed to by u_lines. To undo
 * the last change, insert the lines in u_lines between the lower and
 * upper bounds.
 */
static	LINE	*u_lbound = NULL; /* line just prior to first changed line */
static	LINE	*u_ubound = NULL; /* line just after the last changed line */

static	LINE	*u_lline  = NULL; /* bounds of the saved lines */
static	LINE	*u_uline  = NULL;

static	int	u_col;
static	bool_t	u_valid = FALSE;  /* is the undo buffer valid */

/*
 * Local forward declarations
 */
LINE	*copyline();
void	u_lsave();
void	u_lfree();

/*
 * usave(l, u) - save the current contents of part of the file
 *
 * The lines between 'l' and 'u' are about to be changed. This routine
 * saves their current contents into the undo buffer. The range l to u
 * is not inclusive because when we do an open, for example, there aren't
 * any lines in between. If no lines are to be saved, then l->next == u.
 */
void
usave(l, u)
LINE	*l, *u;
{
	LINE	*nl;			/* copy of the current line */

	/*
	 * If l or u is null, there's an error. We don't return an
	 * indication to the caller. They should find the problem
	 * while trying to perform whatever edit is being requested
	 * (e.g. a join on the last line).
	 */
	if (l == NULL || u == NULL)
		return;

	u_clear();			/* clear the buffer, first */

	u_lsave(l, u);		/* save to the "line undo" buffer, if needed */

	u_lbound = l;
	u_ubound = u;

	if (l->next != u) {		/* there are lines in the middle */
		l = l->next;
		u = u->prev;

		u_lline = nl = copyline(l);	/* copy the first line */
		while (l != u) {
			nl->next = copyline(l->next);
			nl->next->prev = nl;
			l = l->next;
			nl = nl->next;
		}
		u_uline = nl;
	} else
		u_lline = u_uline = NULL;

	u_valid = TRUE;
	u_col = Cursvcol;
}

/*
 * usaveline() - save the current line in the undo buffer
 */
void
usaveline()
{
	usave(Curschar->linep->prev, Curschar->linep->next);
}

/*
 * u_undo() - effect an 'undo' operation
 *
 * The last edit is undone by restoring the modified section of the file
 * to its original state. The lines we're going to trash are copied to
 * the undo buffer so that even an 'undo' can be undone. Rings the bell
 * if the undo buffer is empty.
 */
void
u_undo()
{
	LINE	*tl, *tu;

	if (!u_valid) {
		beep();
		return;
	}

	/*
	 * Get the first line of the thing we're undoing on the screen.
	 */
	Curschar->linep = u_lbound->next;
	Curschar->index = 0;			/* for now */
	if (Curschar->linep == Fileend->linep)
		Curschar->linep = Curschar->linep->prev;
	cursupdate();

	/*
	 * Save pointers to what's in the file now.
	 */
	if (u_lbound->next != u_ubound) {	/* there are lines to get */
		tl = u_lbound->next;
		tu = u_ubound->prev;
		tl->prev = NULL;
		tu->next = NULL;
	} else
		tl = tu = NULL;			/* no lines between bounds */

	/*
	 * Link the undo buffer into the right place in the file.
	 */
	if (u_lline != NULL) {		/* there are lines in the undo buf */

		/*
		 * If the top line of the screen is being undone, we need to
		 * fix up Topchar to point to the new line that will be there.
		 */
		if (u_lbound->next == Topchar->linep)
			Topchar->linep = u_lline;

		u_lbound->next = u_lline;
		u_lline->prev  = u_lbound;
		u_ubound->prev = u_uline;
		u_uline->next  = u_ubound;
	} else {			/* no lines... link the bounds */
		if (u_lbound->next == Topchar->linep)
			Topchar->linep = u_ubound;
		if (u_lbound == Filetop->linep)
			Topchar->linep = u_ubound;
			
		u_lbound->next = u_ubound;
		u_ubound->prev = u_lbound;
	}

	/*
	 * If we swapped the top line, patch up Filemem appropriately.
	 */
	if (u_lbound == Filetop->linep)
		Filemem->linep = Filetop->linep->next;

	/*
	 * Now save the old stuff in the undo buffer.
	 */
	u_lline = tl;
	u_uline = tu;

	renum();		/* have to renumber everything */

	/*
	 * Put the cursor on the first line of the 'undo' region.
	 */
	Curschar->linep = u_lbound->next;
	Curschar->index = 0;
	if (Curschar->linep == Fileend->linep)
		Curschar->linep = Curschar->linep->prev;
	*Curschar = *coladvance(Curschar, u_col);
	cursupdate();
	updscreen();		/* now show the change */

	u_lfree();		/* clear the "line undo" buffer */
}

/*
 * u_clear() - clear the undo buffer
 *
 * This routine is called to clear the undo buffer at times when the
 * pointers are about to become invalid, such as when a new file is
 * about to be editted.
 */
void
u_clear()
{
	LINE	*l, *nextl;

	if (!u_valid)		/* nothing to do */
		return;

	for (l = u_lline; l != NULL ;l = nextl) {
		nextl = l->next;
		free(l->s);
		free(l);
	}

	u_lbound = u_ubound = u_lline = u_uline = NULL;
	u_valid = FALSE;
}

/*
 * The following functions and data implement the "line undo" feature
 * performed by the 'U' command.
 */

static	LINE	*u_line;		/* pointer to the line we last saved */
static	LINE	*u_lcopy = NULL;	/* local copy of the original line */

/*
 * u_lfree() - free the line save buffer
 */
void
u_lfree()
{
	if (u_lcopy != NULL) {
		free(u_lcopy->s);
		free(u_lcopy);
		u_lcopy = NULL;
	}
	u_line = NULL;
}

/*
 * u_lsave() - save the current line if necessary
 */
void
u_lsave(l, u)
LINE	*l, *u;
{

	if (l->next != u->prev) {	/* not changing exactly one line */
		u_lfree();
		return;
	}

	if (l->next == u_line)		/* more edits on the same line */
		return;

	u_lfree();
	u_line = l->next;
	u_lcopy = copyline(l->next);
}

/*
 * u_lundo() - undo the current line (the 'U' command)
 */
void
u_lundo()
{
	if (u_lcopy != NULL) {
		free(Curschar->linep->s);
		Curschar->linep->s = u_lcopy->s;
		Curschar->linep->size = u_lcopy->size;
		free(u_lcopy);
	} else
		beep();
	Curschar->index = 0;

	cursupdate();
	updscreen();		/* now show the change */

	u_lcopy = NULL;	/* can't undo this kind of undo */
	u_line = NULL;
}

/*
 * u_lcheck() - clear the "line undo" buffer if we've moved to a new line
 */
void
u_lcheck()
{
	if (Curschar->linep != u_line)
		u_lfree();
}

/*
 * copyline(l) - copy the given line, and return a pointer to the copy
 */
LINE *
copyline(l)
LINE	*l;
{
	LINE	*nl;		/* the new line */

	nl = newline(strlen(l->s) + 1);
	strcpy(nl->s, l->s);

	return nl;
}
