Mercurial > vim
annotate src/undo.c @ 29928:0c52f8114e16 v9.0.0302
patch 9.0.0302: CI for Coverity is bothered by deprecation warnings
Commit: https://github.com/vim/vim/commit/75e9a6693e8d0126b5fff42203bfba9428cd19ae
Author: Philip H <47042125+pheiduck@users.noreply.github.com>
Date: Sun Aug 28 17:59:05 2022 +0100
patch 9.0.0302: CI for Coverity is bothered by deprecation warnings
Problem: CI for Coverity is bothered by deprecation warnings.
Solution: Ignore deprecation warnings. (closes https://github.com/vim/vim/issues/11002)
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sun, 28 Aug 2022 19:00:10 +0200 |
| parents | 89e1d67814a9 |
| children | 9a6f7e750697 |
| rev | line source |
|---|---|
|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
9674
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
| 7 | 2 * |
| 3 * VIM - Vi IMproved by Bram Moolenaar | |
| 4 * | |
| 5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
| 6 * Do ":help credits" in Vim to see a list of people who contributed. | |
| 7 * See README.txt for an overview of the Vim source code. | |
| 8 */ | |
| 9 | |
| 10 /* | |
| 11 * undo.c: multi level undo facility | |
| 12 * | |
| 13 * The saved lines are stored in a list of lists (one for each buffer): | |
| 14 * | |
| 15 * b_u_oldhead------------------------------------------------+ | |
| 16 * | | |
| 17 * V | |
| 18 * +--------------+ +--------------+ +--------------+ | |
| 19 * b_u_newhead--->| u_header | | u_header | | u_header | | |
| 20 * | uh_next------>| uh_next------>| uh_next---->NULL | |
| 21 * NULL<--------uh_prev |<---------uh_prev |<---------uh_prev | | |
| 22 * | uh_entry | | uh_entry | | uh_entry | | |
| 23 * +--------|-----+ +--------|-----+ +--------|-----+ | |
| 24 * | | | | |
| 25 * V V V | |
| 26 * +--------------+ +--------------+ +--------------+ | |
| 27 * | u_entry | | u_entry | | u_entry | | |
| 28 * | ue_next | | ue_next | | ue_next | | |
| 29 * +--------|-----+ +--------|-----+ +--------|-----+ | |
| 30 * | | | | |
| 31 * V V V | |
| 32 * +--------------+ NULL NULL | |
| 33 * | u_entry | | |
| 34 * | ue_next | | |
| 35 * +--------|-----+ | |
| 36 * | | |
| 37 * V | |
| 38 * etc. | |
| 39 * | |
| 40 * Each u_entry list contains the information for one undo or redo. | |
| 41 * curbuf->b_u_curhead points to the header of the last undo (the next redo), | |
| 758 | 42 * or is NULL if nothing has been undone (end of the branch). |
| 7 | 43 * |
| 753 | 44 * For keeping alternate undo/redo branches the uh_alt field is used. Thus at |
| 45 * each point in the list a branch may appear for an alternate to redo. The | |
| 46 * uh_seq field is numbered sequentially to be able to find a newer or older | |
| 47 * branch. | |
| 48 * | |
| 758 | 49 * +---------------+ +---------------+ |
| 50 * b_u_oldhead --->| u_header | | u_header | | |
| 51 * | uh_alt_next ---->| uh_alt_next ----> NULL | |
| 52 * NULL <----- uh_alt_prev |<------ uh_alt_prev | | |
| 53 * | uh_prev | | uh_prev | | |
| 54 * +-----|---------+ +-----|---------+ | |
| 55 * | | | |
| 56 * V V | |
| 57 * +---------------+ +---------------+ | |
| 58 * | u_header | | u_header | | |
| 59 * | uh_alt_next | | uh_alt_next | | |
| 60 * b_u_newhead --->| uh_alt_prev | | uh_alt_prev | | |
| 61 * | uh_prev | | uh_prev | | |
| 62 * +-----|---------+ +-----|---------+ | |
| 63 * | | | |
| 64 * V V | |
| 65 * NULL +---------------+ +---------------+ | |
| 66 * | u_header | | u_header | | |
| 67 * | uh_alt_next ---->| uh_alt_next | | |
| 68 * | uh_alt_prev |<------ uh_alt_prev | | |
| 69 * | uh_prev | | uh_prev | | |
| 70 * +-----|---------+ +-----|---------+ | |
| 71 * | | | |
| 72 * etc. etc. | |
| 73 * | |
| 74 * | |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
75 * All data is allocated and will all be freed when the buffer is unloaded. |
| 7 | 76 */ |
| 77 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
78 // Uncomment the next line for including the u_check() function. This warns |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
79 // for errors in the debug information. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
80 // #define U_DEBUG 1 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
81 #define UH_MAGIC 0x18dade // value for uh_magic when in use |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
82 #define UE_MAGIC 0xabc123 // value for ue_magic when in use |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
83 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
84 // Size of buffer used for encryption. |
| 6122 | 85 #define CRYPT_BUF_SIZE 8192 |
| 86 | |
| 7 | 87 #include "vim.h" |
| 88 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
89 // Structure passed around between functions. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
90 // Avoids passing cryptstate_T when encryption not available. |
| 6122 | 91 typedef struct { |
| 92 buf_T *bi_buf; | |
| 93 FILE *bi_fp; | |
| 94 #ifdef FEAT_CRYPT | |
| 95 cryptstate_T *bi_state; | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
96 char_u *bi_buffer; // CRYPT_BUF_SIZE, NULL when not buffering |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
97 size_t bi_used; // bytes written to/read from bi_buffer |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
98 size_t bi_avail; // bytes available in bi_buffer |
| 6122 | 99 #endif |
| 100 } bufinfo_T; | |
| 101 | |
| 102 | |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
103 static void u_unch_branch(u_header_T *uhp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
104 static u_entry_T *u_get_headentry(void); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
105 static void u_getbot(void); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
106 static void u_doit(int count); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
107 static void u_undoredo(int undo); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
108 static void u_undo_end(int did_undo, int absolute); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
109 static void u_freeheader(buf_T *buf, u_header_T *uhp, u_header_T **uhpp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
110 static void u_freebranch(buf_T *buf, u_header_T *uhp, u_header_T **uhpp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
111 static void u_freeentries(buf_T *buf, u_header_T *uhp, u_header_T **uhpp); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
112 static void u_freeentry(u_entry_T *, long); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
113 #ifdef FEAT_PERSISTENT_UNDO |
|
8128
985cd5917560
commit https://github.com/vim/vim/commit/1d6fbe654066845ff2a182ed258e6e9d3408fa90
Christian Brabandt <cb@256bit.org>
parents:
7835
diff
changeset
|
114 # ifdef FEAT_CRYPT |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
115 static int undo_flush(bufinfo_T *bi); |
|
8128
985cd5917560
commit https://github.com/vim/vim/commit/1d6fbe654066845ff2a182ed258e6e9d3408fa90
Christian Brabandt <cb@256bit.org>
parents:
7835
diff
changeset
|
116 # endif |
|
7805
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
117 static int undo_read(bufinfo_T *bi, char_u *buffer, size_t size); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
118 static int serialize_uep(bufinfo_T *bi, u_entry_T *uep); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
119 static u_entry_T *unserialize_uep(bufinfo_T *bi, int *error, char_u *file_name); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
120 static void serialize_pos(bufinfo_T *bi, pos_T pos); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
121 static void unserialize_pos(bufinfo_T *bi, pos_T *pos); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
122 static void serialize_visualinfo(bufinfo_T *bi, visualinfo_T *info); |
|
0b6c37dd858d
commit https://github.com/vim/vim/commit/baaa7e9ec7398a813e21285c272fa99792642077
Christian Brabandt <cb@256bit.org>
parents:
6771
diff
changeset
|
123 static void unserialize_visualinfo(bufinfo_T *bi, visualinfo_T *info); |
| 168 | 124 #endif |
|
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17630
diff
changeset
|
125 static void u_saveline(linenr_T lnum); |
| 7 | 126 |
|
16768
695d9ef00b03
patch 8.1.1386: unessesary type casts for lalloc()
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
127 #define U_ALLOC_LINE(size) lalloc(size, FALSE) |
| 7 | 128 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
129 // used in undo_end() to report number of added and deleted lines |
| 7 | 130 static long u_newcount, u_oldcount; |
| 131 | |
| 132 /* | |
| 133 * When 'u' flag included in 'cpoptions', we behave like vi. Need to remember | |
| 134 * the action that "u" should do. | |
| 135 */ | |
| 136 static int undo_undoes = FALSE; | |
| 137 | |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
138 static int lastmark = 0; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
139 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
140 #if defined(U_DEBUG) || defined(PROTO) |
| 1415 | 141 /* |
| 142 * Check the undo structures for being valid. Print a warning when something | |
| 143 * looks wrong. | |
| 144 */ | |
| 145 static int seen_b_u_curhead; | |
| 146 static int seen_b_u_newhead; | |
| 147 static int header_count; | |
| 148 | |
| 149 static void | |
| 150 u_check_tree(u_header_T *uhp, | |
| 151 u_header_T *exp_uh_next, | |
| 152 u_header_T *exp_uh_alt_prev) | |
| 153 { | |
| 154 u_entry_T *uep; | |
| 155 | |
| 156 if (uhp == NULL) | |
| 157 return; | |
| 158 ++header_count; | |
| 159 if (uhp == curbuf->b_u_curhead && ++seen_b_u_curhead > 1) | |
| 160 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
161 emsg("b_u_curhead found twice (looping?)"); |
| 1415 | 162 return; |
| 163 } | |
| 164 if (uhp == curbuf->b_u_newhead && ++seen_b_u_newhead > 1) | |
| 165 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
166 emsg("b_u_newhead found twice (looping?)"); |
| 1415 | 167 return; |
| 168 } | |
| 169 | |
| 170 if (uhp->uh_magic != UH_MAGIC) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
171 emsg("uh_magic wrong (may be using freed memory)"); |
| 1415 | 172 else |
| 173 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
174 // Check pointers back are correct. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
175 if (uhp->uh_next.ptr != exp_uh_next) |
| 1415 | 176 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
177 emsg("uh_next wrong"); |
|
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
178 smsg("expected: 0x%x, actual: 0x%x", |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
179 exp_uh_next, uhp->uh_next.ptr); |
| 1415 | 180 } |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
181 if (uhp->uh_alt_prev.ptr != exp_uh_alt_prev) |
| 1415 | 182 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
183 emsg("uh_alt_prev wrong"); |
|
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
184 smsg("expected: 0x%x, actual: 0x%x", |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
185 exp_uh_alt_prev, uhp->uh_alt_prev.ptr); |
| 1415 | 186 } |
| 187 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
188 // Check the undo tree at this header. |
| 1415 | 189 for (uep = uhp->uh_entry; uep != NULL; uep = uep->ue_next) |
| 190 { | |
| 191 if (uep->ue_magic != UE_MAGIC) | |
| 192 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
193 emsg("ue_magic wrong (may be using freed memory)"); |
| 1415 | 194 break; |
| 195 } | |
| 196 } | |
| 197 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
198 // Check the next alt tree. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
199 u_check_tree(uhp->uh_alt_next.ptr, uhp->uh_next.ptr, uhp); |
| 1415 | 200 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
201 // Check the next header in this branch. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
202 u_check_tree(uhp->uh_prev.ptr, uhp, NULL); |
| 1415 | 203 } |
| 204 } | |
| 205 | |
| 2189 | 206 static void |
| 1415 | 207 u_check(int newhead_may_be_NULL) |
| 208 { | |
| 209 seen_b_u_newhead = 0; | |
| 210 seen_b_u_curhead = 0; | |
| 211 header_count = 0; | |
| 212 | |
| 213 u_check_tree(curbuf->b_u_oldhead, NULL, NULL); | |
| 214 | |
| 215 if (seen_b_u_newhead == 0 && curbuf->b_u_oldhead != NULL | |
| 216 && !(newhead_may_be_NULL && curbuf->b_u_newhead == NULL)) | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
217 semsg("b_u_newhead invalid: 0x%x", curbuf->b_u_newhead); |
| 1415 | 218 if (curbuf->b_u_curhead != NULL && seen_b_u_curhead == 0) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
219 semsg("b_u_curhead invalid: 0x%x", curbuf->b_u_curhead); |
| 1415 | 220 if (header_count != curbuf->b_u_numhead) |
| 221 { | |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
222 emsg("b_u_numhead invalid"); |
|
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
223 smsg("expected: %ld, actual: %ld", |
| 1415 | 224 (long)header_count, (long)curbuf->b_u_numhead); |
| 225 } | |
| 226 } | |
| 227 #endif | |
| 228 | |
| 7 | 229 /* |
| 344 | 230 * Save the current line for both the "u" and "U" command. |
| 4303 | 231 * Careful: may trigger autocommands that reload the buffer. |
| 344 | 232 * Returns OK or FAIL. |
| 7 | 233 */ |
| 234 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
235 u_save_cursor(void) |
| 7 | 236 { |
| 237 return (u_save((linenr_T)(curwin->w_cursor.lnum - 1), | |
| 238 (linenr_T)(curwin->w_cursor.lnum + 1))); | |
| 239 } | |
| 240 | |
| 241 /* | |
| 242 * Save the lines between "top" and "bot" for both the "u" and "U" command. | |
|
26532
255bc9a08e58
patch 8.2.3795: too many #ifdefs
Bram Moolenaar <Bram@vim.org>
parents:
25951
diff
changeset
|
243 * "top" may be 0 and "bot" may be curbuf->b_ml.ml_line_count + 1. |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
244 * Careful: may trigger autocommands that reload the buffer. |
| 7 | 245 * Returns FAIL when lines could not be saved, OK otherwise. |
| 246 */ | |
| 247 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
248 u_save(linenr_T top, linenr_T bot) |
| 7 | 249 { |
| 250 if (undo_off) | |
| 251 return OK; | |
| 252 | |
|
14327
b8f1167aa8ad
patch 8.1.0179: redundant condition for boundary check
Christian Brabandt <cb@256bit.org>
parents:
14301
diff
changeset
|
253 if (top >= bot || bot > curbuf->b_ml.ml_line_count + 1) |
|
b8f1167aa8ad
patch 8.1.0179: redundant condition for boundary check
Christian Brabandt <cb@256bit.org>
parents:
14301
diff
changeset
|
254 return FAIL; // rely on caller to give an error message |
| 7 | 255 |
| 256 if (top + 2 == bot) | |
| 257 u_saveline((linenr_T)(top + 1)); | |
| 258 | |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
259 return (u_savecommon(top, bot, (linenr_T)0, FALSE)); |
| 7 | 260 } |
| 261 | |
| 262 /* | |
| 2181 | 263 * Save the line "lnum" (used by ":s" and "~" command). |
| 7 | 264 * The line is replaced, so the new bottom line is lnum + 1. |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
265 * Careful: may trigger autocommands that reload the buffer. |
|
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
266 * Returns FAIL when lines could not be saved, OK otherwise. |
| 7 | 267 */ |
| 268 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
269 u_savesub(linenr_T lnum) |
| 7 | 270 { |
| 271 if (undo_off) | |
| 272 return OK; | |
| 273 | |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
274 return (u_savecommon(lnum - 1, lnum + 1, lnum + 1, FALSE)); |
| 7 | 275 } |
| 276 | |
| 277 /* | |
| 2181 | 278 * A new line is inserted before line "lnum" (used by :s command). |
| 7 | 279 * The line is inserted, so the new bottom line is lnum + 1. |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
280 * Careful: may trigger autocommands that reload the buffer. |
|
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
281 * Returns FAIL when lines could not be saved, OK otherwise. |
| 7 | 282 */ |
| 283 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
284 u_inssub(linenr_T lnum) |
| 7 | 285 { |
| 286 if (undo_off) | |
| 287 return OK; | |
| 288 | |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
289 return (u_savecommon(lnum - 1, lnum, lnum + 1, FALSE)); |
| 7 | 290 } |
| 291 | |
| 292 /* | |
| 2181 | 293 * Save the lines "lnum" - "lnum" + nlines (used by delete command). |
| 7 | 294 * The lines are deleted, so the new bottom line is lnum, unless the buffer |
| 295 * becomes empty. | |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
296 * Careful: may trigger autocommands that reload the buffer. |
|
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
297 * Returns FAIL when lines could not be saved, OK otherwise. |
| 7 | 298 */ |
| 299 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
300 u_savedel(linenr_T lnum, long nlines) |
| 7 | 301 { |
| 302 if (undo_off) | |
| 303 return OK; | |
| 304 | |
| 305 return (u_savecommon(lnum - 1, lnum + nlines, | |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
306 nlines == curbuf->b_ml.ml_line_count ? 2 : lnum, FALSE)); |
| 7 | 307 } |
| 308 | |
| 632 | 309 /* |
| 310 * Return TRUE when undo is allowed. Otherwise give an error message and | |
| 311 * return FALSE. | |
| 312 */ | |
| 912 | 313 int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
314 undo_allowed(void) |
| 632 | 315 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
316 // Don't allow changes when 'modifiable' is off. |
| 632 | 317 if (!curbuf->b_p_ma) |
| 318 { | |
|
25064
8f2262c72178
patch 8.2.3069: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
24970
diff
changeset
|
319 emsg(_(e_cannot_make_changes_modifiable_is_off)); |
| 632 | 320 return FALSE; |
| 321 } | |
| 322 | |
| 323 #ifdef HAVE_SANDBOX | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
324 // In the sandbox it's not allowed to change the text. |
| 632 | 325 if (sandbox != 0) |
| 326 { | |
|
25320
1e6da8364a02
patch 8.2.3197: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
25064
diff
changeset
|
327 emsg(_(e_not_allowed_in_sandbox)); |
| 632 | 328 return FALSE; |
| 329 } | |
| 330 #endif | |
| 331 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
332 // Don't allow changes in the buffer while editing the cmdline. The |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
333 // caller of getcmdline() may get confused. |
|
29014
45c182c4f7e9
patch 8.2.5029: "textlock" is always zero
Bram Moolenaar <Bram@vim.org>
parents:
29002
diff
changeset
|
334 if (textlock != 0) |
| 632 | 335 { |
|
29014
45c182c4f7e9
patch 8.2.5029: "textlock" is always zero
Bram Moolenaar <Bram@vim.org>
parents:
29002
diff
changeset
|
336 emsg(_(e_not_allowed_to_change_text_or_change_window)); |
| 632 | 337 return FALSE; |
| 338 } | |
| 339 | |
| 340 return TRUE; | |
| 341 } | |
| 342 | |
| 2189 | 343 /* |
|
18498
9e6d5a4abb1c
patch 8.1.2243: typos in comments
Bram Moolenaar <Bram@vim.org>
parents:
18463
diff
changeset
|
344 * Get the undolevel value for the current buffer. |
| 5446 | 345 */ |
| 346 static long | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
347 get_undolevel(void) |
| 5446 | 348 { |
| 349 if (curbuf->b_p_ul == NO_LOCAL_UNDOLEVEL) | |
| 350 return p_ul; | |
| 351 return curbuf->b_p_ul; | |
| 352 } | |
| 353 | |
| 354 /* | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
355 * u_save_line(): save an allocated copy of line "lnum" into "ul". |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
356 * Returns FAIL when out of memory. |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
357 */ |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
358 static int |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
359 u_save_line(undoline_T *ul, linenr_T lnum) |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
360 { |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
361 char_u *line = ml_get(lnum); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
362 |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
363 if (curbuf->b_ml.ml_line_len == 0) |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
364 { |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
365 ul->ul_len = 1; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
366 ul->ul_line = vim_strsave((char_u *)""); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
367 } |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
368 else |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
369 { |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
370 // This uses the length in the memline, thus text properties are |
|
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
371 // included. |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
372 ul->ul_len = curbuf->b_ml.ml_line_len; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
373 ul->ul_line = vim_memsave(line, ul->ul_len); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
374 } |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
375 return ul->ul_line == NULL ? FAIL : OK; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
376 } |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
377 |
|
20585
0b55c9a14ea1
patch 8.2.0846: build failure with small features
Bram Moolenaar <Bram@vim.org>
parents:
20581
diff
changeset
|
378 #ifdef FEAT_PROP_POPUP |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
379 /* |
|
20581
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
380 * return TRUE if line "lnum" has text property "flags". |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
381 */ |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
382 static int |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
383 has_prop_w_flags(linenr_T lnum, int flags) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
384 { |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
385 char_u *props; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
386 int i; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
387 int proplen = get_text_props(curbuf, lnum, &props, FALSE); |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
388 |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
389 for (i = 0; i < proplen; ++i) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
390 { |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
391 textprop_T prop; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
392 |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
393 mch_memmove(&prop, props + i * sizeof prop, sizeof prop); |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
394 if (prop.tp_flags & flags) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
395 return TRUE; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
396 } |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
397 return FALSE; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
398 } |
|
20585
0b55c9a14ea1
patch 8.2.0846: build failure with small features
Bram Moolenaar <Bram@vim.org>
parents:
20581
diff
changeset
|
399 #endif |
|
20581
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
400 |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
401 /* |
| 2189 | 402 * Common code for various ways to save text before a change. |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
403 * "top" is the line above the first changed line. |
|
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
404 * "bot" is the line below the last changed line. |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
405 * "newbot" is the new bottom line. Use zero when not known. |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
406 * "reload" is TRUE when saving for a buffer reload. |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
407 * Careful: may trigger autocommands that reload the buffer. |
|
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
408 * Returns FAIL when lines could not be saved, OK otherwise. |
| 2189 | 409 */ |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
410 int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
411 u_savecommon( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
412 linenr_T top, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
413 linenr_T bot, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
414 linenr_T newbot, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
415 int reload) |
| 7 | 416 { |
| 753 | 417 linenr_T lnum; |
| 418 long i; | |
| 419 u_header_T *uhp; | |
| 420 u_header_T *old_curhead; | |
| 421 u_entry_T *uep; | |
| 422 u_entry_T *prev_uep; | |
| 423 long size; | |
| 7 | 424 |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
425 if (!reload) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
426 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
427 // When making changes is not allowed return FAIL. It's a crude way |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
428 // to make all change commands fail. |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
429 if (!undo_allowed()) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
430 return FAIL; |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
431 |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
432 #ifdef FEAT_NETBEANS_INTG |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
433 /* |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
434 * Netbeans defines areas that cannot be modified. Bail out here when |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
435 * trying to change text in a guarded area. |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
436 */ |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
437 if (netbeans_active()) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
438 { |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
439 if (netbeans_is_guarded(top, bot)) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
440 { |
|
26883
7f150a4936f2
patch 8.2.3970: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26532
diff
changeset
|
441 emsg(_(e_region_is_guarded_cannot_modify)); |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
442 return FAIL; |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
443 } |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
444 if (curbuf->b_p_ro) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
445 { |
|
26883
7f150a4936f2
patch 8.2.3970: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26532
diff
changeset
|
446 emsg(_(e_netbeans_does_not_allow_changes_in_read_only_files)); |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
447 return FAIL; |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
448 } |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
449 } |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
450 #endif |
|
11836
f080b225a2a4
patch 8.0.0798: no highlighting in a terminal window with a finished job
Christian Brabandt <cb@256bit.org>
parents:
11506
diff
changeset
|
451 #ifdef FEAT_TERMINAL |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
452 // A change in a terminal buffer removes the highlighting. |
|
11836
f080b225a2a4
patch 8.0.0798: no highlighting in a terminal window with a finished job
Christian Brabandt <cb@256bit.org>
parents:
11506
diff
changeset
|
453 term_change_in_curbuf(); |
|
f080b225a2a4
patch 8.0.0798: no highlighting in a terminal window with a finished job
Christian Brabandt <cb@256bit.org>
parents:
11506
diff
changeset
|
454 #endif |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
455 |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
456 /* |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
457 * Saving text for undo means we are going to make a change. Give a |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
458 * warning for a read-only file before making the change, so that the |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
459 * FileChangedRO event can replace the buffer with a read-write version |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
460 * (e.g., obtained from a source control system). |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
461 */ |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
462 change_warning(0); |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
463 if (bot > curbuf->b_ml.ml_line_count + 1) |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
464 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
465 // This happens when the FileChangedRO autocommand changes the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
466 // file in a way it becomes shorter. |
|
26966
ac75c145f0a9
patch 8.2.4012: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
467 emsg(_(e_line_count_changed_unexpectedly)); |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
468 return FAIL; |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
469 } |
|
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
470 } |
| 7 | 471 |
| 1415 | 472 #ifdef U_DEBUG |
| 473 u_check(FALSE); | |
| 474 #endif | |
| 7 | 475 |
|
20581
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
476 #ifdef FEAT_PROP_POPUP |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
477 // Include the line above if a text property continues from it. |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
478 // Include the line below if a text property continues to it. |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
479 if (bot - top > 1) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
480 { |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
481 if (top > 0 && has_prop_w_flags(top + 1, TP_FLAG_CONT_PREV)) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
482 --top; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
483 if (bot <= curbuf->b_ml.ml_line_count |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
484 && has_prop_w_flags(bot - 1, TP_FLAG_CONT_NEXT)) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
485 { |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
486 ++bot; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
487 if (newbot != 0) |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
488 ++newbot; |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
489 } |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
490 } |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
491 #endif |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
492 |
| 7 | 493 size = bot - top - 1; |
| 494 | |
| 495 /* | |
| 2189 | 496 * If curbuf->b_u_synced == TRUE make a new header. |
| 7 | 497 */ |
| 498 if (curbuf->b_u_synced) | |
| 499 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
500 // Need to create new entry in b_changelist. |
| 7 | 501 curbuf->b_new_change = TRUE; |
| 502 | |
| 5446 | 503 if (get_undolevel() >= 0) |
| 753 | 504 { |
| 505 /* | |
| 506 * Make a new header entry. Do this first so that we don't mess | |
| 507 * up the undo info when out of memory. | |
| 508 */ | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
509 uhp = U_ALLOC_LINE(sizeof(u_header_T)); |
| 753 | 510 if (uhp == NULL) |
| 511 goto nomem; | |
| 1415 | 512 #ifdef U_DEBUG |
| 513 uhp->uh_magic = UH_MAGIC; | |
| 514 #endif | |
| 753 | 515 } |
| 766 | 516 else |
| 517 uhp = NULL; | |
| 753 | 518 |
| 7 | 519 /* |
| 758 | 520 * If we undid more than we redid, move the entry lists before and |
| 521 * including curbuf->b_u_curhead to an alternate branch. | |
| 7 | 522 */ |
| 753 | 523 old_curhead = curbuf->b_u_curhead; |
| 524 if (old_curhead != NULL) | |
| 525 { | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
526 curbuf->b_u_newhead = old_curhead->uh_next.ptr; |
| 753 | 527 curbuf->b_u_curhead = NULL; |
| 528 } | |
| 7 | 529 |
| 530 /* | |
| 531 * free headers to keep the size right | |
| 532 */ | |
| 5446 | 533 while (curbuf->b_u_numhead > get_undolevel() |
| 534 && curbuf->b_u_oldhead != NULL) | |
| 753 | 535 { |
| 758 | 536 u_header_T *uhfree = curbuf->b_u_oldhead; |
| 753 | 537 |
| 1415 | 538 if (uhfree == old_curhead) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
539 // Can't reconnect the branch, delete all of it. |
| 1415 | 540 u_freebranch(curbuf, uhfree, &old_curhead); |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
541 else if (uhfree->uh_alt_next.ptr == NULL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
542 // There is no branch, only free one header. |
| 758 | 543 u_freeheader(curbuf, uhfree, &old_curhead); |
| 753 | 544 else |
| 545 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
546 // Free the oldest alternate branch as a whole. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
547 while (uhfree->uh_alt_next.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
548 uhfree = uhfree->uh_alt_next.ptr; |
| 758 | 549 u_freebranch(curbuf, uhfree, &old_curhead); |
| 753 | 550 } |
| 1415 | 551 #ifdef U_DEBUG |
| 552 u_check(TRUE); | |
| 553 #endif | |
| 753 | 554 } |
| 7 | 555 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
556 if (uhp == NULL) // no undo at all |
| 7 | 557 { |
| 753 | 558 if (old_curhead != NULL) |
| 559 u_freebranch(curbuf, old_curhead, NULL); | |
| 7 | 560 curbuf->b_u_synced = FALSE; |
| 561 return OK; | |
| 562 } | |
| 563 | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
564 uhp->uh_prev.ptr = NULL; |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
565 uhp->uh_next.ptr = curbuf->b_u_newhead; |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
566 uhp->uh_alt_next.ptr = old_curhead; |
| 753 | 567 if (old_curhead != NULL) |
| 568 { | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
569 uhp->uh_alt_prev.ptr = old_curhead->uh_alt_prev.ptr; |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
570 if (uhp->uh_alt_prev.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
571 uhp->uh_alt_prev.ptr->uh_alt_next.ptr = uhp; |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
572 old_curhead->uh_alt_prev.ptr = uhp; |
| 753 | 573 if (curbuf->b_u_oldhead == old_curhead) |
| 574 curbuf->b_u_oldhead = uhp; | |
| 575 } | |
| 1056 | 576 else |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
577 uhp->uh_alt_prev.ptr = NULL; |
| 758 | 578 if (curbuf->b_u_newhead != NULL) |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
579 curbuf->b_u_newhead->uh_prev.ptr = uhp; |
| 758 | 580 |
| 777 | 581 uhp->uh_seq = ++curbuf->b_u_seq_last; |
| 582 curbuf->b_u_seq_cur = uhp->uh_seq; | |
|
9674
adc7212951ee
commit https://github.com/vim/vim/commit/170b10b421f0c9fda08b7cfd3bb043c064f3659a
Christian Brabandt <cb@256bit.org>
parents:
9536
diff
changeset
|
583 uhp->uh_time = vim_time(); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
584 uhp->uh_save_nr = 0; |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
585 curbuf->b_u_time_cur = uhp->uh_time + 1; |
| 758 | 586 |
| 753 | 587 uhp->uh_walk = 0; |
| 7 | 588 uhp->uh_entry = NULL; |
| 589 uhp->uh_getbot_entry = NULL; | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
590 uhp->uh_cursor = curwin->w_cursor; // save cursor pos. for undo |
| 7 | 591 if (virtual_active() && curwin->w_cursor.coladd > 0) |
| 592 uhp->uh_cursor_vcol = getviscol(); | |
| 593 else | |
| 594 uhp->uh_cursor_vcol = -1; | |
| 595 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
596 // save changed and buffer empty flag for undo |
| 7 | 597 uhp->uh_flags = (curbuf->b_changed ? UH_CHANGED : 0) + |
| 598 ((curbuf->b_ml.ml_flags & ML_EMPTY) ? UH_EMPTYBUF : 0); | |
| 599 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
600 // save named marks and Visual marks for undo |
| 7 | 601 mch_memmove(uhp->uh_namedm, curbuf->b_namedm, sizeof(pos_T) * NMARKS); |
| 692 | 602 uhp->uh_visual = curbuf->b_visual; |
| 603 | |
| 7 | 604 curbuf->b_u_newhead = uhp; |
| 605 if (curbuf->b_u_oldhead == NULL) | |
| 606 curbuf->b_u_oldhead = uhp; | |
| 607 ++curbuf->b_u_numhead; | |
| 608 } | |
| 609 else | |
| 610 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
611 if (get_undolevel() < 0) // no undo at all |
| 7 | 612 return OK; |
| 613 | |
| 614 /* | |
| 615 * When saving a single line, and it has been saved just before, it | |
| 616 * doesn't make sense saving it again. Saves a lot of memory when | |
| 617 * making lots of changes inside the same line. | |
| 618 * This is only possible if the previous change didn't increase or | |
| 619 * decrease the number of lines. | |
| 620 * Check the ten last changes. More doesn't make sense and takes too | |
| 621 * long. | |
| 622 */ | |
| 623 if (size == 1) | |
| 624 { | |
| 625 uep = u_get_headentry(); | |
| 626 prev_uep = NULL; | |
| 627 for (i = 0; i < 10; ++i) | |
| 628 { | |
| 629 if (uep == NULL) | |
| 630 break; | |
| 631 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
632 // If lines have been inserted/deleted we give up. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
633 // Also when the line was included in a multi-line save. |
| 7 | 634 if ((curbuf->b_u_newhead->uh_getbot_entry != uep |
| 635 ? (uep->ue_top + uep->ue_size + 1 | |
| 636 != (uep->ue_bot == 0 | |
| 637 ? curbuf->b_ml.ml_line_count + 1 | |
| 638 : uep->ue_bot)) | |
| 639 : uep->ue_lcount != curbuf->b_ml.ml_line_count) | |
| 640 || (uep->ue_size > 1 | |
| 641 && top >= uep->ue_top | |
| 642 && top + 2 <= uep->ue_top + uep->ue_size + 1)) | |
| 643 break; | |
| 644 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
645 // If it's the same line we can skip saving it again. |
| 7 | 646 if (uep->ue_size == 1 && uep->ue_top == top) |
| 647 { | |
| 648 if (i > 0) | |
| 649 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
650 // It's not the last entry: get ue_bot for the last |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
651 // entry now. Following deleted/inserted lines go to |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
652 // the re-used entry. |
| 7 | 653 u_getbot(); |
| 654 curbuf->b_u_synced = FALSE; | |
| 655 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
656 // Move the found entry to become the last entry. The |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
657 // order of undo/redo doesn't matter for the entries |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
658 // we move it over, since they don't change the line |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
659 // count and don't include this line. It does matter |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
660 // for the found entry if the line count is changed by |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
661 // the executed command. |
| 7 | 662 prev_uep->ue_next = uep->ue_next; |
| 663 uep->ue_next = curbuf->b_u_newhead->uh_entry; | |
| 664 curbuf->b_u_newhead->uh_entry = uep; | |
| 665 } | |
| 666 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
667 // The executed command may change the line count. |
| 7 | 668 if (newbot != 0) |
| 669 uep->ue_bot = newbot; | |
| 670 else if (bot > curbuf->b_ml.ml_line_count) | |
| 671 uep->ue_bot = 0; | |
| 672 else | |
| 673 { | |
| 674 uep->ue_lcount = curbuf->b_ml.ml_line_count; | |
| 675 curbuf->b_u_newhead->uh_getbot_entry = uep; | |
| 676 } | |
| 677 return OK; | |
| 678 } | |
| 679 prev_uep = uep; | |
| 680 uep = uep->ue_next; | |
| 681 } | |
| 682 } | |
| 683 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
684 // find line number for ue_bot for previous u_save() |
| 7 | 685 u_getbot(); |
| 686 } | |
| 687 | |
|
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
688 #if !defined(UNIX) && !defined(MSWIN) |
| 7 | 689 /* |
|
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
8128
diff
changeset
|
690 * With Amiga we can't handle big undo's, because |
| 7 | 691 * then u_alloc_line would have to allocate a block larger than 32K |
| 692 */ | |
| 693 if (size >= 8000) | |
| 694 goto nomem; | |
| 695 #endif | |
| 696 | |
| 697 /* | |
| 698 * add lines in front of entry list | |
| 699 */ | |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
700 uep = U_ALLOC_LINE(sizeof(u_entry_T)); |
| 7 | 701 if (uep == NULL) |
| 702 goto nomem; | |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
18816
diff
changeset
|
703 CLEAR_POINTER(uep); |
| 1415 | 704 #ifdef U_DEBUG |
| 705 uep->ue_magic = UE_MAGIC; | |
| 706 #endif | |
| 7 | 707 |
| 708 uep->ue_size = size; | |
| 709 uep->ue_top = top; | |
| 710 if (newbot != 0) | |
| 711 uep->ue_bot = newbot; | |
| 712 /* | |
| 713 * Use 0 for ue_bot if bot is below last line. | |
| 714 * Otherwise we have to compute ue_bot later. | |
| 715 */ | |
| 716 else if (bot > curbuf->b_ml.ml_line_count) | |
| 717 uep->ue_bot = 0; | |
| 718 else | |
| 719 { | |
| 720 uep->ue_lcount = curbuf->b_ml.ml_line_count; | |
| 721 curbuf->b_u_newhead->uh_getbot_entry = uep; | |
| 722 } | |
| 723 | |
| 168 | 724 if (size > 0) |
| 7 | 725 { |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
726 if ((uep->ue_array = U_ALLOC_LINE(sizeof(undoline_T) * size)) == NULL) |
| 7 | 727 { |
| 728 u_freeentry(uep, 0L); | |
| 729 goto nomem; | |
| 730 } | |
| 731 for (i = 0, lnum = top + 1; i < size; ++i) | |
| 732 { | |
| 481 | 733 fast_breakcheck(); |
| 734 if (got_int) | |
| 735 { | |
| 736 u_freeentry(uep, i); | |
| 737 return FAIL; | |
| 738 } | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
739 if (u_save_line(&uep->ue_array[i], lnum++) == FAIL) |
| 7 | 740 { |
| 741 u_freeentry(uep, i); | |
| 742 goto nomem; | |
| 743 } | |
| 744 } | |
| 745 } | |
| 359 | 746 else |
| 747 uep->ue_array = NULL; | |
| 7 | 748 uep->ue_next = curbuf->b_u_newhead->uh_entry; |
| 749 curbuf->b_u_newhead->uh_entry = uep; | |
| 750 curbuf->b_u_synced = FALSE; | |
| 751 undo_undoes = FALSE; | |
| 752 | |
| 1415 | 753 #ifdef U_DEBUG |
| 754 u_check(FALSE); | |
| 755 #endif | |
| 7 | 756 return OK; |
| 757 | |
| 758 nomem: | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
759 msg_silent = 0; // must display the prompt |
| 7 | 760 if (ask_yesno((char_u *)_("No undo possible; continue anyway"), TRUE) |
| 761 == 'y') | |
| 762 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
763 undo_off = TRUE; // will be reset when character typed |
| 7 | 764 return OK; |
| 765 } | |
| 766 do_outofmem_msg((long_u)0); | |
| 767 return FAIL; | |
| 768 } | |
| 769 | |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
770 #if defined(FEAT_PERSISTENT_UNDO) || defined(PROTO) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
771 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
772 # define UF_START_MAGIC "Vim\237UnDo\345" // magic at start of undofile |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
773 # define UF_START_MAGIC_LEN 9 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
774 # define UF_HEADER_MAGIC 0x5fd0 // magic at start of header |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
775 # define UF_HEADER_END_MAGIC 0xe7aa // magic after last header |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
776 # define UF_ENTRY_MAGIC 0xf518 // magic at start of entry |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
777 # define UF_ENTRY_END_MAGIC 0x3581 // magic after last entry |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
778 # define UF_VERSION 2 // 2-byte undofile version number |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
779 # define UF_VERSION_CRYPT 0x8002 // idem, encrypted |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
780 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
781 // extra fields for header |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
782 # define UF_LAST_SAVE_NR 1 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
783 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
784 // extra fields for uhp |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
785 # define UHP_SAVE_NR 1 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
786 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
787 /* |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
788 * Compute the hash for the current buffer text into hash[UNDO_HASH_SIZE]. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
789 */ |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
790 void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
791 u_compute_hash(char_u *hash) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
792 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
793 context_sha256_T ctx; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
794 linenr_T lnum; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
795 char_u *p; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
796 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
797 sha256_start(&ctx); |
| 3194 | 798 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
799 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
800 p = ml_get(lnum); |
|
2217
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
801 sha256_update(&ctx, p, (UINT32_T)(STRLEN(p) + 1)); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
802 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
803 sha256_finish(&ctx, hash); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
804 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
805 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
806 /* |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
807 * Return an allocated string of the full path of the target undofile. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
808 * When "reading" is TRUE find the file to read, go over all directories in |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
809 * 'undodir'. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
810 * When "reading" is FALSE use the first name where the directory exists. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
811 * Returns NULL when there is no place to write or no file to read. |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
812 */ |
|
18051
d1e77015f60b
patch 8.1.2021: some global functions can be local to the file
Bram Moolenaar <Bram@vim.org>
parents:
18025
diff
changeset
|
813 static char_u * |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
814 u_get_undo_file_name(char_u *buf_ffname, int reading) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
815 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
816 char_u *dirp; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
817 char_u dir_name[IOSIZE + 1]; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
818 char_u *munged_name = NULL; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
819 char_u *undo_file_name = NULL; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
820 int dir_len; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
821 char_u *p; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8568
diff
changeset
|
822 stat_T st; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
823 char_u *ffname = buf_ffname; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
824 #ifdef HAVE_READLINK |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
825 char_u fname_buf[MAXPATHL]; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
826 #endif |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
827 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
828 if (ffname == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
829 return NULL; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
830 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
831 #ifdef HAVE_READLINK |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
832 // Expand symlink in the file name, so that we put the undo file with the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
833 // actual file instead of with the symlink. |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
834 if (resolve_symlink(ffname, fname_buf) == OK) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
835 ffname = fname_buf; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
836 #endif |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
837 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
838 // Loop over 'undodir'. When reading find the first file that exists. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
839 // When not reading use the first directory that exists or ".". |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
840 dirp = p_udir; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
841 while (*dirp != NUL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
842 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
843 dir_len = copy_option_part(&dirp, dir_name, IOSIZE, ","); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
844 if (dir_len == 1 && dir_name[0] == '.') |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
845 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
846 // Use same directory as the ffname, |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
847 // "dir/name" -> "dir/.name.un~" |
|
20830
9064044fd4f6
patch 8.2.0967: unnecessary type casts for vim_strnsave()
Bram Moolenaar <Bram@vim.org>
parents:
20585
diff
changeset
|
848 undo_file_name = vim_strnsave(ffname, STRLEN(ffname) + 5); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
849 if (undo_file_name == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
850 break; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
851 p = gettail(undo_file_name); |
| 5704 | 852 #ifdef VMS |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
853 // VMS can not handle more than one dot in the filenames |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
854 // use "dir/name" -> "dir/_un_name" - add _un_ |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
855 // at the beginning to keep the extension |
| 5704 | 856 mch_memmove(p + 4, p, STRLEN(p) + 1); |
| 857 mch_memmove(p, "_un_", 4); | |
| 858 | |
| 859 #else | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
860 // Use same directory as the ffname, |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
861 // "dir/name" -> "dir/.name.un~" |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
862 mch_memmove(p + 1, p, STRLEN(p) + 1); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
863 *p = '.'; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
864 STRCAT(p, ".un~"); |
| 5704 | 865 #endif |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
866 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
867 else |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
868 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
869 dir_name[dir_len] = NUL; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
870 if (mch_isdir(dir_name)) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
871 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
872 if (munged_name == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
873 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
874 munged_name = vim_strsave(ffname); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
875 if (munged_name == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
876 return NULL; |
|
11127
506f5d8b7d8b
patch 8.0.0451: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
877 for (p = munged_name; *p != NUL; MB_PTR_ADV(p)) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
878 if (vim_ispathsep(*p)) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
879 *p = '%'; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
880 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
881 undo_file_name = concat_fnames(dir_name, munged_name, TRUE); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
882 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
883 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
884 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
885 // When reading check if the file exists. |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
886 if (undo_file_name != NULL && (!reading |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
887 || mch_stat((char *)undo_file_name, &st) >= 0)) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
888 break; |
|
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
13138
diff
changeset
|
889 VIM_CLEAR(undo_file_name); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
890 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
891 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
892 vim_free(munged_name); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
893 return undo_file_name; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
894 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
895 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
896 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
897 corruption_error(char *mesg, char_u *file_name) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
898 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
899 semsg(_(e_corrupted_undo_file_str_str), mesg, file_name); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
900 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
901 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
902 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
903 u_free_uhp(u_header_T *uhp) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
904 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
905 u_entry_T *nuep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
906 u_entry_T *uep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
907 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
908 uep = uhp->uh_entry; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
909 while (uep != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
910 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
911 nuep = uep->ue_next; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
912 u_freeentry(uep, uep->ue_size); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
913 uep = nuep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
914 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
915 vim_free(uhp); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
916 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
917 |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
918 /* |
| 6122 | 919 * Write a sequence of bytes to the undo file. |
| 920 * Buffers and encrypts as needed. | |
| 921 * Returns OK or FAIL. | |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
922 */ |
| 6122 | 923 static int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
924 undo_write(bufinfo_T *bi, char_u *ptr, size_t len) |
| 6122 | 925 { |
| 926 #ifdef FEAT_CRYPT | |
| 927 if (bi->bi_buffer != NULL) | |
| 928 { | |
| 929 size_t len_todo = len; | |
| 930 char_u *p = ptr; | |
| 931 | |
| 932 while (bi->bi_used + len_todo >= CRYPT_BUF_SIZE) | |
| 933 { | |
| 934 size_t n = CRYPT_BUF_SIZE - bi->bi_used; | |
| 935 | |
| 936 mch_memmove(bi->bi_buffer + bi->bi_used, p, n); | |
| 937 len_todo -= n; | |
| 938 p += n; | |
| 939 bi->bi_used = CRYPT_BUF_SIZE; | |
| 940 if (undo_flush(bi) == FAIL) | |
| 941 return FAIL; | |
| 942 } | |
| 943 if (len_todo > 0) | |
| 944 { | |
| 945 mch_memmove(bi->bi_buffer + bi->bi_used, p, len_todo); | |
| 946 bi->bi_used += len_todo; | |
| 947 } | |
| 948 return OK; | |
| 949 } | |
| 950 #endif | |
| 951 if (fwrite(ptr, len, (size_t)1, bi->bi_fp) != 1) | |
| 952 return FAIL; | |
| 953 return OK; | |
| 954 } | |
| 955 | |
| 956 #ifdef FEAT_CRYPT | |
| 957 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
958 undo_flush(bufinfo_T *bi) |
| 6122 | 959 { |
|
12216
e971ef6c0dee
patch 8.0.0988: warning from Covscan about using NULL pointer
Christian Brabandt <cb@256bit.org>
parents:
11957
diff
changeset
|
960 if (bi->bi_buffer != NULL && bi->bi_state != NULL && bi->bi_used > 0) |
| 6122 | 961 { |
|
24970
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
962 // Last parameter is only used for sodium encryption and that |
|
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
963 // explicitly disables encryption of undofiles. |
|
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
964 crypt_encode_inplace(bi->bi_state, bi->bi_buffer, bi->bi_used, FALSE); |
| 6122 | 965 if (fwrite(bi->bi_buffer, bi->bi_used, (size_t)1, bi->bi_fp) != 1) |
| 966 return FAIL; | |
| 967 bi->bi_used = 0; | |
| 968 } | |
| 969 return OK; | |
| 970 } | |
| 971 #endif | |
| 972 | |
| 973 /* | |
| 974 * Write "ptr[len]" and crypt the bytes when needed. | |
| 975 * Returns OK or FAIL. | |
| 976 */ | |
| 977 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
978 fwrite_crypt(bufinfo_T *bi, char_u *ptr, size_t len) |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
979 { |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
980 #ifdef FEAT_CRYPT |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
981 char_u *copy; |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
982 char_u small_buf[100]; |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
983 size_t i; |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
984 |
| 6122 | 985 if (bi->bi_state != NULL && bi->bi_buffer == NULL) |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
986 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
987 // crypting every piece of text separately |
| 6122 | 988 if (len < 100) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
989 copy = small_buf; // no malloc()/free() for short strings |
| 6122 | 990 else |
| 991 { | |
| 992 copy = lalloc(len, FALSE); | |
| 993 if (copy == NULL) | |
| 994 return 0; | |
| 995 } | |
|
24970
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
996 // Last parameter is only used for sodium encryption and that |
|
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
997 // explicitly disables encryption of undofiles. |
|
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
998 crypt_encode(bi->bi_state, ptr, len, copy, TRUE); |
| 6122 | 999 i = fwrite(copy, len, (size_t)1, bi->bi_fp); |
| 1000 if (copy != small_buf) | |
| 1001 vim_free(copy); | |
| 1002 return i == 1 ? OK : FAIL; | |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1003 } |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1004 #endif |
| 6122 | 1005 return undo_write(bi, ptr, len); |
| 1006 } | |
| 1007 | |
| 1008 /* | |
| 1009 * Write a number, MSB first, in "len" bytes. | |
| 1010 * Must match with undo_read_?c() functions. | |
| 1011 * Returns OK or FAIL. | |
| 1012 */ | |
| 1013 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1014 undo_write_bytes(bufinfo_T *bi, long_u nr, int len) |
| 6122 | 1015 { |
| 1016 char_u buf[8]; | |
| 1017 int i; | |
| 1018 int bufi = 0; | |
| 1019 | |
| 1020 for (i = len - 1; i >= 0; --i) | |
| 6132 | 1021 buf[bufi++] = (char_u)(nr >> (i * 8)); |
| 6122 | 1022 return undo_write(bi, buf, (size_t)len); |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1023 } |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1024 |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1025 /* |
| 6122 | 1026 * Write the pointer to an undo header. Instead of writing the pointer itself |
| 1027 * we use the sequence number of the header. This is converted back to | |
| 1028 * pointers when reading. */ | |
| 1029 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1030 put_header_ptr(bufinfo_T *bi, u_header_T *uhp) |
| 6122 | 1031 { |
| 1032 undo_write_bytes(bi, (long_u)(uhp != NULL ? uhp->uh_seq : 0), 4); | |
| 1033 } | |
| 1034 | |
| 1035 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1036 undo_read_4c(bufinfo_T *bi) |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1037 { |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1038 #ifdef FEAT_CRYPT |
| 6122 | 1039 if (bi->bi_buffer != NULL) |
| 1040 { | |
| 1041 char_u buf[4]; | |
| 1042 int n; | |
| 1043 | |
| 1044 undo_read(bi, buf, (size_t)4); | |
| 6216 | 1045 n = ((unsigned)buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + buf[3]; |
| 6122 | 1046 return n; |
| 1047 } | |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1048 #endif |
| 6122 | 1049 return get4c(bi->bi_fp); |
| 1050 } | |
| 1051 | |
| 1052 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1053 undo_read_2c(bufinfo_T *bi) |
| 6122 | 1054 { |
| 1055 #ifdef FEAT_CRYPT | |
| 1056 if (bi->bi_buffer != NULL) | |
| 1057 { | |
| 1058 char_u buf[2]; | |
| 1059 int n; | |
| 1060 | |
| 1061 undo_read(bi, buf, (size_t)2); | |
| 1062 n = (buf[0] << 8) + buf[1]; | |
| 1063 return n; | |
| 1064 } | |
| 1065 #endif | |
| 1066 return get2c(bi->bi_fp); | |
|
2266
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1067 } |
|
ae2e615a7320
Fix tiny build, move functions to undo.c.
Bram Moolenaar <bram@vim.org>
parents:
2262
diff
changeset
|
1068 |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1069 static int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1070 undo_read_byte(bufinfo_T *bi) |
| 6122 | 1071 { |
| 1072 #ifdef FEAT_CRYPT | |
| 1073 if (bi->bi_buffer != NULL) | |
| 1074 { | |
| 1075 char_u buf[1]; | |
| 1076 | |
| 1077 undo_read(bi, buf, (size_t)1); | |
| 1078 return buf[0]; | |
| 1079 } | |
| 1080 #endif | |
| 1081 return getc(bi->bi_fp); | |
| 1082 } | |
| 1083 | |
| 1084 static time_t | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1085 undo_read_time(bufinfo_T *bi) |
| 6122 | 1086 { |
| 1087 #ifdef FEAT_CRYPT | |
| 1088 if (bi->bi_buffer != NULL) | |
| 1089 { | |
| 1090 char_u buf[8]; | |
| 1091 time_t n = 0; | |
| 1092 int i; | |
| 1093 | |
| 1094 undo_read(bi, buf, (size_t)8); | |
| 1095 for (i = 0; i < 8; ++i) | |
| 1096 n = (n << 8) + buf[i]; | |
| 1097 return n; | |
| 1098 } | |
| 1099 #endif | |
| 1100 return get8ctime(bi->bi_fp); | |
| 1101 } | |
| 1102 | |
| 1103 /* | |
| 1104 * Read "buffer[size]" from the undo file. | |
| 1105 * Return OK or FAIL. | |
| 1106 */ | |
| 1107 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1108 undo_read(bufinfo_T *bi, char_u *buffer, size_t size) |
| 6122 | 1109 { |
|
11506
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1110 int retval = OK; |
|
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1111 |
| 6122 | 1112 #ifdef FEAT_CRYPT |
| 1113 if (bi->bi_buffer != NULL) | |
| 1114 { | |
| 6132 | 1115 int size_todo = (int)size; |
| 6122 | 1116 char_u *p = buffer; |
| 1117 | |
| 1118 while (size_todo > 0) | |
| 1119 { | |
| 1120 size_t n; | |
| 1121 | |
| 1122 if (bi->bi_used >= bi->bi_avail) | |
| 1123 { | |
| 1124 n = fread(bi->bi_buffer, 1, (size_t)CRYPT_BUF_SIZE, bi->bi_fp); | |
|
10336
9d282593ba24
commit https://github.com/vim/vim/commit/55952d4dd490bb2f63bda5d7f6d8fb69f58c333c
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
1125 if (n == 0) |
| 6122 | 1126 { |
|
11506
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1127 retval = FAIL; |
|
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1128 break; |
| 6122 | 1129 } |
| 1130 bi->bi_avail = n; | |
| 1131 bi->bi_used = 0; | |
|
24970
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
1132 crypt_decode_inplace(bi->bi_state, bi->bi_buffer, bi->bi_avail, FALSE); |
| 6122 | 1133 } |
| 1134 n = size_todo; | |
| 1135 if (n > bi->bi_avail - bi->bi_used) | |
| 1136 n = bi->bi_avail - bi->bi_used; | |
| 1137 mch_memmove(p, bi->bi_buffer + bi->bi_used, n); | |
| 1138 bi->bi_used += n; | |
| 6132 | 1139 size_todo -= (int)n; |
| 6122 | 1140 p += n; |
| 1141 } | |
| 1142 } | |
|
11506
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1143 else |
| 6122 | 1144 #endif |
|
27426
41e0dcf38521
patch 8.2.4241: some type casts are redundant
Bram Moolenaar <Bram@vim.org>
parents:
27378
diff
changeset
|
1145 if (fread(buffer, size, 1, bi->bi_fp) != 1) |
|
11506
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1146 retval = FAIL; |
|
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1147 |
|
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1148 if (retval == FAIL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1149 // Error may be checked for only later. Fill with zeros, |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1150 // so that the reader won't use garbage. |
|
11506
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1151 vim_memset(buffer, 0, size); |
|
7140ff4857eb
patch 8.0.0636: when reading the undo file fails may use uninitialized data
Christian Brabandt <cb@256bit.org>
parents:
11158
diff
changeset
|
1152 return retval; |
| 6122 | 1153 } |
| 1154 | |
| 1155 /* | |
| 1156 * Read a string of length "len" from "bi->bi_fd". | |
| 1157 * "len" can be zero to allocate an empty line. | |
| 1158 * Decrypt the bytes if needed. | |
| 1159 * Append a NUL. | |
| 1160 * Returns a pointer to allocated memory or NULL for failure. | |
| 1161 */ | |
| 1162 static char_u * | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1163 read_string_decrypt(bufinfo_T *bi, int len) |
| 6122 | 1164 { |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
1165 char_u *ptr = alloc(len + 1); |
| 6122 | 1166 |
| 1167 if (ptr != NULL) | |
| 1168 { | |
| 1169 if (len > 0 && undo_read(bi, ptr, len) == FAIL) | |
| 1170 { | |
| 1171 vim_free(ptr); | |
| 1172 return NULL; | |
| 1173 } | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1174 // In case there are text properties there already is a NUL, but |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1175 // checking for that is more expensive than just adding a dummy byte. |
| 6122 | 1176 ptr[len] = NUL; |
| 1177 #ifdef FEAT_CRYPT | |
| 1178 if (bi->bi_state != NULL && bi->bi_buffer == NULL) | |
|
24970
7e9e53a0368f
patch 8.2.3022: available encryption methods are not strong enough
Bram Moolenaar <Bram@vim.org>
parents:
21996
diff
changeset
|
1179 crypt_decode_inplace(bi->bi_state, ptr, len, FALSE); |
| 6122 | 1180 #endif |
| 1181 } | |
| 1182 return ptr; | |
| 1183 } | |
| 1184 | |
| 1185 /* | |
| 1186 * Writes the (not encrypted) header and initializes encryption if needed. | |
| 1187 */ | |
| 1188 static int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1189 serialize_header(bufinfo_T *bi, char_u *hash) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1190 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1191 long len; |
| 6122 | 1192 buf_T *buf = bi->bi_buf; |
| 1193 FILE *fp = bi->bi_fp; | |
| 1194 char_u time_buf[8]; | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1195 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1196 // Start writing, first the magic marker and undo info version. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1197 if (fwrite(UF_START_MAGIC, (size_t)UF_START_MAGIC_LEN, (size_t)1, fp) != 1) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1198 return FAIL; |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1199 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1200 // If the buffer is encrypted then all text bytes following will be |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1201 // encrypted. Numbers and other info is not crypted. |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1202 #ifdef FEAT_CRYPT |
|
2410
8f6106dd3d12
Fix: editing a not encrypted file after a crypted file messed up reading the
Bram Moolenaar <bram@vim.org>
parents:
2394
diff
changeset
|
1203 if (*buf->b_p_key != NUL) |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1204 { |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1205 char_u *header; |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1206 int header_len; |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1207 |
| 6122 | 1208 undo_write_bytes(bi, (long_u)UF_VERSION_CRYPT, 2); |
| 1209 bi->bi_state = crypt_create_for_writing(crypt_get_method_nr(buf), | |
| 1210 buf->b_p_key, &header, &header_len); | |
| 1211 if (bi->bi_state == NULL) | |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1212 return FAIL; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1213 len = (long)fwrite(header, (size_t)header_len, (size_t)1, fp); |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1214 vim_free(header); |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1215 if (len != 1) |
| 2267 | 1216 { |
| 6122 | 1217 crypt_free_state(bi->bi_state); |
| 1218 bi->bi_state = NULL; | |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1219 return FAIL; |
| 2267 | 1220 } |
| 6122 | 1221 |
| 1222 if (crypt_whole_undofile(crypt_get_method_nr(buf))) | |
| 1223 { | |
| 1224 bi->bi_buffer = alloc(CRYPT_BUF_SIZE); | |
| 1225 if (bi->bi_buffer == NULL) | |
| 1226 { | |
| 1227 crypt_free_state(bi->bi_state); | |
| 1228 bi->bi_state = NULL; | |
| 1229 return FAIL; | |
| 1230 } | |
| 1231 bi->bi_used = 0; | |
| 1232 } | |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1233 } |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1234 else |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1235 #endif |
| 6122 | 1236 undo_write_bytes(bi, (long_u)UF_VERSION, 2); |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1237 |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1238 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1239 // Write a hash of the buffer text, so that we can verify it is still the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1240 // same when reading the buffer text. |
| 6122 | 1241 if (undo_write(bi, hash, (size_t)UNDO_HASH_SIZE) == FAIL) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1242 return FAIL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1243 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1244 // buffer-specific data |
| 6122 | 1245 undo_write_bytes(bi, (long_u)buf->b_ml.ml_line_count, 4); |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1246 len = buf->b_u_line_ptr.ul_line == NULL |
|
15390
00aa76a735e7
patch 8.1.0703: compiler warnings with 64-bit compiler
Bram Moolenaar <Bram@vim.org>
parents:
15361
diff
changeset
|
1247 ? 0L : (long)STRLEN(buf->b_u_line_ptr.ul_line); |
| 6122 | 1248 undo_write_bytes(bi, (long_u)len, 4); |
|
15390
00aa76a735e7
patch 8.1.0703: compiler warnings with 64-bit compiler
Bram Moolenaar <Bram@vim.org>
parents:
15361
diff
changeset
|
1249 if (len > 0 && fwrite_crypt(bi, buf->b_u_line_ptr.ul_line, (size_t)len) |
|
00aa76a735e7
patch 8.1.0703: compiler warnings with 64-bit compiler
Bram Moolenaar <Bram@vim.org>
parents:
15361
diff
changeset
|
1250 == FAIL) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1251 return FAIL; |
| 6122 | 1252 undo_write_bytes(bi, (long_u)buf->b_u_line_lnum, 4); |
| 1253 undo_write_bytes(bi, (long_u)buf->b_u_line_colnr, 4); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1254 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1255 // Undo structures header data |
| 6122 | 1256 put_header_ptr(bi, buf->b_u_oldhead); |
| 1257 put_header_ptr(bi, buf->b_u_newhead); | |
| 1258 put_header_ptr(bi, buf->b_u_curhead); | |
| 1259 | |
| 1260 undo_write_bytes(bi, (long_u)buf->b_u_numhead, 4); | |
| 1261 undo_write_bytes(bi, (long_u)buf->b_u_seq_last, 4); | |
| 1262 undo_write_bytes(bi, (long_u)buf->b_u_seq_cur, 4); | |
| 1263 time_to_bytes(buf->b_u_time_cur, time_buf); | |
| 1264 undo_write(bi, time_buf, 8); | |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
1265 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1266 // Optional fields. |
| 6122 | 1267 undo_write_bytes(bi, 4, 1); |
| 1268 undo_write_bytes(bi, UF_LAST_SAVE_NR, 1); | |
| 1269 undo_write_bytes(bi, (long_u)buf->b_u_save_nr_last, 4); | |
| 1270 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1271 undo_write_bytes(bi, 0, 1); // end marker |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1272 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1273 return OK; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1274 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1275 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1276 static int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1277 serialize_uhp(bufinfo_T *bi, u_header_T *uhp) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1278 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1279 int i; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1280 u_entry_T *uep; |
| 6122 | 1281 char_u time_buf[8]; |
| 1282 | |
| 1283 if (undo_write_bytes(bi, (long_u)UF_HEADER_MAGIC, 2) == FAIL) | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1284 return FAIL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1285 |
| 6122 | 1286 put_header_ptr(bi, uhp->uh_next.ptr); |
| 1287 put_header_ptr(bi, uhp->uh_prev.ptr); | |
| 1288 put_header_ptr(bi, uhp->uh_alt_next.ptr); | |
| 1289 put_header_ptr(bi, uhp->uh_alt_prev.ptr); | |
| 1290 undo_write_bytes(bi, uhp->uh_seq, 4); | |
| 1291 serialize_pos(bi, uhp->uh_cursor); | |
| 1292 undo_write_bytes(bi, (long_u)uhp->uh_cursor_vcol, 4); | |
| 1293 undo_write_bytes(bi, (long_u)uhp->uh_flags, 2); | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1294 // Assume NMARKS will stay the same. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1295 for (i = 0; i < NMARKS; ++i) |
| 6122 | 1296 serialize_pos(bi, uhp->uh_namedm[i]); |
| 1297 serialize_visualinfo(bi, &uhp->uh_visual); | |
| 1298 time_to_bytes(uhp->uh_time, time_buf); | |
| 1299 undo_write(bi, time_buf, 8); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1300 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1301 // Optional fields. |
| 6122 | 1302 undo_write_bytes(bi, 4, 1); |
| 1303 undo_write_bytes(bi, UHP_SAVE_NR, 1); | |
| 1304 undo_write_bytes(bi, (long_u)uhp->uh_save_nr, 4); | |
| 1305 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1306 undo_write_bytes(bi, 0, 1); // end marker |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1307 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1308 // Write all the entries. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1309 for (uep = uhp->uh_entry; uep != NULL; uep = uep->ue_next) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1310 { |
| 6122 | 1311 undo_write_bytes(bi, (long_u)UF_ENTRY_MAGIC, 2); |
| 1312 if (serialize_uep(bi, uep) == FAIL) | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1313 return FAIL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1314 } |
| 6122 | 1315 undo_write_bytes(bi, (long_u)UF_ENTRY_END_MAGIC, 2); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1316 return OK; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1317 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1318 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1319 static u_header_T * |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1320 unserialize_uhp(bufinfo_T *bi, char_u *file_name) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1321 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1322 u_header_T *uhp; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1323 int i; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1324 u_entry_T *uep, *last_uep; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1325 int c; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1326 int error; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1327 |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
1328 uhp = U_ALLOC_LINE(sizeof(u_header_T)); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1329 if (uhp == NULL) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1330 return NULL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
18816
diff
changeset
|
1331 CLEAR_POINTER(uhp); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1332 #ifdef U_DEBUG |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1333 uhp->uh_magic = UH_MAGIC; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1334 #endif |
| 6122 | 1335 uhp->uh_next.seq = undo_read_4c(bi); |
| 1336 uhp->uh_prev.seq = undo_read_4c(bi); | |
| 1337 uhp->uh_alt_next.seq = undo_read_4c(bi); | |
| 1338 uhp->uh_alt_prev.seq = undo_read_4c(bi); | |
| 1339 uhp->uh_seq = undo_read_4c(bi); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1340 if (uhp->uh_seq <= 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1341 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1342 corruption_error("uh_seq", file_name); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1343 vim_free(uhp); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1344 return NULL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1345 } |
| 6122 | 1346 unserialize_pos(bi, &uhp->uh_cursor); |
| 1347 uhp->uh_cursor_vcol = undo_read_4c(bi); | |
| 1348 uhp->uh_flags = undo_read_2c(bi); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1349 for (i = 0; i < NMARKS; ++i) |
| 6122 | 1350 unserialize_pos(bi, &uhp->uh_namedm[i]); |
| 1351 unserialize_visualinfo(bi, &uhp->uh_visual); | |
| 1352 uhp->uh_time = undo_read_time(bi); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1353 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1354 // Optional fields. |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1355 for (;;) |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1356 { |
| 6122 | 1357 int len = undo_read_byte(bi); |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1358 int what; |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1359 |
|
17630
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1360 if (len == EOF) |
|
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1361 { |
|
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1362 corruption_error("truncated", file_name); |
|
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1363 u_free_uhp(uhp); |
|
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1364 return NULL; |
|
380adf86bf66
patch 8.1.1812: reading a truncted undo file hangs Vim
Bram Moolenaar <Bram@vim.org>
parents:
17135
diff
changeset
|
1365 } |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1366 if (len == 0) |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1367 break; |
| 6122 | 1368 what = undo_read_byte(bi); |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1369 switch (what) |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
1370 { |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1371 case UHP_SAVE_NR: |
| 6122 | 1372 uhp->uh_save_nr = undo_read_4c(bi); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
1373 break; |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1374 default: |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1375 // field not supported, skip |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1376 while (--len >= 0) |
| 6122 | 1377 (void)undo_read_byte(bi); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
1378 } |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1379 } |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
1380 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1381 // Unserialize the uep list. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1382 last_uep = NULL; |
| 6122 | 1383 while ((c = undo_read_2c(bi)) == UF_ENTRY_MAGIC) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1384 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1385 error = FALSE; |
| 6122 | 1386 uep = unserialize_uep(bi, &error, file_name); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1387 if (last_uep == NULL) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1388 uhp->uh_entry = uep; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1389 else |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1390 last_uep->ue_next = uep; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1391 last_uep = uep; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1392 if (uep == NULL || error) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1393 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1394 u_free_uhp(uhp); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1395 return NULL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1396 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1397 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1398 if (c != UF_ENTRY_END_MAGIC) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1399 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1400 corruption_error("entry end", file_name); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1401 u_free_uhp(uhp); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1402 return NULL; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1403 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1404 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1405 return uhp; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1406 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1407 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1408 /* |
| 6122 | 1409 * Serialize "uep". |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1410 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1411 static int |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1412 serialize_uep( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1413 bufinfo_T *bi, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1414 u_entry_T *uep) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1415 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1416 int i; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1417 size_t len; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1418 |
| 6122 | 1419 undo_write_bytes(bi, (long_u)uep->ue_top, 4); |
| 1420 undo_write_bytes(bi, (long_u)uep->ue_bot, 4); | |
| 1421 undo_write_bytes(bi, (long_u)uep->ue_lcount, 4); | |
| 1422 undo_write_bytes(bi, (long_u)uep->ue_size, 4); | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1423 for (i = 0; i < uep->ue_size; ++i) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1424 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1425 // Text is written without the text properties, since we cannot restore |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1426 // the text property types. |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1427 len = STRLEN(uep->ue_array[i].ul_line); |
| 6122 | 1428 if (undo_write_bytes(bi, (long_u)len, 4) == FAIL) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1429 return FAIL; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1430 if (len > 0 && fwrite_crypt(bi, uep->ue_array[i].ul_line, len) == FAIL) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1431 return FAIL; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1432 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1433 return OK; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1434 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1435 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1436 static u_entry_T * |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1437 unserialize_uep(bufinfo_T *bi, int *error, char_u *file_name) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1438 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1439 int i; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1440 u_entry_T *uep; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1441 undoline_T *array = NULL; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1442 char_u *line; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1443 int line_len; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1444 |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
1445 uep = U_ALLOC_LINE(sizeof(u_entry_T)); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1446 if (uep == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1447 return NULL; |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
18816
diff
changeset
|
1448 CLEAR_POINTER(uep); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1449 #ifdef U_DEBUG |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1450 uep->ue_magic = UE_MAGIC; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1451 #endif |
| 6122 | 1452 uep->ue_top = undo_read_4c(bi); |
| 1453 uep->ue_bot = undo_read_4c(bi); | |
| 1454 uep->ue_lcount = undo_read_4c(bi); | |
| 1455 uep->ue_size = undo_read_4c(bi); | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1456 if (uep->ue_size > 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1457 { |
|
10978
f3d64d9e5d76
patch 8.0.0378: possible overflow when reading corrupted undo file
Christian Brabandt <cb@256bit.org>
parents:
10976
diff
changeset
|
1458 if (uep->ue_size < LONG_MAX / (int)sizeof(char_u *)) |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
1459 array = U_ALLOC_LINE(sizeof(undoline_T) * uep->ue_size); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1460 if (array == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1461 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1462 *error = TRUE; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1463 return uep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1464 } |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1465 vim_memset(array, 0, sizeof(undoline_T) * uep->ue_size); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1466 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1467 uep->ue_array = array; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1468 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1469 for (i = 0; i < uep->ue_size; ++i) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1470 { |
| 6122 | 1471 line_len = undo_read_4c(bi); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1472 if (line_len >= 0) |
| 6122 | 1473 line = read_string_decrypt(bi, line_len); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1474 else |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1475 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1476 line = NULL; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1477 corruption_error("line length", file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1478 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1479 if (line == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1480 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1481 *error = TRUE; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1482 return uep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1483 } |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1484 array[i].ul_line = line; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1485 array[i].ul_len = line_len + 1; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1486 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1487 return uep; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1488 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1489 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1490 /* |
| 6122 | 1491 * Serialize "pos". |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1492 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1493 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1494 serialize_pos(bufinfo_T *bi, pos_T pos) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1495 { |
| 6122 | 1496 undo_write_bytes(bi, (long_u)pos.lnum, 4); |
| 1497 undo_write_bytes(bi, (long_u)pos.col, 4); | |
| 1498 undo_write_bytes(bi, (long_u)pos.coladd, 4); | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1499 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1500 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1501 /* |
| 6122 | 1502 * Unserialize the pos_T at the current position. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1503 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1504 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1505 unserialize_pos(bufinfo_T *bi, pos_T *pos) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1506 { |
| 6122 | 1507 pos->lnum = undo_read_4c(bi); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1508 if (pos->lnum < 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1509 pos->lnum = 0; |
| 6122 | 1510 pos->col = undo_read_4c(bi); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1511 if (pos->col < 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1512 pos->col = 0; |
| 6122 | 1513 pos->coladd = undo_read_4c(bi); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1514 if (pos->coladd < 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1515 pos->coladd = 0; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1516 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1517 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1518 /* |
| 6122 | 1519 * Serialize "info". |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1520 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1521 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1522 serialize_visualinfo(bufinfo_T *bi, visualinfo_T *info) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1523 { |
| 6122 | 1524 serialize_pos(bi, info->vi_start); |
| 1525 serialize_pos(bi, info->vi_end); | |
| 1526 undo_write_bytes(bi, (long_u)info->vi_mode, 4); | |
| 1527 undo_write_bytes(bi, (long_u)info->vi_curswant, 4); | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1528 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1529 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1530 /* |
| 6122 | 1531 * Unserialize the visualinfo_T at the current position. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1532 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1533 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1534 unserialize_visualinfo(bufinfo_T *bi, visualinfo_T *info) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1535 { |
| 6122 | 1536 unserialize_pos(bi, &info->vi_start); |
| 1537 unserialize_pos(bi, &info->vi_end); | |
| 1538 info->vi_mode = undo_read_4c(bi); | |
| 1539 info->vi_curswant = undo_read_4c(bi); | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1540 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1541 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1542 /* |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1543 * Write the undo tree in an undo file. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1544 * When "name" is not NULL, use it as the name of the undo file. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1545 * Otherwise use buf->b_ffname to generate the undo file name. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1546 * "buf" must never be null, buf->b_ffname is used to obtain the original file |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1547 * permissions. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1548 * "forceit" is TRUE for ":wundo!", FALSE otherwise. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1549 * "hash[UNDO_HASH_SIZE]" must be the hash value of the buffer text. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1550 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1551 void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1552 u_write_undo( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1553 char_u *name, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1554 int forceit, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1555 buf_T *buf, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
1556 char_u *hash) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1557 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1558 u_header_T *uhp; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1559 char_u *file_name; |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1560 int mark; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1561 #ifdef U_DEBUG |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1562 int headers_written = 0; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1563 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1564 int fd; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1565 FILE *fp = NULL; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1566 int perm; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1567 int write_ok = FALSE; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1568 #ifdef UNIX |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1569 int st_old_valid = FALSE; |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8568
diff
changeset
|
1570 stat_T st_old; |
|
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8568
diff
changeset
|
1571 stat_T st_new; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1572 #endif |
| 6122 | 1573 bufinfo_T bi; |
| 1574 | |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
18816
diff
changeset
|
1575 CLEAR_FIELD(bi); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1576 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1577 if (name == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1578 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1579 file_name = u_get_undo_file_name(buf->b_ffname, FALSE); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1580 if (file_name == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1581 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1582 if (p_verbose > 0) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1583 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1584 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1585 smsg( |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1586 _("Cannot write undo file in any directory in 'undodir'")); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1587 verbose_leave(); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1588 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1589 return; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1590 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1591 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1592 else |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1593 file_name = name; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1594 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1595 /* |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1596 * Decide about the permission to use for the undo file. If the buffer |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1597 * has a name use the permission of the original file. Otherwise only |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1598 * allow the user to access the undo file. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1599 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1600 perm = 0600; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1601 if (buf->b_ffname != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1602 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1603 #ifdef UNIX |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1604 if (mch_stat((char *)buf->b_ffname, &st_old) >= 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1605 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1606 perm = st_old.st_mode; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1607 st_old_valid = TRUE; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1608 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1609 #else |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1610 perm = mch_getperm(buf->b_ffname); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1611 if (perm < 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1612 perm = 0600; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1613 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1614 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1615 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1616 // strip any s-bit and executable bit |
| 6771 | 1617 perm = perm & 0666; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1618 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1619 // If the undo file already exists, verify that it actually is an undo |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1620 // file, and delete it. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1621 if (mch_getperm(file_name) >= 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1622 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1623 if (name == NULL || !forceit) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1624 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1625 // Check we can read it and it's an undo file. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1626 fd = mch_open((char *)file_name, O_RDONLY|O_EXTRA, 0); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1627 if (fd < 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1628 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1629 if (name != NULL || p_verbose > 0) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1630 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1631 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1632 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1633 smsg( |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1634 _("Will not overwrite with undo file, cannot read: %s"), |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1635 file_name); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1636 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1637 verbose_leave(); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1638 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1639 goto theend; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1640 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1641 else |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1642 { |
|
2271
2b33a7678e7b
Fix compiler warnings for shadowed variables. Make 'conceal' a long instead
Bram Moolenaar <bram@vim.org>
parents:
2267
diff
changeset
|
1643 char_u mbuf[UF_START_MAGIC_LEN]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1644 int len; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1645 |
| 2664 | 1646 len = read_eintr(fd, mbuf, UF_START_MAGIC_LEN); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1647 close(fd); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1648 if (len < UF_START_MAGIC_LEN |
|
2271
2b33a7678e7b
Fix compiler warnings for shadowed variables. Make 'conceal' a long instead
Bram Moolenaar <bram@vim.org>
parents:
2267
diff
changeset
|
1649 || memcmp(mbuf, UF_START_MAGIC, UF_START_MAGIC_LEN) != 0) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1650 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1651 if (name != NULL || p_verbose > 0) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1652 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1653 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1654 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1655 smsg( |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1656 _("Will not overwrite, this is not an undo file: %s"), |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1657 file_name); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1658 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1659 verbose_leave(); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1660 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1661 goto theend; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1662 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1663 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1664 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1665 mch_remove(file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1666 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1667 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1668 // If there is no undo information at all, quit here after deleting any |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1669 // existing undo file. |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1670 if (buf->b_u_numhead == 0 && buf->b_u_line_ptr.ul_line == NULL) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1671 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1672 if (p_verbose > 0) |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
1673 verb_msg(_("Skipping undo file write, nothing to undo")); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1674 goto theend; |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1675 } |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1676 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1677 fd = mch_open((char *)file_name, |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1678 O_CREAT|O_EXTRA|O_WRONLY|O_EXCL|O_NOFOLLOW, perm); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1679 if (fd < 0) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1680 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1681 semsg(_(e_cannot_open_undo_file_for_writing_str), file_name); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1682 goto theend; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1683 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1684 (void)mch_setperm(file_name, perm); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1685 if (p_verbose > 0) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1686 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1687 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1688 smsg(_("Writing undo file: %s"), file_name); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1689 verbose_leave(); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1690 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1691 |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1692 #ifdef U_DEBUG |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1693 // Check there is no problem in undo info before writing. |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1694 u_check(FALSE); |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1695 #endif |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1696 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1697 #ifdef UNIX |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1698 /* |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1699 * Try to set the group of the undo file same as the original file. If |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1700 * this fails, set the protection bits for the group same as the |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1701 * protection bits for others. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1702 */ |
|
2367
76b7ba68a098
Fix build problem when fchown() not available. (Gary Johnson)
Bram Moolenaar <bram@vim.org>
parents:
2348
diff
changeset
|
1703 if (st_old_valid |
|
76b7ba68a098
Fix build problem when fchown() not available. (Gary Johnson)
Bram Moolenaar <bram@vim.org>
parents:
2348
diff
changeset
|
1704 && mch_stat((char *)file_name, &st_new) >= 0 |
|
76b7ba68a098
Fix build problem when fchown() not available. (Gary Johnson)
Bram Moolenaar <bram@vim.org>
parents:
2348
diff
changeset
|
1705 && st_new.st_gid != st_old.st_gid |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1706 # ifdef HAVE_FCHOWN // sequent-ptx lacks fchown() |
|
2367
76b7ba68a098
Fix build problem when fchown() not available. (Gary Johnson)
Bram Moolenaar <bram@vim.org>
parents:
2348
diff
changeset
|
1707 && fchown(fd, (uid_t)-1, st_old.st_gid) != 0 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1708 # endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1709 ) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1710 mch_setperm(file_name, (perm & 0707) | ((perm & 07) << 3)); |
| 5788 | 1711 # if defined(HAVE_SELINUX) || defined(HAVE_SMACK) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1712 if (buf->b_ffname != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1713 mch_copy_sec(buf->b_ffname, file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1714 # endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1715 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1716 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1717 fp = fdopen(fd, "w"); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1718 if (fp == NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1719 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1720 semsg(_(e_cannot_open_undo_file_for_writing_str), file_name); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1721 close(fd); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1722 mch_remove(file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1723 goto theend; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1724 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1725 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1726 // Undo must be synced. |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1727 u_sync(TRUE); |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1728 |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1729 /* |
| 6122 | 1730 * Write the header. Initializes encryption, if enabled. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1731 */ |
| 6122 | 1732 bi.bi_buf = buf; |
| 1733 bi.bi_fp = fp; | |
| 1734 if (serialize_header(&bi, hash) == FAIL) | |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1735 goto write_error; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1736 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1737 /* |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1738 * Iteratively serialize UHPs and their UEPs from the top down. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1739 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1740 mark = ++lastmark; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1741 uhp = buf->b_u_oldhead; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1742 while (uhp != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1743 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1744 // Serialize current UHP if we haven't seen it |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1745 if (uhp->uh_walk != mark) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1746 { |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1747 uhp->uh_walk = mark; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1748 #ifdef U_DEBUG |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1749 ++headers_written; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1750 #endif |
| 6122 | 1751 if (serialize_uhp(&bi, uhp) == FAIL) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1752 goto write_error; |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1753 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1754 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1755 // Now walk through the tree - algorithm from undo_time(). |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1756 if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != mark) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1757 uhp = uhp->uh_prev.ptr; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1758 else if (uhp->uh_alt_next.ptr != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
1759 && uhp->uh_alt_next.ptr->uh_walk != mark) |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1760 uhp = uhp->uh_alt_next.ptr; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1761 else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
1762 && uhp->uh_next.ptr->uh_walk != mark) |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1763 uhp = uhp->uh_next.ptr; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1764 else if (uhp->uh_alt_prev.ptr != NULL) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1765 uhp = uhp->uh_alt_prev.ptr; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1766 else |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1767 uhp = uhp->uh_next.ptr; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1768 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1769 |
| 6122 | 1770 if (undo_write_bytes(&bi, (long_u)UF_HEADER_END_MAGIC, 2) == OK) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1771 write_ok = TRUE; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1772 #ifdef U_DEBUG |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1773 if (headers_written != buf->b_u_numhead) |
|
4827
60301d4d1682
updated for version 7.3.1160
Bram Moolenaar <bram@vim.org>
parents:
4303
diff
changeset
|
1774 { |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1775 semsg("Written %ld headers, ...", headers_written); |
|
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1776 semsg("... but numhead is %ld", buf->b_u_numhead); |
|
4827
60301d4d1682
updated for version 7.3.1160
Bram Moolenaar <bram@vim.org>
parents:
4303
diff
changeset
|
1777 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1778 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1779 |
| 6122 | 1780 #ifdef FEAT_CRYPT |
| 1781 if (bi.bi_state != NULL && undo_flush(&bi) == FAIL) | |
| 1782 write_ok = FALSE; | |
| 1783 #endif | |
| 1784 | |
|
25951
560132056b97
patch 8.2.3509: undo file is not synced
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1785 #if defined(UNIX) && defined(HAVE_FSYNC) |
|
560132056b97
patch 8.2.3509: undo file is not synced
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1786 if (p_fs && fflush(fp) == 0 && vim_fsync(fd) != 0) |
|
560132056b97
patch 8.2.3509: undo file is not synced
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1787 write_ok = FALSE; |
|
560132056b97
patch 8.2.3509: undo file is not synced
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1788 #endif |
|
560132056b97
patch 8.2.3509: undo file is not synced
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1789 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1790 write_error: |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1791 fclose(fp); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1792 if (!write_ok) |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1793 semsg(_(e_write_error_in_undo_file_str), file_name); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1794 |
|
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15636
diff
changeset
|
1795 #if defined(MSWIN) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1796 // Copy file attributes; for systems where this can only be done after |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1797 // closing the file. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1798 if (buf->b_ffname != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1799 (void)mch_copy_file_attribute(buf->b_ffname, file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1800 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1801 #ifdef HAVE_ACL |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1802 if (buf->b_ffname != NULL) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1803 { |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1804 vim_acl_T acl; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1805 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1806 // For systems that support ACL: get the ACL from the original file. |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1807 acl = mch_get_acl(buf->b_ffname); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1808 mch_set_acl(file_name, acl); |
| 3545 | 1809 mch_free_acl(acl); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1810 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1811 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1812 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1813 theend: |
| 2267 | 1814 #ifdef FEAT_CRYPT |
| 6122 | 1815 if (bi.bi_state != NULL) |
| 1816 crypt_free_state(bi.bi_state); | |
| 1817 vim_free(bi.bi_buffer); | |
| 2267 | 1818 #endif |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1819 if (file_name != name) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1820 vim_free(file_name); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1821 } |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1822 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1823 /* |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1824 * Load the undo tree from an undo file. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1825 * If "name" is not NULL use it as the undo file name. This also means being |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1826 * a bit more verbose. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1827 * Otherwise use curbuf->b_ffname to generate the undo file name. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1828 * "hash[UNDO_HASH_SIZE]" must be the hash value of the buffer text. |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1829 */ |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1830 void |
|
18139
59bc3cd42cf5
patch 8.1.2064: MS-Windows: compiler warnings for unused arguments
Bram Moolenaar <Bram@vim.org>
parents:
18051
diff
changeset
|
1831 u_read_undo(char_u *name, char_u *hash, char_u *orig_name UNUSED) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1832 { |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1833 char_u *file_name; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1834 FILE *fp; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1835 long version, str_len; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1836 undoline_T line_ptr; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1837 linenr_T line_lnum; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1838 colnr_T line_colnr; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1839 linenr_T line_count; |
|
10976
f97a72ad8ffa
patch 8.0.0377: possible overflow when reading corrupted undo file
Christian Brabandt <cb@256bit.org>
parents:
10631
diff
changeset
|
1840 long num_head = 0; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1841 long old_header_seq, new_header_seq, cur_header_seq; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1842 long seq_last, seq_cur; |
|
2282
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
1843 long last_save_nr = 0; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1844 short old_idx = -1, new_idx = -1, cur_idx = -1; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1845 long num_read_uhps = 0; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1846 time_t seq_time; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1847 int i, j; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1848 int c; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1849 u_header_T *uhp; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1850 u_header_T **uhp_table = NULL; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1851 char_u read_hash[UNDO_HASH_SIZE]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1852 char_u magic_buf[UF_START_MAGIC_LEN]; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1853 #ifdef U_DEBUG |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1854 int *uhp_table_used; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1855 #endif |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1856 #ifdef UNIX |
|
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8568
diff
changeset
|
1857 stat_T st_orig; |
|
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8568
diff
changeset
|
1858 stat_T st_undo; |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1859 #endif |
| 6122 | 1860 bufinfo_T bi; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1861 |
|
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
18816
diff
changeset
|
1862 CLEAR_FIELD(bi); |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1863 line_ptr.ul_len = 0; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1864 line_ptr.ul_line = NULL; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1865 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1866 if (name == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1867 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1868 file_name = u_get_undo_file_name(curbuf->b_ffname, TRUE); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1869 if (file_name == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1870 return; |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1871 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1872 #ifdef UNIX |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1873 // For safety we only read an undo file if the owner is equal to the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1874 // owner of the text file or equal to the current user. |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1875 if (mch_stat((char *)orig_name, &st_orig) >= 0 |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1876 && mch_stat((char *)file_name, &st_undo) >= 0 |
| 5343 | 1877 && st_orig.st_uid != st_undo.st_uid |
| 1878 && st_undo.st_uid != getuid()) | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1879 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1880 if (p_verbose > 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1881 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1882 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1883 smsg(_("Not reading undo file, owner differs: %s"), |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1884 file_name); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1885 verbose_leave(); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1886 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1887 return; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1888 } |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1889 #endif |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1890 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1891 else |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1892 file_name = name; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1893 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1894 if (p_verbose > 0) |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1895 { |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1896 verbose_enter(); |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
1897 smsg(_("Reading undo file: %s"), file_name); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1898 verbose_leave(); |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1899 } |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1900 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1901 fp = mch_fopen((char *)file_name, "r"); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1902 if (fp == NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1903 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1904 if (name != NULL || p_verbose > 0) |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1905 semsg(_(e_cannot_open_undo_file_for_reading_str), file_name); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1906 goto error; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1907 } |
| 6122 | 1908 bi.bi_buf = curbuf; |
| 1909 bi.bi_fp = fp; | |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1910 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1911 /* |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1912 * Read the undo file header. |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1913 */ |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1914 if (fread(magic_buf, UF_START_MAGIC_LEN, 1, fp) != 1 |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1915 || memcmp(magic_buf, UF_START_MAGIC, UF_START_MAGIC_LEN) != 0) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1916 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1917 semsg(_(e_not_an_undo_file_str), file_name); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1918 goto error; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1919 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1920 version = get2c(fp); |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1921 if (version == UF_VERSION_CRYPT) |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1922 { |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1923 #ifdef FEAT_CRYPT |
|
2251
646d34788036
Fix a few compiler warnings. Fix crash with encrypted undo file.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1924 if (*curbuf->b_p_key == NUL) |
|
646d34788036
Fix a few compiler warnings. Fix crash with encrypted undo file.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1925 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1926 semsg(_(e_non_encrypted_file_has_encrypted_undo_file), file_name); |
|
2251
646d34788036
Fix a few compiler warnings. Fix crash with encrypted undo file.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1927 goto error; |
|
646d34788036
Fix a few compiler warnings. Fix crash with encrypted undo file.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1928 } |
| 6122 | 1929 bi.bi_state = crypt_create_from_file(fp, curbuf->b_p_key); |
| 1930 if (bi.bi_state == NULL) | |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1931 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1932 semsg(_(e_undo_file_decryption_failed), file_name); |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1933 goto error; |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1934 } |
| 6122 | 1935 if (crypt_whole_undofile(bi.bi_state->method_nr)) |
| 1936 { | |
| 1937 bi.bi_buffer = alloc(CRYPT_BUF_SIZE); | |
| 1938 if (bi.bi_buffer == NULL) | |
| 1939 { | |
| 1940 crypt_free_state(bi.bi_state); | |
| 1941 bi.bi_state = NULL; | |
| 1942 goto error; | |
| 1943 } | |
| 1944 bi.bi_avail = 0; | |
| 1945 bi.bi_used = 0; | |
| 1946 } | |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1947 #else |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1948 semsg(_(e_undo_file_is_encrypted_str), file_name); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1949 goto error; |
|
2239
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1950 #endif |
|
732cb7b31956
Crypt the text in the undo file if the file itself is crypted.
Bram Moolenaar <bram@vim.org>
parents:
2238
diff
changeset
|
1951 } |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
1952 else if (version != UF_VERSION) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1953 { |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1954 semsg(_(e_incompatible_undo_file_str), file_name); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1955 goto error; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1956 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1957 |
| 6122 | 1958 if (undo_read(&bi, read_hash, (size_t)UNDO_HASH_SIZE) == FAIL) |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1959 { |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1960 corruption_error("hash", file_name); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1961 goto error; |
|
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1962 } |
| 6122 | 1963 line_count = (linenr_T)undo_read_4c(&bi); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1964 if (memcmp(hash, read_hash, UNDO_HASH_SIZE) != 0 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1965 || line_count != curbuf->b_ml.ml_line_count) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1966 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1967 if (p_verbose > 0 || name != NULL) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1968 { |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1969 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1970 verbose_enter(); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1971 give_warning((char_u *) |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1972 _("File contents changed, cannot use undo info"), TRUE); |
|
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1973 if (name == NULL) |
|
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1974 verbose_leave(); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1975 } |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1976 goto error; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1977 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1978 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1979 // Read undo data for "U" command. |
| 6122 | 1980 str_len = undo_read_4c(&bi); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1981 if (str_len < 0) |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
1982 goto error; |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1983 if (str_len > 0) |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1984 { |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1985 line_ptr.ul_line = read_string_decrypt(&bi, str_len); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1986 line_ptr.ul_len = str_len + 1; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
1987 } |
| 6122 | 1988 line_lnum = (linenr_T)undo_read_4c(&bi); |
| 1989 line_colnr = (colnr_T)undo_read_4c(&bi); | |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1990 if (line_lnum < 0 || line_colnr < 0) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1991 { |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1992 corruption_error("line lnum/col", file_name); |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1993 goto error; |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
1994 } |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1995 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1996 // Begin general undo data |
| 6122 | 1997 old_header_seq = undo_read_4c(&bi); |
| 1998 new_header_seq = undo_read_4c(&bi); | |
| 1999 cur_header_seq = undo_read_4c(&bi); | |
| 2000 num_head = undo_read_4c(&bi); | |
| 2001 seq_last = undo_read_4c(&bi); | |
| 2002 seq_cur = undo_read_4c(&bi); | |
| 2003 seq_time = undo_read_time(&bi); | |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2004 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2005 // Optional header fields. |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2006 for (;;) |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2007 { |
| 6122 | 2008 int len = undo_read_byte(&bi); |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2009 int what; |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2010 |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2011 if (len == 0 || len == EOF) |
|
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2012 break; |
| 6122 | 2013 what = undo_read_byte(&bi); |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2014 switch (what) |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2015 { |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2016 case UF_LAST_SAVE_NR: |
| 6122 | 2017 last_save_nr = undo_read_4c(&bi); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2018 break; |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2019 default: |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2020 // field not supported, skip |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2021 while (--len >= 0) |
| 6122 | 2022 (void)undo_read_byte(&bi); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2023 } |
|
2342
f6540762173d
Fixes and improvements for MS-Windows build.
Bram Moolenaar <bram@vim.org>
parents:
2311
diff
changeset
|
2024 } |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2025 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2026 // uhp_table will store the freshly created undo headers we allocate |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2027 // until we insert them into curbuf. The table remains sorted by the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2028 // sequence numbers of the headers. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2029 // When there are no headers uhp_table is NULL. |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2030 if (num_head > 0) |
|
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2031 { |
|
10976
f97a72ad8ffa
patch 8.0.0377: possible overflow when reading corrupted undo file
Christian Brabandt <cb@256bit.org>
parents:
10631
diff
changeset
|
2032 if (num_head < LONG_MAX / (long)sizeof(u_header_T *)) |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
2033 uhp_table = U_ALLOC_LINE(num_head * sizeof(u_header_T *)); |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2034 if (uhp_table == NULL) |
|
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2035 goto error; |
|
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2036 } |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2037 |
| 6122 | 2038 while ((c = undo_read_2c(&bi)) == UF_HEADER_MAGIC) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2039 { |
|
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2040 if (num_read_uhps >= num_head) |
|
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2041 { |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
2042 corruption_error("num_head too small", file_name); |
|
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2043 goto error; |
|
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2044 } |
|
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2045 |
| 6122 | 2046 uhp = unserialize_uhp(&bi, file_name); |
|
2238
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
2047 if (uhp == NULL) |
|
3d0a7beb0d75
Made reading/writing undo info a bit more robust.
Bram Moolenaar <bram@vim.org>
parents:
2236
diff
changeset
|
2048 goto error; |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2049 uhp_table[num_read_uhps++] = uhp; |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2050 } |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2051 |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2052 if (num_read_uhps != num_head) |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2053 { |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2054 corruption_error("num_head", file_name); |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2055 goto error; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2056 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2057 if (c != UF_HEADER_END_MAGIC) |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2058 { |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2059 corruption_error("end marker", file_name); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2060 goto error; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2061 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2062 |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2063 #ifdef U_DEBUG |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
2064 uhp_table_used = alloc_clear(sizeof(int) * num_head + 1); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2065 # define SET_FLAG(j) ++uhp_table_used[j] |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2066 #else |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2067 # define SET_FLAG(j) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2068 #endif |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2069 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2070 // We have put all of the headers into a table. Now we iterate through the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2071 // table and swizzle each sequence number we have stored in uh_*_seq into |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2072 // a pointer corresponding to the header with that sequence number. |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2073 for (i = 0; i < num_head; i++) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2074 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2075 uhp = uhp_table[i]; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2076 if (uhp == NULL) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2077 continue; |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2078 for (j = 0; j < num_head; j++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2079 if (uhp_table[j] != NULL && i != j |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2080 && uhp_table[i]->uh_seq == uhp_table[j]->uh_seq) |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2081 { |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2082 corruption_error("duplicate uh_seq", file_name); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2083 goto error; |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2084 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2085 for (j = 0; j < num_head; j++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2086 if (uhp_table[j] != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2087 && uhp_table[j]->uh_seq == uhp->uh_next.seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2088 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2089 uhp->uh_next.ptr = uhp_table[j]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2090 SET_FLAG(j); |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2091 break; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2092 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2093 for (j = 0; j < num_head; j++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2094 if (uhp_table[j] != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2095 && uhp_table[j]->uh_seq == uhp->uh_prev.seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2096 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2097 uhp->uh_prev.ptr = uhp_table[j]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2098 SET_FLAG(j); |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2099 break; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2100 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2101 for (j = 0; j < num_head; j++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2102 if (uhp_table[j] != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2103 && uhp_table[j]->uh_seq == uhp->uh_alt_next.seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2104 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2105 uhp->uh_alt_next.ptr = uhp_table[j]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2106 SET_FLAG(j); |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2107 break; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2108 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2109 for (j = 0; j < num_head; j++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2110 if (uhp_table[j] != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2111 && uhp_table[j]->uh_seq == uhp->uh_alt_prev.seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2112 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2113 uhp->uh_alt_prev.ptr = uhp_table[j]; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2114 SET_FLAG(j); |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2115 break; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2116 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2117 if (old_header_seq > 0 && old_idx < 0 && uhp->uh_seq == old_header_seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2118 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2119 old_idx = i; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2120 SET_FLAG(i); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2121 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2122 if (new_header_seq > 0 && new_idx < 0 && uhp->uh_seq == new_header_seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2123 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2124 new_idx = i; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2125 SET_FLAG(i); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2126 } |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2127 if (cur_header_seq > 0 && cur_idx < 0 && uhp->uh_seq == cur_header_seq) |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2128 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2129 cur_idx = i; |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2130 SET_FLAG(i); |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2131 } |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2132 } |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2133 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2134 // Now that we have read the undo info successfully, free the current undo |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2135 // info and use the info from the file. |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2136 u_blockfree(curbuf); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2137 curbuf->b_u_oldhead = old_idx < 0 ? NULL : uhp_table[old_idx]; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2138 curbuf->b_u_newhead = new_idx < 0 ? NULL : uhp_table[new_idx]; |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2139 curbuf->b_u_curhead = cur_idx < 0 ? NULL : uhp_table[cur_idx]; |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2140 curbuf->b_u_line_ptr = line_ptr; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2141 curbuf->b_u_line_lnum = line_lnum; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2142 curbuf->b_u_line_colnr = line_colnr; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2143 curbuf->b_u_numhead = num_head; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2144 curbuf->b_u_seq_last = seq_last; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2145 curbuf->b_u_seq_cur = seq_cur; |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2146 curbuf->b_u_time_cur = seq_time; |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2147 curbuf->b_u_save_nr_last = last_save_nr; |
| 2627 | 2148 curbuf->b_u_save_nr_cur = last_save_nr; |
|
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2149 |
|
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
2150 curbuf->b_u_synced = TRUE; |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2151 vim_free(uhp_table); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2152 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2153 #ifdef U_DEBUG |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2154 for (i = 0; i < num_head; ++i) |
|
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2155 if (uhp_table_used[i] == 0) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
2156 semsg("uhp_table entry %ld not used, leaking memory", i); |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2157 vim_free(uhp_table_used); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2158 u_check(TRUE); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2159 #endif |
|
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
2160 |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2161 if (name != NULL) |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
2162 smsg(_("Finished reading undo file %s"), file_name); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2163 goto theend; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2164 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2165 error: |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2166 vim_free(line_ptr.ul_line); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2167 if (uhp_table != NULL) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2168 { |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2169 for (i = 0; i < num_read_uhps; i++) |
|
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2170 if (uhp_table[i] != NULL) |
|
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
2171 u_free_uhp(uhp_table[i]); |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2172 vim_free(uhp_table); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2173 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2174 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2175 theend: |
| 2267 | 2176 #ifdef FEAT_CRYPT |
| 6122 | 2177 if (bi.bi_state != NULL) |
| 2178 crypt_free_state(bi.bi_state); | |
| 2179 vim_free(bi.bi_buffer); | |
| 2267 | 2180 #endif |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2181 if (fp != NULL) |
|
2311
ccda151dde4e
Support completion for ":find". (Nazri Ramliy)
Bram Moolenaar <bram@vim.org>
parents:
2289
diff
changeset
|
2182 fclose(fp); |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2183 if (file_name != name) |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2184 vim_free(file_name); |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2185 return; |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2186 } |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2187 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2188 #endif // FEAT_PERSISTENT_UNDO |
|
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2189 |
|
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
2190 |
| 7 | 2191 /* |
| 2192 * If 'cpoptions' contains 'u': Undo the previous undo or redo (vi compatible). | |
| 2193 * If 'cpoptions' does not contain 'u': Always undo. | |
| 2194 */ | |
| 2195 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2196 u_undo(int count) |
| 7 | 2197 { |
| 2198 /* | |
| 2199 * If we get an undo command while executing a macro, we behave like the | |
| 2200 * original vi. If this happens twice in one macro the result will not | |
| 2201 * be compatible. | |
| 2202 */ | |
| 2203 if (curbuf->b_u_synced == FALSE) | |
| 2204 { | |
| 825 | 2205 u_sync(TRUE); |
| 7 | 2206 count = 1; |
| 2207 } | |
| 2208 | |
| 2209 if (vim_strchr(p_cpo, CPO_UNDO) == NULL) | |
| 2210 undo_undoes = TRUE; | |
| 2211 else | |
| 2212 undo_undoes = !undo_undoes; | |
| 2213 u_doit(count); | |
| 2214 } | |
| 2215 | |
| 2216 /* | |
| 2217 * If 'cpoptions' contains 'u': Repeat the previous undo or redo. | |
| 2218 * If 'cpoptions' does not contain 'u': Always redo. | |
| 2219 */ | |
| 2220 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2221 u_redo(int count) |
| 7 | 2222 { |
| 2223 if (vim_strchr(p_cpo, CPO_UNDO) == NULL) | |
| 2224 undo_undoes = FALSE; | |
| 2225 u_doit(count); | |
| 2226 } | |
| 2227 | |
| 2228 /* | |
| 2229 * Undo or redo, depending on 'undo_undoes', 'count' times. | |
| 2230 */ | |
| 2231 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2232 u_doit(int startcount) |
| 7 | 2233 { |
| 777 | 2234 int count = startcount; |
| 2235 | |
| 632 | 2236 if (!undo_allowed()) |
| 7 | 2237 return; |
| 2238 | |
| 2239 u_newcount = 0; | |
| 2240 u_oldcount = 0; | |
| 179 | 2241 if (curbuf->b_ml.ml_flags & ML_EMPTY) |
| 2242 u_oldcount = -1; | |
| 7 | 2243 while (count--) |
| 2244 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2245 // Do the change warning now, so that it triggers FileChangedRO when |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2246 // needed. This may cause the file to be reloaded, that must happen |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2247 // before we do anything, because it may change curbuf->b_u_curhead |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2248 // and more. |
| 2189 | 2249 change_warning(0); |
| 2250 | |
| 7 | 2251 if (undo_undoes) |
| 2252 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2253 if (curbuf->b_u_curhead == NULL) // first undo |
| 7 | 2254 curbuf->b_u_curhead = curbuf->b_u_newhead; |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2255 else if (get_undolevel() > 0) // multi level undo |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2256 // get next undo |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2257 curbuf->b_u_curhead = curbuf->b_u_curhead->uh_next.ptr; |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2258 // nothing to undo |
| 7 | 2259 if (curbuf->b_u_numhead == 0 || curbuf->b_u_curhead == NULL) |
| 2260 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2261 // stick curbuf->b_u_curhead at end |
| 7 | 2262 curbuf->b_u_curhead = curbuf->b_u_oldhead; |
| 2263 beep_flush(); | |
| 777 | 2264 if (count == startcount - 1) |
| 2265 { | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
2266 msg(_("Already at oldest change")); |
| 777 | 2267 return; |
| 2268 } | |
| 7 | 2269 break; |
| 2270 } | |
| 2271 | |
| 777 | 2272 u_undoredo(TRUE); |
| 7 | 2273 } |
| 2274 else | |
| 2275 { | |
| 5446 | 2276 if (curbuf->b_u_curhead == NULL || get_undolevel() <= 0) |
| 7 | 2277 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2278 beep_flush(); // nothing to redo |
| 777 | 2279 if (count == startcount - 1) |
| 2280 { | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
2281 msg(_("Already at newest change")); |
| 777 | 2282 return; |
| 2283 } | |
| 7 | 2284 break; |
| 2285 } | |
| 2286 | |
| 777 | 2287 u_undoredo(FALSE); |
| 753 | 2288 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2289 // Advance for next redo. Set "newhead" when at the end of the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2290 // redoable changes. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2291 if (curbuf->b_u_curhead->uh_prev.ptr == NULL) |
| 753 | 2292 curbuf->b_u_newhead = curbuf->b_u_curhead; |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2293 curbuf->b_u_curhead = curbuf->b_u_curhead->uh_prev.ptr; |
| 7 | 2294 } |
| 2295 } | |
| 798 | 2296 u_undo_end(undo_undoes, FALSE); |
| 753 | 2297 } |
| 2298 | |
| 2299 /* | |
| 2300 * Undo or redo over the timeline. | |
| 2301 * When "step" is negative go back in time, otherwise goes forward in time. | |
| 758 | 2302 * When "sec" is FALSE make "step" steps, when "sec" is TRUE use "step" as |
| 2303 * seconds. | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2304 * When "file" is TRUE use "step" as a number of file writes. |
| 772 | 2305 * When "absolute" is TRUE use "step" as the sequence number to jump to. |
| 2306 * "sec" must be FALSE then. | |
| 753 | 2307 */ |
| 2308 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2309 undo_time( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2310 long step, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2311 int sec, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2312 int file, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2313 int absolute) |
| 753 | 2314 { |
| 2315 long target; | |
| 2316 long closest; | |
| 758 | 2317 long closest_start; |
| 2318 long closest_seq = 0; | |
| 2319 long val; | |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2320 u_header_T *uhp = NULL; |
| 753 | 2321 u_header_T *last; |
| 2322 int mark; | |
|
16405
840fa633ad64
patch 8.1.1207: some compilers give warning messages
Bram Moolenaar <Bram@vim.org>
parents:
16097
diff
changeset
|
2323 int nomark = 0; // shut up compiler |
| 753 | 2324 int round; |
| 758 | 2325 int dosec = sec; |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2326 int dofile = file; |
| 758 | 2327 int above = FALSE; |
| 794 | 2328 int did_undo = TRUE; |
| 753 | 2329 |
|
29002
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2330 if (text_locked()) |
|
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2331 { |
|
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2332 text_locked_msg(); |
|
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2333 return; |
|
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2334 } |
|
48d74a5822eb
patch 8.2.5023: substitute overwrites allocated buffer
Bram Moolenaar <Bram@vim.org>
parents:
28835
diff
changeset
|
2335 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2336 // First make sure the current undoable change is synced. |
| 766 | 2337 if (curbuf->b_u_synced == FALSE) |
| 825 | 2338 u_sync(TRUE); |
| 766 | 2339 |
| 753 | 2340 u_newcount = 0; |
| 2341 u_oldcount = 0; | |
| 179 | 2342 if (curbuf->b_ml.ml_flags & ML_EMPTY) |
| 753 | 2343 u_oldcount = -1; |
| 2344 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2345 // "target" is the node below which we want to be. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2346 // Init "closest" to a value we can't reach. |
| 772 | 2347 if (absolute) |
| 2348 { | |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2349 target = step; |
| 777 | 2350 closest = -1; |
| 753 | 2351 } |
| 2352 else | |
| 2353 { | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2354 if (dosec) |
|
10518
de77fa909414
commit https://github.com/vim/vim/commit/cbd4de44e8d08fba3c09eb40ad6e36e83faf020a
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2355 target = (long)(curbuf->b_u_time_cur) + step; |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2356 else if (dofile) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2357 { |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2358 if (step < 0) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2359 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2360 // Going back to a previous write. If there were changes after |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2361 // the last write, count that as moving one file-write, so |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2362 // that ":earlier 1f" undoes all changes since the last save. |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2363 uhp = curbuf->b_u_curhead; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2364 if (uhp != NULL) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2365 uhp = uhp->uh_next.ptr; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2366 else |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2367 uhp = curbuf->b_u_newhead; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2368 if (uhp != NULL && uhp->uh_save_nr != 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2369 // "uh_save_nr" was set in the last block, that means |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2370 // there were no changes since the last write |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2371 target = curbuf->b_u_save_nr_cur + step; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2372 else |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2373 // count the changes since the last write as one step |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2374 target = curbuf->b_u_save_nr_cur + step + 1; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2375 if (target <= 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2376 // Go to before first write: before the oldest change. Use |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2377 // the sequence number for that. |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2378 dofile = FALSE; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2379 } |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2380 else |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2381 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2382 // Moving forward to a newer write. |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2383 target = curbuf->b_u_save_nr_cur + step; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2384 if (target > curbuf->b_u_save_nr_last) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2385 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2386 // Go to after last write: after the latest change. Use |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2387 // the sequence number for that. |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2388 target = curbuf->b_u_seq_last + 1; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2389 dofile = FALSE; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2390 } |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2391 } |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2392 } |
| 777 | 2393 else |
| 2394 target = curbuf->b_u_seq_cur + step; | |
| 2395 if (step < 0) | |
| 758 | 2396 { |
| 777 | 2397 if (target < 0) |
| 2398 target = 0; | |
| 2399 closest = -1; | |
| 758 | 2400 } |
| 2401 else | |
| 2402 { | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2403 if (dosec) |
|
10518
de77fa909414
commit https://github.com/vim/vim/commit/cbd4de44e8d08fba3c09eb40ad6e36e83faf020a
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2404 closest = (long)(vim_time() + 1); |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2405 else if (dofile) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2406 closest = curbuf->b_u_save_nr_last + 2; |
| 777 | 2407 else |
| 2408 closest = curbuf->b_u_seq_last + 2; | |
| 2409 if (target >= closest) | |
| 2410 target = closest - 1; | |
| 758 | 2411 } |
| 753 | 2412 } |
| 758 | 2413 closest_start = closest; |
| 777 | 2414 closest_seq = curbuf->b_u_seq_cur; |
| 753 | 2415 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2416 // When "target" is 0; Back to origin. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2417 if (target == 0) |
|
13138
0f906f414c69
patch 8.0.1443: compiler complains about uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
13134
diff
changeset
|
2418 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2419 mark = lastmark; // avoid that GCC complains |
|
13138
0f906f414c69
patch 8.0.1443: compiler complains about uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
13134
diff
changeset
|
2420 goto target_zero; |
|
0f906f414c69
patch 8.0.1443: compiler complains about uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
13134
diff
changeset
|
2421 } |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2422 |
| 758 | 2423 /* |
| 2424 * May do this twice: | |
| 753 | 2425 * 1. Search for "target", update "closest" to the best match found. |
| 758 | 2426 * 2. If "target" not found search for "closest". |
| 2427 * | |
| 2428 * When using the closest time we use the sequence number in the second | |
| 2429 * round, because there may be several entries with the same time. | |
| 2430 */ | |
| 753 | 2431 for (round = 1; round <= 2; ++round) |
| 2432 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2433 // Find the path from the current state to where we want to go. The |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2434 // desired state can be anywhere in the undo tree, need to go all over |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2435 // it. We put "nomark" in uh_walk where we have been without success, |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2436 // "mark" where it could possibly be. |
| 753 | 2437 mark = ++lastmark; |
| 2438 nomark = ++lastmark; | |
| 2439 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2440 if (curbuf->b_u_curhead == NULL) // at leaf of the tree |
| 753 | 2441 uhp = curbuf->b_u_newhead; |
| 2442 else | |
| 2443 uhp = curbuf->b_u_curhead; | |
| 2444 | |
| 2445 while (uhp != NULL) | |
| 2446 { | |
| 2447 uhp->uh_walk = mark; | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2448 if (dosec) |
|
10518
de77fa909414
commit https://github.com/vim/vim/commit/cbd4de44e8d08fba3c09eb40ad6e36e83faf020a
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
2449 val = (long)(uhp->uh_time); |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2450 else if (dofile) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2451 val = uhp->uh_save_nr; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2452 else |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2453 val = uhp->uh_seq; |
| 753 | 2454 |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2455 if (round == 1 && !(dofile && val == 0)) |
| 758 | 2456 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2457 // Remember the header that is closest to the target. |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2458 // It must be at least in the right direction (checked with |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2459 // "b_u_seq_cur"). When the timestamp is equal find the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2460 // highest/lowest sequence number. |
| 777 | 2461 if ((step < 0 ? uhp->uh_seq <= curbuf->b_u_seq_cur |
| 2462 : uhp->uh_seq > curbuf->b_u_seq_cur) | |
| 2463 && ((dosec && val == closest) | |
| 2464 ? (step < 0 | |
| 2465 ? uhp->uh_seq < closest_seq | |
| 2466 : uhp->uh_seq > closest_seq) | |
| 2467 : closest == closest_start | |
| 2468 || (val > target | |
| 2469 ? (closest > target | |
| 2470 ? val - target <= closest - target | |
| 2471 : val - target <= target - closest) | |
| 2472 : (closest > target | |
| 2473 ? target - val <= closest - target | |
| 2474 : target - val <= target - closest)))) | |
| 758 | 2475 { |
| 2476 closest = val; | |
| 2477 closest_seq = uhp->uh_seq; | |
| 2478 } | |
| 2479 } | |
| 2480 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2481 // Quit searching when we found a match. But when searching for a |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2482 // time we need to continue looking for the best uh_seq. |
| 758 | 2483 if (target == val && !dosec) |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2484 { |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2485 target = uhp->uh_seq; |
| 758 | 2486 break; |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2487 } |
| 753 | 2488 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2489 // go down in the tree if we haven't been there |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2490 if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2491 && uhp->uh_prev.ptr->uh_walk != mark) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2492 uhp = uhp->uh_prev.ptr; |
| 753 | 2493 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2494 // go to alternate branch if we haven't been there |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2495 else if (uhp->uh_alt_next.ptr != NULL |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2496 && uhp->uh_alt_next.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2497 && uhp->uh_alt_next.ptr->uh_walk != mark) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2498 uhp = uhp->uh_alt_next.ptr; |
| 753 | 2499 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2500 // go up in the tree if we haven't been there and we are at the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2501 // start of alternate branches |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2502 else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2503 && uhp->uh_next.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2504 && uhp->uh_next.ptr->uh_walk != mark) |
| 798 | 2505 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2506 // If still at the start we don't go through this change. |
| 798 | 2507 if (uhp == curbuf->b_u_curhead) |
| 2508 uhp->uh_walk = nomark; | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2509 uhp = uhp->uh_next.ptr; |
| 798 | 2510 } |
| 753 | 2511 |
| 2512 else | |
| 2513 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2514 // need to backtrack; mark this node as useless |
| 753 | 2515 uhp->uh_walk = nomark; |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2516 if (uhp->uh_alt_prev.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2517 uhp = uhp->uh_alt_prev.ptr; |
| 753 | 2518 else |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2519 uhp = uhp->uh_next.ptr; |
| 753 | 2520 } |
| 2521 } | |
| 2522 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2523 if (uhp != NULL) // found it |
| 753 | 2524 break; |
| 772 | 2525 |
| 2526 if (absolute) | |
| 2527 { | |
|
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
2528 semsg(_(e_undo_number_nr_not_found), step); |
| 772 | 2529 return; |
| 2530 } | |
| 2531 | |
| 758 | 2532 if (closest == closest_start) |
| 753 | 2533 { |
| 758 | 2534 if (step < 0) |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
2535 msg(_("Already at oldest change")); |
| 758 | 2536 else |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
2537 msg(_("Already at newest change")); |
| 753 | 2538 return; |
| 2539 } | |
| 2540 | |
| 758 | 2541 target = closest_seq; |
| 2542 dosec = FALSE; | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2543 dofile = FALSE; |
| 758 | 2544 if (step < 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2545 above = TRUE; // stop above the header |
| 753 | 2546 } |
| 2547 | |
|
13138
0f906f414c69
patch 8.0.1443: compiler complains about uninitialized variable
Christian Brabandt <cb@256bit.org>
parents:
13134
diff
changeset
|
2548 target_zero: |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2549 // If we found it: Follow the path to go to where we want to be. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2550 if (uhp != NULL || target == 0) |
| 753 | 2551 { |
| 2552 /* | |
| 2553 * First go up the tree as much as needed. | |
| 2554 */ | |
| 2189 | 2555 while (!got_int) |
| 753 | 2556 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2557 // Do the change warning now, for the same reason as above. |
| 2189 | 2558 change_warning(0); |
| 2559 | |
| 753 | 2560 uhp = curbuf->b_u_curhead; |
| 2561 if (uhp == NULL) | |
| 2562 uhp = curbuf->b_u_newhead; | |
| 2563 else | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2564 uhp = uhp->uh_next.ptr; |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2565 if (uhp == NULL || (target > 0 && uhp->uh_walk != mark) |
| 777 | 2566 || (uhp->uh_seq == target && !above)) |
| 753 | 2567 break; |
| 2568 curbuf->b_u_curhead = uhp; | |
| 777 | 2569 u_undoredo(TRUE); |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2570 if (target > 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2571 uhp->uh_walk = nomark; // don't go back down here |
| 753 | 2572 } |
| 2573 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2574 // When back to origin, redo is not needed. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2575 if (target > 0) |
| 753 | 2576 { |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2577 /* |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2578 * And now go down the tree (redo), branching off where needed. |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2579 */ |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2580 while (!got_int) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2581 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2582 // Do the change warning now, for the same reason as above. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2583 change_warning(0); |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2584 |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2585 uhp = curbuf->b_u_curhead; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2586 if (uhp == NULL) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2587 break; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2588 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2589 // Go back to the first branch with a mark. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2590 while (uhp->uh_alt_prev.ptr != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2591 && uhp->uh_alt_prev.ptr->uh_walk == mark) |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2592 uhp = uhp->uh_alt_prev.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2593 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2594 // Find the last branch with a mark, that's the one. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2595 last = uhp; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2596 while (last->uh_alt_next.ptr != NULL |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2597 && last->uh_alt_next.ptr->uh_walk == mark) |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2598 last = last->uh_alt_next.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2599 if (last != uhp) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2600 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2601 // Make the used branch the first entry in the list of |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2602 // alternatives to make "u" and CTRL-R take this branch. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2603 while (uhp->uh_alt_prev.ptr != NULL) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2604 uhp = uhp->uh_alt_prev.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2605 if (last->uh_alt_next.ptr != NULL) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2606 last->uh_alt_next.ptr->uh_alt_prev.ptr = |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
2607 last->uh_alt_prev.ptr; |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2608 last->uh_alt_prev.ptr->uh_alt_next.ptr = |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2609 last->uh_alt_next.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2610 last->uh_alt_prev.ptr = NULL; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2611 last->uh_alt_next.ptr = uhp; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2612 uhp->uh_alt_prev.ptr = last; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2613 |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2614 if (curbuf->b_u_oldhead == uhp) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2615 curbuf->b_u_oldhead = last; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2616 uhp = last; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2617 if (uhp->uh_next.ptr != NULL) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2618 uhp->uh_next.ptr->uh_prev.ptr = uhp; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2619 } |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2620 curbuf->b_u_curhead = uhp; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2621 |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2622 if (uhp->uh_walk != mark) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2623 break; // must have reached the target |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2624 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2625 // Stop when going backwards in time and didn't find the exact |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2626 // header we were looking for. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2627 if (uhp->uh_seq == target && above) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2628 { |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2629 curbuf->b_u_seq_cur = target - 1; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2630 break; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2631 } |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2632 |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2633 u_undoredo(FALSE); |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2634 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2635 // Advance "curhead" to below the header we last used. If it |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2636 // becomes NULL then we need to set "newhead" to this leaf. |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2637 if (uhp->uh_prev.ptr == NULL) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2638 curbuf->b_u_newhead = uhp; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2639 curbuf->b_u_curhead = uhp->uh_prev.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2640 did_undo = FALSE; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2641 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2642 if (uhp->uh_seq == target) // found it! |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2643 break; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2644 |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2645 uhp = uhp->uh_prev.ptr; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2646 if (uhp == NULL || uhp->uh_walk != mark) |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2647 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2648 // Need to redo more but can't find it... |
|
13134
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2649 internal_error("undo_time()"); |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2650 break; |
|
c4b5ad2b3596
patch 8.0.1441: using ":undo 0" leaves undo in wrong state
Christian Brabandt <cb@256bit.org>
parents:
13012
diff
changeset
|
2651 } |
| 753 | 2652 } |
| 2653 } | |
| 2654 } | |
| 798 | 2655 u_undo_end(did_undo, absolute); |
| 7 | 2656 } |
| 2657 | |
| 2658 /* | |
| 2659 * u_undoredo: common code for undo and redo | |
| 2660 * | |
| 2661 * The lines in the file are replaced by the lines in the entry list at | |
| 2662 * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry | |
| 2663 * list for the next undo/redo. | |
| 777 | 2664 * |
| 2665 * When "undo" is TRUE we go up in the tree, when FALSE we go down. | |
| 7 | 2666 */ |
| 2667 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2668 u_undoredo(int undo) |
| 7 | 2669 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2670 undoline_T *newarray = NULL; |
| 7 | 2671 linenr_T oldsize; |
| 2672 linenr_T newsize; | |
| 2673 linenr_T top, bot; | |
| 2674 linenr_T lnum; | |
| 2675 linenr_T newlnum = MAXLNUM; | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2676 pos_T new_curpos = curwin->w_cursor; |
| 7 | 2677 long i; |
| 2678 u_entry_T *uep, *nuep; | |
| 2679 u_entry_T *newlist = NULL; | |
| 2680 int old_flags; | |
| 2681 int new_flags; | |
| 2682 pos_T namedm[NMARKS]; | |
| 692 | 2683 visualinfo_T visualinfo; |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2684 int empty_buffer; // buffer became empty |
| 758 | 2685 u_header_T *curhead = curbuf->b_u_curhead; |
| 7 | 2686 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2687 // Don't want autocommands using the undo structures here, they are |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2688 // invalid till the end. |
| 2189 | 2689 block_autocmds(); |
| 2690 | |
| 1415 | 2691 #ifdef U_DEBUG |
| 2692 u_check(FALSE); | |
| 2693 #endif | |
| 758 | 2694 old_flags = curhead->uh_flags; |
| 7 | 2695 new_flags = (curbuf->b_changed ? UH_CHANGED : 0) + |
| 2696 ((curbuf->b_ml.ml_flags & ML_EMPTY) ? UH_EMPTYBUF : 0); | |
| 2697 setpcmark(); | |
| 2698 | |
| 2699 /* | |
| 2700 * save marks before undo/redo | |
| 2701 */ | |
| 2702 mch_memmove(namedm, curbuf->b_namedm, sizeof(pos_T) * NMARKS); | |
| 692 | 2703 visualinfo = curbuf->b_visual; |
| 7 | 2704 curbuf->b_op_start.lnum = curbuf->b_ml.ml_line_count; |
| 2705 curbuf->b_op_start.col = 0; | |
| 2706 curbuf->b_op_end.lnum = 0; | |
| 2707 curbuf->b_op_end.col = 0; | |
| 2708 | |
| 758 | 2709 for (uep = curhead->uh_entry; uep != NULL; uep = nuep) |
| 7 | 2710 { |
| 2711 top = uep->ue_top; | |
| 2712 bot = uep->ue_bot; | |
| 2713 if (bot == 0) | |
| 2714 bot = curbuf->b_ml.ml_line_count + 1; | |
| 2715 if (top > curbuf->b_ml.ml_line_count || top >= bot | |
| 2716 || bot > curbuf->b_ml.ml_line_count + 1) | |
| 2717 { | |
| 2189 | 2718 unblock_autocmds(); |
|
26913
d4e61d61afd9
patch 8.2.3985: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26883
diff
changeset
|
2719 iemsg(_(e_u_undo_line_numbers_wrong)); |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2720 changed(); // don't want UNCHANGED now |
| 7 | 2721 return; |
| 2722 } | |
| 2723 | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2724 oldsize = bot - top - 1; // number of lines before undo |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2725 newsize = uep->ue_size; // number of lines after undo |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2726 |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2727 // Decide about the cursor position, depending on what text changed. |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2728 // Don't set it yet, it may be invalid if lines are going to be added. |
| 7 | 2729 if (top < newlnum) |
| 2730 { | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2731 // If the saved cursor is somewhere in this undo block, move it to |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2732 // the remembered position. Makes "gwap" put the cursor back |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2733 // where it was. |
| 758 | 2734 lnum = curhead->uh_cursor.lnum; |
| 7 | 2735 if (lnum >= top && lnum <= top + newsize + 1) |
| 2736 { | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2737 new_curpos = curhead->uh_cursor; |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2738 newlnum = new_curpos.lnum - 1; |
| 7 | 2739 } |
| 2740 else | |
| 2741 { | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2742 // Use the first line that actually changed. Avoids that |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2743 // undoing auto-formatting puts the cursor in the previous |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2744 // line. |
| 7 | 2745 for (i = 0; i < newsize && i < oldsize; ++i) |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2746 { |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2747 char_u *p = ml_get(top + 1 + i); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2748 |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2749 if (curbuf->b_ml.ml_line_len != uep->ue_array[i].ul_len |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
2750 || memcmp(uep->ue_array[i].ul_line, p, |
|
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
2751 curbuf->b_ml.ml_line_len) != 0) |
| 7 | 2752 break; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2753 } |
| 7 | 2754 if (i == newsize && newlnum == MAXLNUM && uep->ue_next == NULL) |
| 2755 { | |
| 2756 newlnum = top; | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2757 new_curpos.lnum = newlnum + 1; |
| 7 | 2758 } |
| 2759 else if (i < newsize) | |
| 2760 { | |
| 2761 newlnum = top + i; | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2762 new_curpos.lnum = newlnum + 1; |
| 7 | 2763 } |
| 2764 } | |
| 2765 } | |
| 2766 | |
| 2767 empty_buffer = FALSE; | |
| 2768 | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2769 /* |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2770 * Delete the lines between top and bot and save them in newarray. |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2771 */ |
| 168 | 2772 if (oldsize > 0) |
| 7 | 2773 { |
|
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
2774 if ((newarray = U_ALLOC_LINE(sizeof(undoline_T) * oldsize)) == NULL) |
| 7 | 2775 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2776 do_outofmem_msg((long_u)(sizeof(undoline_T) * oldsize)); |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2777 |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2778 // We have messed up the entry list, repair is impossible. |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2779 // we have to free the rest of the list. |
| 7 | 2780 while (uep != NULL) |
| 2781 { | |
| 2782 nuep = uep->ue_next; | |
| 2783 u_freeentry(uep, uep->ue_size); | |
| 2784 uep = nuep; | |
| 2785 } | |
| 2786 break; | |
| 2787 } | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2788 // delete backwards, it goes faster in most cases |
| 7 | 2789 for (lnum = bot - 1, i = oldsize; --i >= 0; --lnum) |
| 2790 { | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2791 // what can we do when we run out of memory? |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2792 if (u_save_line(&newarray[i], lnum) == FAIL) |
| 7 | 2793 do_outofmem_msg((long_u)0); |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2794 // remember we deleted the last line in the buffer, and a |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2795 // dummy empty line will be inserted |
| 7 | 2796 if (curbuf->b_ml.ml_line_count == 1) |
| 2797 empty_buffer = TRUE; | |
|
20581
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
2798 ml_delete_flags(lnum, ML_DEL_UNDO); |
| 7 | 2799 } |
| 2800 } | |
| 414 | 2801 else |
| 2802 newarray = NULL; | |
| 7 | 2803 |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2804 // make sure the cursor is on a valid line after the deletions |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2805 check_cursor_lnum(); |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2806 |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2807 /* |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2808 * Insert the lines in u_array between top and bot. |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2809 */ |
| 7 | 2810 if (newsize) |
| 2811 { | |
| 2812 for (lnum = top, i = 0; i < newsize; ++i, ++lnum) | |
| 2813 { | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2814 // If the file is empty, there is an empty line 1 that we |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2815 // should get rid of, by replacing it with the new line. |
| 7 | 2816 if (empty_buffer && lnum == 0) |
|
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
2817 ml_replace_len((linenr_T)1, uep->ue_array[i].ul_line, |
|
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
16627
diff
changeset
|
2818 uep->ue_array[i].ul_len, TRUE, TRUE); |
| 7 | 2819 else |
|
20581
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
2820 ml_append_flags(lnum, uep->ue_array[i].ul_line, |
|
e529690f27bc
patch 8.2.0844: text properties crossing lines not handled correctly
Bram Moolenaar <Bram@vim.org>
parents:
20229
diff
changeset
|
2821 (colnr_T)uep->ue_array[i].ul_len, ML_APPEND_UNDO); |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
2822 vim_free(uep->ue_array[i].ul_line); |
| 7 | 2823 } |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2824 vim_free((char_u *)uep->ue_array); |
| 7 | 2825 } |
| 2826 | |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2827 // adjust marks |
| 7 | 2828 if (oldsize != newsize) |
| 2829 { | |
| 2830 mark_adjust(top + 1, top + oldsize, (long)MAXLNUM, | |
| 2831 (long)newsize - (long)oldsize); | |
| 2832 if (curbuf->b_op_start.lnum > top + oldsize) | |
| 2833 curbuf->b_op_start.lnum += newsize - oldsize; | |
| 2834 if (curbuf->b_op_end.lnum > top + oldsize) | |
| 2835 curbuf->b_op_end.lnum += newsize - oldsize; | |
| 2836 } | |
|
27706
17cd22b7151b
patch 8.2.4379: an empty change is reported to a listener
Bram Moolenaar <Bram@vim.org>
parents:
27426
diff
changeset
|
2837 if (oldsize > 0 || newsize > 0) |
|
17cd22b7151b
patch 8.2.4379: an empty change is reported to a listener
Bram Moolenaar <Bram@vim.org>
parents:
27426
diff
changeset
|
2838 changed_lines(top + 1, 0, bot, newsize - oldsize); |
| 7 | 2839 |
|
28835
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2840 // Set the '[ mark. |
| 7 | 2841 if (top + 1 < curbuf->b_op_start.lnum) |
| 2842 curbuf->b_op_start.lnum = top + 1; | |
|
28835
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2843 // Set the '] mark. |
| 7 | 2844 if (newsize == 0 && top + 1 > curbuf->b_op_end.lnum) |
| 2845 curbuf->b_op_end.lnum = top + 1; | |
| 2846 else if (top + newsize > curbuf->b_op_end.lnum) | |
| 2847 curbuf->b_op_end.lnum = top + newsize; | |
| 2848 | |
| 2849 u_newcount += newsize; | |
| 2850 u_oldcount += oldsize; | |
| 2851 uep->ue_size = oldsize; | |
| 2852 uep->ue_array = newarray; | |
| 2853 uep->ue_bot = top + newsize + 1; | |
| 2854 | |
| 2855 /* | |
| 2856 * insert this entry in front of the new entry list | |
| 2857 */ | |
| 2858 nuep = uep->ue_next; | |
| 2859 uep->ue_next = newlist; | |
| 2860 newlist = uep; | |
| 2861 } | |
| 2862 | |
|
28835
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2863 // Ensure the '[ and '] marks are within bounds. |
|
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2864 if (curbuf->b_op_start.lnum > curbuf->b_ml.ml_line_count) |
|
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2865 curbuf->b_op_start.lnum = curbuf->b_ml.ml_line_count; |
|
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2866 if (curbuf->b_op_end.lnum > curbuf->b_ml.ml_line_count) |
|
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2867 curbuf->b_op_end.lnum = curbuf->b_ml.ml_line_count; |
|
58d2315b096e
patch 8.2.4941: '[ and '] marks may be wrong after undo
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
2868 |
|
18025
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2869 // Set the cursor to the desired position. Check that the line is valid. |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2870 curwin->w_cursor = new_curpos; |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2871 check_cursor_lnum(); |
|
d19caa851682
patch 8.1.2008: error for invalid range when using listener and undo
Bram Moolenaar <Bram@vim.org>
parents:
17970
diff
changeset
|
2872 |
| 758 | 2873 curhead->uh_entry = newlist; |
| 2874 curhead->uh_flags = new_flags; | |
|
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10978
diff
changeset
|
2875 if ((old_flags & UH_EMPTYBUF) && BUFEMPTY()) |
| 7 | 2876 curbuf->b_ml.ml_flags |= ML_EMPTY; |
| 2877 if (old_flags & UH_CHANGED) | |
| 2878 changed(); | |
| 2879 else | |
| 33 | 2880 #ifdef FEAT_NETBEANS_INTG |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2881 // per netbeans undo rules, keep it as modified |
| 33 | 2882 if (!isNetbeansModified(curbuf)) |
| 2883 #endif | |
|
16996
d5e1e09a829f
patch 8.1.1498: ":write" increments b:changedtick even though nothing changed
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
2884 unchanged(curbuf, FALSE, TRUE); |
| 7 | 2885 |
| 2886 /* | |
| 2887 * restore marks from before undo/redo | |
| 2888 */ | |
| 2889 for (i = 0; i < NMARKS; ++i) | |
| 6616 | 2890 { |
| 758 | 2891 if (curhead->uh_namedm[i].lnum != 0) |
| 2892 curbuf->b_namedm[i] = curhead->uh_namedm[i]; | |
| 6616 | 2893 if (namedm[i].lnum != 0) |
| 758 | 2894 curhead->uh_namedm[i] = namedm[i]; |
| 6616 | 2895 else |
| 2896 curhead->uh_namedm[i].lnum = 0; | |
| 2897 } | |
| 758 | 2898 if (curhead->uh_visual.vi_start.lnum != 0) |
| 692 | 2899 { |
| 758 | 2900 curbuf->b_visual = curhead->uh_visual; |
| 2901 curhead->uh_visual = visualinfo; | |
| 692 | 2902 } |
| 7 | 2903 |
| 2904 /* | |
| 2905 * If the cursor is only off by one line, put it at the same position as | |
| 2906 * before starting the change (for the "o" command). | |
| 2907 * Otherwise the cursor should go to the first undone line. | |
| 2908 */ | |
| 758 | 2909 if (curhead->uh_cursor.lnum + 1 == curwin->w_cursor.lnum |
| 7 | 2910 && curwin->w_cursor.lnum > 1) |
| 2911 --curwin->w_cursor.lnum; | |
|
2501
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2912 if (curwin->w_cursor.lnum <= curbuf->b_ml.ml_line_count) |
| 7 | 2913 { |
|
2501
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2914 if (curhead->uh_cursor.lnum == curwin->w_cursor.lnum) |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2915 { |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2916 curwin->w_cursor.col = curhead->uh_cursor.col; |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2917 if (virtual_active() && curhead->uh_cursor_vcol >= 0) |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2918 coladvance((colnr_T)curhead->uh_cursor_vcol); |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2919 else |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2920 curwin->w_cursor.coladd = 0; |
|
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2921 } |
| 7 | 2922 else |
|
2501
c43e99e9baaf
Fix: ml_get errors when using undo with 'virtualedit'.
Bram Moolenaar <bram@vim.org>
parents:
2482
diff
changeset
|
2923 beginline(BL_SOL | BL_FIX); |
| 7 | 2924 } |
| 2925 else | |
| 2926 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2927 // We get here with the current cursor line being past the end (eg |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2928 // after adding lines at the end of the file, and then undoing it). |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2929 // check_cursor() will move the cursor to the last line. Move it to |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2930 // the first column here. |
| 7 | 2931 curwin->w_cursor.col = 0; |
| 2932 curwin->w_cursor.coladd = 0; | |
| 2933 } | |
| 2934 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2935 // Make sure the cursor is on an existing line and column. |
| 7 | 2936 check_cursor(); |
| 758 | 2937 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2938 // Remember where we are for "g-" and ":earlier 10s". |
| 758 | 2939 curbuf->b_u_seq_cur = curhead->uh_seq; |
| 777 | 2940 if (undo) |
|
12827
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2941 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2942 // We are below the previous undo. However, to make ":earlier 1s" |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2943 // work we compute this as being just above the just undone change. |
|
12827
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2944 if (curhead->uh_next.ptr != NULL) |
|
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2945 curbuf->b_u_seq_cur = curhead->uh_next.ptr->uh_seq; |
|
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2946 else |
|
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2947 curbuf->b_u_seq_cur = 0; |
|
ff494a964ab7
patch 8.0.1290: seq_cur of undotree() wrong after undo
Christian Brabandt <cb@256bit.org>
parents:
12716
diff
changeset
|
2948 } |
| 777 | 2949 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2950 // Remember where we are for ":earlier 1f" and ":later 1f". |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2951 if (curhead->uh_save_nr != 0) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2952 { |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2953 if (undo) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2954 curbuf->b_u_save_nr_cur = curhead->uh_save_nr - 1; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2955 else |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2956 curbuf->b_u_save_nr_cur = curhead->uh_save_nr; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2957 } |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
2958 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2959 // The timestamp can be the same for multiple changes, just use the one of |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2960 // the undone/redone change. |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
2961 curbuf->b_u_time_cur = curhead->uh_time; |
| 2189 | 2962 |
| 2963 unblock_autocmds(); | |
| 1415 | 2964 #ifdef U_DEBUG |
| 2965 u_check(FALSE); | |
| 2966 #endif | |
| 7 | 2967 } |
| 2968 | |
| 2969 /* | |
| 2970 * If we deleted or added lines, report the number of less/more lines. | |
| 2971 * Otherwise, report the number of changes (this may be incorrect | |
| 2972 * in some cases, but it's better than nothing). | |
| 2973 */ | |
| 2974 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
2975 u_undo_end( |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2976 int did_undo, // just did an undo |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2977 int absolute) // used ":undo N" |
| 7 | 2978 { |
| 944 | 2979 char *msgstr; |
| 772 | 2980 u_header_T *uhp; |
| 2981 char_u msgbuf[80]; | |
| 753 | 2982 |
| 7 | 2983 #ifdef FEAT_FOLDING |
| 2984 if ((fdo_flags & FDO_UNDO) && KeyTyped) | |
| 2985 foldOpenCursor(); | |
| 2986 #endif | |
| 753 | 2987 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2988 if (global_busy // no messages now, wait until global is finished |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2989 || !messaging()) // 'lazyredraw' set, don't do messages now |
| 753 | 2990 return; |
| 2991 | |
| 2992 if (curbuf->b_ml.ml_flags & ML_EMPTY) | |
| 2993 --u_newcount; | |
| 2994 | |
| 2995 u_oldcount -= u_newcount; | |
| 2996 if (u_oldcount == -1) | |
| 944 | 2997 msgstr = N_("more line"); |
| 753 | 2998 else if (u_oldcount < 0) |
| 944 | 2999 msgstr = N_("more lines"); |
| 753 | 3000 else if (u_oldcount == 1) |
| 944 | 3001 msgstr = N_("line less"); |
| 753 | 3002 else if (u_oldcount > 1) |
| 944 | 3003 msgstr = N_("fewer lines"); |
| 753 | 3004 else |
| 3005 { | |
| 3006 u_oldcount = u_newcount; | |
| 3007 if (u_newcount == 1) | |
| 944 | 3008 msgstr = N_("change"); |
| 753 | 3009 else |
| 944 | 3010 msgstr = N_("changes"); |
| 753 | 3011 } |
| 3012 | |
| 772 | 3013 if (curbuf->b_u_curhead != NULL) |
| 794 | 3014 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3015 // For ":undo N" we prefer a "after #N" message. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3016 if (absolute && curbuf->b_u_curhead->uh_next.ptr != NULL) |
| 798 | 3017 { |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3018 uhp = curbuf->b_u_curhead->uh_next.ptr; |
| 798 | 3019 did_undo = FALSE; |
| 3020 } | |
| 3021 else if (did_undo) | |
| 794 | 3022 uhp = curbuf->b_u_curhead; |
| 3023 else | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3024 uhp = curbuf->b_u_curhead->uh_next.ptr; |
| 794 | 3025 } |
| 753 | 3026 else |
| 772 | 3027 uhp = curbuf->b_u_newhead; |
| 753 | 3028 |
| 772 | 3029 if (uhp == NULL) |
| 3030 *msgbuf = NUL; | |
| 3031 else | |
|
18463
18d7337b6837
patch 8.1.2225: the "last used" info of a buffer is under used
Bram Moolenaar <Bram@vim.org>
parents:
18139
diff
changeset
|
3032 add_time(msgbuf, sizeof(msgbuf), uhp->uh_time); |
| 772 | 3033 |
|
2282
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3034 #ifdef FEAT_CONCEAL |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3035 { |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3036 win_T *wp; |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3037 |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3038 FOR_ALL_WINDOWS(wp) |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3039 { |
|
2378
85b7dc8da5eb
Add the 'concealcursor' option to decide when the cursor line is to be
Bram Moolenaar <bram@vim.org>
parents:
2367
diff
changeset
|
3040 if (wp->w_buffer == curbuf && wp->w_p_cole > 0) |
|
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29038
diff
changeset
|
3041 redraw_win_later(wp, UPD_NOT_VALID); |
|
2282
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3042 } |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3043 } |
|
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3044 #endif |
|
27378
a4746d1a3cf3
patch 8.2.4217: illegal memory access when undo makes Visual area invalid
Bram Moolenaar <Bram@vim.org>
parents:
27028
diff
changeset
|
3045 if (VIsual_active) |
|
a4746d1a3cf3
patch 8.2.4217: illegal memory access when undo makes Visual area invalid
Bram Moolenaar <Bram@vim.org>
parents:
27028
diff
changeset
|
3046 check_pos(curbuf, &VIsual); |
|
2282
a888ed7ba375
Make updating text for conceal mode simpler. A few compiler warning fixes.
Bram Moolenaar <bram@vim.org>
parents:
2281
diff
changeset
|
3047 |
|
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15390
diff
changeset
|
3048 smsg_attr_keep(0, _("%ld %s; %s #%ld %s"), |
| 777 | 3049 u_oldcount < 0 ? -u_oldcount : u_oldcount, |
| 944 | 3050 _(msgstr), |
| 794 | 3051 did_undo ? _("before") : _("after"), |
| 3052 uhp == NULL ? 0L : uhp->uh_seq, | |
| 3053 msgbuf); | |
| 7 | 3054 } |
| 3055 | |
| 3056 /* | |
| 3057 * u_sync: stop adding to the current entry list | |
| 3058 */ | |
| 3059 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3060 u_sync( |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3061 int force) // Also sync when no_u_sync is set. |
| 7 | 3062 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3063 // Skip it when already synced or syncing is disabled. |
| 825 | 3064 if (curbuf->b_u_synced || (!force && no_u_sync > 0)) |
| 3065 return; | |
| 7 | 3066 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) |
|
12293
1ff5e5dfa9b0
patch 8.0.1026: GTK on-the-spot input has problems
Christian Brabandt <cb@256bit.org>
parents:
12216
diff
changeset
|
3067 if (p_imst == IM_ON_THE_SPOT && im_is_preediting()) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3068 return; // XIM is busy, don't break an undo sequence |
| 7 | 3069 #endif |
| 5446 | 3070 if (get_undolevel() < 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3071 curbuf->b_u_synced = TRUE; // no entries, nothing to do |
| 7 | 3072 else |
| 3073 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3074 u_getbot(); // compute ue_bot of previous u_save |
| 7 | 3075 curbuf->b_u_curhead = NULL; |
| 3076 } | |
| 3077 } | |
| 3078 | |
| 3079 /* | |
| 772 | 3080 * ":undolist": List the leafs of the undo tree |
| 3081 */ | |
| 3082 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3083 ex_undolist(exarg_T *eap UNUSED) |
| 772 | 3084 { |
| 3085 garray_T ga; | |
| 3086 u_header_T *uhp; | |
| 3087 int mark; | |
| 3088 int nomark; | |
| 3089 int changes = 1; | |
| 3090 int i; | |
| 3091 | |
| 3092 /* | |
| 3093 * 1: walk the tree to find all leafs, put the info in "ga". | |
| 3094 * 2: sort the lines | |
| 3095 * 3: display the list | |
| 3096 */ | |
| 3097 mark = ++lastmark; | |
| 3098 nomark = ++lastmark; | |
|
27028
c9474ae175f4
patch 8.2.4043: using int for second argument of ga_init2()
Bram Moolenaar <Bram@vim.org>
parents:
26966
diff
changeset
|
3099 ga_init2(&ga, sizeof(char *), 20); |
| 772 | 3100 |
| 3101 uhp = curbuf->b_u_oldhead; | |
| 3102 while (uhp != NULL) | |
| 3103 { | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3104 if (uhp->uh_prev.ptr == NULL && uhp->uh_walk != nomark |
| 777 | 3105 && uhp->uh_walk != mark) |
| 772 | 3106 { |
| 3107 if (ga_grow(&ga, 1) == FAIL) | |
| 3108 break; | |
|
13610
e76499e85744
patch 8.0.1677: no compiler warning for wrong format in vim_snprintf()
Christian Brabandt <cb@256bit.org>
parents:
13380
diff
changeset
|
3109 vim_snprintf((char *)IObuff, IOSIZE, "%6ld %7d ", |
| 772 | 3110 uhp->uh_seq, changes); |
|
18463
18d7337b6837
patch 8.1.2225: the "last used" info of a buffer is under used
Bram Moolenaar <Bram@vim.org>
parents:
18139
diff
changeset
|
3111 add_time(IObuff + STRLEN(IObuff), IOSIZE - STRLEN(IObuff), |
| 772 | 3112 uhp->uh_time); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3113 if (uhp->uh_save_nr > 0) |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3114 { |
| 2627 | 3115 while (STRLEN(IObuff) < 33) |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3116 STRCAT(IObuff, " "); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3117 vim_snprintf_add((char *)IObuff, IOSIZE, |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3118 " %3ld", uhp->uh_save_nr); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3119 } |
| 772 | 3120 ((char_u **)(ga.ga_data))[ga.ga_len++] = vim_strsave(IObuff); |
| 3121 } | |
| 3122 | |
| 3123 uhp->uh_walk = mark; | |
| 3124 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3125 // go down in the tree if we haven't been there |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3126 if (uhp->uh_prev.ptr != NULL && uhp->uh_prev.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3127 && uhp->uh_prev.ptr->uh_walk != mark) |
| 772 | 3128 { |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3129 uhp = uhp->uh_prev.ptr; |
| 772 | 3130 ++changes; |
| 3131 } | |
| 3132 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3133 // go to alternate branch if we haven't been there |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3134 else if (uhp->uh_alt_next.ptr != NULL |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3135 && uhp->uh_alt_next.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3136 && uhp->uh_alt_next.ptr->uh_walk != mark) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3137 uhp = uhp->uh_alt_next.ptr; |
| 772 | 3138 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3139 // go up in the tree if we haven't been there and we are at the |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3140 // start of alternate branches |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3141 else if (uhp->uh_next.ptr != NULL && uhp->uh_alt_prev.ptr == NULL |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3142 && uhp->uh_next.ptr->uh_walk != nomark |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3143 && uhp->uh_next.ptr->uh_walk != mark) |
| 772 | 3144 { |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3145 uhp = uhp->uh_next.ptr; |
| 772 | 3146 --changes; |
| 3147 } | |
| 3148 | |
| 3149 else | |
| 3150 { | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3151 // need to backtrack; mark this node as done |
| 772 | 3152 uhp->uh_walk = nomark; |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3153 if (uhp->uh_alt_prev.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3154 uhp = uhp->uh_alt_prev.ptr; |
| 772 | 3155 else |
| 3156 { | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3157 uhp = uhp->uh_next.ptr; |
| 772 | 3158 --changes; |
| 3159 } | |
| 3160 } | |
| 3161 } | |
| 3162 | |
| 3163 if (ga.ga_len == 0) | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
3164 msg(_("Nothing to undo")); |
| 772 | 3165 else |
| 3166 { | |
| 3167 sort_strings((char_u **)ga.ga_data, ga.ga_len); | |
| 3168 | |
| 3169 msg_start(); | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
3170 msg_puts_attr(_("number changes when saved"), |
|
11158
501f46f7644c
patch 8.0.0466: still macros that should be all-caps
Christian Brabandt <cb@256bit.org>
parents:
11127
diff
changeset
|
3171 HL_ATTR(HLF_T)); |
| 772 | 3172 for (i = 0; i < ga.ga_len && !got_int; ++i) |
| 3173 { | |
| 3174 msg_putchar('\n'); | |
| 3175 if (got_int) | |
| 3176 break; | |
|
15543
dd725a8ab112
patch 8.1.0779: argument for message functions is inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
3177 msg_puts(((char **)ga.ga_data)[i]); |
| 772 | 3178 } |
| 3179 msg_end(); | |
| 3180 | |
| 3181 ga_clear_strings(&ga); | |
| 3182 } | |
| 3183 } | |
| 3184 | |
| 3185 /* | |
| 697 | 3186 * ":undojoin": continue adding to the last entry list |
| 3187 */ | |
| 3188 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3189 ex_undojoin(exarg_T *eap UNUSED) |
| 697 | 3190 { |
| 839 | 3191 if (curbuf->b_u_newhead == NULL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3192 return; // nothing changed before |
| 839 | 3193 if (curbuf->b_u_curhead != NULL) |
| 3194 { | |
|
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26913
diff
changeset
|
3195 emsg(_(e_undojoin_is_not_allowed_after_undo)); |
| 839 | 3196 return; |
| 3197 } | |
| 697 | 3198 if (!curbuf->b_u_synced) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3199 return; // already unsynced |
| 5446 | 3200 if (get_undolevel() < 0) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3201 return; // no entries, nothing to do |
| 697 | 3202 else |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3203 // Append next change to the last entry |
|
10631
cbf17371627c
patch 8.0.0205: wrong behavior after :undojoin
Christian Brabandt <cb@256bit.org>
parents:
10518
diff
changeset
|
3204 curbuf->b_u_synced = FALSE; |
| 697 | 3205 } |
| 3206 | |
| 3207 /* | |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
3208 * Called after writing or reloading the file and setting b_changed to FALSE. |
| 7 | 3209 * Now an undo means that the buffer is modified. |
| 3210 */ | |
| 3211 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3212 u_unchanged(buf_T *buf) |
| 7 | 3213 { |
| 758 | 3214 u_unch_branch(buf->b_u_oldhead); |
| 3215 buf->b_did_warn = FALSE; | |
| 3216 } | |
| 3217 | |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3218 /* |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3219 * After reloading a buffer which was saved for 'undoreload': Find the first |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3220 * line that was changed and set the cursor there. |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3221 */ |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3222 void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3223 u_find_first_changed(void) |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3224 { |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3225 u_header_T *uhp = curbuf->b_u_newhead; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3226 u_entry_T *uep; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3227 linenr_T lnum; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3228 |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3229 if (curbuf->b_u_curhead != NULL || uhp == NULL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3230 return; // undid something in an autocmd? |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3231 |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3232 // Check that the last undo block was for the whole file. |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3233 uep = uhp->uh_entry; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3234 if (uep->ue_top != 0 || uep->ue_bot != 0) |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3235 return; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3236 |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3237 for (lnum = 1; lnum < curbuf->b_ml.ml_line_count |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3238 && lnum <= uep->ue_size; ++lnum) |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3239 { |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3240 char_u *p = ml_get_buf(curbuf, lnum, FALSE); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3241 |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3242 if (uep->ue_array[lnum - 1].ul_len != curbuf->b_ml.ml_line_len |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3243 || memcmp(p, uep->ue_array[lnum - 1].ul_line, uep->ue_array[lnum - 1].ul_len) != 0) |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3244 { |
|
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10978
diff
changeset
|
3245 CLEAR_POS(&(uhp->uh_cursor)); |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3246 uhp->uh_cursor.lnum = lnum; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3247 return; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3248 } |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3249 } |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3250 if (curbuf->b_ml.ml_line_count != uep->ue_size) |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3251 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3252 // lines added or deleted at the end, put the cursor there |
|
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
10978
diff
changeset
|
3253 CLEAR_POS(&(uhp->uh_cursor)); |
|
2482
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3254 uhp->uh_cursor.lnum = lnum; |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3255 } |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3256 } |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3257 |
|
88751831fa0a
When undoing a reload, move the cursor to the first changed line.
Bram Moolenaar <bram@vim.org>
parents:
2410
diff
changeset
|
3258 /* |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3259 * Increase the write count, store it in the last undo header, what would be |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3260 * used for "u". |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3261 */ |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3262 void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3263 u_update_save_nr(buf_T *buf) |
|
2281
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3264 { |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3265 u_header_T *uhp; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3266 |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3267 ++buf->b_u_save_nr_last; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3268 buf->b_u_save_nr_cur = buf->b_u_save_nr_last; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3269 uhp = buf->b_u_curhead; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3270 if (uhp != NULL) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3271 uhp = uhp->uh_next.ptr; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3272 else |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3273 uhp = buf->b_u_newhead; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3274 if (uhp != NULL) |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3275 uhp->uh_save_nr = buf->b_u_save_nr_last; |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3276 } |
|
e41433ea71df
Added ":earlier 1f" and ":later 1f".
Bram Moolenaar <bram@vim.org>
parents:
2280
diff
changeset
|
3277 |
| 758 | 3278 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3279 u_unch_branch(u_header_T *uhp) |
| 758 | 3280 { |
| 753 | 3281 u_header_T *uh; |
| 7 | 3282 |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3283 for (uh = uhp; uh != NULL; uh = uh->uh_prev.ptr) |
| 758 | 3284 { |
| 7 | 3285 uh->uh_flags |= UH_CHANGED; |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3286 if (uh->uh_alt_next.ptr != NULL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3287 u_unch_branch(uh->uh_alt_next.ptr); // recursive |
| 758 | 3288 } |
| 7 | 3289 } |
| 3290 | |
| 3291 /* | |
| 3292 * Get pointer to last added entry. | |
| 3293 * If it's not valid, give an error message and return NULL. | |
| 3294 */ | |
| 3295 static u_entry_T * | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3296 u_get_headentry(void) |
| 7 | 3297 { |
| 3298 if (curbuf->b_u_newhead == NULL || curbuf->b_u_newhead->uh_entry == NULL) | |
| 3299 { | |
|
26913
d4e61d61afd9
patch 8.2.3985: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26883
diff
changeset
|
3300 iemsg(_(e_undo_list_corrupt)); |
| 7 | 3301 return NULL; |
| 3302 } | |
| 3303 return curbuf->b_u_newhead->uh_entry; | |
| 3304 } | |
| 3305 | |
| 3306 /* | |
| 3307 * u_getbot(): compute the line number of the previous u_save | |
| 3308 * It is called only when b_u_synced is FALSE. | |
| 3309 */ | |
| 3310 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3311 u_getbot(void) |
| 7 | 3312 { |
| 3313 u_entry_T *uep; | |
| 3314 linenr_T extra; | |
| 3315 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3316 uep = u_get_headentry(); // check for corrupt undo list |
| 7 | 3317 if (uep == NULL) |
| 3318 return; | |
| 3319 | |
| 3320 uep = curbuf->b_u_newhead->uh_getbot_entry; | |
| 3321 if (uep != NULL) | |
| 3322 { | |
| 3323 /* | |
| 3324 * the new ue_bot is computed from the number of lines that has been | |
| 3325 * inserted (0 - deleted) since calling u_save. This is equal to the | |
| 3326 * old line count subtracted from the current line count. | |
| 3327 */ | |
| 3328 extra = curbuf->b_ml.ml_line_count - uep->ue_lcount; | |
| 3329 uep->ue_bot = uep->ue_top + uep->ue_size + 1 + extra; | |
| 3330 if (uep->ue_bot < 1 || uep->ue_bot > curbuf->b_ml.ml_line_count) | |
| 3331 { | |
|
26913
d4e61d61afd9
patch 8.2.3985: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26883
diff
changeset
|
3332 iemsg(_(e_undo_line_missing)); |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3333 uep->ue_bot = uep->ue_top + 1; // assume all lines deleted, will |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3334 // get all the old lines back |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3335 // without deleting the current |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3336 // ones |
| 7 | 3337 } |
| 3338 | |
| 3339 curbuf->b_u_newhead->uh_getbot_entry = NULL; | |
| 3340 } | |
| 3341 | |
| 3342 curbuf->b_u_synced = TRUE; | |
| 3343 } | |
| 3344 | |
| 3345 /* | |
| 1415 | 3346 * Free one header "uhp" and its entry list and adjust the pointers. |
| 7 | 3347 */ |
| 3348 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3349 u_freeheader( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3350 buf_T *buf, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3351 u_header_T *uhp, |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3352 u_header_T **uhpp) // if not NULL reset when freeing this header |
| 7 | 3353 { |
| 1415 | 3354 u_header_T *uhap; |
| 3355 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3356 // When there is an alternate redo list free that branch completely, |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3357 // because we can never go there. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3358 if (uhp->uh_alt_next.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3359 u_freebranch(buf, uhp->uh_alt_next.ptr, uhpp); |
| 7 | 3360 |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3361 if (uhp->uh_alt_prev.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3362 uhp->uh_alt_prev.ptr->uh_alt_next.ptr = NULL; |
| 7 | 3363 |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3364 // Update the links in the list to remove the header. |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3365 if (uhp->uh_next.ptr == NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3366 buf->b_u_oldhead = uhp->uh_prev.ptr; |
| 7 | 3367 else |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3368 uhp->uh_next.ptr->uh_prev.ptr = uhp->uh_prev.ptr; |
| 7 | 3369 |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3370 if (uhp->uh_prev.ptr == NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3371 buf->b_u_newhead = uhp->uh_next.ptr; |
| 7 | 3372 else |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3373 for (uhap = uhp->uh_prev.ptr; uhap != NULL; |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3374 uhap = uhap->uh_alt_next.ptr) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3375 uhap->uh_next.ptr = uhp->uh_next.ptr; |
| 7 | 3376 |
| 753 | 3377 u_freeentries(buf, uhp, uhpp); |
| 3378 } | |
| 3379 | |
| 3380 /* | |
| 758 | 3381 * Free an alternate branch and any following alternate branches. |
| 753 | 3382 */ |
| 3383 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3384 u_freebranch( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3385 buf_T *buf, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3386 u_header_T *uhp, |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3387 u_header_T **uhpp) // if not NULL reset when freeing this header |
| 753 | 3388 { |
| 3389 u_header_T *tofree, *next; | |
| 3390 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3391 // If this is the top branch we may need to use u_freeheader() to update |
|
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3392 // all the pointers. |
| 1440 | 3393 if (uhp == buf->b_u_oldhead) |
| 3394 { | |
| 5448 | 3395 while (buf->b_u_oldhead != NULL) |
| 3396 u_freeheader(buf, buf->b_u_oldhead, uhpp); | |
| 1440 | 3397 return; |
| 3398 } | |
| 3399 | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3400 if (uhp->uh_alt_prev.ptr != NULL) |
|
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3401 uhp->uh_alt_prev.ptr->uh_alt_next.ptr = NULL; |
| 753 | 3402 |
| 3403 next = uhp; | |
| 3404 while (next != NULL) | |
| 3405 { | |
| 3406 tofree = next; | |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3407 if (tofree->uh_alt_next.ptr != NULL) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3408 u_freebranch(buf, tofree->uh_alt_next.ptr, uhpp); // recursive |
|
2242
bc4685345719
Don't use pointers to store numbers, use a union.
Bram Moolenaar <bram@vim.org>
parents:
2239
diff
changeset
|
3409 next = tofree->uh_prev.ptr; |
| 753 | 3410 u_freeentries(buf, tofree, uhpp); |
| 3411 } | |
| 3412 } | |
| 3413 | |
| 3414 /* | |
| 3415 * Free all the undo entries for one header and the header itself. | |
| 3416 * This means that "uhp" is invalid when returning. | |
| 3417 */ | |
| 3418 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3419 u_freeentries( |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3420 buf_T *buf, |
|
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3421 u_header_T *uhp, |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3422 u_header_T **uhpp) // if not NULL reset when freeing this header |
| 753 | 3423 { |
| 3424 u_entry_T *uep, *nuep; | |
| 3425 | |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3426 // Check for pointers to the header that become invalid now. |
| 753 | 3427 if (buf->b_u_curhead == uhp) |
| 3428 buf->b_u_curhead = NULL; | |
| 1415 | 3429 if (buf->b_u_newhead == uhp) |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3430 buf->b_u_newhead = NULL; // freeing the newest entry |
| 753 | 3431 if (uhpp != NULL && uhp == *uhpp) |
| 3432 *uhpp = NULL; | |
| 3433 | |
| 3434 for (uep = uhp->uh_entry; uep != NULL; uep = nuep) | |
| 3435 { | |
| 3436 nuep = uep->ue_next; | |
| 3437 u_freeentry(uep, uep->ue_size); | |
| 3438 } | |
| 3439 | |
| 1415 | 3440 #ifdef U_DEBUG |
| 3441 uhp->uh_magic = 0; | |
| 3442 #endif | |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
3443 vim_free((char_u *)uhp); |
| 168 | 3444 --buf->b_u_numhead; |
| 7 | 3445 } |
| 3446 | |
| 3447 /* | |
| 3448 * free entry 'uep' and 'n' lines in uep->ue_array[] | |
| 3449 */ | |
| 3450 static void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3451 u_freeentry(u_entry_T *uep, long n) |
| 7 | 3452 { |
| 414 | 3453 while (n > 0) |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3454 vim_free(uep->ue_array[--n].ul_line); |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
3455 vim_free((char_u *)uep->ue_array); |
| 1415 | 3456 #ifdef U_DEBUG |
| 3457 uep->ue_magic = 0; | |
| 3458 #endif | |
|
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
3459 vim_free((char_u *)uep); |
| 7 | 3460 } |
| 3461 | |
| 3462 /* | |
| 3463 * invalidate the undo buffer; called when storage has already been released | |
| 3464 */ | |
| 3465 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3466 u_clearall(buf_T *buf) |
| 7 | 3467 { |
| 3468 buf->b_u_newhead = buf->b_u_oldhead = buf->b_u_curhead = NULL; | |
| 3469 buf->b_u_synced = TRUE; | |
| 3470 buf->b_u_numhead = 0; | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3471 buf->b_u_line_ptr.ul_line = NULL; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3472 buf->b_u_line_ptr.ul_len = 0; |
| 7 | 3473 buf->b_u_line_lnum = 0; |
| 3474 } | |
| 3475 | |
| 3476 /* | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3477 * Save the line "lnum" for the "U" command. |
| 7 | 3478 */ |
|
17789
0f7ae8010787
patch 8.1.1891: functions used in one file are global
Bram Moolenaar <Bram@vim.org>
parents:
17630
diff
changeset
|
3479 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3480 u_saveline(linenr_T lnum) |
| 7 | 3481 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3482 if (lnum == curbuf->b_u_line_lnum) // line is already saved |
| 7 | 3483 return; |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3484 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) // should never happen |
| 7 | 3485 return; |
| 3486 u_clearline(); | |
| 3487 curbuf->b_u_line_lnum = lnum; | |
| 3488 if (curwin->w_cursor.lnum == lnum) | |
| 3489 curbuf->b_u_line_colnr = curwin->w_cursor.col; | |
| 3490 else | |
| 3491 curbuf->b_u_line_colnr = 0; | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3492 if (u_save_line(&curbuf->b_u_line_ptr, lnum) == FAIL) |
| 7 | 3493 do_outofmem_msg((long_u)0); |
| 3494 } | |
| 3495 | |
| 3496 /* | |
| 3497 * clear the line saved for the "U" command | |
| 3498 * (this is used externally for crossing a line while in insert mode) | |
| 3499 */ | |
| 3500 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3501 u_clearline(void) |
| 7 | 3502 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3503 if (curbuf->b_u_line_ptr.ul_line != NULL) |
| 7 | 3504 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3505 VIM_CLEAR(curbuf->b_u_line_ptr.ul_line); |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3506 curbuf->b_u_line_ptr.ul_len = 0; |
| 7 | 3507 curbuf->b_u_line_lnum = 0; |
| 3508 } | |
| 3509 } | |
| 3510 | |
| 3511 /* | |
| 3512 * Implementation of the "U" command. | |
| 3513 * Differentiation from vi: "U" can be undone with the next "U". | |
| 3514 * We also allow the cursor to be in another line. | |
|
2289
3331756e4232
Make synstack() work on the character just after the end of the line.
Bram Moolenaar <bram@vim.org>
parents:
2288
diff
changeset
|
3515 * Careful: may trigger autocommands that reload the buffer. |
| 7 | 3516 */ |
| 3517 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3518 u_undoline(void) |
| 7 | 3519 { |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3520 colnr_T t; |
|
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3521 undoline_T oldp; |
| 7 | 3522 |
| 3523 if (undo_off) | |
| 3524 return; | |
| 3525 | |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3526 if (curbuf->b_u_line_ptr.ul_line == NULL |
| 1534 | 3527 || curbuf->b_u_line_lnum > curbuf->b_ml.ml_line_count) |
| 7 | 3528 { |
| 3529 beep_flush(); | |
| 3530 return; | |
| 3531 } | |
| 1534 | 3532 |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3533 // first save the line for the 'u' command |
| 7 | 3534 if (u_savecommon(curbuf->b_u_line_lnum - 1, |
|
2394
a3aca345aafa
Add the 'undoreload' option to be able to undo a file reload.
Bram Moolenaar <bram@vim.org>
parents:
2378
diff
changeset
|
3535 curbuf->b_u_line_lnum + 1, (linenr_T)0, FALSE) == FAIL) |
| 7 | 3536 return; |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3537 if (u_save_line(&oldp, curbuf->b_u_line_lnum) == FAIL) |
| 7 | 3538 { |
| 3539 do_outofmem_msg((long_u)0); | |
| 3540 return; | |
| 3541 } | |
|
21996
808edde1e97d
patch 8.2.1547: various comment problems
Bram Moolenaar <Bram@vim.org>
parents:
20830
diff
changeset
|
3542 ml_replace_len(curbuf->b_u_line_lnum, curbuf->b_u_line_ptr.ul_line, |
|
808edde1e97d
patch 8.2.1547: various comment problems
Bram Moolenaar <Bram@vim.org>
parents:
20830
diff
changeset
|
3543 curbuf->b_u_line_ptr.ul_len, TRUE, FALSE); |
| 7 | 3544 changed_bytes(curbuf->b_u_line_lnum, 0); |
| 3545 curbuf->b_u_line_ptr = oldp; | |
| 3546 | |
| 3547 t = curbuf->b_u_line_colnr; | |
| 3548 if (curwin->w_cursor.lnum == curbuf->b_u_line_lnum) | |
| 3549 curbuf->b_u_line_colnr = curwin->w_cursor.col; | |
| 3550 curwin->w_cursor.col = t; | |
| 3551 curwin->w_cursor.lnum = curbuf->b_u_line_lnum; | |
| 1534 | 3552 check_cursor_col(); |
| 7 | 3553 } |
| 3554 | |
| 3555 /* | |
| 168 | 3556 * Free all allocated memory blocks for the buffer 'buf'. |
| 3557 */ | |
| 3558 void | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3559 u_blockfree(buf_T *buf) |
| 168 | 3560 { |
| 753 | 3561 while (buf->b_u_oldhead != NULL) |
| 758 | 3562 u_freeheader(buf, buf->b_u_oldhead, NULL); |
|
15361
58b125df3e9b
patch 8.1.0688: text properties are not restored by undo
Bram Moolenaar <Bram@vim.org>
parents:
14862
diff
changeset
|
3563 vim_free(buf->b_u_line_ptr.ul_line); |
| 7 | 3564 } |
| 3565 | |
| 3566 /* | |
| 3567 * Check if the 'modified' flag is set, or 'ff' has changed (only need to | |
| 3568 * check the first character, because it can only be "dos", "unix" or "mac"). | |
| 3569 * "nofile" and "scratch" type buffers are considered to always be unchanged. | |
|
13012
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3570 * Also considers a buffer changed when a terminal window contains a running |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3571 * job. |
| 7 | 3572 */ |
| 3573 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3574 bufIsChanged(buf_T *buf) |
| 7 | 3575 { |
|
11957
bc0fee081e1e
patch 8.0.0858: can exit while a terminal is still running a job
Christian Brabandt <cb@256bit.org>
parents:
11836
diff
changeset
|
3576 #ifdef FEAT_TERMINAL |
|
29038
ad99b7b9df13
patch 8.2.5041: cannot close a terminal popup with "NONE" job
Bram Moolenaar <Bram@vim.org>
parents:
29014
diff
changeset
|
3577 if (term_job_running_not_none(buf->b_term)) |
|
11957
bc0fee081e1e
patch 8.0.0858: can exit while a terminal is still running a job
Christian Brabandt <cb@256bit.org>
parents:
11836
diff
changeset
|
3578 return TRUE; |
| 7 | 3579 #endif |
|
13012
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3580 return bufIsChangedNotTerm(buf); |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3581 } |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3582 |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3583 /* |
|
16089
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3584 * Return TRUE if any buffer has changes. Also buffers that are not written. |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3585 */ |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3586 int |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3587 anyBufIsChanged(void) |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3588 { |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3589 buf_T *buf; |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3590 |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3591 FOR_ALL_BUFFERS(buf) |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3592 if (bufIsChanged(buf)) |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3593 return TRUE; |
|
16097
d45e42b45470
patch 8.1.1053: warning for missing return statement
Bram Moolenaar <Bram@vim.org>
parents:
16089
diff
changeset
|
3594 return FALSE; |
|
16089
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3595 } |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3596 |
|
4411c38f3d16
patch 8.1.1049: when user tries to exit with CTRL-C message is confusing
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
3597 /* |
|
13012
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3598 * Like bufIsChanged() but ignoring a terminal window. |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3599 */ |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3600 int |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3601 bufIsChangedNotTerm(buf_T *buf) |
|
8d5b451d7bab
patch 8.0.1382: get "no write since last change" message if terminal is open
Christian Brabandt <cb@256bit.org>
parents:
12827
diff
changeset
|
3602 { |
|
14147
de75c249723d
patch 8.1.0091: MS-Windows: Cannot interrupt gdb when program is running
Christian Brabandt <cb@256bit.org>
parents:
13610
diff
changeset
|
3603 // In a "prompt" buffer we do respect 'modified', so that we can control |
|
de75c249723d
patch 8.1.0091: MS-Windows: Cannot interrupt gdb when program is running
Christian Brabandt <cb@256bit.org>
parents:
13610
diff
changeset
|
3604 // closing the window by setting or resetting that option. |
|
de75c249723d
patch 8.1.0091: MS-Windows: Cannot interrupt gdb when program is running
Christian Brabandt <cb@256bit.org>
parents:
13610
diff
changeset
|
3605 return (!bt_dontwrite(buf) || bt_prompt(buf)) |
|
11957
bc0fee081e1e
patch 8.0.0858: can exit while a terminal is still running a job
Christian Brabandt <cb@256bit.org>
parents:
11836
diff
changeset
|
3606 && (buf->b_changed || file_ff_differs(buf, TRUE)); |
| 7 | 3607 } |
| 3608 | |
| 3609 int | |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3610 curbufIsChanged(void) |
| 7 | 3611 { |
|
11957
bc0fee081e1e
patch 8.0.0858: can exit while a terminal is still running a job
Christian Brabandt <cb@256bit.org>
parents:
11836
diff
changeset
|
3612 return bufIsChanged(curbuf); |
| 7 | 3613 } |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3614 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3615 #if defined(FEAT_EVAL) || defined(PROTO) |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3616 |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3617 /* |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3618 * For undotree(): Append the list of undo blocks at "first_uhp" to "list". |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3619 * Recursive. |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3620 */ |
|
18051
d1e77015f60b
patch 8.1.2021: some global functions can be local to the file
Bram Moolenaar <Bram@vim.org>
parents:
18025
diff
changeset
|
3621 static void |
|
7835
4d7ce6c03fda
commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7
Christian Brabandt <cb@256bit.org>
parents:
7805
diff
changeset
|
3622 u_eval_tree(u_header_T *first_uhp, list_T *list) |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3623 { |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3624 u_header_T *uhp = first_uhp; |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3625 dict_T *dict; |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3626 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3627 while (uhp != NULL) |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3628 { |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3629 dict = dict_alloc(); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3630 if (dict == NULL) |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3631 return; |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14237
diff
changeset
|
3632 dict_add_number(dict, "seq", uhp->uh_seq); |
|
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14237
diff
changeset
|
3633 dict_add_number(dict, "time", (long)uhp->uh_time); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3634 if (uhp == curbuf->b_u_newhead) |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14237
diff
changeset
|
3635 dict_add_number(dict, "newhead", 1); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3636 if (uhp == curbuf->b_u_curhead) |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14237
diff
changeset
|
3637 dict_add_number(dict, "curhead", 1); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3638 if (uhp->uh_save_nr > 0) |
|
14301
3c80092eb211
patch 8.1.0166: using dict_add_nr_str() is clumsy
Christian Brabandt <cb@256bit.org>
parents:
14237
diff
changeset
|
3639 dict_add_number(dict, "save", uhp->uh_save_nr); |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3640 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3641 if (uhp->uh_alt_next.ptr != NULL) |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3642 { |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3643 list_T *alt_list = list_alloc(); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3644 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3645 if (alt_list != NULL) |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3646 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3647 // Recursive call to add alternate undo tree. |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3648 u_eval_tree(uhp->uh_alt_next.ptr, alt_list); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3649 dict_add_list(dict, "alt", alt_list); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3650 } |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3651 } |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3652 |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3653 list_append_dict(list, dict); |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3654 uhp = uhp->uh_prev.ptr; |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3655 } |
|
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3656 } |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3657 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3658 /* |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3659 * "undofile(name)" function |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3660 */ |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3661 void |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3662 f_undofile(typval_T *argvars UNUSED, typval_T *rettv) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3663 { |
|
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25362
diff
changeset
|
3664 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
|
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25362
diff
changeset
|
3665 return; |
|
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25362
diff
changeset
|
3666 |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3667 rettv->v_type = VAR_STRING; |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3668 #ifdef FEAT_PERSISTENT_UNDO |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3669 { |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3670 char_u *fname = tv_get_string(&argvars[0]); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3671 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3672 if (*fname == NUL) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3673 { |
|
18816
15539899a112
patch 8.1.2396: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
3674 // If there is no file name there will be no undo file. |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3675 rettv->vval.v_string = NULL; |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3676 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3677 else |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3678 { |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3679 char_u *ffname = FullName_save(fname, TRUE); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3680 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3681 if (ffname != NULL) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3682 rettv->vval.v_string = u_get_undo_file_name(ffname, FALSE); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3683 vim_free(ffname); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3684 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3685 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3686 #else |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3687 rettv->vval.v_string = NULL; |
|
2280
941ff1cd317a
Add file save counter to undo information. Add undotree() function.
Bram Moolenaar <bram@vim.org>
parents:
2271
diff
changeset
|
3688 #endif |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3689 } |
|
25362
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3690 #ifdef FEAT_PERSISTENT_UNDO |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3691 /* |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3692 * Reset undofile option and delete the undofile |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3693 */ |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3694 void |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3695 u_undofile_reset_and_delete(buf_T *buf) |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3696 { |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3697 char_u *file_name; |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3698 |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3699 if (!buf->b_p_udf) |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3700 return; |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3701 |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3702 file_name = u_get_undo_file_name(buf->b_ffname, TRUE); |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3703 if (file_name != NULL) |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3704 { |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3705 mch_remove(file_name); |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3706 vim_free(file_name); |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3707 } |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3708 |
|
28457
4dcccb2673fe
patch 8.2.4753: error from setting an option is silently ignored
Bram Moolenaar <Bram@vim.org>
parents:
27706
diff
changeset
|
3709 set_option_value_give_err((char_u *)"undofile", 0L, NULL, OPT_LOCAL); |
|
25362
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3710 } |
|
68a7e6d70a5e
patch 8.2.3218: when using xchaha20 crypt undo file is not removed
Bram Moolenaar <Bram@vim.org>
parents:
25320
diff
changeset
|
3711 #endif |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3712 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3713 /* |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3714 * "undotree()" function |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3715 */ |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3716 void |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3717 f_undotree(typval_T *argvars UNUSED, typval_T *rettv) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3718 { |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3719 if (rettv_dict_alloc(rettv) == OK) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3720 { |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3721 dict_T *dict = rettv->vval.v_dict; |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3722 list_T *list; |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3723 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3724 dict_add_number(dict, "synced", (long)curbuf->b_u_synced); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3725 dict_add_number(dict, "seq_last", curbuf->b_u_seq_last); |
|
27426
41e0dcf38521
patch 8.2.4241: some type casts are redundant
Bram Moolenaar <Bram@vim.org>
parents:
27378
diff
changeset
|
3726 dict_add_number(dict, "save_last", curbuf->b_u_save_nr_last); |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3727 dict_add_number(dict, "seq_cur", curbuf->b_u_seq_cur); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3728 dict_add_number(dict, "time_cur", (long)curbuf->b_u_time_cur); |
|
27426
41e0dcf38521
patch 8.2.4241: some type casts are redundant
Bram Moolenaar <Bram@vim.org>
parents:
27378
diff
changeset
|
3729 dict_add_number(dict, "save_cur", curbuf->b_u_save_nr_cur); |
|
17970
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3730 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3731 list = list_alloc(); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3732 if (list != NULL) |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3733 { |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3734 u_eval_tree(curbuf->b_u_oldhead, list); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3735 dict_add_list(dict, "entries", list); |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3736 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3737 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3738 } |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3739 |
|
684a15da9929
patch 8.1.1981: the evalfunc.c file is too big
Bram Moolenaar <Bram@vim.org>
parents:
17789
diff
changeset
|
3740 #endif |