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