vim: src/undo.c annotate

annotate src/undo.c @ 2281:e41433ea71df vim73

Added ":earlier 1f" and ":later 1f".

author	Bram Moolenaar <bram@vim.org>
date	Sun, 27 Jun 2010 05:18:54 +0200
parents	941ff1cd317a
children	a888ed7ba375

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

Mercurial > vim

annotate src/undo.c @ 2281:e41433ea71df vim73