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