Mercurial > vim
annotate src/undo.c @ 2235:4ba83ae8d505 vim73
Do not write an undo file if there is nothing to undo.
author | Bram Moolenaar <bram@vim.org> |
---|---|
date | Sun, 30 May 2010 17:17:42 +0200 |
parents | 3b241fd8d7c0 |
children | dc2e5ec0500d |
rev | line source |
---|---|
7 | 1 /* vi:set ts=8 sts=4 sw=4: |
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 | |
2217
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
84 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64) |
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
85 # include "vimio.h" /* for vim_read(), must be before vim.h */ |
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
86 #endif |
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
87 |
7 | 88 #include "vim.h" |
89 | |
758 | 90 static void u_unch_branch __ARGS((u_header_T *uhp)); |
7 | 91 static u_entry_T *u_get_headentry __ARGS((void)); |
92 static void u_getbot __ARGS((void)); | |
93 static int u_savecommon __ARGS((linenr_T, linenr_T, linenr_T)); | |
94 static void u_doit __ARGS((int count)); | |
777 | 95 static void u_undoredo __ARGS((int undo)); |
798 | 96 static void u_undo_end __ARGS((int did_undo, int absolute)); |
772 | 97 static void u_add_time __ARGS((char_u *buf, size_t buflen, time_t tt)); |
758 | 98 static void u_freeheader __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp)); |
753 | 99 static void u_freebranch __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp)); |
100 static void u_freeentries __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp)); | |
7 | 101 static void u_freeentry __ARGS((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
|
102 #ifdef FEAT_PERSISTENT_UNDO |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
103 static char_u *u_get_undo_file_name __ARGS((char_u *, int reading)); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
104 static void corruption_error __ARGS((char *msg, char_u *file_name)); |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
105 static void u_free_uhp __ARGS((u_header_T *uhp)); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
106 static int serialize_uep __ARGS((u_entry_T *uep, FILE *fp)); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
107 static u_entry_T *unserialize_uep __ARGS((FILE *fp, int *error, char_u *file_name)); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
108 static void serialize_pos __ARGS((pos_T pos, FILE *fp)); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
109 static void unserialize_pos __ARGS((pos_T *pos, FILE *fp)); |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
110 static void serialize_visualinfo __ARGS((visualinfo_T *info, FILE *fp)); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
111 static void unserialize_visualinfo __ARGS((visualinfo_T *info, FILE *fp)); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
112 static void put_header_ptr __ARGS((FILE *fp, u_header_T *uhp)); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
113 #endif |
7 | 114 |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
115 #define U_ALLOC_LINE(size) lalloc((long_u)(size), FALSE) |
7 | 116 static char_u *u_save_line __ARGS((linenr_T)); |
117 | |
118 static long u_newcount, u_oldcount; | |
119 | |
120 /* | |
121 * When 'u' flag included in 'cpoptions', we behave like vi. Need to remember | |
122 * the action that "u" should do. | |
123 */ | |
124 static int undo_undoes = FALSE; | |
125 | |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
126 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
|
127 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
128 #if defined(U_DEBUG) || defined(PROTO) |
1415 | 129 /* |
130 * Check the undo structures for being valid. Print a warning when something | |
131 * looks wrong. | |
132 */ | |
133 static int seen_b_u_curhead; | |
134 static int seen_b_u_newhead; | |
135 static int header_count; | |
136 | |
137 static void | |
138 u_check_tree(u_header_T *uhp, | |
139 u_header_T *exp_uh_next, | |
140 u_header_T *exp_uh_alt_prev) | |
141 { | |
142 u_entry_T *uep; | |
143 | |
144 if (uhp == NULL) | |
145 return; | |
146 ++header_count; | |
147 if (uhp == curbuf->b_u_curhead && ++seen_b_u_curhead > 1) | |
148 { | |
149 EMSG("b_u_curhead found twice (looping?)"); | |
150 return; | |
151 } | |
152 if (uhp == curbuf->b_u_newhead && ++seen_b_u_newhead > 1) | |
153 { | |
154 EMSG("b_u_newhead found twice (looping?)"); | |
155 return; | |
156 } | |
157 | |
158 if (uhp->uh_magic != UH_MAGIC) | |
159 EMSG("uh_magic wrong (may be using freed memory)"); | |
160 else | |
161 { | |
162 /* Check pointers back are correct. */ | |
163 if (uhp->uh_next != exp_uh_next) | |
164 { | |
165 EMSG("uh_next wrong"); | |
166 smsg((char_u *)"expected: 0x%x, actual: 0x%x", | |
167 exp_uh_next, uhp->uh_next); | |
168 } | |
169 if (uhp->uh_alt_prev != exp_uh_alt_prev) | |
170 { | |
171 EMSG("uh_alt_prev wrong"); | |
172 smsg((char_u *)"expected: 0x%x, actual: 0x%x", | |
173 exp_uh_alt_prev, uhp->uh_alt_prev); | |
174 } | |
175 | |
176 /* Check the undo tree at this header. */ | |
177 for (uep = uhp->uh_entry; uep != NULL; uep = uep->ue_next) | |
178 { | |
179 if (uep->ue_magic != UE_MAGIC) | |
180 { | |
181 EMSG("ue_magic wrong (may be using freed memory)"); | |
182 break; | |
183 } | |
184 } | |
185 | |
186 /* Check the next alt tree. */ | |
187 u_check_tree(uhp->uh_alt_next, uhp->uh_next, uhp); | |
188 | |
189 /* Check the next header in this branch. */ | |
190 u_check_tree(uhp->uh_prev, uhp, NULL); | |
191 } | |
192 } | |
193 | |
194 void | |
195 u_check(int newhead_may_be_NULL) | |
196 { | |
197 seen_b_u_newhead = 0; | |
198 seen_b_u_curhead = 0; | |
199 header_count = 0; | |
200 | |
201 u_check_tree(curbuf->b_u_oldhead, NULL, NULL); | |
202 | |
203 if (seen_b_u_newhead == 0 && curbuf->b_u_oldhead != NULL | |
204 && !(newhead_may_be_NULL && curbuf->b_u_newhead == NULL)) | |
205 EMSGN("b_u_newhead invalid: 0x%x", curbuf->b_u_newhead); | |
206 if (curbuf->b_u_curhead != NULL && seen_b_u_curhead == 0) | |
207 EMSGN("b_u_curhead invalid: 0x%x", curbuf->b_u_curhead); | |
208 if (header_count != curbuf->b_u_numhead) | |
209 { | |
210 EMSG("b_u_numhead invalid"); | |
211 smsg((char_u *)"expected: %ld, actual: %ld", | |
212 (long)header_count, (long)curbuf->b_u_numhead); | |
213 } | |
214 } | |
215 #endif | |
216 | |
7 | 217 /* |
344 | 218 * Save the current line for both the "u" and "U" command. |
219 * Returns OK or FAIL. | |
7 | 220 */ |
221 int | |
222 u_save_cursor() | |
223 { | |
224 return (u_save((linenr_T)(curwin->w_cursor.lnum - 1), | |
225 (linenr_T)(curwin->w_cursor.lnum + 1))); | |
226 } | |
227 | |
228 /* | |
229 * Save the lines between "top" and "bot" for both the "u" and "U" command. | |
230 * "top" may be 0 and bot may be curbuf->b_ml.ml_line_count + 1. | |
231 * Returns FAIL when lines could not be saved, OK otherwise. | |
232 */ | |
233 int | |
234 u_save(top, bot) | |
235 linenr_T top, bot; | |
236 { | |
237 if (undo_off) | |
238 return OK; | |
239 | |
240 if (top > curbuf->b_ml.ml_line_count || | |
241 top >= bot || bot > curbuf->b_ml.ml_line_count + 1) | |
242 return FALSE; /* rely on caller to do error messages */ | |
243 | |
244 if (top + 2 == bot) | |
245 u_saveline((linenr_T)(top + 1)); | |
246 | |
247 return (u_savecommon(top, bot, (linenr_T)0)); | |
248 } | |
249 | |
250 /* | |
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
1534
diff
changeset
|
251 * Save the line "lnum" (used by ":s" and "~" command). |
7 | 252 * The line is replaced, so the new bottom line is lnum + 1. |
253 */ | |
254 int | |
255 u_savesub(lnum) | |
256 linenr_T lnum; | |
257 { | |
258 if (undo_off) | |
259 return OK; | |
260 | |
261 return (u_savecommon(lnum - 1, lnum + 1, lnum + 1)); | |
262 } | |
263 | |
264 /* | |
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
1534
diff
changeset
|
265 * A new line is inserted before line "lnum" (used by :s command). |
7 | 266 * The line is inserted, so the new bottom line is lnum + 1. |
267 */ | |
268 int | |
269 u_inssub(lnum) | |
270 linenr_T lnum; | |
271 { | |
272 if (undo_off) | |
273 return OK; | |
274 | |
275 return (u_savecommon(lnum - 1, lnum, lnum + 1)); | |
276 } | |
277 | |
278 /* | |
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
1534
diff
changeset
|
279 * Save the lines "lnum" - "lnum" + nlines (used by delete command). |
7 | 280 * The lines are deleted, so the new bottom line is lnum, unless the buffer |
281 * becomes empty. | |
282 */ | |
283 int | |
284 u_savedel(lnum, nlines) | |
285 linenr_T lnum; | |
286 long nlines; | |
287 { | |
288 if (undo_off) | |
289 return OK; | |
290 | |
291 return (u_savecommon(lnum - 1, lnum + nlines, | |
292 nlines == curbuf->b_ml.ml_line_count ? 2 : lnum)); | |
293 } | |
294 | |
632 | 295 /* |
296 * Return TRUE when undo is allowed. Otherwise give an error message and | |
297 * return FALSE. | |
298 */ | |
912 | 299 int |
632 | 300 undo_allowed() |
301 { | |
302 /* Don't allow changes when 'modifiable' is off. */ | |
303 if (!curbuf->b_p_ma) | |
304 { | |
305 EMSG(_(e_modifiable)); | |
306 return FALSE; | |
307 } | |
308 | |
309 #ifdef HAVE_SANDBOX | |
310 /* In the sandbox it's not allowed to change the text. */ | |
311 if (sandbox != 0) | |
312 { | |
313 EMSG(_(e_sandbox)); | |
314 return FALSE; | |
315 } | |
316 #endif | |
317 | |
318 /* Don't allow changes in the buffer while editing the cmdline. The | |
319 * caller of getcmdline() may get confused. */ | |
634 | 320 if (textlock != 0) |
632 | 321 { |
322 EMSG(_(e_secure)); | |
323 return FALSE; | |
324 } | |
325 | |
326 return TRUE; | |
327 } | |
328 | |
7 | 329 static int |
330 u_savecommon(top, bot, newbot) | |
331 linenr_T top, bot; | |
332 linenr_T newbot; | |
333 { | |
753 | 334 linenr_T lnum; |
335 long i; | |
336 u_header_T *uhp; | |
337 u_header_T *old_curhead; | |
338 u_entry_T *uep; | |
339 u_entry_T *prev_uep; | |
340 long size; | |
7 | 341 |
632 | 342 /* When making changes is not allowed return FAIL. It's a crude way to |
343 * make all change commands fail. */ | |
344 if (!undo_allowed()) | |
7 | 345 return FAIL; |
346 | |
1415 | 347 #ifdef U_DEBUG |
348 u_check(FALSE); | |
349 #endif | |
7 | 350 #ifdef FEAT_NETBEANS_INTG |
351 /* | |
352 * Netbeans defines areas that cannot be modified. Bail out here when | |
353 * trying to change text in a guarded area. | |
354 */ | |
2210 | 355 if (netbeans_active()) |
7 | 356 { |
33 | 357 if (netbeans_is_guarded(top, bot)) |
358 { | |
359 EMSG(_(e_guarded)); | |
360 return FAIL; | |
361 } | |
362 if (curbuf->b_p_ro) | |
363 { | |
364 EMSG(_(e_nbreadonly)); | |
365 return FAIL; | |
366 } | |
7 | 367 } |
368 #endif | |
369 | |
370 #ifdef FEAT_AUTOCMD | |
371 /* | |
372 * Saving text for undo means we are going to make a change. Give a | |
373 * warning for a read-only file before making the change, so that the | |
374 * FileChangedRO event can replace the buffer with a read-write version | |
375 * (e.g., obtained from a source control system). | |
376 */ | |
377 change_warning(0); | |
378 #endif | |
379 | |
380 size = bot - top - 1; | |
381 | |
382 /* | |
383 * if curbuf->b_u_synced == TRUE make a new header | |
384 */ | |
385 if (curbuf->b_u_synced) | |
386 { | |
387 #ifdef FEAT_JUMPLIST | |
388 /* Need to create new entry in b_changelist. */ | |
389 curbuf->b_new_change = TRUE; | |
390 #endif | |
391 | |
753 | 392 if (p_ul >= 0) |
393 { | |
394 /* | |
395 * Make a new header entry. Do this first so that we don't mess | |
396 * up the undo info when out of memory. | |
397 */ | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
398 uhp = (u_header_T *)U_ALLOC_LINE(sizeof(u_header_T)); |
753 | 399 if (uhp == NULL) |
400 goto nomem; | |
1415 | 401 #ifdef U_DEBUG |
402 uhp->uh_magic = UH_MAGIC; | |
403 #endif | |
753 | 404 } |
766 | 405 else |
406 uhp = NULL; | |
753 | 407 |
7 | 408 /* |
758 | 409 * If we undid more than we redid, move the entry lists before and |
410 * including curbuf->b_u_curhead to an alternate branch. | |
7 | 411 */ |
753 | 412 old_curhead = curbuf->b_u_curhead; |
413 if (old_curhead != NULL) | |
414 { | |
415 curbuf->b_u_newhead = old_curhead->uh_next; | |
416 curbuf->b_u_curhead = NULL; | |
417 } | |
7 | 418 |
419 /* | |
420 * free headers to keep the size right | |
421 */ | |
422 while (curbuf->b_u_numhead > p_ul && curbuf->b_u_oldhead != NULL) | |
753 | 423 { |
758 | 424 u_header_T *uhfree = curbuf->b_u_oldhead; |
753 | 425 |
1415 | 426 if (uhfree == old_curhead) |
427 /* Can't reconnect the branch, delete all of it. */ | |
428 u_freebranch(curbuf, uhfree, &old_curhead); | |
429 else if (uhfree->uh_alt_next == NULL) | |
430 /* There is no branch, only free one header. */ | |
758 | 431 u_freeheader(curbuf, uhfree, &old_curhead); |
753 | 432 else |
433 { | |
434 /* Free the oldest alternate branch as a whole. */ | |
758 | 435 while (uhfree->uh_alt_next != NULL) |
436 uhfree = uhfree->uh_alt_next; | |
437 u_freebranch(curbuf, uhfree, &old_curhead); | |
753 | 438 } |
1415 | 439 #ifdef U_DEBUG |
440 u_check(TRUE); | |
441 #endif | |
753 | 442 } |
7 | 443 |
766 | 444 if (uhp == NULL) /* no undo at all */ |
7 | 445 { |
753 | 446 if (old_curhead != NULL) |
447 u_freebranch(curbuf, old_curhead, NULL); | |
7 | 448 curbuf->b_u_synced = FALSE; |
449 return OK; | |
450 } | |
451 | |
452 uhp->uh_prev = NULL; | |
453 uhp->uh_next = curbuf->b_u_newhead; | |
753 | 454 uhp->uh_alt_next = old_curhead; |
455 if (old_curhead != NULL) | |
456 { | |
1056 | 457 uhp->uh_alt_prev = old_curhead->uh_alt_prev; |
458 if (uhp->uh_alt_prev != NULL) | |
459 uhp->uh_alt_prev->uh_alt_next = uhp; | |
753 | 460 old_curhead->uh_alt_prev = uhp; |
461 if (curbuf->b_u_oldhead == old_curhead) | |
462 curbuf->b_u_oldhead = uhp; | |
463 } | |
1056 | 464 else |
465 uhp->uh_alt_prev = NULL; | |
758 | 466 if (curbuf->b_u_newhead != NULL) |
467 curbuf->b_u_newhead->uh_prev = uhp; | |
468 | |
777 | 469 uhp->uh_seq = ++curbuf->b_u_seq_last; |
470 curbuf->b_u_seq_cur = uhp->uh_seq; | |
758 | 471 uhp->uh_time = time(NULL); |
472 curbuf->b_u_seq_time = uhp->uh_time + 1; | |
473 | |
753 | 474 uhp->uh_walk = 0; |
7 | 475 uhp->uh_entry = NULL; |
476 uhp->uh_getbot_entry = NULL; | |
477 uhp->uh_cursor = curwin->w_cursor; /* save cursor pos. for undo */ | |
478 #ifdef FEAT_VIRTUALEDIT | |
479 if (virtual_active() && curwin->w_cursor.coladd > 0) | |
480 uhp->uh_cursor_vcol = getviscol(); | |
481 else | |
482 uhp->uh_cursor_vcol = -1; | |
483 #endif | |
484 | |
485 /* save changed and buffer empty flag for undo */ | |
486 uhp->uh_flags = (curbuf->b_changed ? UH_CHANGED : 0) + | |
487 ((curbuf->b_ml.ml_flags & ML_EMPTY) ? UH_EMPTYBUF : 0); | |
488 | |
692 | 489 /* save named marks and Visual marks for undo */ |
7 | 490 mch_memmove(uhp->uh_namedm, curbuf->b_namedm, sizeof(pos_T) * NMARKS); |
692 | 491 #ifdef FEAT_VISUAL |
492 uhp->uh_visual = curbuf->b_visual; | |
493 #endif | |
494 | |
7 | 495 curbuf->b_u_newhead = uhp; |
496 if (curbuf->b_u_oldhead == NULL) | |
497 curbuf->b_u_oldhead = uhp; | |
498 ++curbuf->b_u_numhead; | |
499 } | |
500 else | |
501 { | |
502 if (p_ul < 0) /* no undo at all */ | |
503 return OK; | |
504 | |
505 /* | |
506 * When saving a single line, and it has been saved just before, it | |
507 * doesn't make sense saving it again. Saves a lot of memory when | |
508 * making lots of changes inside the same line. | |
509 * This is only possible if the previous change didn't increase or | |
510 * decrease the number of lines. | |
511 * Check the ten last changes. More doesn't make sense and takes too | |
512 * long. | |
513 */ | |
514 if (size == 1) | |
515 { | |
516 uep = u_get_headentry(); | |
517 prev_uep = NULL; | |
518 for (i = 0; i < 10; ++i) | |
519 { | |
520 if (uep == NULL) | |
521 break; | |
522 | |
523 /* If lines have been inserted/deleted we give up. | |
524 * Also when the line was included in a multi-line save. */ | |
525 if ((curbuf->b_u_newhead->uh_getbot_entry != uep | |
526 ? (uep->ue_top + uep->ue_size + 1 | |
527 != (uep->ue_bot == 0 | |
528 ? curbuf->b_ml.ml_line_count + 1 | |
529 : uep->ue_bot)) | |
530 : uep->ue_lcount != curbuf->b_ml.ml_line_count) | |
531 || (uep->ue_size > 1 | |
532 && top >= uep->ue_top | |
533 && top + 2 <= uep->ue_top + uep->ue_size + 1)) | |
534 break; | |
535 | |
536 /* If it's the same line we can skip saving it again. */ | |
537 if (uep->ue_size == 1 && uep->ue_top == top) | |
538 { | |
539 if (i > 0) | |
540 { | |
541 /* It's not the last entry: get ue_bot for the last | |
542 * entry now. Following deleted/inserted lines go to | |
543 * the re-used entry. */ | |
544 u_getbot(); | |
545 curbuf->b_u_synced = FALSE; | |
546 | |
547 /* Move the found entry to become the last entry. The | |
548 * order of undo/redo doesn't matter for the entries | |
549 * we move it over, since they don't change the line | |
550 * count and don't include this line. It does matter | |
551 * for the found entry if the line count is changed by | |
552 * the executed command. */ | |
553 prev_uep->ue_next = uep->ue_next; | |
554 uep->ue_next = curbuf->b_u_newhead->uh_entry; | |
555 curbuf->b_u_newhead->uh_entry = uep; | |
556 } | |
557 | |
558 /* The executed command may change the line count. */ | |
559 if (newbot != 0) | |
560 uep->ue_bot = newbot; | |
561 else if (bot > curbuf->b_ml.ml_line_count) | |
562 uep->ue_bot = 0; | |
563 else | |
564 { | |
565 uep->ue_lcount = curbuf->b_ml.ml_line_count; | |
566 curbuf->b_u_newhead->uh_getbot_entry = uep; | |
567 } | |
568 return OK; | |
569 } | |
570 prev_uep = uep; | |
571 uep = uep->ue_next; | |
572 } | |
573 } | |
574 | |
575 /* find line number for ue_bot for previous u_save() */ | |
576 u_getbot(); | |
577 } | |
578 | |
579 #if !defined(UNIX) && !defined(DJGPP) && !defined(WIN32) && !defined(__EMX__) | |
580 /* | |
581 * With Amiga and MSDOS 16 bit we can't handle big undo's, because | |
582 * then u_alloc_line would have to allocate a block larger than 32K | |
583 */ | |
584 if (size >= 8000) | |
585 goto nomem; | |
586 #endif | |
587 | |
588 /* | |
589 * add lines in front of entry list | |
590 */ | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
591 uep = (u_entry_T *)U_ALLOC_LINE(sizeof(u_entry_T)); |
7 | 592 if (uep == NULL) |
593 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
|
594 vim_memset(uep, 0, sizeof(u_entry_T)); |
1415 | 595 #ifdef U_DEBUG |
596 uep->ue_magic = UE_MAGIC; | |
597 #endif | |
7 | 598 |
599 uep->ue_size = size; | |
600 uep->ue_top = top; | |
601 if (newbot != 0) | |
602 uep->ue_bot = newbot; | |
603 /* | |
604 * Use 0 for ue_bot if bot is below last line. | |
605 * Otherwise we have to compute ue_bot later. | |
606 */ | |
607 else if (bot > curbuf->b_ml.ml_line_count) | |
608 uep->ue_bot = 0; | |
609 else | |
610 { | |
611 uep->ue_lcount = curbuf->b_ml.ml_line_count; | |
612 curbuf->b_u_newhead->uh_getbot_entry = uep; | |
613 } | |
614 | |
168 | 615 if (size > 0) |
7 | 616 { |
168 | 617 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
|
618 sizeof(char_u *) * size)) == NULL) |
7 | 619 { |
620 u_freeentry(uep, 0L); | |
621 goto nomem; | |
622 } | |
623 for (i = 0, lnum = top + 1; i < size; ++i) | |
624 { | |
481 | 625 fast_breakcheck(); |
626 if (got_int) | |
627 { | |
628 u_freeentry(uep, i); | |
629 return FAIL; | |
630 } | |
7 | 631 if ((uep->ue_array[i] = u_save_line(lnum++)) == NULL) |
632 { | |
633 u_freeentry(uep, i); | |
634 goto nomem; | |
635 } | |
636 } | |
637 } | |
359 | 638 else |
639 uep->ue_array = NULL; | |
7 | 640 uep->ue_next = curbuf->b_u_newhead->uh_entry; |
641 curbuf->b_u_newhead->uh_entry = uep; | |
642 curbuf->b_u_synced = FALSE; | |
643 undo_undoes = FALSE; | |
644 | |
1415 | 645 #ifdef U_DEBUG |
646 u_check(FALSE); | |
647 #endif | |
7 | 648 return OK; |
649 | |
650 nomem: | |
651 msg_silent = 0; /* must display the prompt */ | |
652 if (ask_yesno((char_u *)_("No undo possible; continue anyway"), TRUE) | |
653 == 'y') | |
654 { | |
655 undo_off = TRUE; /* will be reset when character typed */ | |
656 return OK; | |
657 } | |
658 do_outofmem_msg((long_u)0); | |
659 return FAIL; | |
660 } | |
661 | |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
662 #ifdef FEAT_PERSISTENT_UNDO |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
663 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
664 # 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
|
665 # 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
|
666 # 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
|
667 # 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
|
668 # 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
|
669 # define UF_ENTRY_END_MAGIC 0x3581 /* magic after last entry */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
670 # define UF_VERSION 1 /* 2-byte undofile version number */ |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
671 |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
672 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
|
673 |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
674 /* |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
675 * 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
|
676 */ |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
677 void |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
678 u_compute_hash(hash) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
679 char_u *hash; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
680 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
681 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
|
682 linenr_T lnum; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
683 char_u *p; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
684 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
685 sha256_start(&ctx); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
686 for (lnum = 1; lnum < curbuf->b_ml.ml_line_count; ++lnum) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
687 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
688 p = ml_get(lnum); |
2217
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
689 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
|
690 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
691 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
|
692 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
693 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
694 /* |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
695 * 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
|
696 * 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
|
697 * 'undodir'. |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
698 * 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
|
699 * 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
|
700 */ |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
701 static char_u * |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
702 u_get_undo_file_name(buf_ffname, reading) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
703 char_u *buf_ffname; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
704 int reading; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
705 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
706 char_u *dirp; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
707 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
|
708 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
|
709 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
|
710 int dir_len; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
711 char_u *p; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
712 struct stat st; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
713 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
|
714 #ifdef HAVE_READLINK |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
715 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
|
716 #endif |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
717 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
718 if (ffname == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
719 return NULL; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
720 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
721 #ifdef HAVE_READLINK |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
722 /* 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
|
723 * 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
|
724 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
|
725 ffname = fname_buf; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
726 #endif |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
727 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
728 /* 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
|
729 * 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
|
730 dirp = p_udir; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
731 while (*dirp != NUL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
732 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
733 dir_len = copy_option_part(&dirp, dir_name, IOSIZE, ","); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
734 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
|
735 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
736 /* 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
|
737 * "dir/name" -> "dir/.name.un~" */ |
2217
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
738 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
|
739 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
|
740 break; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
741 p = gettail(undo_file_name); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
742 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
|
743 *p = '.'; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
744 STRCAT(p, ".un~"); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
745 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
746 else |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
747 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
748 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
|
749 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
|
750 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
751 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
|
752 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
753 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
|
754 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
|
755 return NULL; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
756 for (p = munged_name; *p != NUL; mb_ptr_adv(p)) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
757 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
|
758 *p = '%'; |
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 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
|
761 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
762 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
763 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
764 /* 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
|
765 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
|
766 || 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
|
767 break; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
768 vim_free(undo_file_name); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
769 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
|
770 } |
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 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
|
773 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
|
774 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
775 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
776 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
777 corruption_error(msg, file_name) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
778 char *msg; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
779 char_u *file_name; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
780 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
781 EMSG3(_("E825: Corrupted undo file (%s): %s"), msg, file_name); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
782 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
783 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
784 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
785 u_free_uhp(uhp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
786 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
|
787 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
788 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
|
789 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
|
790 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
791 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
|
792 while (uep != NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
793 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
794 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
|
795 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
|
796 uep = nuep; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
797 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
798 vim_free(uhp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
799 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
800 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
801 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
802 * Serialize "uep" to "fp". |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
803 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
804 static int |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
805 serialize_uep(uep, fp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
806 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
|
807 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
808 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
809 int i; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
810 size_t len; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
811 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
812 put_bytes(fp, (long_u)uep->ue_top, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
813 put_bytes(fp, (long_u)uep->ue_bot, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
814 put_bytes(fp, (long_u)uep->ue_lcount, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
815 put_bytes(fp, (long_u)uep->ue_size, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
816 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
|
817 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
818 len = STRLEN(uep->ue_array[i]); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
819 if (put_bytes(fp, (long_u)len, 4) == FAIL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
820 return FAIL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
821 if (len > 0 && fwrite(uep->ue_array[i], len, (size_t)1, fp) != 1) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
822 return FAIL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
823 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
824 return OK; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
825 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
826 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
827 static u_entry_T * |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
828 unserialize_uep(fp, error, file_name) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
829 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
830 int *error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
831 char_u *file_name; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
832 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
833 int i; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
834 int j; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
835 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
|
836 char_u **array; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
837 char_u *line; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
838 int line_len; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
839 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
840 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
|
841 if (uep == NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
842 return NULL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
843 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
|
844 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
845 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
|
846 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
847 uep->ue_top = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
848 uep->ue_bot = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
849 uep->ue_lcount = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
850 uep->ue_size = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
851 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
|
852 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
853 array = (char_u **)U_ALLOC_LINE(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
|
854 if (array == NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
855 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
856 *error = TRUE; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
857 return uep; |
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_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
|
860 } |
2232
2e6906bbc5f4
A few more fixes for undo file. Split test in two parts so that it doesn't
Bram Moolenaar <bram@vim.org>
parents:
2231
diff
changeset
|
861 else |
2e6906bbc5f4
A few more fixes for undo file. Split test in two parts so that it doesn't
Bram Moolenaar <bram@vim.org>
parents:
2231
diff
changeset
|
862 array = NULL; |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
863 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
|
864 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
865 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
|
866 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
867 line_len = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
868 if (line_len >= 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
869 line = (char_u *)U_ALLOC_LINE(line_len + 1); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
870 else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
871 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
872 line = NULL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
873 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
|
874 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
875 if (line == NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
876 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
877 *error = TRUE; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
878 return uep; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
879 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
880 for (j = 0; j < line_len; j++) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
881 line[j] = getc(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
882 line[j] = NUL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
883 array[i] = line; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
884 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
885 return uep; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
886 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
887 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
888 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
889 * Serialize "pos" to "fp". |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
890 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
891 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
892 serialize_pos(pos, fp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
893 pos_T pos; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
894 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
895 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
896 put_bytes(fp, (long_u)pos.lnum, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
897 put_bytes(fp, (long_u)pos.col, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
898 #ifdef FEAT_VIRTUALEDIT |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
899 put_bytes(fp, (long_u)pos.coladd, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
900 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
901 put_bytes(fp, (long_u)0, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
902 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
903 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
904 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
905 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
906 * Unserialize the pos_T at the current position in fp. |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
907 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
908 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
909 unserialize_pos(pos, fp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
910 pos_T *pos; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
911 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
912 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
913 pos->lnum = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
914 pos->col = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
915 #ifdef FEAT_VIRTUALEDIT |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
916 pos->coladd = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
917 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
918 (void)get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
919 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
920 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
921 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
922 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
923 * Serialize "info" to "fp". |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
924 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
925 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
926 serialize_visualinfo(info, fp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
927 visualinfo_T *info; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
928 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
929 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
930 serialize_pos(info->vi_start, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
931 serialize_pos(info->vi_end, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
932 put_bytes(fp, (long_u)info->vi_mode, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
933 put_bytes(fp, (long_u)info->vi_curswant, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
934 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
935 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
936 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
937 * Unserialize the visualinfo_T at the current position in fp. |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
938 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
939 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
940 unserialize_visualinfo(info, fp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
941 visualinfo_T *info; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
942 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
943 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
944 unserialize_pos(&info->vi_start, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
945 unserialize_pos(&info->vi_end, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
946 info->vi_mode = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
947 info->vi_curswant = get4c(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
948 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
949 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
950 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
951 * Write the pointer to an undo header. Instead of writing the pointer itself |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
952 * we use the sequence number of the header. This is converted back to |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
953 * pointers when reading. */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
954 static void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
955 put_header_ptr(fp, uhp) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
956 FILE *fp; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
957 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
|
958 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
959 put_bytes(fp, (long_u)(uhp != NULL ? uhp->uh_seq : 0), 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
960 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
961 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
962 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
963 * 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
|
964 * 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
|
965 * 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
|
966 * "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
|
967 * permissions. |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
968 * "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
|
969 * "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
|
970 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
971 void |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
972 u_write_undo(name, forceit, buf, hash) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
973 char_u *name; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
974 int forceit; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
975 buf_T *buf; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
976 char_u *hash; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
977 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
978 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
|
979 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
|
980 char_u *file_name; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
981 int str_len, i, mark; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
982 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
983 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
|
984 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
985 int fd; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
986 FILE *fp = NULL; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
987 int perm; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
988 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
|
989 #ifdef UNIX |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
990 int st_old_valid = FALSE; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
991 struct stat st_old; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
992 struct stat st_new; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
993 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
994 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
995 if (name == NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
996 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
997 file_name = u_get_undo_file_name(buf->b_ffname, FALSE); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
998 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
|
999 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1000 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
|
1001 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1002 verbose_enter(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1003 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
|
1004 _("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
|
1005 verbose_leave(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1006 } |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1007 return; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1008 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1009 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1010 else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1011 file_name = name; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1012 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1013 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1014 * 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
|
1015 * 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
|
1016 * 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
|
1017 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1018 perm = 0600; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1019 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
|
1020 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1021 #ifdef UNIX |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1022 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
|
1023 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1024 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
|
1025 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
|
1026 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1027 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1028 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
|
1029 if (perm < 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1030 perm = 0600; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1031 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1032 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1033 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1034 /* strip any s-bit */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1035 perm = perm & 0777; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1036 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1037 /* 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
|
1038 * 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
|
1039 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
|
1040 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1041 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
|
1042 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1043 /* 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
|
1044 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
|
1045 if (fd < 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1046 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1047 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
|
1048 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1049 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
|
1050 verbose_enter(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1051 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
|
1052 _("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
|
1053 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
|
1054 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
|
1055 verbose_leave(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1056 } |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1057 goto theend; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1058 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1059 else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1060 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1061 char_u 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
|
1062 int len; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1063 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1064 len = vim_read(fd, 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
|
1065 close(fd); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1066 if (len < 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
|
1067 || memcmp(buf, UF_START_MAGIC, UF_START_MAGIC_LEN) != 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1068 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1069 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
|
1070 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1071 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
|
1072 verbose_enter(); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1073 smsg((char_u *)_("Will not overwrite, this is not an undo file: %s"), |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1074 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
|
1075 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
|
1076 verbose_leave(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1077 } |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1078 goto theend; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1079 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1080 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1081 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1082 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
|
1083 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1084 |
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1085 /* 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
|
1086 * existing undo file. */ |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1087 if (buf->b_u_numhead == 0) |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1088 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1089 if (p_verbose > 0) |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1090 verb_msg((char_u *)_("Skipping undo file write, noting to undo")); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1091 goto theend; |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1092 } |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1093 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1094 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
|
1095 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
|
1096 if (fd < 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1097 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1098 EMSG2(_(e_not_open), file_name); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1099 goto theend; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1100 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1101 (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
|
1102 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
|
1103 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1104 verbose_enter(); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1105 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
|
1106 verbose_leave(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1107 } |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1108 |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1109 #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
|
1110 /* 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
|
1111 u_check(FALSE); |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1112 #endif |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1113 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1114 #ifdef UNIX |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1115 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1116 * 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
|
1117 * 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
|
1118 * 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
|
1119 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1120 if (st_old_valid && (mch_stat((char *)file_name, &st_new) >= 0 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1121 && st_new.st_gid != st_old.st_gid |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1122 # ifdef HAVE_FCHOWN /* sequent-ptx lacks fchown() */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1123 && fchown(fd, (uid_t)-1, st_old.st_gid) != 0) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1124 # endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1125 ) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1126 mch_setperm(file_name, (perm & 0707) | ((perm & 07) << 3)); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1127 # ifdef HAVE_SELINUX |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1128 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
|
1129 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
|
1130 # endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1131 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1132 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1133 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
|
1134 if (fp == NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1135 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1136 EMSG2(_(e_not_open), file_name); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1137 close(fd); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1138 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
|
1139 goto theend; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1140 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1141 |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1142 /* Undo must be synced. */ |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1143 u_sync(TRUE); |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1144 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1145 /* Start writing, first 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
|
1146 if (fwrite(UF_START_MAGIC, (size_t)UF_START_MAGIC_LEN, (size_t)1, fp) != 1) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1147 goto write_error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1148 put_bytes(fp, (long_u)UF_VERSION, 2); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1149 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1150 /* Write a hash of the buffer text, so that we can verify it is still the |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1151 * same when reading the buffer text. */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1152 if (fwrite(hash, (size_t)UNDO_HASH_SIZE, (size_t)1, fp) != 1) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1153 goto write_error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1154 put_bytes(fp, (long_u)buf->b_ml.ml_line_count, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1155 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1156 /* Begin undo data for U */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1157 str_len = buf->b_u_line_ptr != NULL ? (int)STRLEN(buf->b_u_line_ptr) : 0; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1158 put_bytes(fp, (long_u)str_len, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1159 if (str_len > 0 && fwrite(buf->b_u_line_ptr, (size_t)str_len, |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1160 (size_t)1, fp) != 1) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1161 goto write_error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1162 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1163 put_bytes(fp, (long_u)buf->b_u_line_lnum, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1164 put_bytes(fp, (long_u)buf->b_u_line_colnr, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1165 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1166 /* Begin general undo data */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1167 put_header_ptr(fp, 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
|
1168 put_header_ptr(fp, buf->b_u_newhead); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1169 put_header_ptr(fp, buf->b_u_curhead); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1170 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1171 put_bytes(fp, (long_u)buf->b_u_numhead, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1172 put_bytes(fp, (long_u)buf->b_u_seq_last, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1173 put_bytes(fp, (long_u)buf->b_u_seq_cur, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1174 put_time(fp, buf->b_u_seq_time); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1175 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1176 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1177 * 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
|
1178 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1179 mark = ++lastmark; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1180 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
|
1181 while (uhp != NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1182 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1183 /* Serialize current UHP if we haven't seen it */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1184 if (uhp->uh_walk != mark) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1185 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1186 uhp->uh_walk = mark; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1187 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1188 ++headers_written; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1189 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1190 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1191 if (put_bytes(fp, (long_u)UF_HEADER_MAGIC, 2) == FAIL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1192 goto write_error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1193 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1194 put_header_ptr(fp, uhp->uh_next); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1195 put_header_ptr(fp, uhp->uh_prev); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1196 put_header_ptr(fp, uhp->uh_alt_next); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1197 put_header_ptr(fp, uhp->uh_alt_prev); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1198 put_bytes(fp, uhp->uh_seq, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1199 serialize_pos(uhp->uh_cursor, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1200 #ifdef FEAT_VIRTUALEDIT |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1201 put_bytes(fp, (long_u)uhp->uh_cursor_vcol, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1202 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1203 put_bytes(fp, (long_u)0, 4); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1204 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1205 put_bytes(fp, (long_u)uhp->uh_flags, 2); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1206 /* Assume NMARKS will stay the same. */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1207 for (i = 0; i < NMARKS; ++i) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1208 serialize_pos(uhp->uh_namedm[i], fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1209 #ifdef FEAT_VISUAL |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1210 serialize_visualinfo(&uhp->uh_visual, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1211 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1212 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1213 visualinfo_T info; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1214 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1215 memset(&info, 0, sizeof(visualinfo_T)); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1216 serialize_visualinfo(&info, fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1217 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1218 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1219 put_time(fp, uhp->uh_time); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1220 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1221 /* Write all the entries. */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1222 for (uep = uhp->uh_entry; uep != NULL; uep = uep->ue_next) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1223 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1224 put_bytes(fp, (long_u)UF_ENTRY_MAGIC, 2); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1225 if (serialize_uep(uep, fp) == FAIL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1226 goto write_error; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1227 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1228 put_bytes(fp, (long_u)UF_ENTRY_END_MAGIC, 2); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1229 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1230 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1231 /* Now walk through the tree - algorithm from undo_time */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1232 if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != mark) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1233 uhp = uhp->uh_prev; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1234 else if (uhp->uh_alt_next != NULL && uhp->uh_alt_next->uh_walk != mark) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1235 uhp = uhp->uh_alt_next; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1236 else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1237 && uhp->uh_next->uh_walk != mark) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1238 uhp = uhp->uh_next; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1239 else if (uhp->uh_alt_prev != NULL) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1240 uhp = uhp->uh_alt_prev; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1241 else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1242 uhp = uhp->uh_next; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1243 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1244 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1245 if (put_bytes(fp, (long_u)UF_HEADER_END_MAGIC, 2) == OK) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1246 write_ok = TRUE; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1247 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1248 if (headers_written != buf->b_u_numhead) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1249 EMSG3("Written %ld headers, but numhead is %ld", |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1250 headers_written, buf->b_u_numhead); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1251 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1252 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1253 write_error: |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1254 fclose(fp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1255 if (!write_ok) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1256 EMSG2(_("E829: write error in undo file: %s"), file_name); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1257 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1258 #if defined(MACOS_CLASSIC) || defined(WIN3264) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1259 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
|
1260 (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
|
1261 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1262 #ifdef HAVE_ACL |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1263 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
|
1264 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1265 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
|
1266 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1267 /* 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
|
1268 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
|
1269 mch_set_acl(file_name, acl); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1270 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1271 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1272 |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1273 theend: |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1274 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
|
1275 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
|
1276 } |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1277 |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1278 /* |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1279 * 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
|
1280 * 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
|
1281 * 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
|
1282 * 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
|
1283 * "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
|
1284 */ |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1285 void |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1286 u_read_undo(name, hash) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1287 char_u *name; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1288 char_u *hash; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1289 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1290 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
|
1291 FILE *fp; |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1292 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
|
1293 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
|
1294 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
|
1295 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
|
1296 linenr_T line_count; |
2217
120502692d82
Improve the MS-Windows installer.
Bram Moolenaar <bram@vim.org>
parents:
2215
diff
changeset
|
1297 int 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
|
1298 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
|
1299 long seq_last, seq_cur; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1300 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
|
1301 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
|
1302 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
|
1303 int i, j; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1304 int c; |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1305 u_entry_T *uep, *last_uep; |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1306 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
|
1307 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
|
1308 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
|
1309 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
|
1310 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1311 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
|
1312 #endif |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1313 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1314 if (name == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1315 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1316 file_name = u_get_undo_file_name(curbuf->b_ffname, TRUE); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1317 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
|
1318 return; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1319 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1320 else |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1321 file_name = name; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1322 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1323 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
|
1324 { |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1325 verbose_enter(); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1326 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
|
1327 verbose_leave(); |
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1328 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1329 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
|
1330 if (fp == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1331 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1332 if (name != NULL || p_verbose > 0) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1333 EMSG2(_("E822: Cannot open undo file for reading: %s"), file_name); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1334 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1335 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1336 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1337 /* |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1338 * 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
|
1339 */ |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1340 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
|
1341 || 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
|
1342 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1343 EMSG2(_("E823: Not an undo file: %s"), file_name); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1344 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1345 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1346 version = get2c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1347 if (version != UF_VERSION) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1348 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1349 EMSG2(_("E824: Incompatible 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
|
1350 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1351 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1352 |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1353 if (fread(read_hash, UNDO_HASH_SIZE, 1, fp) != 1) |
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1354 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1355 corruption_error("hash", file_name); |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1356 goto error; |
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1357 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1358 line_count = (linenr_T)get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1359 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
|
1360 || 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
|
1361 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1362 if (p_verbose > 0 || name != NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1363 { |
2235
4ba83ae8d505
Do not write an undo file if there is nothing to undo.
Bram Moolenaar <bram@vim.org>
parents:
2234
diff
changeset
|
1364 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
|
1365 verbose_enter(); |
2215
cccb71c2c5c1
Fix uninit memory read in undo code. Fix uint32_t in proto file.
Bram Moolenaar <bram@vim.org>
parents:
2214
diff
changeset
|
1366 give_warning((char_u *)_("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
|
1367 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
|
1368 verbose_leave(); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1369 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1370 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1371 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1372 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1373 /* Begin undo data for U */ |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1374 str_len = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1375 if (str_len < 0) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1376 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1377 else if (str_len > 0) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1378 { |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1379 if ((line_ptr = U_ALLOC_LINE(str_len + 1)) == NULL) |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1380 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1381 for (i = 0; i < str_len; i++) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1382 line_ptr[i] = (char_u)getc(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1383 line_ptr[i] = NUL; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1384 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1385 line_lnum = (linenr_T)get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1386 line_colnr = (colnr_T)get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1387 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1388 /* Begin general undo data */ |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1389 old_header_seq = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1390 new_header_seq = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1391 cur_header_seq = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1392 num_head = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1393 seq_last = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1394 seq_cur = get4c(fp); |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1395 seq_time = get8ctime(fp); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1396 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1397 /* 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
|
1398 * 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
|
1399 * 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
|
1400 * 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
|
1401 if (num_head > 0) |
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1402 { |
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1403 uhp_table = (u_header_T **)U_ALLOC_LINE( |
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1404 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
|
1405 if (uhp_table == NULL) |
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1406 goto error; |
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1407 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1408 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1409 while ((c = get2c(fp)) == 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
|
1410 { |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1411 if (num_read_uhps >= num_head) |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1412 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1413 corruption_error("num_head", file_name); |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1414 goto error; |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1415 } |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1416 |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1417 uhp = (u_header_T *)U_ALLOC_LINE(sizeof(u_header_T)); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1418 if (uhp == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1419 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1420 vim_memset(uhp, 0, sizeof(u_header_T)); |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1421 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1422 uhp->uh_magic = UH_MAGIC; |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1423 #endif |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1424 /* We're not actually trying to store pointers here. We're just storing |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1425 * IDs so we can swizzle them into pointers later - hence the type |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1426 * cast. */ |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1427 uhp->uh_next = (u_header_T *)(long_u)get4c(fp); |
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1428 uhp->uh_prev = (u_header_T *)(long_u)get4c(fp); |
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1429 uhp->uh_alt_next = (u_header_T *)(long_u)get4c(fp); |
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1430 uhp->uh_alt_prev = (u_header_T *)(long_u)get4c(fp); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1431 uhp->uh_seq = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1432 if (uhp->uh_seq <= 0) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1433 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1434 corruption_error("uh_seq", file_name); |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1435 vim_free(uhp); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1436 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1437 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1438 uhp->uh_walk = 0; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1439 unserialize_pos(&uhp->uh_cursor, fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1440 #ifdef FEAT_VIRTUALEDIT |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1441 uhp->uh_cursor_vcol = get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1442 #else |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1443 (void)get4c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1444 #endif |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1445 uhp->uh_flags = get2c(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1446 for (i = 0; i < NMARKS; ++i) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1447 unserialize_pos(&uhp->uh_namedm[i], fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1448 #ifdef FEAT_VISUAL |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1449 unserialize_visualinfo(&uhp->uh_visual, fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1450 #else |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1451 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1452 visualinfo_T info; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1453 unserialize_visualinfo(&info, fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1454 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1455 #endif |
2229
d45902a5c61c
Fix a few more things for persistent undo.
Bram Moolenaar <bram@vim.org>
parents:
2223
diff
changeset
|
1456 uhp->uh_time = get8ctime(fp); |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1457 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1458 /* Unserialize the uep list. */ |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1459 last_uep = NULL; |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1460 while ((c = get2c(fp)) == UF_ENTRY_MAGIC) |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1461 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1462 int error = FALSE; |
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 uep = unserialize_uep(fp, &error, file_name); |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1465 if (last_uep == NULL) |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1466 uhp->uh_entry = uep; |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1467 else |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1468 last_uep->ue_next = uep; |
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1469 last_uep = uep; |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1470 if (uep == NULL || error) |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1471 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1472 u_free_uhp(uhp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1473 goto error; |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1474 } |
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 if (c != UF_ENTRY_END_MAGIC) |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1477 { |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1478 corruption_error("entry end", file_name); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1479 u_free_uhp(uhp); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1480 goto error; |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1481 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1482 |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1483 uhp_table[num_read_uhps++] = uhp; |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1484 } |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1485 |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1486 if (num_read_uhps != num_head) |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1487 { |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1488 corruption_error("num_head", file_name); |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1489 goto error; |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1490 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1491 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1492 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
|
1493 { |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1494 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
|
1495 goto error; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1496 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1497 |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1498 #ifdef U_DEBUG |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1499 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
|
1500 (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
|
1501 # 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
|
1502 #else |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1503 # 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
|
1504 #endif |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1505 |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1506 /* We have put all of the uhps into a table. Now we iterate through the |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1507 * table and swizzle each sequence number we've stored in uh_* into a |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1508 * 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
|
1509 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
|
1510 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1511 uhp = uhp_table[i]; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1512 if (uhp == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1513 continue; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1514 for (j = 0; j < num_head; j++) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1515 { |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1516 if (uhp_table[j] == NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1517 continue; |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1518 if (i != j && uhp_table[i]->uh_seq == uhp_table[j]->uh_seq) |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1519 { |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1520 corruption_error("duplicate uh_seq", file_name); |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1521 goto error; |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1522 } |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1523 |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1524 if (uhp_table[j]->uh_seq == (long)uhp->uh_next) |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1525 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1526 uhp->uh_next = 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
|
1527 SET_FLAG(j); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1528 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1529 if (uhp_table[j]->uh_seq == (long)uhp->uh_prev) |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1530 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1531 uhp->uh_prev = 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
|
1532 SET_FLAG(j); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1533 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1534 if (uhp_table[j]->uh_seq == (long)uhp->uh_alt_next) |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1535 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1536 uhp->uh_alt_next = 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
|
1537 SET_FLAG(j); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1538 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1539 if (uhp_table[j]->uh_seq == (long)uhp->uh_alt_prev) |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1540 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1541 uhp->uh_alt_prev = 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
|
1542 SET_FLAG(j); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1543 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1544 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1545 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
|
1546 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1547 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
|
1548 SET_FLAG(i); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1549 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1550 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
|
1551 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1552 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
|
1553 SET_FLAG(i); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1554 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1555 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
|
1556 { |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1557 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
|
1558 SET_FLAG(i); |
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1559 } |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1560 } |
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 /* 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
|
1563 * 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
|
1564 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
|
1565 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
|
1566 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
|
1567 curbuf->b_u_curhead = cur_idx < 0 ? NULL : uhp_table[cur_idx]; |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1568 #ifdef U_DEBUG |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1569 if (curbuf->b_u_curhead != NULL) |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1570 corruption_error("curhead not NULL", file_name); |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1571 #endif |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1572 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
|
1573 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
|
1574 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
|
1575 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
|
1576 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
|
1577 curbuf->b_u_seq_cur = seq_cur; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1578 curbuf->b_u_seq_time = seq_time; |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1579 |
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1580 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
|
1581 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
|
1582 |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1583 #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
|
1584 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
|
1585 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
|
1586 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
|
1587 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
|
1588 u_check(TRUE); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1589 #endif |
2231
aa6412cab544
Various improvements to undo file code to make it more robust.
Bram Moolenaar <bram@vim.org>
parents:
2230
diff
changeset
|
1590 |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1591 if (name != NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1592 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
|
1593 goto theend; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1594 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1595 error: |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1596 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
|
1597 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
|
1598 { |
2233
43cad213cb7f
A bit of cleanup and simplification for undofile.
Bram Moolenaar <bram@vim.org>
parents:
2232
diff
changeset
|
1599 for (i = 0; i < num_read_uhps; i++) |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1600 if (uhp_table[i] != NULL) |
2223
81b83a19e127
More strict checks for the undo file.
Bram Moolenaar <bram@vim.org>
parents:
2222
diff
changeset
|
1601 u_free_uhp(uhp_table[i]); |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
1602 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
|
1603 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1604 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1605 theend: |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1606 if (fp != NULL) |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1607 fclose(fp); |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1608 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
|
1609 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
|
1610 return; |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1611 } |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1612 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1613 #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
|
1614 |
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1615 |
7 | 1616 /* |
1617 * If 'cpoptions' contains 'u': Undo the previous undo or redo (vi compatible). | |
1618 * If 'cpoptions' does not contain 'u': Always undo. | |
1619 */ | |
1620 void | |
1621 u_undo(count) | |
1622 int count; | |
1623 { | |
1624 /* | |
1625 * If we get an undo command while executing a macro, we behave like the | |
1626 * original vi. If this happens twice in one macro the result will not | |
1627 * be compatible. | |
1628 */ | |
1629 if (curbuf->b_u_synced == FALSE) | |
1630 { | |
825 | 1631 u_sync(TRUE); |
7 | 1632 count = 1; |
1633 } | |
1634 | |
1635 if (vim_strchr(p_cpo, CPO_UNDO) == NULL) | |
1636 undo_undoes = TRUE; | |
1637 else | |
1638 undo_undoes = !undo_undoes; | |
1639 u_doit(count); | |
1640 } | |
1641 | |
1642 /* | |
1643 * If 'cpoptions' contains 'u': Repeat the previous undo or redo. | |
1644 * If 'cpoptions' does not contain 'u': Always redo. | |
1645 */ | |
1646 void | |
1647 u_redo(count) | |
1648 int count; | |
1649 { | |
1650 if (vim_strchr(p_cpo, CPO_UNDO) == NULL) | |
1651 undo_undoes = FALSE; | |
1652 u_doit(count); | |
1653 } | |
1654 | |
1655 /* | |
1656 * Undo or redo, depending on 'undo_undoes', 'count' times. | |
1657 */ | |
1658 static void | |
777 | 1659 u_doit(startcount) |
1660 int startcount; | |
7 | 1661 { |
777 | 1662 int count = startcount; |
1663 | |
632 | 1664 if (!undo_allowed()) |
7 | 1665 return; |
1666 | |
1667 u_newcount = 0; | |
1668 u_oldcount = 0; | |
179 | 1669 if (curbuf->b_ml.ml_flags & ML_EMPTY) |
1670 u_oldcount = -1; | |
7 | 1671 while (count--) |
1672 { | |
1673 if (undo_undoes) | |
1674 { | |
1675 if (curbuf->b_u_curhead == NULL) /* first undo */ | |
1676 curbuf->b_u_curhead = curbuf->b_u_newhead; | |
1677 else if (p_ul > 0) /* multi level undo */ | |
1678 /* get next undo */ | |
1679 curbuf->b_u_curhead = curbuf->b_u_curhead->uh_next; | |
1680 /* nothing to undo */ | |
1681 if (curbuf->b_u_numhead == 0 || curbuf->b_u_curhead == NULL) | |
1682 { | |
1683 /* stick curbuf->b_u_curhead at end */ | |
1684 curbuf->b_u_curhead = curbuf->b_u_oldhead; | |
1685 beep_flush(); | |
777 | 1686 if (count == startcount - 1) |
1687 { | |
1688 MSG(_("Already at oldest change")); | |
1689 return; | |
1690 } | |
7 | 1691 break; |
1692 } | |
1693 | |
777 | 1694 u_undoredo(TRUE); |
7 | 1695 } |
1696 else | |
1697 { | |
1698 if (curbuf->b_u_curhead == NULL || p_ul <= 0) | |
1699 { | |
1700 beep_flush(); /* nothing to redo */ | |
777 | 1701 if (count == startcount - 1) |
1702 { | |
1703 MSG(_("Already at newest change")); | |
1704 return; | |
1705 } | |
7 | 1706 break; |
1707 } | |
1708 | |
777 | 1709 u_undoredo(FALSE); |
753 | 1710 |
1711 /* Advance for next redo. Set "newhead" when at the end of the | |
1712 * redoable changes. */ | |
1713 if (curbuf->b_u_curhead->uh_prev == NULL) | |
1714 curbuf->b_u_newhead = curbuf->b_u_curhead; | |
7 | 1715 curbuf->b_u_curhead = curbuf->b_u_curhead->uh_prev; |
1716 } | |
1717 } | |
798 | 1718 u_undo_end(undo_undoes, FALSE); |
753 | 1719 } |
1720 | |
1721 /* | |
1722 * Undo or redo over the timeline. | |
1723 * When "step" is negative go back in time, otherwise goes forward in time. | |
758 | 1724 * When "sec" is FALSE make "step" steps, when "sec" is TRUE use "step" as |
1725 * seconds. | |
772 | 1726 * When "absolute" is TRUE use "step" as the sequence number to jump to. |
1727 * "sec" must be FALSE then. | |
753 | 1728 */ |
1729 void | |
772 | 1730 undo_time(step, sec, absolute) |
758 | 1731 long step; |
1732 int sec; | |
772 | 1733 int absolute; |
753 | 1734 { |
1735 long target; | |
1736 long closest; | |
758 | 1737 long closest_start; |
1738 long closest_seq = 0; | |
1739 long val; | |
753 | 1740 u_header_T *uhp; |
1741 u_header_T *last; | |
1742 int mark; | |
1743 int nomark; | |
1744 int round; | |
758 | 1745 int dosec = sec; |
1746 int above = FALSE; | |
794 | 1747 int did_undo = TRUE; |
753 | 1748 |
766 | 1749 /* First make sure the current undoable change is synced. */ |
1750 if (curbuf->b_u_synced == FALSE) | |
825 | 1751 u_sync(TRUE); |
766 | 1752 |
753 | 1753 u_newcount = 0; |
1754 u_oldcount = 0; | |
179 | 1755 if (curbuf->b_ml.ml_flags & ML_EMPTY) |
753 | 1756 u_oldcount = -1; |
1757 | |
777 | 1758 /* "target" is the node below which we want to be. |
1759 * Init "closest" to a value we can't reach. */ | |
772 | 1760 if (absolute) |
1761 { | |
1762 target = step; | |
777 | 1763 closest = -1; |
753 | 1764 } |
1765 else | |
1766 { | |
777 | 1767 /* When doing computations with time_t subtract starttime, because |
1768 * time_t converted to a long may result in a wrong number. */ | |
758 | 1769 if (sec) |
777 | 1770 target = (long)(curbuf->b_u_seq_time - starttime) + step; |
1771 else | |
1772 target = curbuf->b_u_seq_cur + step; | |
1773 if (step < 0) | |
758 | 1774 { |
777 | 1775 if (target < 0) |
1776 target = 0; | |
1777 closest = -1; | |
758 | 1778 } |
1779 else | |
1780 { | |
777 | 1781 if (sec) |
798 | 1782 closest = (long)(time(NULL) - starttime + 1); |
777 | 1783 else |
1784 closest = curbuf->b_u_seq_last + 2; | |
1785 if (target >= closest) | |
1786 target = closest - 1; | |
758 | 1787 } |
753 | 1788 } |
758 | 1789 closest_start = closest; |
777 | 1790 closest_seq = curbuf->b_u_seq_cur; |
753 | 1791 |
758 | 1792 /* |
1793 * May do this twice: | |
753 | 1794 * 1. Search for "target", update "closest" to the best match found. |
758 | 1795 * 2. If "target" not found search for "closest". |
1796 * | |
1797 * When using the closest time we use the sequence number in the second | |
1798 * round, because there may be several entries with the same time. | |
1799 */ | |
753 | 1800 for (round = 1; round <= 2; ++round) |
1801 { | |
1802 /* Find the path from the current state to where we want to go. The | |
1803 * desired state can be anywhere in the undo tree, need to go all over | |
1804 * it. We put "nomark" in uh_walk where we have been without success, | |
1805 * "mark" where it could possibly be. */ | |
1806 mark = ++lastmark; | |
1807 nomark = ++lastmark; | |
1808 | |
1809 if (curbuf->b_u_curhead == NULL) /* at leaf of the tree */ | |
1810 uhp = curbuf->b_u_newhead; | |
1811 else | |
1812 uhp = curbuf->b_u_curhead; | |
1813 | |
1814 while (uhp != NULL) | |
1815 { | |
1816 uhp->uh_walk = mark; | |
798 | 1817 val = (long)(dosec ? (uhp->uh_time - starttime) : uhp->uh_seq); |
753 | 1818 |
758 | 1819 if (round == 1) |
1820 { | |
1821 /* Remember the header that is closest to the target. | |
1822 * It must be at least in the right direction (checked with | |
777 | 1823 * "b_u_seq_cur"). When the timestamp is equal find the |
758 | 1824 * highest/lowest sequence number. */ |
777 | 1825 if ((step < 0 ? uhp->uh_seq <= curbuf->b_u_seq_cur |
1826 : uhp->uh_seq > curbuf->b_u_seq_cur) | |
1827 && ((dosec && val == closest) | |
1828 ? (step < 0 | |
1829 ? uhp->uh_seq < closest_seq | |
1830 : uhp->uh_seq > closest_seq) | |
1831 : closest == closest_start | |
1832 || (val > target | |
1833 ? (closest > target | |
1834 ? val - target <= closest - target | |
1835 : val - target <= target - closest) | |
1836 : (closest > target | |
1837 ? target - val <= closest - target | |
1838 : target - val <= target - closest)))) | |
758 | 1839 { |
1840 closest = val; | |
1841 closest_seq = uhp->uh_seq; | |
1842 } | |
1843 } | |
1844 | |
1845 /* Quit searching when we found a match. But when searching for a | |
1846 * time we need to continue looking for the best uh_seq. */ | |
1847 if (target == val && !dosec) | |
1848 break; | |
753 | 1849 |
1850 /* go down in the tree if we haven't been there */ | |
1851 if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != nomark | |
1852 && uhp->uh_prev->uh_walk != mark) | |
1853 uhp = uhp->uh_prev; | |
1854 | |
1855 /* go to alternate branch if we haven't been there */ | |
1856 else if (uhp->uh_alt_next != NULL | |
1857 && uhp->uh_alt_next->uh_walk != nomark | |
1858 && uhp->uh_alt_next->uh_walk != mark) | |
1859 uhp = uhp->uh_alt_next; | |
1860 | |
1861 /* go up in the tree if we haven't been there and we are at the | |
1862 * start of alternate branches */ | |
1863 else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL | |
1864 && uhp->uh_next->uh_walk != nomark | |
1865 && uhp->uh_next->uh_walk != mark) | |
798 | 1866 { |
1867 /* If still at the start we don't go through this change. */ | |
1868 if (uhp == curbuf->b_u_curhead) | |
1869 uhp->uh_walk = nomark; | |
753 | 1870 uhp = uhp->uh_next; |
798 | 1871 } |
753 | 1872 |
1873 else | |
1874 { | |
1875 /* need to backtrack; mark this node as useless */ | |
1876 uhp->uh_walk = nomark; | |
1877 if (uhp->uh_alt_prev != NULL) | |
1878 uhp = uhp->uh_alt_prev; | |
1879 else | |
1880 uhp = uhp->uh_next; | |
1881 } | |
1882 } | |
1883 | |
1884 if (uhp != NULL) /* found it */ | |
1885 break; | |
772 | 1886 |
1887 if (absolute) | |
1888 { | |
2214
f8222d1f9a73
Included patch for persistent undo. Lots of changes and added test.
Bram Moolenaar <bram@vim.org>
parents:
2210
diff
changeset
|
1889 EMSGN(_("E830: Undo number %ld not found"), step); |
772 | 1890 return; |
1891 } | |
1892 | |
758 | 1893 if (closest == closest_start) |
753 | 1894 { |
758 | 1895 if (step < 0) |
1896 MSG(_("Already at oldest change")); | |
1897 else | |
1898 MSG(_("Already at newest change")); | |
753 | 1899 return; |
1900 } | |
1901 | |
758 | 1902 target = closest_seq; |
1903 dosec = FALSE; | |
1904 if (step < 0) | |
1905 above = TRUE; /* stop above the header */ | |
753 | 1906 } |
1907 | |
1908 /* If we found it: Follow the path to go to where we want to be. */ | |
1909 if (uhp != NULL) | |
1910 { | |
1911 /* | |
1912 * First go up the tree as much as needed. | |
1913 */ | |
1914 for (;;) | |
1915 { | |
1916 uhp = curbuf->b_u_curhead; | |
1917 if (uhp == NULL) | |
1918 uhp = curbuf->b_u_newhead; | |
1919 else | |
1920 uhp = uhp->uh_next; | |
777 | 1921 if (uhp == NULL || uhp->uh_walk != mark |
1922 || (uhp->uh_seq == target && !above)) | |
753 | 1923 break; |
1924 curbuf->b_u_curhead = uhp; | |
777 | 1925 u_undoredo(TRUE); |
753 | 1926 uhp->uh_walk = nomark; /* don't go back down here */ |
1927 } | |
1928 | |
1929 /* | |
758 | 1930 * And now go down the tree (redo), branching off where needed. |
753 | 1931 */ |
1932 uhp = curbuf->b_u_curhead; | |
777 | 1933 while (uhp != NULL) |
753 | 1934 { |
1056 | 1935 /* Go back to the first branch with a mark. */ |
1936 while (uhp->uh_alt_prev != NULL | |
1937 && uhp->uh_alt_prev->uh_walk == mark) | |
1938 uhp = uhp->uh_alt_prev; | |
1939 | |
753 | 1940 /* Find the last branch with a mark, that's the one. */ |
1941 last = uhp; | |
1942 while (last->uh_alt_next != NULL | |
1943 && last->uh_alt_next->uh_walk == mark) | |
1944 last = last->uh_alt_next; | |
1945 if (last != uhp) | |
1946 { | |
1947 /* Make the used branch the first entry in the list of | |
1948 * alternatives to make "u" and CTRL-R take this branch. */ | |
1056 | 1949 while (uhp->uh_alt_prev != NULL) |
1950 uhp = uhp->uh_alt_prev; | |
753 | 1951 if (last->uh_alt_next != NULL) |
1952 last->uh_alt_next->uh_alt_prev = last->uh_alt_prev; | |
1953 last->uh_alt_prev->uh_alt_next = last->uh_alt_next; | |
1954 last->uh_alt_prev = NULL; | |
1955 last->uh_alt_next = uhp; | |
1956 uhp->uh_alt_prev = last; | |
1957 | |
2234 | 1958 if (curbuf->b_u_oldhead == uhp) |
1959 curbuf->b_u_oldhead = last; | |
753 | 1960 uhp = last; |
777 | 1961 if (uhp->uh_next != NULL) |
1962 uhp->uh_next->uh_prev = uhp; | |
753 | 1963 } |
758 | 1964 curbuf->b_u_curhead = uhp; |
753 | 1965 |
1966 if (uhp->uh_walk != mark) | |
1967 break; /* must have reached the target */ | |
1968 | |
758 | 1969 /* Stop when going backwards in time and didn't find the exact |
1970 * header we were looking for. */ | |
1971 if (uhp->uh_seq == target && above) | |
798 | 1972 { |
1973 curbuf->b_u_seq_cur = target - 1; | |
758 | 1974 break; |
798 | 1975 } |
758 | 1976 |
777 | 1977 u_undoredo(FALSE); |
753 | 1978 |
1979 /* Advance "curhead" to below the header we last used. If it | |
1980 * becomes NULL then we need to set "newhead" to this leaf. */ | |
1981 if (uhp->uh_prev == NULL) | |
1982 curbuf->b_u_newhead = uhp; | |
1983 curbuf->b_u_curhead = uhp->uh_prev; | |
794 | 1984 did_undo = FALSE; |
753 | 1985 |
1986 if (uhp->uh_seq == target) /* found it! */ | |
1987 break; | |
1988 | |
1989 uhp = uhp->uh_prev; | |
1990 if (uhp == NULL || uhp->uh_walk != mark) | |
1991 { | |
777 | 1992 /* Need to redo more but can't find it... */ |
753 | 1993 EMSG2(_(e_intern2), "undo_time()"); |
1994 break; | |
1995 } | |
1996 } | |
1997 } | |
798 | 1998 u_undo_end(did_undo, absolute); |
7 | 1999 } |
2000 | |
2001 /* | |
2002 * u_undoredo: common code for undo and redo | |
2003 * | |
2004 * The lines in the file are replaced by the lines in the entry list at | |
2005 * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry | |
2006 * list for the next undo/redo. | |
777 | 2007 * |
2008 * When "undo" is TRUE we go up in the tree, when FALSE we go down. | |
7 | 2009 */ |
2010 static void | |
777 | 2011 u_undoredo(undo) |
2012 int undo; | |
7 | 2013 { |
2014 char_u **newarray = NULL; | |
2015 linenr_T oldsize; | |
2016 linenr_T newsize; | |
2017 linenr_T top, bot; | |
2018 linenr_T lnum; | |
2019 linenr_T newlnum = MAXLNUM; | |
2020 long i; | |
2021 u_entry_T *uep, *nuep; | |
2022 u_entry_T *newlist = NULL; | |
2023 int old_flags; | |
2024 int new_flags; | |
2025 pos_T namedm[NMARKS]; | |
692 | 2026 #ifdef FEAT_VISUAL |
2027 visualinfo_T visualinfo; | |
2028 #endif | |
7 | 2029 int empty_buffer; /* buffer became empty */ |
758 | 2030 u_header_T *curhead = curbuf->b_u_curhead; |
7 | 2031 |
1415 | 2032 #ifdef U_DEBUG |
2033 u_check(FALSE); | |
2034 #endif | |
758 | 2035 old_flags = curhead->uh_flags; |
7 | 2036 new_flags = (curbuf->b_changed ? UH_CHANGED : 0) + |
2037 ((curbuf->b_ml.ml_flags & ML_EMPTY) ? UH_EMPTYBUF : 0); | |
2038 setpcmark(); | |
2039 | |
2040 /* | |
2041 * save marks before undo/redo | |
2042 */ | |
2043 mch_memmove(namedm, curbuf->b_namedm, sizeof(pos_T) * NMARKS); | |
692 | 2044 #ifdef FEAT_VISUAL |
2045 visualinfo = curbuf->b_visual; | |
2046 #endif | |
7 | 2047 curbuf->b_op_start.lnum = curbuf->b_ml.ml_line_count; |
2048 curbuf->b_op_start.col = 0; | |
2049 curbuf->b_op_end.lnum = 0; | |
2050 curbuf->b_op_end.col = 0; | |
2051 | |
758 | 2052 for (uep = curhead->uh_entry; uep != NULL; uep = nuep) |
7 | 2053 { |
2054 top = uep->ue_top; | |
2055 bot = uep->ue_bot; | |
2056 if (bot == 0) | |
2057 bot = curbuf->b_ml.ml_line_count + 1; | |
2058 if (top > curbuf->b_ml.ml_line_count || top >= bot | |
2059 || bot > curbuf->b_ml.ml_line_count + 1) | |
2060 { | |
2061 EMSG(_("E438: u_undo: line numbers wrong")); | |
2062 changed(); /* don't want UNCHANGED now */ | |
2063 return; | |
2064 } | |
2065 | |
2066 oldsize = bot - top - 1; /* number of lines before undo */ | |
2067 newsize = uep->ue_size; /* number of lines after undo */ | |
2068 | |
2069 if (top < newlnum) | |
2070 { | |
2071 /* If the saved cursor is somewhere in this undo block, move it to | |
2072 * the remembered position. Makes "gwap" put the cursor back | |
2073 * where it was. */ | |
758 | 2074 lnum = curhead->uh_cursor.lnum; |
7 | 2075 if (lnum >= top && lnum <= top + newsize + 1) |
2076 { | |
758 | 2077 curwin->w_cursor = curhead->uh_cursor; |
7 | 2078 newlnum = curwin->w_cursor.lnum - 1; |
2079 } | |
2080 else | |
2081 { | |
2082 /* Use the first line that actually changed. Avoids that | |
2083 * undoing auto-formatting puts the cursor in the previous | |
2084 * line. */ | |
2085 for (i = 0; i < newsize && i < oldsize; ++i) | |
2086 if (STRCMP(uep->ue_array[i], ml_get(top + 1 + i)) != 0) | |
2087 break; | |
2088 if (i == newsize && newlnum == MAXLNUM && uep->ue_next == NULL) | |
2089 { | |
2090 newlnum = top; | |
2091 curwin->w_cursor.lnum = newlnum + 1; | |
2092 } | |
2093 else if (i < newsize) | |
2094 { | |
2095 newlnum = top + i; | |
2096 curwin->w_cursor.lnum = newlnum + 1; | |
2097 } | |
2098 } | |
2099 } | |
2100 | |
2101 empty_buffer = FALSE; | |
2102 | |
2103 /* delete the lines between top and bot and save them in newarray */ | |
168 | 2104 if (oldsize > 0) |
7 | 2105 { |
168 | 2106 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
|
2107 sizeof(char_u *) * oldsize)) == NULL) |
7 | 2108 { |
2109 do_outofmem_msg((long_u)(sizeof(char_u *) * oldsize)); | |
2110 /* | |
2111 * We have messed up the entry list, repair is impossible. | |
2112 * we have to free the rest of the list. | |
2113 */ | |
2114 while (uep != NULL) | |
2115 { | |
2116 nuep = uep->ue_next; | |
2117 u_freeentry(uep, uep->ue_size); | |
2118 uep = nuep; | |
2119 } | |
2120 break; | |
2121 } | |
2122 /* delete backwards, it goes faster in most cases */ | |
2123 for (lnum = bot - 1, i = oldsize; --i >= 0; --lnum) | |
2124 { | |
2125 /* what can we do when we run out of memory? */ | |
2126 if ((newarray[i] = u_save_line(lnum)) == NULL) | |
2127 do_outofmem_msg((long_u)0); | |
2128 /* remember we deleted the last line in the buffer, and a | |
2129 * dummy empty line will be inserted */ | |
2130 if (curbuf->b_ml.ml_line_count == 1) | |
2131 empty_buffer = TRUE; | |
2132 ml_delete(lnum, FALSE); | |
2133 } | |
2134 } | |
414 | 2135 else |
2136 newarray = NULL; | |
7 | 2137 |
2138 /* insert the lines in u_array between top and bot */ | |
2139 if (newsize) | |
2140 { | |
2141 for (lnum = top, i = 0; i < newsize; ++i, ++lnum) | |
2142 { | |
2143 /* | |
2144 * If the file is empty, there is an empty line 1 that we | |
2145 * should get rid of, by replacing it with the new line | |
2146 */ | |
2147 if (empty_buffer && lnum == 0) | |
2148 ml_replace((linenr_T)1, uep->ue_array[i], TRUE); | |
2149 else | |
2150 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
|
2151 vim_free(uep->ue_array[i]); |
7 | 2152 } |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2153 vim_free((char_u *)uep->ue_array); |
7 | 2154 } |
2155 | |
2156 /* adjust marks */ | |
2157 if (oldsize != newsize) | |
2158 { | |
2159 mark_adjust(top + 1, top + oldsize, (long)MAXLNUM, | |
2160 (long)newsize - (long)oldsize); | |
2161 if (curbuf->b_op_start.lnum > top + oldsize) | |
2162 curbuf->b_op_start.lnum += newsize - oldsize; | |
2163 if (curbuf->b_op_end.lnum > top + oldsize) | |
2164 curbuf->b_op_end.lnum += newsize - oldsize; | |
2165 } | |
2166 | |
2167 changed_lines(top + 1, 0, bot, newsize - oldsize); | |
2168 | |
2169 /* set '[ and '] mark */ | |
2170 if (top + 1 < curbuf->b_op_start.lnum) | |
2171 curbuf->b_op_start.lnum = top + 1; | |
2172 if (newsize == 0 && top + 1 > curbuf->b_op_end.lnum) | |
2173 curbuf->b_op_end.lnum = top + 1; | |
2174 else if (top + newsize > curbuf->b_op_end.lnum) | |
2175 curbuf->b_op_end.lnum = top + newsize; | |
2176 | |
2177 u_newcount += newsize; | |
2178 u_oldcount += oldsize; | |
2179 uep->ue_size = oldsize; | |
2180 uep->ue_array = newarray; | |
2181 uep->ue_bot = top + newsize + 1; | |
2182 | |
2183 /* | |
2184 * insert this entry in front of the new entry list | |
2185 */ | |
2186 nuep = uep->ue_next; | |
2187 uep->ue_next = newlist; | |
2188 newlist = uep; | |
2189 } | |
2190 | |
758 | 2191 curhead->uh_entry = newlist; |
2192 curhead->uh_flags = new_flags; | |
7 | 2193 if ((old_flags & UH_EMPTYBUF) && bufempty()) |
2194 curbuf->b_ml.ml_flags |= ML_EMPTY; | |
2195 if (old_flags & UH_CHANGED) | |
2196 changed(); | |
2197 else | |
33 | 2198 #ifdef FEAT_NETBEANS_INTG |
2199 /* per netbeans undo rules, keep it as modified */ | |
2200 if (!isNetbeansModified(curbuf)) | |
2201 #endif | |
7 | 2202 unchanged(curbuf, FALSE); |
2203 | |
2204 /* | |
2205 * restore marks from before undo/redo | |
2206 */ | |
2207 for (i = 0; i < NMARKS; ++i) | |
758 | 2208 if (curhead->uh_namedm[i].lnum != 0) |
7 | 2209 { |
758 | 2210 curbuf->b_namedm[i] = curhead->uh_namedm[i]; |
2211 curhead->uh_namedm[i] = namedm[i]; | |
7 | 2212 } |
692 | 2213 #ifdef FEAT_VISUAL |
758 | 2214 if (curhead->uh_visual.vi_start.lnum != 0) |
692 | 2215 { |
758 | 2216 curbuf->b_visual = curhead->uh_visual; |
2217 curhead->uh_visual = visualinfo; | |
692 | 2218 } |
2219 #endif | |
7 | 2220 |
2221 /* | |
2222 * If the cursor is only off by one line, put it at the same position as | |
2223 * before starting the change (for the "o" command). | |
2224 * Otherwise the cursor should go to the first undone line. | |
2225 */ | |
758 | 2226 if (curhead->uh_cursor.lnum + 1 == curwin->w_cursor.lnum |
7 | 2227 && curwin->w_cursor.lnum > 1) |
2228 --curwin->w_cursor.lnum; | |
758 | 2229 if (curhead->uh_cursor.lnum == curwin->w_cursor.lnum) |
7 | 2230 { |
758 | 2231 curwin->w_cursor.col = curhead->uh_cursor.col; |
7 | 2232 #ifdef FEAT_VIRTUALEDIT |
758 | 2233 if (virtual_active() && curhead->uh_cursor_vcol >= 0) |
2234 coladvance((colnr_T)curhead->uh_cursor_vcol); | |
7 | 2235 else |
2236 curwin->w_cursor.coladd = 0; | |
2237 #endif | |
2238 } | |
2239 else if (curwin->w_cursor.lnum <= curbuf->b_ml.ml_line_count) | |
2240 beginline(BL_SOL | BL_FIX); | |
2241 else | |
2242 { | |
2243 /* We get here with the current cursor line being past the end (eg | |
2244 * after adding lines at the end of the file, and then undoing it). | |
2245 * check_cursor() will move the cursor to the last line. Move it to | |
2246 * the first column here. */ | |
2247 curwin->w_cursor.col = 0; | |
2248 #ifdef FEAT_VIRTUALEDIT | |
2249 curwin->w_cursor.coladd = 0; | |
2250 #endif | |
2251 } | |
2252 | |
2253 /* Make sure the cursor is on an existing line and column. */ | |
2254 check_cursor(); | |
758 | 2255 |
2256 /* Remember where we are for "g-" and ":earlier 10s". */ | |
2257 curbuf->b_u_seq_cur = curhead->uh_seq; | |
777 | 2258 if (undo) |
2259 /* We are below the previous undo. However, to make ":earlier 1s" | |
2260 * work we compute this as being just above the just undone change. */ | |
2261 --curbuf->b_u_seq_cur; | |
2262 | |
2263 /* The timestamp can be the same for multiple changes, just use the one of | |
2264 * the undone/redone change. */ | |
758 | 2265 curbuf->b_u_seq_time = curhead->uh_time; |
1415 | 2266 #ifdef U_DEBUG |
2267 u_check(FALSE); | |
2268 #endif | |
7 | 2269 } |
2270 | |
2271 /* | |
2272 * If we deleted or added lines, report the number of less/more lines. | |
2273 * Otherwise, report the number of changes (this may be incorrect | |
2274 * in some cases, but it's better than nothing). | |
2275 */ | |
2276 static void | |
798 | 2277 u_undo_end(did_undo, absolute) |
794 | 2278 int did_undo; /* just did an undo */ |
798 | 2279 int absolute; /* used ":undo N" */ |
7 | 2280 { |
944 | 2281 char *msgstr; |
772 | 2282 u_header_T *uhp; |
2283 char_u msgbuf[80]; | |
753 | 2284 |
7 | 2285 #ifdef FEAT_FOLDING |
2286 if ((fdo_flags & FDO_UNDO) && KeyTyped) | |
2287 foldOpenCursor(); | |
2288 #endif | |
753 | 2289 |
2290 if (global_busy /* no messages now, wait until global is finished */ | |
2291 || !messaging()) /* 'lazyredraw' set, don't do messages now */ | |
2292 return; | |
2293 | |
2294 if (curbuf->b_ml.ml_flags & ML_EMPTY) | |
2295 --u_newcount; | |
2296 | |
2297 u_oldcount -= u_newcount; | |
2298 if (u_oldcount == -1) | |
944 | 2299 msgstr = N_("more line"); |
753 | 2300 else if (u_oldcount < 0) |
944 | 2301 msgstr = N_("more lines"); |
753 | 2302 else if (u_oldcount == 1) |
944 | 2303 msgstr = N_("line less"); |
753 | 2304 else if (u_oldcount > 1) |
944 | 2305 msgstr = N_("fewer lines"); |
753 | 2306 else |
2307 { | |
2308 u_oldcount = u_newcount; | |
2309 if (u_newcount == 1) | |
944 | 2310 msgstr = N_("change"); |
753 | 2311 else |
944 | 2312 msgstr = N_("changes"); |
753 | 2313 } |
2314 | |
772 | 2315 if (curbuf->b_u_curhead != NULL) |
794 | 2316 { |
798 | 2317 /* For ":undo N" we prefer a "after #N" message. */ |
2318 if (absolute && curbuf->b_u_curhead->uh_next != NULL) | |
2319 { | |
2320 uhp = curbuf->b_u_curhead->uh_next; | |
2321 did_undo = FALSE; | |
2322 } | |
2323 else if (did_undo) | |
794 | 2324 uhp = curbuf->b_u_curhead; |
2325 else | |
2326 uhp = curbuf->b_u_curhead->uh_next; | |
2327 } | |
753 | 2328 else |
772 | 2329 uhp = curbuf->b_u_newhead; |
753 | 2330 |
772 | 2331 if (uhp == NULL) |
2332 *msgbuf = NUL; | |
2333 else | |
2334 u_add_time(msgbuf, sizeof(msgbuf), uhp->uh_time); | |
2335 | |
794 | 2336 smsg((char_u *)_("%ld %s; %s #%ld %s"), |
777 | 2337 u_oldcount < 0 ? -u_oldcount : u_oldcount, |
944 | 2338 _(msgstr), |
794 | 2339 did_undo ? _("before") : _("after"), |
2340 uhp == NULL ? 0L : uhp->uh_seq, | |
2341 msgbuf); | |
7 | 2342 } |
2343 | |
2344 /* | |
2345 * u_sync: stop adding to the current entry list | |
2346 */ | |
2347 void | |
825 | 2348 u_sync(force) |
2349 int force; /* Also sync when no_u_sync is set. */ | |
7 | 2350 { |
825 | 2351 /* Skip it when already synced or syncing is disabled. */ |
2352 if (curbuf->b_u_synced || (!force && no_u_sync > 0)) | |
2353 return; | |
7 | 2354 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) |
2355 if (im_is_preediting()) | |
2356 return; /* XIM is busy, don't break an undo sequence */ | |
2357 #endif | |
2358 if (p_ul < 0) | |
2359 curbuf->b_u_synced = TRUE; /* no entries, nothing to do */ | |
2360 else | |
2361 { | |
2362 u_getbot(); /* compute ue_bot of previous u_save */ | |
2363 curbuf->b_u_curhead = NULL; | |
2364 } | |
2365 } | |
2366 | |
2367 /* | |
772 | 2368 * ":undolist": List the leafs of the undo tree |
2369 */ | |
2370 void | |
2371 ex_undolist(eap) | |
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
1534
diff
changeset
|
2372 exarg_T *eap UNUSED; |
772 | 2373 { |
2374 garray_T ga; | |
2375 u_header_T *uhp; | |
2376 int mark; | |
2377 int nomark; | |
2378 int changes = 1; | |
2379 int i; | |
2380 | |
2381 /* | |
2382 * 1: walk the tree to find all leafs, put the info in "ga". | |
2383 * 2: sort the lines | |
2384 * 3: display the list | |
2385 */ | |
2386 mark = ++lastmark; | |
2387 nomark = ++lastmark; | |
2388 ga_init2(&ga, (int)sizeof(char *), 20); | |
2389 | |
2390 uhp = curbuf->b_u_oldhead; | |
2391 while (uhp != NULL) | |
2392 { | |
777 | 2393 if (uhp->uh_prev == NULL && uhp->uh_walk != nomark |
2394 && uhp->uh_walk != mark) | |
772 | 2395 { |
2396 if (ga_grow(&ga, 1) == FAIL) | |
2397 break; | |
2398 vim_snprintf((char *)IObuff, IOSIZE, "%6ld %7ld ", | |
2399 uhp->uh_seq, changes); | |
2400 u_add_time(IObuff + STRLEN(IObuff), IOSIZE - STRLEN(IObuff), | |
2401 uhp->uh_time); | |
2402 ((char_u **)(ga.ga_data))[ga.ga_len++] = vim_strsave(IObuff); | |
2403 } | |
2404 | |
2405 uhp->uh_walk = mark; | |
2406 | |
2407 /* go down in the tree if we haven't been there */ | |
2408 if (uhp->uh_prev != NULL && uhp->uh_prev->uh_walk != nomark | |
2409 && uhp->uh_prev->uh_walk != mark) | |
2410 { | |
2411 uhp = uhp->uh_prev; | |
2412 ++changes; | |
2413 } | |
2414 | |
2415 /* go to alternate branch if we haven't been there */ | |
2416 else if (uhp->uh_alt_next != NULL | |
2417 && uhp->uh_alt_next->uh_walk != nomark | |
2418 && uhp->uh_alt_next->uh_walk != mark) | |
2419 uhp = uhp->uh_alt_next; | |
2420 | |
2421 /* go up in the tree if we haven't been there and we are at the | |
2422 * start of alternate branches */ | |
2423 else if (uhp->uh_next != NULL && uhp->uh_alt_prev == NULL | |
2424 && uhp->uh_next->uh_walk != nomark | |
2425 && uhp->uh_next->uh_walk != mark) | |
2426 { | |
2427 uhp = uhp->uh_next; | |
2428 --changes; | |
2429 } | |
2430 | |
2431 else | |
2432 { | |
2433 /* need to backtrack; mark this node as done */ | |
2434 uhp->uh_walk = nomark; | |
2435 if (uhp->uh_alt_prev != NULL) | |
2436 uhp = uhp->uh_alt_prev; | |
2437 else | |
2438 { | |
2439 uhp = uhp->uh_next; | |
2440 --changes; | |
2441 } | |
2442 } | |
2443 } | |
2444 | |
2445 if (ga.ga_len == 0) | |
2446 MSG(_("Nothing to undo")); | |
2447 else | |
2448 { | |
2449 sort_strings((char_u **)ga.ga_data, ga.ga_len); | |
2450 | |
2451 msg_start(); | |
2452 msg_puts_attr((char_u *)_("number changes time"), hl_attr(HLF_T)); | |
2453 for (i = 0; i < ga.ga_len && !got_int; ++i) | |
2454 { | |
2455 msg_putchar('\n'); | |
2456 if (got_int) | |
2457 break; | |
2458 msg_puts(((char_u **)ga.ga_data)[i]); | |
2459 } | |
2460 msg_end(); | |
2461 | |
2462 ga_clear_strings(&ga); | |
2463 } | |
2464 } | |
2465 | |
2466 /* | |
2467 * Put the timestamp of an undo header in "buf[buflen]" in a nice format. | |
2468 */ | |
2469 static void | |
2470 u_add_time(buf, buflen, tt) | |
2471 char_u *buf; | |
2472 size_t buflen; | |
2473 time_t tt; | |
2474 { | |
2475 #ifdef HAVE_STRFTIME | |
2476 struct tm *curtime; | |
2477 | |
2478 if (time(NULL) - tt >= 100) | |
2479 { | |
2480 curtime = localtime(&tt); | |
810 | 2481 (void)strftime((char *)buf, buflen, "%H:%M:%S", curtime); |
772 | 2482 } |
2483 else | |
2484 #endif | |
835 | 2485 vim_snprintf((char *)buf, buflen, _("%ld seconds ago"), |
772 | 2486 (long)(time(NULL) - tt)); |
2487 } | |
2488 | |
2489 /* | |
697 | 2490 * ":undojoin": continue adding to the last entry list |
2491 */ | |
2492 void | |
2493 ex_undojoin(eap) | |
2154
7c8c7c95a865
First step in the Vim 7.3 branch. Changed version numbers.
Bram Moolenaar <bram@zimbu.org>
parents:
1534
diff
changeset
|
2494 exarg_T *eap UNUSED; |
697 | 2495 { |
839 | 2496 if (curbuf->b_u_newhead == NULL) |
2497 return; /* nothing changed before */ | |
2498 if (curbuf->b_u_curhead != NULL) | |
2499 { | |
2500 EMSG(_("E790: undojoin is not allowed after undo")); | |
2501 return; | |
2502 } | |
697 | 2503 if (!curbuf->b_u_synced) |
2504 return; /* already unsynced */ | |
2505 if (p_ul < 0) | |
2506 return; /* no entries, nothing to do */ | |
2507 else | |
2508 { | |
2509 /* Go back to the last entry */ | |
2510 curbuf->b_u_curhead = curbuf->b_u_newhead; | |
2511 curbuf->b_u_synced = FALSE; /* no entries, nothing to do */ | |
2512 } | |
2513 } | |
2514 | |
2515 /* | |
7 | 2516 * Called after writing the file and setting b_changed to FALSE. |
2517 * Now an undo means that the buffer is modified. | |
2518 */ | |
2519 void | |
2520 u_unchanged(buf) | |
2521 buf_T *buf; | |
2522 { | |
758 | 2523 u_unch_branch(buf->b_u_oldhead); |
2524 buf->b_did_warn = FALSE; | |
2525 } | |
2526 | |
2527 static void | |
2528 u_unch_branch(uhp) | |
2529 u_header_T *uhp; | |
2530 { | |
753 | 2531 u_header_T *uh; |
7 | 2532 |
758 | 2533 for (uh = uhp; uh != NULL; uh = uh->uh_prev) |
2534 { | |
7 | 2535 uh->uh_flags |= UH_CHANGED; |
758 | 2536 if (uh->uh_alt_next != NULL) |
2537 u_unch_branch(uh->uh_alt_next); /* recursive */ | |
2538 } | |
7 | 2539 } |
2540 | |
2541 /* | |
2542 * Get pointer to last added entry. | |
2543 * If it's not valid, give an error message and return NULL. | |
2544 */ | |
2545 static u_entry_T * | |
2546 u_get_headentry() | |
2547 { | |
2548 if (curbuf->b_u_newhead == NULL || curbuf->b_u_newhead->uh_entry == NULL) | |
2549 { | |
2550 EMSG(_("E439: undo list corrupt")); | |
2551 return NULL; | |
2552 } | |
2553 return curbuf->b_u_newhead->uh_entry; | |
2554 } | |
2555 | |
2556 /* | |
2557 * u_getbot(): compute the line number of the previous u_save | |
2558 * It is called only when b_u_synced is FALSE. | |
2559 */ | |
2560 static void | |
2561 u_getbot() | |
2562 { | |
2563 u_entry_T *uep; | |
2564 linenr_T extra; | |
2565 | |
2566 uep = u_get_headentry(); /* check for corrupt undo list */ | |
2567 if (uep == NULL) | |
2568 return; | |
2569 | |
2570 uep = curbuf->b_u_newhead->uh_getbot_entry; | |
2571 if (uep != NULL) | |
2572 { | |
2573 /* | |
2574 * the new ue_bot is computed from the number of lines that has been | |
2575 * inserted (0 - deleted) since calling u_save. This is equal to the | |
2576 * old line count subtracted from the current line count. | |
2577 */ | |
2578 extra = curbuf->b_ml.ml_line_count - uep->ue_lcount; | |
2579 uep->ue_bot = uep->ue_top + uep->ue_size + 1 + extra; | |
2580 if (uep->ue_bot < 1 || uep->ue_bot > curbuf->b_ml.ml_line_count) | |
2581 { | |
2582 EMSG(_("E440: undo line missing")); | |
2583 uep->ue_bot = uep->ue_top + 1; /* assume all lines deleted, will | |
2584 * get all the old lines back | |
2585 * without deleting the current | |
2586 * ones */ | |
2587 } | |
2588 | |
2589 curbuf->b_u_newhead->uh_getbot_entry = NULL; | |
2590 } | |
2591 | |
2592 curbuf->b_u_synced = TRUE; | |
2593 } | |
2594 | |
2595 /* | |
1415 | 2596 * Free one header "uhp" and its entry list and adjust the pointers. |
7 | 2597 */ |
2598 static void | |
758 | 2599 u_freeheader(buf, uhp, uhpp) |
168 | 2600 buf_T *buf; |
753 | 2601 u_header_T *uhp; |
2602 u_header_T **uhpp; /* if not NULL reset when freeing this header */ | |
7 | 2603 { |
1415 | 2604 u_header_T *uhap; |
2605 | |
753 | 2606 /* When there is an alternate redo list free that branch completely, |
2607 * because we can never go there. */ | |
2608 if (uhp->uh_alt_next != NULL) | |
2609 u_freebranch(buf, uhp->uh_alt_next, uhpp); | |
7 | 2610 |
753 | 2611 if (uhp->uh_alt_prev != NULL) |
2612 uhp->uh_alt_prev->uh_alt_next = NULL; | |
7 | 2613 |
753 | 2614 /* Update the links in the list to remove the header. */ |
7 | 2615 if (uhp->uh_next == NULL) |
168 | 2616 buf->b_u_oldhead = uhp->uh_prev; |
7 | 2617 else |
2618 uhp->uh_next->uh_prev = uhp->uh_prev; | |
2619 | |
2620 if (uhp->uh_prev == NULL) | |
168 | 2621 buf->b_u_newhead = uhp->uh_next; |
7 | 2622 else |
1415 | 2623 for (uhap = uhp->uh_prev; uhap != NULL; uhap = uhap->uh_alt_next) |
2624 uhap->uh_next = uhp->uh_next; | |
7 | 2625 |
753 | 2626 u_freeentries(buf, uhp, uhpp); |
2627 } | |
2628 | |
2629 /* | |
758 | 2630 * Free an alternate branch and any following alternate branches. |
753 | 2631 */ |
2632 static void | |
2633 u_freebranch(buf, uhp, uhpp) | |
2634 buf_T *buf; | |
2635 u_header_T *uhp; | |
2636 u_header_T **uhpp; /* if not NULL reset when freeing this header */ | |
2637 { | |
2638 u_header_T *tofree, *next; | |
2639 | |
1440 | 2640 /* If this is the top branch we may need to use u_freeheader() to update |
2641 * all the pointers. */ | |
2642 if (uhp == buf->b_u_oldhead) | |
2643 { | |
2644 u_freeheader(buf, uhp, uhpp); | |
2645 return; | |
2646 } | |
2647 | |
753 | 2648 if (uhp->uh_alt_prev != NULL) |
2649 uhp->uh_alt_prev->uh_alt_next = NULL; | |
2650 | |
2651 next = uhp; | |
2652 while (next != NULL) | |
2653 { | |
2654 tofree = next; | |
2655 if (tofree->uh_alt_next != NULL) | |
2656 u_freebranch(buf, tofree->uh_alt_next, uhpp); /* recursive */ | |
2657 next = tofree->uh_prev; | |
2658 u_freeentries(buf, tofree, uhpp); | |
2659 } | |
2660 } | |
2661 | |
2662 /* | |
2663 * Free all the undo entries for one header and the header itself. | |
2664 * This means that "uhp" is invalid when returning. | |
2665 */ | |
2666 static void | |
2667 u_freeentries(buf, uhp, uhpp) | |
2668 buf_T *buf; | |
2669 u_header_T *uhp; | |
2670 u_header_T **uhpp; /* if not NULL reset when freeing this header */ | |
2671 { | |
2672 u_entry_T *uep, *nuep; | |
2673 | |
2674 /* Check for pointers to the header that become invalid now. */ | |
2675 if (buf->b_u_curhead == uhp) | |
2676 buf->b_u_curhead = NULL; | |
1415 | 2677 if (buf->b_u_newhead == uhp) |
2678 buf->b_u_newhead = NULL; /* freeing the newest entry */ | |
753 | 2679 if (uhpp != NULL && uhp == *uhpp) |
2680 *uhpp = NULL; | |
2681 | |
2682 for (uep = uhp->uh_entry; uep != NULL; uep = nuep) | |
2683 { | |
2684 nuep = uep->ue_next; | |
2685 u_freeentry(uep, uep->ue_size); | |
2686 } | |
2687 | |
1415 | 2688 #ifdef U_DEBUG |
2689 uhp->uh_magic = 0; | |
2690 #endif | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2691 vim_free((char_u *)uhp); |
168 | 2692 --buf->b_u_numhead; |
7 | 2693 } |
2694 | |
2695 /* | |
2696 * free entry 'uep' and 'n' lines in uep->ue_array[] | |
2697 */ | |
2698 static void | |
2699 u_freeentry(uep, n) | |
2700 u_entry_T *uep; | |
2701 long n; | |
2702 { | |
414 | 2703 while (n > 0) |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2704 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
|
2705 vim_free((char_u *)uep->ue_array); |
1415 | 2706 #ifdef U_DEBUG |
2707 uep->ue_magic = 0; | |
2708 #endif | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2709 vim_free((char_u *)uep); |
7 | 2710 } |
2711 | |
2712 /* | |
2713 * invalidate the undo buffer; called when storage has already been released | |
2714 */ | |
2715 void | |
2716 u_clearall(buf) | |
2717 buf_T *buf; | |
2718 { | |
2719 buf->b_u_newhead = buf->b_u_oldhead = buf->b_u_curhead = NULL; | |
2720 buf->b_u_synced = TRUE; | |
2721 buf->b_u_numhead = 0; | |
2722 buf->b_u_line_ptr = NULL; | |
2723 buf->b_u_line_lnum = 0; | |
2724 } | |
2725 | |
2726 /* | |
2727 * save the line "lnum" for the "U" command | |
2728 */ | |
2729 void | |
2730 u_saveline(lnum) | |
2731 linenr_T lnum; | |
2732 { | |
2733 if (lnum == curbuf->b_u_line_lnum) /* line is already saved */ | |
2734 return; | |
356 | 2735 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) /* should never happen */ |
7 | 2736 return; |
2737 u_clearline(); | |
2738 curbuf->b_u_line_lnum = lnum; | |
2739 if (curwin->w_cursor.lnum == lnum) | |
2740 curbuf->b_u_line_colnr = curwin->w_cursor.col; | |
2741 else | |
2742 curbuf->b_u_line_colnr = 0; | |
2743 if ((curbuf->b_u_line_ptr = u_save_line(lnum)) == NULL) | |
2744 do_outofmem_msg((long_u)0); | |
2745 } | |
2746 | |
2747 /* | |
2748 * clear the line saved for the "U" command | |
2749 * (this is used externally for crossing a line while in insert mode) | |
2750 */ | |
2751 void | |
2752 u_clearline() | |
2753 { | |
2754 if (curbuf->b_u_line_ptr != NULL) | |
2755 { | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2756 vim_free(curbuf->b_u_line_ptr); |
7 | 2757 curbuf->b_u_line_ptr = NULL; |
2758 curbuf->b_u_line_lnum = 0; | |
2759 } | |
2760 } | |
2761 | |
2762 /* | |
2763 * Implementation of the "U" command. | |
2764 * Differentiation from vi: "U" can be undone with the next "U". | |
2765 * We also allow the cursor to be in another line. | |
2766 */ | |
2767 void | |
2768 u_undoline() | |
2769 { | |
2770 colnr_T t; | |
2771 char_u *oldp; | |
2772 | |
2773 if (undo_off) | |
2774 return; | |
2775 | |
1534 | 2776 if (curbuf->b_u_line_ptr == NULL |
2777 || curbuf->b_u_line_lnum > curbuf->b_ml.ml_line_count) | |
7 | 2778 { |
2779 beep_flush(); | |
2780 return; | |
2781 } | |
1534 | 2782 |
2783 /* first save the line for the 'u' command */ | |
7 | 2784 if (u_savecommon(curbuf->b_u_line_lnum - 1, |
2785 curbuf->b_u_line_lnum + 1, (linenr_T)0) == FAIL) | |
2786 return; | |
2787 oldp = u_save_line(curbuf->b_u_line_lnum); | |
2788 if (oldp == NULL) | |
2789 { | |
2790 do_outofmem_msg((long_u)0); | |
2791 return; | |
2792 } | |
2793 ml_replace(curbuf->b_u_line_lnum, curbuf->b_u_line_ptr, TRUE); | |
2794 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
|
2795 vim_free(curbuf->b_u_line_ptr); |
7 | 2796 curbuf->b_u_line_ptr = oldp; |
2797 | |
2798 t = curbuf->b_u_line_colnr; | |
2799 if (curwin->w_cursor.lnum == curbuf->b_u_line_lnum) | |
2800 curbuf->b_u_line_colnr = curwin->w_cursor.col; | |
2801 curwin->w_cursor.col = t; | |
2802 curwin->w_cursor.lnum = curbuf->b_u_line_lnum; | |
1534 | 2803 check_cursor_col(); |
7 | 2804 } |
2805 | |
2806 /* | |
168 | 2807 * Free all allocated memory blocks for the buffer 'buf'. |
2808 */ | |
2809 void | |
2810 u_blockfree(buf) | |
2811 buf_T *buf; | |
2812 { | |
753 | 2813 while (buf->b_u_oldhead != NULL) |
758 | 2814 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
|
2815 vim_free(buf->b_u_line_ptr); |
7 | 2816 } |
2817 | |
2818 /* | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2819 * 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
|
2820 * Returns NULL when out of memory. |
7 | 2821 */ |
2822 static char_u * | |
2823 u_save_line(lnum) | |
2824 linenr_T lnum; | |
2825 { | |
2230
290ee42cae85
Remove old and unused method to allocate memory for undo.
Bram Moolenaar <bram@vim.org>
parents:
2229
diff
changeset
|
2826 return vim_strsave(ml_get(lnum)); |
7 | 2827 } |
2828 | |
2829 /* | |
2830 * Check if the 'modified' flag is set, or 'ff' has changed (only need to | |
2831 * check the first character, because it can only be "dos", "unix" or "mac"). | |
2832 * "nofile" and "scratch" type buffers are considered to always be unchanged. | |
2833 */ | |
2834 int | |
2835 bufIsChanged(buf) | |
2836 buf_T *buf; | |
2837 { | |
2838 return | |
2839 #ifdef FEAT_QUICKFIX | |
2840 !bt_dontwrite(buf) && | |
2841 #endif | |
2842 (buf->b_changed || file_ff_differs(buf)); | |
2843 } | |
2844 | |
2845 int | |
2846 curbufIsChanged() | |
2847 { | |
2848 return | |
2849 #ifdef FEAT_QUICKFIX | |
2850 !bt_dontwrite(curbuf) && | |
2851 #endif | |
2852 (curbuf->b_changed || file_ff_differs(curbuf)); | |
2853 } |