mirror of
https://github.com/vim/vim.git
synced 2025-07-24 10:45:12 -04:00
Don't use pointers to store numbers, use a union.
Fixed MSVC makefile use of /Wp64 flag.
This commit is contained in:
parent
914703bee2
commit
83d09bb85e
@ -1085,6 +1085,7 @@ Vim 7.3:
|
||||
- using NSIS 2.46: install on Windows 7 works, but no "Edit with Vim" menu.
|
||||
Use register_shell_extension()? (George Reilly, 2010 May 26)
|
||||
Ron's version: http://dev.ronware.org/p/vim/finfo?name=gvim.nsi
|
||||
- Undo code: use union to store long in place of pointers?
|
||||
- Also crypt the swap file, each block separately. Change mf_write() and
|
||||
mf_read(). How to get b_p_key to these functions?
|
||||
Generate seed for each block, store in pointer block. Block 1 is not
|
||||
|
@ -208,11 +208,8 @@ MAKEFLAGS_GVIMEXT = DEBUG=yes
|
||||
|
||||
!include <Win32.mak>
|
||||
|
||||
# Turn on Win64 compatibility warnings for VC7.x and VC8.
|
||||
# (/Wp64 is deprecated in VC9 and generates an obnoxious warning.)
|
||||
!if ("$(MSVCVER)" == "7.0") || ("$(MSVCVER)" == "7.1") || ("$(MSVCVER)" == "8.0")
|
||||
DEFINES=$(DEFINES) /Wp64
|
||||
!endif
|
||||
# May turn on Win64 compatibility warnings for VC7.x and VC8.
|
||||
WP64CHECK = /Wp64
|
||||
|
||||
#>>>>> path of the compiler and linker; name of include and lib directories
|
||||
# PATH = c:\msvc20\bin;$(PATH)
|
||||
@ -414,12 +411,19 @@ OPTFLAG = /O2
|
||||
!else # MAXSPEED
|
||||
OPTFLAG = /Ox
|
||||
!endif
|
||||
|
||||
!if ("$(MSVCVER)" == "8.0") || ("$(MSVCVER)" == "9.0") || ("$(MSVCVER)" == "10.0")
|
||||
# Use link time code generation if not worried about size
|
||||
!if "$(OPTIMIZE)" != "SPACE"
|
||||
OPTFLAG = $(OPTFLAG) /GL
|
||||
!endif
|
||||
!endif
|
||||
|
||||
# (/Wp64 is deprecated in VC9 and generates an obnoxious warning.)
|
||||
!if ("$(MSVCVER)" == "7.0") || ("$(MSVCVER)" == "7.1") || ("$(MSVCVER)" == "8.0")
|
||||
CFLAGS=$(CFLAGS) $(WP64CHECK)
|
||||
!endif
|
||||
|
||||
CFLAGS = $(CFLAGS) $(OPTFLAG) -DNDEBUG $(CPUARG)
|
||||
RCFLAGS = $(rcflags) $(rcvars) -DNDEBUG
|
||||
! ifdef USE_MSVCRT
|
||||
|
@ -287,10 +287,24 @@ struct u_entry
|
||||
|
||||
struct u_header
|
||||
{
|
||||
u_header_T *uh_next; /* pointer to next undo header in list */
|
||||
u_header_T *uh_prev; /* pointer to previous header in list */
|
||||
u_header_T *uh_alt_next; /* pointer to next header for alt. redo */
|
||||
u_header_T *uh_alt_prev; /* pointer to previous header for alt. redo */
|
||||
/* The following have a pointer and a number. The number is used when
|
||||
* reading the undo file in u_read_undo() */
|
||||
union {
|
||||
u_header_T *ptr; /* pointer to next undo header in list */
|
||||
long seq;
|
||||
} uh_next;
|
||||
union {
|
||||
u_header_T *ptr; /* pointer to previous header in list */
|
||||
long seq;
|
||||
} uh_prev;
|
||||
union {
|
||||
u_header_T *ptr; /* pointer to next header for alt. redo */
|
||||
long seq;
|
||||
} uh_alt_next;
|
||||
union {
|
||||
u_header_T *ptr; /* pointer to previous header for alt. redo */
|
||||
long seq;
|
||||
} uh_alt_prev;
|
||||
long uh_seq; /* sequence number, higher == newer undo */
|
||||
int uh_walk; /* used by undo_time() */
|
||||
u_entry_T *uh_entry; /* pointer to first entry */
|
||||
|
267
src/undo.c
267
src/undo.c
@ -162,17 +162,17 @@ u_check_tree(u_header_T *uhp,
|
||||
else
|
||||
{
|
||||
/* Check pointers back are correct. */
|
||||
if (uhp->uh_next != exp_uh_next)
|
||||
if (uhp->uh_next.ptr != exp_uh_next)
|
||||
{
|
||||
EMSG("uh_next wrong");
|
||||
smsg((char_u *)"expected: 0x%x, actual: 0x%x",
|
||||
exp_uh_next, uhp->uh_next);
|
||||
exp_uh_next, uhp->uh_next.ptr);
|
||||
}
|
||||
if (uhp->uh_alt_prev != exp_uh_alt_prev)
|
||||
if (uhp->uh_alt_prev.ptr != exp_uh_alt_prev)
|
||||
{
|
||||
EMSG("uh_alt_prev wrong");
|
||||
smsg((char_u *)"expected: 0x%x, actual: 0x%x",
|
||||
exp_uh_alt_prev, uhp->uh_alt_prev);
|
||||
exp_uh_alt_prev, uhp->uh_alt_prev.ptr);
|
||||
}
|
||||
|
||||
/* Check the undo tree at this header. */
|
||||
@ -186,10 +186,10 @@ u_check_tree(u_header_T *uhp,
|
||||
}
|
||||
|
||||
/* Check the next alt tree. */
|
||||
u_check_tree(uhp->uh_alt_next, uhp->uh_next, uhp);
|
||||
u_check_tree(uhp->uh_alt_next.ptr, uhp->uh_next.ptr, uhp);
|
||||
|
||||
/* Check the next header in this branch. */
|
||||
u_check_tree(uhp->uh_prev, uhp, NULL);
|
||||
u_check_tree(uhp->uh_prev.ptr, uhp, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
@ -414,7 +414,7 @@ u_savecommon(top, bot, newbot)
|
||||
old_curhead = curbuf->b_u_curhead;
|
||||
if (old_curhead != NULL)
|
||||
{
|
||||
curbuf->b_u_newhead = old_curhead->uh_next;
|
||||
curbuf->b_u_newhead = old_curhead->uh_next.ptr;
|
||||
curbuf->b_u_curhead = NULL;
|
||||
}
|
||||
|
||||
@ -428,14 +428,14 @@ u_savecommon(top, bot, newbot)
|
||||
if (uhfree == old_curhead)
|
||||
/* Can't reconnect the branch, delete all of it. */
|
||||
u_freebranch(curbuf, uhfree, &old_curhead);
|
||||
else if (uhfree->uh_alt_next == NULL)
|
||||
else if (uhfree->uh_alt_next.ptr == NULL)
|
||||
/* There is no branch, only free one header. */
|
||||
u_freeheader(curbuf, uhfree, &old_curhead);
|
||||
else
|
||||
{
|
||||
/* Free the oldest alternate branch as a whole. */
|
||||
while (uhfree->uh_alt_next != NULL)
|
||||
uhfree = uhfree->uh_alt_next;
|
||||
while (uhfree->uh_alt_next.ptr != NULL)
|
||||
uhfree = uhfree->uh_alt_next.ptr;
|
||||
u_freebranch(curbuf, uhfree, &old_curhead);
|
||||
}
|
||||
#ifdef U_DEBUG
|
||||
@ -451,22 +451,22 @@ u_savecommon(top, bot, newbot)
|
||||
return OK;
|
||||
}
|
||||
|
||||
uhp->uh_prev = NULL;
|
||||
uhp->uh_next = curbuf->b_u_newhead;
|
||||
uhp->uh_alt_next = old_curhead;
|
||||
uhp->uh_prev.ptr = NULL;
|
||||
uhp->uh_next.ptr = curbuf->b_u_newhead;
|
||||
uhp->uh_alt_next.ptr = old_curhead;
|
||||
if (old_curhead != NULL)
|
||||
{
|
||||
uhp->uh_alt_prev = old_curhead->uh_alt_prev;
|
||||
if (uhp->uh_alt_prev != NULL)
|
||||
uhp->uh_alt_prev->uh_alt_next = uhp;
|
||||
old_curhead->uh_alt_prev = uhp;
|
||||
uhp->uh_alt_prev.ptr = old_curhead->uh_alt_prev.ptr;
|
||||
if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp->uh_alt_prev.ptr->uh_alt_next.ptr = uhp;
|
||||
old_curhead->uh_alt_prev.ptr = uhp;
|
||||
if (curbuf->b_u_oldhead == old_curhead)
|
||||
curbuf->b_u_oldhead = uhp;
|
||||
}
|
||||
else
|
||||
uhp->uh_alt_prev = NULL;
|
||||
uhp->uh_alt_prev.ptr = NULL;
|
||||
if (curbuf->b_u_newhead != NULL)
|
||||
curbuf->b_u_newhead->uh_prev = uhp;
|
||||
curbuf->b_u_newhead->uh_prev.ptr = uhp;
|
||||
|
||||
uhp->uh_seq = ++curbuf->b_u_seq_last;
|
||||
curbuf->b_u_seq_cur = uhp->uh_seq;
|
||||
@ -874,10 +874,10 @@ serialize_uhp(fp, buf, uhp)
|
||||
if (put_bytes(fp, (long_u)UF_HEADER_MAGIC, 2) == FAIL)
|
||||
return FAIL;
|
||||
|
||||
put_header_ptr(fp, uhp->uh_next);
|
||||
put_header_ptr(fp, uhp->uh_prev);
|
||||
put_header_ptr(fp, uhp->uh_alt_next);
|
||||
put_header_ptr(fp, uhp->uh_alt_prev);
|
||||
put_header_ptr(fp, uhp->uh_next.ptr);
|
||||
put_header_ptr(fp, uhp->uh_prev.ptr);
|
||||
put_header_ptr(fp, uhp->uh_alt_next.ptr);
|
||||
put_header_ptr(fp, uhp->uh_alt_prev.ptr);
|
||||
put_bytes(fp, uhp->uh_seq, 4);
|
||||
serialize_pos(uhp->uh_cursor, fp);
|
||||
#ifdef FEAT_VIRTUALEDIT
|
||||
@ -930,13 +930,10 @@ unserialize_uhp(fp, file_name)
|
||||
#ifdef U_DEBUG
|
||||
uhp->uh_magic = UH_MAGIC;
|
||||
#endif
|
||||
/* We're not actually trying to store pointers here. We're just storing
|
||||
* uh_seq numbers of the header pointed to, so we can swizzle them into
|
||||
* pointers later - hence the type cast. */
|
||||
uhp->uh_next = (u_header_T *)(long_u)get4c(fp);
|
||||
uhp->uh_prev = (u_header_T *)(long_u)get4c(fp);
|
||||
uhp->uh_alt_next = (u_header_T *)(long_u)get4c(fp);
|
||||
uhp->uh_alt_prev = (u_header_T *)(long_u)get4c(fp);
|
||||
uhp->uh_next.seq = get4c(fp);
|
||||
uhp->uh_prev.seq = get4c(fp);
|
||||
uhp->uh_alt_next.seq = get4c(fp);
|
||||
uhp->uh_alt_prev.seq = get4c(fp);
|
||||
uhp->uh_seq = get4c(fp);
|
||||
if (uhp->uh_seq <= 0)
|
||||
{
|
||||
@ -1362,17 +1359,18 @@ u_write_undo(name, forceit, buf, hash)
|
||||
}
|
||||
|
||||
/* Now walk through the tree - algorithm from undo_time(). */
|
||||
if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != mark)
|
||||
uhp = uhp->uh_prev;
|
||||
else if (uhp->uh_alt_next != NULL && uhp->uh_alt_next->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next;
|
||||
else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL
|
||||
&& uhp->uh_next->uh_walk != mark)
|
||||
uhp = uhp->uh_next;
|
||||
else if (uhp->uh_alt_prev != NULL)
|
||||
uhp = uhp->uh_alt_prev;
|
||||
if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_prev.ptr;
|
||||
else if (uhp->uh_alt_next.ptr != NULL
|
||||
&& uhp->uh_alt_next.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next.ptr;
|
||||
else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL
|
||||
&& uhp->uh_next.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_next.ptr;
|
||||
else if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp = uhp->uh_alt_prev.ptr;
|
||||
else
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
}
|
||||
|
||||
if (put_bytes(fp, (long_u)UF_HEADER_END_MAGIC, 2) == OK)
|
||||
@ -1611,43 +1609,52 @@ u_read_undo(name, hash, orig_name)
|
||||
#endif
|
||||
|
||||
/* We have put all of the headers into a table. Now we iterate through the
|
||||
* table and swizzle each sequence number we have stored in uh_* into a
|
||||
* pointer corresponding to the header with that sequence number. */
|
||||
* table and swizzle each sequence number we have stored in uh_*_seq into
|
||||
* a pointer corresponding to the header with that sequence number. */
|
||||
for (i = 0; i < num_head; i++)
|
||||
{
|
||||
uhp = uhp_table[i];
|
||||
if (uhp == NULL)
|
||||
continue;
|
||||
for (j = 0; j < num_head; j++)
|
||||
{
|
||||
if (uhp_table[j] == NULL)
|
||||
continue;
|
||||
if (i != j && uhp_table[i]->uh_seq == uhp_table[j]->uh_seq)
|
||||
if (uhp_table[j] != NULL && i != j
|
||||
&& uhp_table[i]->uh_seq == uhp_table[j]->uh_seq)
|
||||
{
|
||||
corruption_error("duplicate uh_seq", file_name);
|
||||
goto error;
|
||||
}
|
||||
if (uhp_table[j]->uh_seq == (long)uhp->uh_next)
|
||||
for (j = 0; j < num_head; j++)
|
||||
if (uhp_table[j] != NULL
|
||||
&& uhp_table[j]->uh_seq == uhp->uh_next.seq)
|
||||
{
|
||||
uhp->uh_next = uhp_table[j];
|
||||
uhp->uh_next.ptr = uhp_table[j];
|
||||
SET_FLAG(j);
|
||||
break;
|
||||
}
|
||||
if (uhp_table[j]->uh_seq == (long)uhp->uh_prev)
|
||||
for (j = 0; j < num_head; j++)
|
||||
if (uhp_table[j] != NULL
|
||||
&& uhp_table[j]->uh_seq == uhp->uh_prev.seq)
|
||||
{
|
||||
uhp->uh_prev = uhp_table[j];
|
||||
uhp->uh_prev.ptr = uhp_table[j];
|
||||
SET_FLAG(j);
|
||||
break;
|
||||
}
|
||||
if (uhp_table[j]->uh_seq == (long)uhp->uh_alt_next)
|
||||
for (j = 0; j < num_head; j++)
|
||||
if (uhp_table[j] != NULL
|
||||
&& uhp_table[j]->uh_seq == uhp->uh_alt_next.seq)
|
||||
{
|
||||
uhp->uh_alt_next = uhp_table[j];
|
||||
uhp->uh_alt_next.ptr = uhp_table[j];
|
||||
SET_FLAG(j);
|
||||
break;
|
||||
}
|
||||
if (uhp_table[j]->uh_seq == (long)uhp->uh_alt_prev)
|
||||
for (j = 0; j < num_head; j++)
|
||||
if (uhp_table[j] != NULL
|
||||
&& uhp_table[j]->uh_seq == uhp->uh_alt_prev.seq)
|
||||
{
|
||||
uhp->uh_alt_prev = uhp_table[j];
|
||||
uhp->uh_alt_prev.ptr = uhp_table[j];
|
||||
SET_FLAG(j);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (old_header_seq > 0 && old_idx < 0 && uhp->uh_seq == old_header_seq)
|
||||
{
|
||||
old_idx = i;
|
||||
@ -1778,7 +1785,7 @@ u_doit(startcount)
|
||||
curbuf->b_u_curhead = curbuf->b_u_newhead;
|
||||
else if (p_ul > 0) /* multi level undo */
|
||||
/* get next undo */
|
||||
curbuf->b_u_curhead = curbuf->b_u_curhead->uh_next;
|
||||
curbuf->b_u_curhead = curbuf->b_u_curhead->uh_next.ptr;
|
||||
/* nothing to undo */
|
||||
if (curbuf->b_u_numhead == 0 || curbuf->b_u_curhead == NULL)
|
||||
{
|
||||
@ -1812,9 +1819,9 @@ u_doit(startcount)
|
||||
|
||||
/* Advance for next redo. Set "newhead" when at the end of the
|
||||
* redoable changes. */
|
||||
if (curbuf->b_u_curhead->uh_prev == NULL)
|
||||
if (curbuf->b_u_curhead->uh_prev.ptr == NULL)
|
||||
curbuf->b_u_newhead = curbuf->b_u_curhead;
|
||||
curbuf->b_u_curhead = curbuf->b_u_curhead->uh_prev;
|
||||
curbuf->b_u_curhead = curbuf->b_u_curhead->uh_prev.ptr;
|
||||
}
|
||||
}
|
||||
u_undo_end(undo_undoes, FALSE);
|
||||
@ -1950,36 +1957,36 @@ undo_time(step, sec, absolute)
|
||||
break;
|
||||
|
||||
/* go down in the tree if we haven't been there */
|
||||
if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != nomark
|
||||
&& uhp->uh_prev->uh_walk != mark)
|
||||
uhp = uhp->uh_prev;
|
||||
if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != nomark
|
||||
&& uhp->uh_prev.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_prev.ptr;
|
||||
|
||||
/* go to alternate branch if we haven't been there */
|
||||
else if (uhp->uh_alt_next != NULL
|
||||
&& uhp->uh_alt_next->uh_walk != nomark
|
||||
&& uhp->uh_alt_next->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next;
|
||||
else if (uhp->uh_alt_next.ptr != NULL
|
||||
&& uhp->uh_alt_next.ptr->uh_walk != nomark
|
||||
&& uhp->uh_alt_next.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next.ptr;
|
||||
|
||||
/* go up in the tree if we haven't been there and we are at the
|
||||
* start of alternate branches */
|
||||
else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL
|
||||
&& uhp->uh_next->uh_walk != nomark
|
||||
&& uhp->uh_next->uh_walk != mark)
|
||||
else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL
|
||||
&& uhp->uh_next.ptr->uh_walk != nomark
|
||||
&& uhp->uh_next.ptr->uh_walk != mark)
|
||||
{
|
||||
/* If still at the start we don't go through this change. */
|
||||
if (uhp == curbuf->b_u_curhead)
|
||||
uhp->uh_walk = nomark;
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
/* need to backtrack; mark this node as useless */
|
||||
uhp->uh_walk = nomark;
|
||||
if (uhp->uh_alt_prev != NULL)
|
||||
uhp = uhp->uh_alt_prev;
|
||||
if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp = uhp->uh_alt_prev.ptr;
|
||||
else
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2019,7 +2026,7 @@ undo_time(step, sec, absolute)
|
||||
if (uhp == NULL)
|
||||
uhp = curbuf->b_u_newhead;
|
||||
else
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
if (uhp == NULL || uhp->uh_walk != mark
|
||||
|| (uhp->uh_seq == target && !above))
|
||||
break;
|
||||
@ -2035,33 +2042,34 @@ undo_time(step, sec, absolute)
|
||||
while (uhp != NULL)
|
||||
{
|
||||
/* Go back to the first branch with a mark. */
|
||||
while (uhp->uh_alt_prev != NULL
|
||||
&& uhp->uh_alt_prev->uh_walk == mark)
|
||||
uhp = uhp->uh_alt_prev;
|
||||
while (uhp->uh_alt_prev.ptr != NULL
|
||||
&& 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. */
|
||||
last = uhp;
|
||||
while (last->uh_alt_next != NULL
|
||||
&& last->uh_alt_next->uh_walk == mark)
|
||||
last = last->uh_alt_next;
|
||||
while (last->uh_alt_next.ptr != NULL
|
||||
&& 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 != NULL)
|
||||
uhp = uhp->uh_alt_prev;
|
||||
if (last->uh_alt_next != NULL)
|
||||
last->uh_alt_next->uh_alt_prev = last->uh_alt_prev;
|
||||
last->uh_alt_prev->uh_alt_next = last->uh_alt_next;
|
||||
last->uh_alt_prev = NULL;
|
||||
last->uh_alt_next = uhp;
|
||||
uhp->uh_alt_prev = last;
|
||||
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;
|
||||
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)
|
||||
curbuf->b_u_oldhead = last;
|
||||
uhp = last;
|
||||
if (uhp->uh_next != NULL)
|
||||
uhp->uh_next->uh_prev = uhp;
|
||||
if (uhp->uh_next.ptr != NULL)
|
||||
uhp->uh_next.ptr->uh_prev.ptr = uhp;
|
||||
}
|
||||
curbuf->b_u_curhead = uhp;
|
||||
|
||||
@ -2080,15 +2088,15 @@ undo_time(step, sec, absolute)
|
||||
|
||||
/* 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)
|
||||
if (uhp->uh_prev.ptr == NULL)
|
||||
curbuf->b_u_newhead = uhp;
|
||||
curbuf->b_u_curhead = uhp->uh_prev;
|
||||
curbuf->b_u_curhead = uhp->uh_prev.ptr;
|
||||
did_undo = FALSE;
|
||||
|
||||
if (uhp->uh_seq == target) /* found it! */
|
||||
break;
|
||||
|
||||
uhp = uhp->uh_prev;
|
||||
uhp = uhp->uh_prev.ptr;
|
||||
if (uhp == NULL || uhp->uh_walk != mark)
|
||||
{
|
||||
/* Need to redo more but can't find it... */
|
||||
@ -2417,15 +2425,15 @@ u_undo_end(did_undo, absolute)
|
||||
if (curbuf->b_u_curhead != NULL)
|
||||
{
|
||||
/* For ":undo N" we prefer a "after #N" message. */
|
||||
if (absolute && curbuf->b_u_curhead->uh_next != NULL)
|
||||
if (absolute && curbuf->b_u_curhead->uh_next.ptr != NULL)
|
||||
{
|
||||
uhp = curbuf->b_u_curhead->uh_next;
|
||||
uhp = curbuf->b_u_curhead->uh_next.ptr;
|
||||
did_undo = FALSE;
|
||||
}
|
||||
else if (did_undo)
|
||||
uhp = curbuf->b_u_curhead;
|
||||
else
|
||||
uhp = curbuf->b_u_curhead->uh_next;
|
||||
uhp = curbuf->b_u_curhead->uh_next.ptr;
|
||||
}
|
||||
else
|
||||
uhp = curbuf->b_u_newhead;
|
||||
@ -2492,7 +2500,7 @@ ex_undolist(eap)
|
||||
uhp = curbuf->b_u_oldhead;
|
||||
while (uhp != NULL)
|
||||
{
|
||||
if (uhp->uh_prev == NULL && uhp->uh_walk != nomark
|
||||
if (uhp->uh_prev.ptr == NULL && uhp->uh_walk != nomark
|
||||
&& uhp->uh_walk != mark)
|
||||
{
|
||||
if (ga_grow(&ga, 1) == FAIL)
|
||||
@ -2507,26 +2515,26 @@ ex_undolist(eap)
|
||||
uhp->uh_walk = mark;
|
||||
|
||||
/* go down in the tree if we haven't been there */
|
||||
if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != nomark
|
||||
&& uhp->uh_prev->uh_walk != mark)
|
||||
if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != nomark
|
||||
&& uhp->uh_prev.ptr->uh_walk != mark)
|
||||
{
|
||||
uhp = uhp->uh_prev;
|
||||
uhp = uhp->uh_prev.ptr;
|
||||
++changes;
|
||||
}
|
||||
|
||||
/* go to alternate branch if we haven't been there */
|
||||
else if (uhp->uh_alt_next != NULL
|
||||
&& uhp->uh_alt_next->uh_walk != nomark
|
||||
&& uhp->uh_alt_next->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next;
|
||||
else if (uhp->uh_alt_next.ptr != NULL
|
||||
&& uhp->uh_alt_next.ptr->uh_walk != nomark
|
||||
&& uhp->uh_alt_next.ptr->uh_walk != mark)
|
||||
uhp = uhp->uh_alt_next.ptr;
|
||||
|
||||
/* go up in the tree if we haven't been there and we are at the
|
||||
* start of alternate branches */
|
||||
else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL
|
||||
&& uhp->uh_next->uh_walk != nomark
|
||||
&& uhp->uh_next->uh_walk != mark)
|
||||
else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL
|
||||
&& uhp->uh_next.ptr->uh_walk != nomark
|
||||
&& uhp->uh_next.ptr->uh_walk != mark)
|
||||
{
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
--changes;
|
||||
}
|
||||
|
||||
@ -2534,11 +2542,11 @@ ex_undolist(eap)
|
||||
{
|
||||
/* need to backtrack; mark this node as done */
|
||||
uhp->uh_walk = nomark;
|
||||
if (uhp->uh_alt_prev != NULL)
|
||||
uhp = uhp->uh_alt_prev;
|
||||
if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp = uhp->uh_alt_prev.ptr;
|
||||
else
|
||||
{
|
||||
uhp = uhp->uh_next;
|
||||
uhp = uhp->uh_next.ptr;
|
||||
--changes;
|
||||
}
|
||||
}
|
||||
@ -2632,11 +2640,11 @@ u_unch_branch(uhp)
|
||||
{
|
||||
u_header_T *uh;
|
||||
|
||||
for (uh = uhp; uh != NULL; uh = uh->uh_prev)
|
||||
for (uh = uhp; uh != NULL; uh = uh->uh_prev.ptr)
|
||||
{
|
||||
uh->uh_flags |= UH_CHANGED;
|
||||
if (uh->uh_alt_next != NULL)
|
||||
u_unch_branch(uh->uh_alt_next); /* recursive */
|
||||
if (uh->uh_alt_next.ptr != NULL)
|
||||
u_unch_branch(uh->uh_alt_next.ptr); /* recursive */
|
||||
}
|
||||
}
|
||||
|
||||
@ -2707,23 +2715,24 @@ u_freeheader(buf, uhp, uhpp)
|
||||
|
||||
/* When there is an alternate redo list free that branch completely,
|
||||
* because we can never go there. */
|
||||
if (uhp->uh_alt_next != NULL)
|
||||
u_freebranch(buf, uhp->uh_alt_next, uhpp);
|
||||
if (uhp->uh_alt_next.ptr != NULL)
|
||||
u_freebranch(buf, uhp->uh_alt_next.ptr, uhpp);
|
||||
|
||||
if (uhp->uh_alt_prev != NULL)
|
||||
uhp->uh_alt_prev->uh_alt_next = NULL;
|
||||
if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp->uh_alt_prev.ptr->uh_alt_next.ptr = NULL;
|
||||
|
||||
/* Update the links in the list to remove the header. */
|
||||
if (uhp->uh_next == NULL)
|
||||
buf->b_u_oldhead = uhp->uh_prev;
|
||||
if (uhp->uh_next.ptr == NULL)
|
||||
buf->b_u_oldhead = uhp->uh_prev.ptr;
|
||||
else
|
||||
uhp->uh_next->uh_prev = uhp->uh_prev;
|
||||
uhp->uh_next.ptr->uh_prev.ptr = uhp->uh_prev.ptr;
|
||||
|
||||
if (uhp->uh_prev == NULL)
|
||||
buf->b_u_newhead = uhp->uh_next;
|
||||
if (uhp->uh_prev.ptr == NULL)
|
||||
buf->b_u_newhead = uhp->uh_next.ptr;
|
||||
else
|
||||
for (uhap = uhp->uh_prev; uhap != NULL; uhap = uhap->uh_alt_next)
|
||||
uhap->uh_next = uhp->uh_next;
|
||||
for (uhap = uhp->uh_prev.ptr; uhap != NULL;
|
||||
uhap = uhap->uh_alt_next.ptr)
|
||||
uhap->uh_next.ptr = uhp->uh_next.ptr;
|
||||
|
||||
u_freeentries(buf, uhp, uhpp);
|
||||
}
|
||||
@ -2747,16 +2756,16 @@ u_freebranch(buf, uhp, uhpp)
|
||||
return;
|
||||
}
|
||||
|
||||
if (uhp->uh_alt_prev != NULL)
|
||||
uhp->uh_alt_prev->uh_alt_next = NULL;
|
||||
if (uhp->uh_alt_prev.ptr != NULL)
|
||||
uhp->uh_alt_prev.ptr->uh_alt_next.ptr = NULL;
|
||||
|
||||
next = uhp;
|
||||
while (next != NULL)
|
||||
{
|
||||
tofree = next;
|
||||
if (tofree->uh_alt_next != NULL)
|
||||
u_freebranch(buf, tofree->uh_alt_next, uhpp); /* recursive */
|
||||
next = tofree->uh_prev;
|
||||
if (tofree->uh_alt_next.ptr != NULL)
|
||||
u_freebranch(buf, tofree->uh_alt_next.ptr, uhpp); /* recursive */
|
||||
next = tofree->uh_prev.ptr;
|
||||
u_freeentries(buf, tofree, uhpp);
|
||||
}
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user