vim: src/undo.c comparison

comparison src/undo.c @ 777:f664cc974a7a

updated for version 7.0227

author	vimboss
date	Fri, 17 Mar 2006 23:19:38 +0000
parents	aaaca5077255
children	f19994020dad

comparison

equal deleted inserted replaced

-:5a5a080c2776
+:f664cc974a7a
 static u_entry_T *u_get_headentry __ARGS((void));
 static void u_getbot __ARGS((void));
 static int undo_allowed __ARGS((void));
 static int u_savecommon __ARGS((linenr_T, linenr_T, linenr_T));
 static void u_doit __ARGS((int count));
-static void u_undoredo __ARGS((void));
+static void u_undoredo __ARGS((int undo));
 static void u_undo_end __ARGS((void));
 static void u_add_time __ARGS((char_u *buf, size_t buflen, time_t tt));
 static void u_freeheader __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
 static void u_freebranch __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
 static void u_freeentries __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp));
 	}
 	uhp->uh_alt_prev = NULL;
 	if (curbuf->b_u_newhead != NULL)
 	    curbuf->b_u_newhead->uh_prev = uhp;
-	uhp->uh_seq = curbuf->b_u_seq_last++;
+	uhp->uh_seq = ++curbuf->b_u_seq_last;
-	curbuf->b_u_seq_cur = curbuf->b_u_seq_last;
+	curbuf->b_u_seq_cur = uhp->uh_seq;
 	uhp->uh_time = time(NULL);
 	curbuf->b_u_seq_time = uhp->uh_time + 1;
 	uhp->uh_walk = 0;
 	uhp->uh_entry = NULL;
 /*
 * Undo or redo, depending on 'undo_undoes', 'count' times.
 */
 static void
-u_doit(count)
+u_doit(startcount)
-int count;
+int startcount;
 {
+int count = startcount;
 if (!undo_allowed())
 	return;
 u_newcount = 0;
 u_oldcount = 0;
 	    if (curbuf->b_u_numhead == 0 || curbuf->b_u_curhead == NULL)
 	    {
 		/* stick curbuf->b_u_curhead at end */
 		curbuf->b_u_curhead = curbuf->b_u_oldhead;
 		beep_flush();
+		if (count == startcount - 1)
+		{
+		    MSG(_("Already at oldest change"));
+		    return;
+		}
 		break;
 	    }
-	    u_undoredo();
+	    u_undoredo(TRUE);
 	}
 	else
 	{
 	    if (curbuf->b_u_curhead == NULL || p_ul <= 0)
 	    {
 		beep_flush();	/* nothing to redo */
+		if (count == startcount - 1)
+		{
+		    MSG(_("Already at newest change"));
+		    return;
+		}
 		break;
 	    }
-	    u_undoredo();
+	    u_undoredo(FALSE);
-	    ++curbuf->b_u_seq_cur;
-	    ++curbuf->b_u_seq_time;
 	    /* Advance for next redo.  Set "newhead" when at the end of the
 	     * redoable changes. */
 	    if (curbuf->b_u_curhead->uh_prev == NULL)
 		curbuf->b_u_newhead = curbuf->b_u_curhead;
 long	    target;
 long	    closest;
 long	    closest_start;
 long	    closest_seq = 0;
 long	    val;
-long	    limit;
 u_header_T	    *uhp;
 u_header_T	    *last;
 int		    mark;
 int		    nomark;
 int		    round;
 u_newcount = 0;
 u_oldcount = 0;
 if (curbuf->b_ml.ml_flags & ML_EMPTY)
 	u_oldcount = -1;
-/* "target" is the node below which we want to be.  When going forward
+/* "target" is the node below which we want to be.
-* the current one also counts, thus do one less. */
+* Init "closest" to a value we can't reach. */
 if (absolute)
 {
 	target = step;
-	closest = -2;
+	closest = -1;
 }
-else if (step < 0)
+else
 {
+	/* When doing computations with time_t subtract starttime, because
+	 * time_t converted to a long may result in a wrong number. */
 	if (sec)
-	    target = (long)curbuf->b_u_seq_time + step;
+	    target = (long)(curbuf->b_u_seq_time - starttime) + step;
 	else
 	    target = curbuf->b_u_seq_cur + step;
-	if (target < 0)
+	if (step < 0)
-	    target = -1;
+	{
-	closest = -2;
+	    if (target < 0)
-}
+		target = 0;
-else
+	    closest = -1;
-{
-	if (sec)
-	{
-	    target = curbuf->b_u_seq_time + step - 1;
-	    closest = time(NULL) + 1;
 	}
 	else
 	{
-	    target = curbuf->b_u_seq_cur + step - 1;
+	    if (sec)
-	    closest = curbuf->b_u_seq_last + 1;
+		closest = time(NULL) - starttime + 1;
-	}
+	    else
-	if (target >= closest)
+		closest = curbuf->b_u_seq_last + 2;
-	    target = closest - 1;
+	    if (target >= closest)
+		target = closest - 1;
+	}
 }
 closest_start = closest;
-if (sec)
+closest_seq = curbuf->b_u_seq_cur;
-	limit = curbuf->b_u_seq_time + (step > 0 ? -1 : 1);
-else
-	limit = curbuf->b_u_seq_cur;
 /*
 * May do this twice:
 * 1. Search for "target", update "closest" to the best match found.
 * 2. If "target" not found search for "closest".
 	    uhp = curbuf->b_u_curhead;
 	while (uhp != NULL)
 	{
 	    uhp->uh_walk = mark;
-	    val = (dosec ? uhp->uh_time : uhp->uh_seq);
+	    val = (dosec ? (uhp->uh_time - starttime) : uhp->uh_seq);
 	    if (round == 1)
 	    {
 		/* Remember the header that is closest to the target.
 		 * It must be at least in the right direction (checked with
-		 * "limit").  When the timestamp is equal find the
+		 * "b_u_seq_cur").  When the timestamp is equal find the
 		 * highest/lowest sequence number. */
-		if ((dosec && val == closest)
+		if ((step < 0 ? uhp->uh_seq <= curbuf->b_u_seq_cur
-			? (step < 0
+			      : uhp->uh_seq > curbuf->b_u_seq_cur)
-			    ? uhp->uh_seq < closest_seq
+			&& ((dosec && val == closest)
-			    : uhp->uh_seq > closest_seq)
+			    ? (step < 0
-			: (step < 0
+				? uhp->uh_seq < closest_seq
-			    ? (val < limit
+				: uhp->uh_seq > closest_seq)
-				&& (closest > target
+			    : closest == closest_start
-				    ? (val <= closest)
+				|| (val > target
-				    : (val >= closest)))
+				    ? (closest > target
-			    : (val > limit
+					? val - target <= closest - target
-				&& (closest < target
+					: val - target <= target - closest)
-				    ? val >= closest
+				    : (closest > target
-				    : val <= closest))))
+					? target - val <= closest - target
+					: target - val <= target - closest))))
 		{
 		    closest = val;
 		    closest_seq = uhp->uh_seq;
 		}
 	    }
 	{
 	    uhp = curbuf->b_u_curhead;
 	    if (uhp == NULL)
 		uhp = curbuf->b_u_newhead;
 	    else
-	    {
-		while (uhp->uh_alt_prev != NULL
-					 && uhp->uh_alt_prev->uh_walk == mark)
-		{
-		    uhp->uh_walk = nomark;
-		    uhp = uhp->uh_alt_prev;
-		}
 		uhp = uhp->uh_next;
-	    }
+	    if (uhp == NULL || uhp->uh_walk != mark
-	    if (uhp == NULL || uhp->uh_walk != mark)
+					 || (uhp->uh_seq == target && !above))
 		break;
 	    curbuf->b_u_curhead = uhp;
-	    u_undoredo();
+	    u_undoredo(TRUE);
 	    uhp->uh_walk = nomark;	/* don't go back down here */
 	}
 	/*
 	 * And now go down the tree (redo), branching off where needed.
 	 */
 	uhp = curbuf->b_u_curhead;
-	for (;;)
+	while (uhp != NULL)
 	{
 	    /* Find the last branch with a mark, that's the one. */
 	    last = uhp;
 	    while (last->uh_alt_next != NULL
 					&& last->uh_alt_next->uh_walk == mark)
 		last->uh_alt_prev = NULL;
 		last->uh_alt_next = uhp;
 		uhp->uh_alt_prev = last;
 		uhp = last;
+		if (uhp->uh_next != NULL)
+		    uhp->uh_next->uh_prev = uhp;
 	    }
 	    curbuf->b_u_curhead = uhp;
-	    curbuf->b_u_seq_cur = uhp->uh_seq;
-	    curbuf->b_u_seq_time = uhp->uh_time;
 	    if (uhp->uh_walk != mark)
 		break;	    /* must have reached the target */
 	    /* Stop when going backwards in time and didn't find the exact
 	     * header we were looking for. */
 	    if (uhp->uh_seq == target && above)
 		break;
-	    u_undoredo();
+	    u_undoredo(FALSE);
-	    ++curbuf->b_u_seq_cur;
-	    ++curbuf->b_u_seq_time;
 	    /* Advance "curhead" to below the header we last used.  If it
 	     * becomes NULL then we need to set "newhead" to this leaf. */
 	    if (uhp->uh_prev == NULL)
 		curbuf->b_u_newhead = uhp;
 		break;
 	    uhp = uhp->uh_prev;
 	    if (uhp == NULL || uhp->uh_walk != mark)
 	    {
+		/* Need to redo more but can't find it... */
 		EMSG2(_(e_intern2), "undo_time()");
 		break;
 	    }
 	}
 }
 * u_undoredo: common code for undo and redo
 *
 * The lines in the file are replaced by the lines in the entry list at
 * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
 * list for the next undo/redo.
+*
+* When "undo" is TRUE we go up in the tree, when FALSE we go down.
 */
 static void
-u_undoredo()
+u_undoredo(undo)
+int		undo;
 {
 char_u	**newarray = NULL;
 linenr_T	oldsize;
 linenr_T	newsize;
 linenr_T	top, bot;
 /* Make sure the cursor is on an existing line and column. */
 check_cursor();
 /* Remember where we are for "g-" and ":earlier 10s". */
 curbuf->b_u_seq_cur = curhead->uh_seq;
+if (undo)
+	/* We are below the previous undo.  However, to make ":earlier 1s"
+	 * work we compute this as being just above the just undone change. */
+	--curbuf->b_u_seq_cur;
+/* The timestamp can be the same for multiple changes, just use the one of
+* the undone/redone change. */
 curbuf->b_u_seq_time = curhead->uh_time;
 }
 /*
 * If we deleted or added lines, report the number of less/more lines.
 if (uhp == NULL)
 	*msgbuf = NUL;
 else
 	u_add_time(msgbuf, sizeof(msgbuf), uhp->uh_time);
-smsg((char_u *)_("%ld %s; #%ld  %s"), u_oldcount, _(msg),
+smsg((char_u *)_("%ld %s; #%ld  %s"),
-				      uhp == NULL ? 0L : uhp->uh_seq, msgbuf);
+	    u_oldcount < 0 ? -u_oldcount : u_oldcount,
+	    _(msg), uhp == NULL ? 0L : uhp->uh_seq, msgbuf);
 }
 /*
 * u_sync: stop adding to the current entry list
 */
 ga_init2(&ga, (int)sizeof(char *), 20);
 uhp = curbuf->b_u_oldhead;
 while (uhp != NULL)
 {
-	if (uhp->uh_prev == NULL)
+	if (uhp->uh_prev == NULL && uhp->uh_walk != nomark
+						      && uhp->uh_walk != mark)
 	{
 	    if (ga_grow(&ga, 1) == FAIL)
 		break;
 	    vim_snprintf((char *)IObuff, IOSIZE, "%6ld %7ld  ",
 							uhp->uh_seq, changes);

Mercurial > vim

comparison src/undo.c @ 777:f664cc974a7a