IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

vim-patch:8.0.1441: using ":undo 0" leaves undo in wrong state

Browse Source 
Problem:    Using ":undo 0" leaves undo in wrong state.
Solution:   Instead of searching for state 1 and go above, just use the start.
            (Ozaki Kiichi, closes vim/vim#2595)
ce46d934af
This commit is contained in:
Jan Edmund Lazo 2018-08-20 21:24:30 -04:00
parent 0839c44257
commit 66ed6297b0
2 changed files with 126 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/nvim/testdir/test_undo.vim
View File

@ -390,3 +390,47 @@ funct Test_undofile()
set undodir&
endfunc
func Test_undo_0()
new
set ul=100
normal i1
undo
normal i2
undo
normal i3
undo 0
let d = undotree()
call assert_equal('', getline(1))
call assert_equal(0, d.seq_cur)
redo
let d = undotree()
call assert_equal('3', getline(1))
call assert_equal(3, d.seq_cur)
undo 2
undo 0
let d = undotree()
call assert_equal('', getline(1))
call assert_equal(0, d.seq_cur)
redo
let d = undotree()
call assert_equal('2', getline(1))
call assert_equal(2, d.seq_cur)
undo 1
undo 0
let d = undotree()
call assert_equal('', getline(1))
call assert_equal(0, d.seq_cur)
redo
let d = undotree()
call assert_equal('1', getline(1))
call assert_equal(1, d.seq_cur)
bwipe!
endfunc

82
src/nvim/undo.c
View File

@ -1820,7 +1820,7 @@ void undo_time(long step, int sec, int file, int absolute)
long closest_start;
long closest_seq = 0;
long val;
u_header_T *uhp;
u_header_T *uhp = NULL;
u_header_T *last;
int mark;
int nomark;
@ -1842,13 +1842,7 @@ void undo_time(long step, int sec, int file, int absolute)
/* "target" is the node below which we want to be.
* Init "closest" to a value we can't reach. */
if (absolute) {
if (step == 0) {
// target 0 does not exist, got to 1 and above it.
target = 1;
above = true;
} else {
target = step;
}
closest = -1;
} else {
if (dosec) {
@ -1906,6 +1900,11 @@ void undo_time(long step, int sec, int file, int absolute)
closest_start = closest;
closest_seq = curbuf->b_u_seq_cur;
// When "target" is 0; Back to origin.
if (target == 0) {
goto found;
}
/*
* May do this twice:
* 1. Search for "target", update "closest" to the best match found.
@ -2021,8 +2020,9 @@ void undo_time(long step, int sec, int file, int absolute)
above = TRUE; /* stop above the header */
}
found:
/* If we found it: Follow the path to go to where we want to be. */
if (uhp != NULL) {
if (uhp != NULL || target == 0) {
/*
* First go up the tree as much as needed.
*/
@ -2035,61 +2035,70 @@ void undo_time(long step, int sec, int file, int absolute)
uhp = curbuf->b_u_newhead;
else
uhp = uhp->uh_next.ptr;
if (uhp == NULL || uhp->uh_walk != mark
if (uhp == NULL || (target > 0 && uhp->uh_walk != mark)
|| (uhp->uh_seq == target && !above))
break;
curbuf->b_u_curhead = uhp;
u_undoredo(true, true);
if (target > 0) {
uhp->uh_walk = nomark; // don't go back down here
}
}
/*
* And now go down the tree (redo), branching off where needed.
*/
// When back to origin, redo is not needed.
if (target > 0) {
// And now go down the tree (redo), branching off where needed.
while (!got_int) {
/* Do the change warning now, for the same reason as above. */
// Do the change warning now, for the same reason as above.
change_warning(0);
uhp = curbuf->b_u_curhead;
if (uhp == NULL)
if (uhp == NULL) {
break;
}
/* Go back to the first branch with a mark. */
// Go back to the first branch with a mark.
while (uhp->uh_alt_prev.ptr != NULL
&& uhp->uh_alt_prev.ptr->uh_walk == mark)
&& uhp->uh_alt_prev.ptr->uh_walk == mark) {
uhp = uhp->uh_alt_prev.ptr;
}
/* Find the last branch with a mark, that's the one. */
// Find the last branch with a mark, that's the one.
last = uhp;
while (last->uh_alt_next.ptr != NULL
&& last->uh_alt_next.ptr->uh_walk == mark)
&& last->uh_alt_next.ptr->uh_walk == mark) {
last = last->uh_alt_next.ptr;
}
if (last != uhp) {
/* Make the used branch the first entry in the list of
* alternatives to make "u" and CTRL-R take this branch. */
while (uhp->uh_alt_prev.ptr != NULL)
// Make the used branch the first entry in the list of
// alternatives to make "u" and CTRL-R take this branch.
while (uhp->uh_alt_prev.ptr != NULL) {
uhp = uhp->uh_alt_prev.ptr;
if (last->uh_alt_next.ptr != NULL)
last->uh_alt_next.ptr->uh_alt_prev.ptr =
last->uh_alt_prev.ptr;
}
if (last->uh_alt_next.ptr != NULL) {
last->uh_alt_next.ptr->uh_alt_prev.ptr = last->uh_alt_prev.ptr;
}
last->uh_alt_prev.ptr->uh_alt_next.ptr = last->uh_alt_next.ptr;
last->uh_alt_prev.ptr = NULL;
last->uh_alt_next.ptr = uhp;
uhp->uh_alt_prev.ptr = last;
if (curbuf->b_u_oldhead == uhp)
if (curbuf->b_u_oldhead == uhp) {
curbuf->b_u_oldhead = last;
}
uhp = last;
if (uhp->uh_next.ptr != NULL)
if (uhp->uh_next.ptr != NULL) {
uhp->uh_next.ptr->uh_prev.ptr = uhp;
}
}
curbuf->b_u_curhead = uhp;
if (uhp->uh_walk != mark)
break; /* must have reached the target */
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. */
// Stop when going backwards in time and didn't find the exact
// header we were looking for.
if (uhp->uh_seq == target && above) {
curbuf->b_u_seq_cur = target - 1;
break;
@ -2097,15 +2106,17 @@ void undo_time(long step, int sec, int file, int absolute)
u_undoredo(false, true);
/* 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.ptr == NULL)
// 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.ptr == NULL) {
curbuf->b_u_newhead = uhp;
}
curbuf->b_u_curhead = uhp->uh_prev.ptr;
did_undo = FALSE;
did_undo = false;
if (uhp->uh_seq == target) /* found it! */
if (uhp->uh_seq == target) { // found it!
break;
}
uhp = uhp->uh_prev.ptr;
if (uhp == NULL || uhp->uh_walk != mark) {
@ -2115,6 +2126,7 @@ void undo_time(long step, int sec, int file, int absolute)
}
}
}
}
u_undo_end(did_undo, absolute, false);
}