blob: b6f0300516ccfd1f883bde70f7ff82485e6d2362 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/* for debugging */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +010011/* #define CHECK(c, s) do { if (c) emsg((s)); } while (0) */
Bram Moolenaar6f470022018-04-10 18:47:20 +020012#define CHECK(c, s) do { /**/ } while (0)
Bram Moolenaar071d4272004-06-13 20:20:40 +000013
14/*
15 * memline.c: Contains the functions for appending, deleting and changing the
Bram Moolenaar4770d092006-01-12 23:22:24 +000016 * text lines. The memfile functions are used to store the information in
17 * blocks of memory, backed up by a file. The structure of the information is
18 * a tree. The root of the tree is a pointer block. The leaves of the tree
19 * are data blocks. In between may be several layers of pointer blocks,
20 * forming branches.
Bram Moolenaar071d4272004-06-13 20:20:40 +000021 *
22 * Three types of blocks are used:
23 * - Block nr 0 contains information for recovery
24 * - Pointer blocks contain list of pointers to other blocks.
25 * - Data blocks contain the actual text.
26 *
27 * Block nr 0 contains the block0 structure (see below).
28 *
29 * Block nr 1 is the first pointer block. It is the root of the tree.
30 * Other pointer blocks are branches.
31 *
32 * If a line is too big to fit in a single page, the block containing that
33 * line is made big enough to hold the line. It may span several pages.
34 * Otherwise all blocks are one page.
35 *
36 * A data block that was filled when starting to edit a file and was not
37 * changed since then, can have a negative block number. This means that it
38 * has not yet been assigned a place in the file. When recovering, the lines
39 * in this data block can be read from the original file. When the block is
40 * changed (lines appended/deleted/changed) or when it is flushed it gets a
41 * positive number. Use mf_trans_del() to get the new number, before calling
42 * mf_get().
43 */
44
Bram Moolenaar071d4272004-06-13 20:20:40 +000045#include "vim.h"
46
Bram Moolenaar071d4272004-06-13 20:20:40 +000047#ifndef UNIX /* it's in os_unix.h for Unix */
48# include <time.h>
49#endif
50
Bram Moolenaar5a6404c2006-11-01 17:12:57 +000051#if defined(SASC) || defined(__amigaos4__)
Bram Moolenaar071d4272004-06-13 20:20:40 +000052# include <proto/dos.h> /* for Open() and Close() */
53#endif
54
55typedef struct block0 ZERO_BL; /* contents of the first block */
56typedef struct pointer_block PTR_BL; /* contents of a pointer block */
57typedef struct data_block DATA_BL; /* contents of a data block */
58typedef struct pointer_entry PTR_EN; /* block/line-count pair */
59
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +020060#define DATA_ID (('d' << 8) + 'a') /* data block id */
61#define PTR_ID (('p' << 8) + 't') /* pointer block id */
62#define BLOCK0_ID0 'b' /* block 0 id 0 */
63#define BLOCK0_ID1 '0' /* block 0 id 1 */
64#define BLOCK0_ID1_C0 'c' /* block 0 id 1 'cm' 0 */
65#define BLOCK0_ID1_C1 'C' /* block 0 id 1 'cm' 1 */
Bram Moolenaar8f4ac012014-08-10 13:38:34 +020066#define BLOCK0_ID1_C2 'd' /* block 0 id 1 'cm' 2 */
67
68#if defined(FEAT_CRYPT)
69static int id1_codes[] = {
70 BLOCK0_ID1_C0, /* CRYPT_M_ZIP */
71 BLOCK0_ID1_C1, /* CRYPT_M_BF */
72 BLOCK0_ID1_C2, /* CRYPT_M_BF2 */
73};
74#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000075
76/*
77 * pointer to a block, used in a pointer block
78 */
79struct pointer_entry
80{
81 blocknr_T pe_bnum; /* block number */
82 linenr_T pe_line_count; /* number of lines in this branch */
83 linenr_T pe_old_lnum; /* lnum for this block (for recovery) */
84 int pe_page_count; /* number of pages in block pe_bnum */
85};
86
87/*
88 * A pointer block contains a list of branches in the tree.
89 */
90struct pointer_block
91{
92 short_u pb_id; /* ID for pointer block: PTR_ID */
Bram Moolenaar20a825a2010-05-31 21:27:30 +020093 short_u pb_count; /* number of pointers in this block */
Bram Moolenaar071d4272004-06-13 20:20:40 +000094 short_u pb_count_max; /* maximum value for pb_count */
95 PTR_EN pb_pointer[1]; /* list of pointers to blocks (actually longer)
96 * followed by empty space until end of page */
97};
98
99/*
100 * A data block is a leaf in the tree.
101 *
102 * The text of the lines is at the end of the block. The text of the first line
103 * in the block is put at the end, the text of the second line in front of it,
104 * etc. Thus the order of the lines is the opposite of the line number.
105 */
106struct data_block
107{
108 short_u db_id; /* ID for data block: DATA_ID */
109 unsigned db_free; /* free space available */
110 unsigned db_txt_start; /* byte where text starts */
111 unsigned db_txt_end; /* byte just after data block */
112 linenr_T db_line_count; /* number of lines in this block */
113 unsigned db_index[1]; /* index for start of line (actually bigger)
114 * followed by empty space upto db_txt_start
115 * followed by the text in the lines until
116 * end of page */
117};
118
119/*
120 * The low bits of db_index hold the actual index. The topmost bit is
121 * used for the global command to be able to mark a line.
122 * This method is not clean, but otherwise there would be at least one extra
123 * byte used for each line.
124 * The mark has to be in this place to keep it with the correct line when other
125 * lines are inserted or deleted.
126 */
127#define DB_MARKED ((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
128#define DB_INDEX_MASK (~DB_MARKED)
129
130#define INDEX_SIZE (sizeof(unsigned)) /* size of one db_index entry */
131#define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE) /* size of data block header */
132
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000133#define B0_FNAME_SIZE_ORG 900 /* what it was in older versions */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200134#define B0_FNAME_SIZE_NOCRYPT 898 /* 2 bytes used for other things */
135#define B0_FNAME_SIZE_CRYPT 890 /* 10 bytes used for other things */
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000136#define B0_UNAME_SIZE 40
137#define B0_HNAME_SIZE 40
Bram Moolenaar071d4272004-06-13 20:20:40 +0000138/*
139 * Restrict the numbers to 32 bits, otherwise most compilers will complain.
140 * This won't detect a 64 bit machine that only swaps a byte in the top 32
141 * bits, but that is crazy anyway.
142 */
143#define B0_MAGIC_LONG 0x30313233L
144#define B0_MAGIC_INT 0x20212223L
145#define B0_MAGIC_SHORT 0x10111213L
146#define B0_MAGIC_CHAR 0x55
147
148/*
149 * Block zero holds all info about the swap file.
150 *
151 * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing
152 * swap files unusable!
153 *
154 * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!!
155 *
Bram Moolenaarbae0c162007-05-10 19:30:25 +0000156 * This block is built up of single bytes, to make it portable across
Bram Moolenaar071d4272004-06-13 20:20:40 +0000157 * different machines. b0_magic_* is used to check the byte order and size of
158 * variables, because the rest of the swap file is not portable.
159 */
160struct block0
161{
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200162 char_u b0_id[2]; /* id for block 0: BLOCK0_ID0 and BLOCK0_ID1,
Bram Moolenaar8f4ac012014-08-10 13:38:34 +0200163 * BLOCK0_ID1_C0, BLOCK0_ID1_C1, etc. */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000164 char_u b0_version[10]; /* Vim version string */
165 char_u b0_page_size[4];/* number of bytes per page */
166 char_u b0_mtime[4]; /* last modification time of file */
167 char_u b0_ino[4]; /* inode of b0_fname */
168 char_u b0_pid[4]; /* process id of creator (or 0) */
169 char_u b0_uname[B0_UNAME_SIZE]; /* name of user (uid if no name) */
170 char_u b0_hname[B0_HNAME_SIZE]; /* host name (if it has a name) */
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000171 char_u b0_fname[B0_FNAME_SIZE_ORG]; /* name of file being edited */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000172 long b0_magic_long; /* check for byte order of long */
173 int b0_magic_int; /* check for byte order of int */
174 short b0_magic_short; /* check for byte order of short */
175 char_u b0_magic_char; /* check for last char */
176};
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000177
178/*
Bram Moolenaar4770d092006-01-12 23:22:24 +0000179 * Note: b0_dirty and b0_flags are put at the end of the file name. For very
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000180 * long file names in older versions of Vim they are invalid.
181 * The 'fileencoding' comes before b0_flags, with a NUL in front. But only
182 * when there is room, for very long file names it's omitted.
183 */
184#define B0_DIRTY 0x55
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200185#define b0_dirty b0_fname[B0_FNAME_SIZE_ORG - 1]
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000186
187/*
188 * The b0_flags field is new in Vim 7.0.
189 */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200190#define b0_flags b0_fname[B0_FNAME_SIZE_ORG - 2]
191
192/*
193 * Crypt seed goes here, 8 bytes. New in Vim 7.3.
194 * Without encryption these bytes may be used for 'fenc'.
195 */
196#define b0_seed b0_fname[B0_FNAME_SIZE_ORG - 2 - MF_SEED_LEN]
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000197
198/* The lowest two bits contain the fileformat. Zero means it's not set
199 * (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or
200 * EOL_MAC + 1. */
201#define B0_FF_MASK 3
202
203/* Swap file is in directory of edited file. Used to find the file from
204 * different mount points. */
205#define B0_SAME_DIR 4
206
207/* The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it.
208 * When empty there is only the NUL. */
209#define B0_HAS_FENC 8
Bram Moolenaar071d4272004-06-13 20:20:40 +0000210
211#define STACK_INCR 5 /* nr of entries added to ml_stack at a time */
212
213/*
214 * The line number where the first mark may be is remembered.
215 * If it is 0 there are no marks at all.
216 * (always used for the current buffer only, no buffer change possible while
217 * executing a global command).
218 */
219static linenr_T lowest_marked = 0;
220
221/*
222 * arguments for ml_find_line()
223 */
224#define ML_DELETE 0x11 /* delete line */
225#define ML_INSERT 0x12 /* insert line */
226#define ML_FIND 0x13 /* just find the line */
227#define ML_FLUSH 0x02 /* flush locked block */
228#define ML_SIMPLE(x) (x & 0x10) /* DEL, INS or FIND */
229
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200230/* argument for ml_upd_block0() */
231typedef enum {
232 UB_FNAME = 0 /* update timestamp and filename */
233 , UB_SAME_DIR /* update the B0_SAME_DIR flag */
234 , UB_CRYPT /* update crypt key */
235} upd_block0_T;
236
237#ifdef FEAT_CRYPT
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100238static void ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200239#endif
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100240static void ml_upd_block0(buf_T *buf, upd_block0_T what);
241static void set_b0_fname(ZERO_BL *, buf_T *buf);
242static void set_b0_dir_flag(ZERO_BL *b0p, buf_T *buf);
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100243static void add_b0_fenc(ZERO_BL *b0p, buf_T *buf);
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100244static time_t swapfile_info(char_u *);
245static int recov_file_names(char_u **, char_u *, int prepend_dot);
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100246static int ml_delete_int(buf_T *, linenr_T, int);
247static char_u *findswapname(buf_T *, char_u **, char_u *);
248static void ml_flush_line(buf_T *);
249static bhdr_T *ml_new_data(memfile_T *, int, int);
250static bhdr_T *ml_new_ptr(memfile_T *);
251static bhdr_T *ml_find_line(buf_T *, linenr_T, int);
252static int ml_add_stack(buf_T *);
253static void ml_lineadd(buf_T *, int);
254static int b0_magic_wrong(ZERO_BL *);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000255#ifdef CHECK_INODE
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100256static int fnamecmp_ino(char_u *, char_u *, long);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000257#endif
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100258static void long_to_char(long, char_u *);
259static long char_to_long(char_u *);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200260#ifdef FEAT_CRYPT
Bram Moolenaar8767f522016-07-01 17:17:39 +0200261static cryptstate_T *ml_crypt_prepare(memfile_T *mfp, off_T offset, int reading);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200262#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000263#ifdef FEAT_BYTEOFF
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +0100264static void ml_updatechunk(buf_T *buf, long line, long len, int updtype);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000265#endif
266
267/*
Bram Moolenaar4770d092006-01-12 23:22:24 +0000268 * Open a new memline for "buf".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000269 *
Bram Moolenaar4770d092006-01-12 23:22:24 +0000270 * Return FAIL for failure, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000271 */
272 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100273ml_open(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000274{
275 memfile_T *mfp;
276 bhdr_T *hp = NULL;
277 ZERO_BL *b0p;
278 PTR_BL *pp;
279 DATA_BL *dp;
280
Bram Moolenaar4770d092006-01-12 23:22:24 +0000281 /*
282 * init fields in memline struct
283 */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200284 buf->b_ml.ml_stack_size = 0; /* no stack yet */
Bram Moolenaar4770d092006-01-12 23:22:24 +0000285 buf->b_ml.ml_stack = NULL; /* no stack yet */
286 buf->b_ml.ml_stack_top = 0; /* nothing in the stack */
287 buf->b_ml.ml_locked = NULL; /* no cached block */
288 buf->b_ml.ml_line_lnum = 0; /* no cached line */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000289#ifdef FEAT_BYTEOFF
Bram Moolenaar4770d092006-01-12 23:22:24 +0000290 buf->b_ml.ml_chunksize = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000291#endif
292
Bram Moolenaar5803ae62014-03-23 16:04:02 +0100293 if (cmdmod.noswapfile)
294 buf->b_p_swf = FALSE;
295
Bram Moolenaar4770d092006-01-12 23:22:24 +0000296 /*
297 * When 'updatecount' is non-zero swap file may be opened later.
298 */
299 if (p_uc && buf->b_p_swf)
300 buf->b_may_swap = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000301 else
Bram Moolenaar4770d092006-01-12 23:22:24 +0000302 buf->b_may_swap = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000303
Bram Moolenaar4770d092006-01-12 23:22:24 +0000304 /*
305 * Open the memfile. No swap file is created yet.
306 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000307 mfp = mf_open(NULL, 0);
308 if (mfp == NULL)
309 goto error;
310
Bram Moolenaar4770d092006-01-12 23:22:24 +0000311 buf->b_ml.ml_mfp = mfp;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200312#ifdef FEAT_CRYPT
313 mfp->mf_buffer = buf;
314#endif
Bram Moolenaar4770d092006-01-12 23:22:24 +0000315 buf->b_ml.ml_flags = ML_EMPTY;
316 buf->b_ml.ml_line_count = 1;
Bram Moolenaar592e0a22004-07-03 16:05:59 +0000317#ifdef FEAT_LINEBREAK
318 curwin->w_nrwidth_line_count = 0;
319#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000320
Bram Moolenaar071d4272004-06-13 20:20:40 +0000321/*
322 * fill block0 struct and write page 0
323 */
324 if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
325 goto error;
326 if (hp->bh_bnum != 0)
327 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100328 iemsg(_("E298: Didn't get block nr 0?"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000329 goto error;
330 }
331 b0p = (ZERO_BL *)(hp->bh_data);
332
333 b0p->b0_id[0] = BLOCK0_ID0;
334 b0p->b0_id[1] = BLOCK0_ID1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000335 b0p->b0_magic_long = (long)B0_MAGIC_LONG;
336 b0p->b0_magic_int = (int)B0_MAGIC_INT;
337 b0p->b0_magic_short = (short)B0_MAGIC_SHORT;
338 b0p->b0_magic_char = B0_MAGIC_CHAR;
Bram Moolenaar22c10562018-05-26 17:35:27 +0200339 mch_memmove(b0p->b0_version, "VIM ", 4);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000340 STRNCPY(b0p->b0_version + 4, Version, 6);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000341 long_to_char((long)mfp->mf_page_size, b0p->b0_page_size);
Bram Moolenaar4770d092006-01-12 23:22:24 +0000342
Bram Moolenaar76b92b22006-03-24 22:46:53 +0000343#ifdef FEAT_SPELL
344 if (!buf->b_spell)
345#endif
Bram Moolenaar4770d092006-01-12 23:22:24 +0000346 {
347 b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0;
348 b0p->b0_flags = get_fileformat(buf) + 1;
349 set_b0_fname(b0p, buf);
350 (void)get_user_name(b0p->b0_uname, B0_UNAME_SIZE);
351 b0p->b0_uname[B0_UNAME_SIZE - 1] = NUL;
352 mch_get_host_name(b0p->b0_hname, B0_HNAME_SIZE);
353 b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL;
354 long_to_char(mch_get_pid(), b0p->b0_pid);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200355#ifdef FEAT_CRYPT
Bram Moolenaar8f4ac012014-08-10 13:38:34 +0200356 ml_set_b0_crypt(buf, b0p);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200357#endif
Bram Moolenaar4770d092006-01-12 23:22:24 +0000358 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000359
360 /*
361 * Always sync block number 0 to disk, so we can check the file name in
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200362 * the swap file in findswapname(). Don't do this for a help files or
363 * a spell buffer though.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000364 * Only works when there's a swapfile, otherwise it's done when the file
365 * is created.
366 */
367 mf_put(mfp, hp, TRUE, FALSE);
Bram Moolenaar4770d092006-01-12 23:22:24 +0000368 if (!buf->b_help && !B_SPELL(buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000369 (void)mf_sync(mfp, 0);
370
Bram Moolenaar4770d092006-01-12 23:22:24 +0000371 /*
372 * Fill in root pointer block and write page 1.
373 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000374 if ((hp = ml_new_ptr(mfp)) == NULL)
375 goto error;
376 if (hp->bh_bnum != 1)
377 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100378 iemsg(_("E298: Didn't get block nr 1?"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000379 goto error;
380 }
381 pp = (PTR_BL *)(hp->bh_data);
382 pp->pb_count = 1;
383 pp->pb_pointer[0].pe_bnum = 2;
384 pp->pb_pointer[0].pe_page_count = 1;
385 pp->pb_pointer[0].pe_old_lnum = 1;
386 pp->pb_pointer[0].pe_line_count = 1; /* line count after insertion */
387 mf_put(mfp, hp, TRUE, FALSE);
388
Bram Moolenaar4770d092006-01-12 23:22:24 +0000389 /*
390 * Allocate first data block and create an empty line 1.
391 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000392 if ((hp = ml_new_data(mfp, FALSE, 1)) == NULL)
393 goto error;
394 if (hp->bh_bnum != 2)
395 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100396 iemsg(_("E298: Didn't get block nr 2?"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000397 goto error;
398 }
399
400 dp = (DATA_BL *)(hp->bh_data);
401 dp->db_index[0] = --dp->db_txt_start; /* at end of block */
402 dp->db_free -= 1 + INDEX_SIZE;
403 dp->db_line_count = 1;
Bram Moolenaarf05da212009-11-17 16:13:15 +0000404 *((char_u *)dp + dp->db_txt_start) = NUL; /* empty line */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000405
406 return OK;
407
408error:
409 if (mfp != NULL)
410 {
411 if (hp)
412 mf_put(mfp, hp, FALSE, FALSE);
413 mf_close(mfp, TRUE); /* will also free(mfp->mf_fname) */
414 }
Bram Moolenaar4770d092006-01-12 23:22:24 +0000415 buf->b_ml.ml_mfp = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000416 return FAIL;
417}
418
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200419#if defined(FEAT_CRYPT) || defined(PROTO)
420/*
Bram Moolenaar2be79502014-08-13 21:58:28 +0200421 * Prepare encryption for "buf" for the current key and method.
422 */
423 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100424ml_set_mfp_crypt(buf_T *buf)
Bram Moolenaar2be79502014-08-13 21:58:28 +0200425{
426 if (*buf->b_p_key != NUL)
427 {
428 int method_nr = crypt_get_method_nr(buf);
429
430 if (method_nr > CRYPT_M_ZIP)
431 {
432 /* Generate a seed and store it in the memfile. */
433 sha2_seed(buf->b_ml.ml_mfp->mf_seed, MF_SEED_LEN, NULL, 0);
434 }
435 }
436}
437
438/*
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200439 * Prepare encryption for "buf" with block 0 "b0p".
440 */
441 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100442ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200443{
444 if (*buf->b_p_key == NUL)
445 b0p->b0_id[1] = BLOCK0_ID1;
446 else
447 {
Bram Moolenaar8f4ac012014-08-10 13:38:34 +0200448 int method_nr = crypt_get_method_nr(buf);
449
450 b0p->b0_id[1] = id1_codes[method_nr];
451 if (method_nr > CRYPT_M_ZIP)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200452 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200453 /* Generate a seed and store it in block 0 and in the memfile. */
454 sha2_seed(&b0p->b0_seed, MF_SEED_LEN, NULL, 0);
455 mch_memmove(buf->b_ml.ml_mfp->mf_seed, &b0p->b0_seed, MF_SEED_LEN);
456 }
457 }
458}
459
460/*
461 * Called after the crypt key or 'cryptmethod' was changed for "buf".
462 * Will apply this to the swapfile.
463 * "old_key" is the previous key. It is equal to buf->b_p_key when
464 * 'cryptmethod' is changed.
Bram Moolenaar49771f42010-07-20 17:32:38 +0200465 * "old_cm" is the previous 'cryptmethod'. It is equal to the current
466 * 'cryptmethod' when 'key' is changed.
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200467 */
468 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100469ml_set_crypt_key(
470 buf_T *buf,
471 char_u *old_key,
472 char_u *old_cm)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200473{
474 memfile_T *mfp = buf->b_ml.ml_mfp;
475 bhdr_T *hp;
476 int page_count;
477 int idx;
478 long error;
479 infoptr_T *ip;
480 PTR_BL *pp;
481 DATA_BL *dp;
482 blocknr_T bnum;
483 int top;
Bram Moolenaarbc563362015-06-09 18:35:25 +0200484 int old_method;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200485
Bram Moolenaar3832c462010-08-04 15:32:46 +0200486 if (mfp == NULL)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200487 return; /* no memfile yet, nothing to do */
Bram Moolenaarbc563362015-06-09 18:35:25 +0200488 old_method = crypt_method_nr_from_name(old_cm);
489
490 /* First make sure the swapfile is in a consistent state, using the old
491 * key and method. */
492 {
493 char_u *new_key = buf->b_p_key;
494 char_u *new_buf_cm = buf->b_p_cm;
495
496 buf->b_p_key = old_key;
497 buf->b_p_cm = old_cm;
498 ml_preserve(buf, FALSE);
499 buf->b_p_key = new_key;
500 buf->b_p_cm = new_buf_cm;
501 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200502
503 /* Set the key, method and seed to be used for reading, these must be the
504 * old values. */
505 mfp->mf_old_key = old_key;
Bram Moolenaarbc563362015-06-09 18:35:25 +0200506 mfp->mf_old_cm = old_method;
507 if (old_method > 0 && *old_key != NUL)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200508 mch_memmove(mfp->mf_old_seed, mfp->mf_seed, MF_SEED_LEN);
509
510 /* Update block 0 with the crypt flag and may set a new seed. */
511 ml_upd_block0(buf, UB_CRYPT);
512
513 if (mfp->mf_infile_count > 2)
514 {
515 /*
516 * Need to read back all data blocks from disk, decrypt them with the
517 * old key/method and mark them to be written. The algorithm is
518 * similar to what happens in ml_recover(), but we skip negative block
519 * numbers.
520 */
521 ml_flush_line(buf); /* flush buffered line */
522 (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
523
524 hp = NULL;
525 bnum = 1; /* start with block 1 */
526 page_count = 1; /* which is 1 page */
527 idx = 0; /* start with first index in block 1 */
528 error = 0;
529 buf->b_ml.ml_stack_top = 0;
Bram Moolenaard23a8232018-02-10 18:45:26 +0100530 VIM_CLEAR(buf->b_ml.ml_stack);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200531 buf->b_ml.ml_stack_size = 0; /* no stack yet */
532
533 for ( ; !got_int; line_breakcheck())
534 {
535 if (hp != NULL)
536 mf_put(mfp, hp, FALSE, FALSE); /* release previous block */
537
538 /* get the block (pointer or data) */
539 if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL)
540 {
541 if (bnum == 1)
542 break;
543 ++error;
544 }
545 else
546 {
547 pp = (PTR_BL *)(hp->bh_data);
548 if (pp->pb_id == PTR_ID) /* it is a pointer block */
549 {
550 if (pp->pb_count == 0)
551 {
552 /* empty block? */
553 ++error;
554 }
555 else if (idx < (int)pp->pb_count) /* go a block deeper */
556 {
557 if (pp->pb_pointer[idx].pe_bnum < 0)
558 {
Bram Moolenaarbc563362015-06-09 18:35:25 +0200559 /* Skip data block with negative block number.
560 * Should not happen, because of the ml_preserve()
561 * above. Get same block again for next index. */
Bram Moolenaar4b7214e2019-01-03 21:55:32 +0100562 ++idx;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200563 continue;
564 }
565
566 /* going one block deeper in the tree, new entry in
567 * stack */
568 if ((top = ml_add_stack(buf)) < 0)
569 {
570 ++error;
571 break; /* out of memory */
572 }
573 ip = &(buf->b_ml.ml_stack[top]);
574 ip->ip_bnum = bnum;
575 ip->ip_index = idx;
576
577 bnum = pp->pb_pointer[idx].pe_bnum;
578 page_count = pp->pb_pointer[idx].pe_page_count;
Bram Moolenaarbc563362015-06-09 18:35:25 +0200579 idx = 0;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200580 continue;
581 }
582 }
583 else /* not a pointer block */
584 {
585 dp = (DATA_BL *)(hp->bh_data);
586 if (dp->db_id != DATA_ID) /* block id wrong */
587 ++error;
588 else
589 {
590 /* It is a data block, need to write it back to disk. */
591 mf_put(mfp, hp, TRUE, FALSE);
592 hp = NULL;
593 }
594 }
595 }
596
597 if (buf->b_ml.ml_stack_top == 0) /* finished */
598 break;
599
600 /* go one block up in the tree */
601 ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
602 bnum = ip->ip_bnum;
603 idx = ip->ip_index + 1; /* go to next index */
604 page_count = 1;
605 }
Bram Moolenaarbc563362015-06-09 18:35:25 +0200606 if (hp != NULL)
607 mf_put(mfp, hp, FALSE, FALSE); /* release previous block */
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +0100608
609 if (error > 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100610 emsg(_("E843: Error while updating swap file crypt"));
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200611 }
612
613 mfp->mf_old_key = NULL;
614}
615#endif
616
Bram Moolenaar071d4272004-06-13 20:20:40 +0000617/*
618 * ml_setname() is called when the file name of "buf" has been changed.
619 * It may rename the swap file.
620 */
621 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100622ml_setname(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000623{
624 int success = FALSE;
625 memfile_T *mfp;
626 char_u *fname;
627 char_u *dirp;
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100628#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000629 char_u *p;
630#endif
631
632 mfp = buf->b_ml.ml_mfp;
633 if (mfp->mf_fd < 0) /* there is no swap file yet */
634 {
635 /*
636 * When 'updatecount' is 0 and 'noswapfile' there is no swap file.
637 * For help files we will make a swap file now.
638 */
Bram Moolenaar5803ae62014-03-23 16:04:02 +0100639 if (p_uc != 0 && !cmdmod.noswapfile)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000640 ml_open_file(buf); /* create a swap file */
641 return;
642 }
643
644 /*
645 * Try all directories in the 'directory' option.
646 */
647 dirp = p_dir;
648 for (;;)
649 {
650 if (*dirp == NUL) /* tried all directories, fail */
651 break;
Bram Moolenaar8fc061c2004-12-29 21:03:02 +0000652 fname = findswapname(buf, &dirp, mfp->mf_fname);
653 /* alloc's fname */
Bram Moolenaarf541c362011-10-26 11:44:18 +0200654 if (dirp == NULL) /* out of memory */
655 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000656 if (fname == NULL) /* no file name found for this dir */
657 continue;
658
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100659#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000660 /*
661 * Set full pathname for swap file now, because a ":!cd dir" may
662 * change directory without us knowing it.
663 */
664 p = FullName_save(fname, FALSE);
665 vim_free(fname);
666 fname = p;
667 if (fname == NULL)
668 continue;
669#endif
670 /* if the file name is the same we don't have to do anything */
671 if (fnamecmp(fname, mfp->mf_fname) == 0)
672 {
673 vim_free(fname);
674 success = TRUE;
675 break;
676 }
677 /* need to close the swap file before renaming */
678 if (mfp->mf_fd >= 0)
679 {
680 close(mfp->mf_fd);
681 mfp->mf_fd = -1;
682 }
683
684 /* try to rename the swap file */
685 if (vim_rename(mfp->mf_fname, fname) == 0)
686 {
687 success = TRUE;
688 vim_free(mfp->mf_fname);
689 mfp->mf_fname = fname;
690 vim_free(mfp->mf_ffname);
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100691#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000692 mfp->mf_ffname = NULL; /* mf_fname is full pathname already */
693#else
694 mf_set_ffname(mfp);
695#endif
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200696 ml_upd_block0(buf, UB_SAME_DIR);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000697 break;
698 }
699 vim_free(fname); /* this fname didn't work, try another */
700 }
701
702 if (mfp->mf_fd == -1) /* need to (re)open the swap file */
703 {
704 mfp->mf_fd = mch_open((char *)mfp->mf_fname, O_RDWR | O_EXTRA, 0);
705 if (mfp->mf_fd < 0)
706 {
707 /* could not (re)open the swap file, what can we do???? */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100708 emsg(_("E301: Oops, lost the swap file!!!"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000709 return;
710 }
Bram Moolenaarf05da212009-11-17 16:13:15 +0000711#ifdef HAVE_FD_CLOEXEC
712 {
713 int fdflags = fcntl(mfp->mf_fd, F_GETFD);
714 if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0)
Bram Moolenaarfbc4b4d2016-02-07 15:14:01 +0100715 (void)fcntl(mfp->mf_fd, F_SETFD, fdflags | FD_CLOEXEC);
Bram Moolenaarf05da212009-11-17 16:13:15 +0000716 }
717#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000718 }
719 if (!success)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100720 emsg(_("E302: Could not rename swap file"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000721}
722
723/*
724 * Open a file for the memfile for all buffers that are not readonly or have
725 * been modified.
726 * Used when 'updatecount' changes from zero to non-zero.
727 */
728 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100729ml_open_files(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000730{
731 buf_T *buf;
732
Bram Moolenaar29323592016-07-24 22:04:11 +0200733 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000734 if (!buf->b_p_ro || buf->b_changed)
735 ml_open_file(buf);
736}
737
738/*
739 * Open a swap file for an existing memfile, if there is no swap file yet.
740 * If we are unable to find a file name, mf_fname will be NULL
741 * and the memfile will be in memory only (no recovery possible).
742 */
743 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100744ml_open_file(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000745{
746 memfile_T *mfp;
747 char_u *fname;
748 char_u *dirp;
749
750 mfp = buf->b_ml.ml_mfp;
Bram Moolenaar5803ae62014-03-23 16:04:02 +0100751 if (mfp == NULL || mfp->mf_fd >= 0 || !buf->b_p_swf || cmdmod.noswapfile)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000752 return; /* nothing to do */
753
Bram Moolenaara1956f62006-03-12 22:18:00 +0000754#ifdef FEAT_SPELL
Bram Moolenaar4770d092006-01-12 23:22:24 +0000755 /* For a spell buffer use a temp file name. */
756 if (buf->b_spell)
757 {
Bram Moolenaare5c421c2015-03-31 13:33:08 +0200758 fname = vim_tempname('s', FALSE);
Bram Moolenaar4770d092006-01-12 23:22:24 +0000759 if (fname != NULL)
760 (void)mf_open_file(mfp, fname); /* consumes fname! */
761 buf->b_may_swap = FALSE;
762 return;
763 }
764#endif
765
Bram Moolenaar071d4272004-06-13 20:20:40 +0000766 /*
767 * Try all directories in 'directory' option.
768 */
769 dirp = p_dir;
770 for (;;)
771 {
772 if (*dirp == NUL)
773 break;
Bram Moolenaare242b832010-06-24 05:39:03 +0200774 /* There is a small chance that between choosing the swap file name
775 * and creating it, another Vim creates the file. In that case the
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776 * creation will fail and we will use another directory. */
Bram Moolenaar8fc061c2004-12-29 21:03:02 +0000777 fname = findswapname(buf, &dirp, NULL); /* allocates fname */
Bram Moolenaarf541c362011-10-26 11:44:18 +0200778 if (dirp == NULL)
779 break; /* out of memory */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000780 if (fname == NULL)
781 continue;
782 if (mf_open_file(mfp, fname) == OK) /* consumes fname! */
783 {
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100784#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000785 /*
786 * set full pathname for swap file now, because a ":!cd dir" may
787 * change directory without us knowing it.
788 */
789 mf_fullname(mfp);
790#endif
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200791 ml_upd_block0(buf, UB_SAME_DIR);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000792
Bram Moolenaar071d4272004-06-13 20:20:40 +0000793 /* Flush block zero, so others can read it */
794 if (mf_sync(mfp, MFS_ZERO) == OK)
Bram Moolenaarc32840f2006-01-14 21:23:38 +0000795 {
796 /* Mark all blocks that should be in the swapfile as dirty.
797 * Needed for when the 'swapfile' option was reset, so that
798 * the swap file was deleted, and then on again. */
799 mf_set_dirty(mfp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000800 break;
Bram Moolenaarc32840f2006-01-14 21:23:38 +0000801 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000802 /* Writing block 0 failed: close the file and try another dir */
803 mf_close_file(buf, FALSE);
804 }
805 }
806
807 if (mfp->mf_fname == NULL) /* Failed! */
808 {
809 need_wait_return = TRUE; /* call wait_return later */
810 ++no_wait_return;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100811 (void)semsg(_("E303: Unable to open swap file for \"%s\", recovery impossible"),
Bram Moolenaare1704ba2012-10-03 18:25:00 +0200812 buf_spname(buf) != NULL ? buf_spname(buf) : buf->b_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000813 --no_wait_return;
814 }
815
816 /* don't try to open a swap file again */
817 buf->b_may_swap = FALSE;
818}
819
820/*
821 * If still need to create a swap file, and starting to edit a not-readonly
822 * file, or reading into an existing buffer, create a swap file now.
823 */
824 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100825check_need_swap(
Bram Moolenaar2f0f8712018-08-21 18:50:18 +0200826 int newfile) // reading file into new buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +0000827{
Bram Moolenaar2f0f8712018-08-21 18:50:18 +0200828 int old_msg_silent = msg_silent; // might be reset by an E325 message
829
Bram Moolenaar071d4272004-06-13 20:20:40 +0000830 if (curbuf->b_may_swap && (!curbuf->b_p_ro || !newfile))
831 ml_open_file(curbuf);
Bram Moolenaar2f0f8712018-08-21 18:50:18 +0200832 msg_silent = old_msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000833}
834
835/*
836 * Close memline for buffer 'buf'.
837 * If 'del_file' is TRUE, delete the swap file
838 */
839 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100840ml_close(buf_T *buf, int del_file)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000841{
842 if (buf->b_ml.ml_mfp == NULL) /* not open */
843 return;
844 mf_close(buf->b_ml.ml_mfp, del_file); /* close the .swp file */
845 if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY))
846 vim_free(buf->b_ml.ml_line_ptr);
847 vim_free(buf->b_ml.ml_stack);
848#ifdef FEAT_BYTEOFF
Bram Moolenaard23a8232018-02-10 18:45:26 +0100849 VIM_CLEAR(buf->b_ml.ml_chunksize);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850#endif
851 buf->b_ml.ml_mfp = NULL;
852
853 /* Reset the "recovered" flag, give the ATTENTION prompt the next time
854 * this buffer is loaded. */
855 buf->b_flags &= ~BF_RECOVERED;
856}
857
858/*
859 * Close all existing memlines and memfiles.
860 * Only used when exiting.
861 * When 'del_file' is TRUE, delete the memfiles.
Bram Moolenaar81bf7082005-02-12 14:31:42 +0000862 * But don't delete files that were ":preserve"d when we are POSIX compatible.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000863 */
864 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100865ml_close_all(int del_file)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000866{
867 buf_T *buf;
868
Bram Moolenaar29323592016-07-24 22:04:11 +0200869 FOR_ALL_BUFFERS(buf)
Bram Moolenaar81bf7082005-02-12 14:31:42 +0000870 ml_close(buf, del_file && ((buf->b_flags & BF_PRESERVED) == 0
871 || vim_strchr(p_cpo, CPO_PRESERVE) == NULL));
Bram Moolenaar34b466e2013-11-28 17:41:46 +0100872#ifdef FEAT_SPELL
873 spell_delete_wordlist(); /* delete the internal wordlist */
874#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000875#ifdef TEMPDIRNAMES
Bram Moolenaar34b466e2013-11-28 17:41:46 +0100876 vim_deltempdir(); /* delete created temp directory */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000877#endif
878}
879
880/*
881 * Close all memfiles for not modified buffers.
882 * Only use just before exiting!
883 */
884 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100885ml_close_notmod(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000886{
887 buf_T *buf;
888
Bram Moolenaar29323592016-07-24 22:04:11 +0200889 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000890 if (!bufIsChanged(buf))
891 ml_close(buf, TRUE); /* close all not-modified buffers */
892}
893
894/*
895 * Update the timestamp in the .swp file.
896 * Used when the file has been written.
897 */
898 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100899ml_timestamp(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000900{
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200901 ml_upd_block0(buf, UB_FNAME);
902}
903
904/*
905 * Return FAIL when the ID of "b0p" is wrong.
906 */
907 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100908ml_check_b0_id(ZERO_BL *b0p)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200909{
910 if (b0p->b0_id[0] != BLOCK0_ID0
911 || (b0p->b0_id[1] != BLOCK0_ID1
912 && b0p->b0_id[1] != BLOCK0_ID1_C0
Bram Moolenaar8f4ac012014-08-10 13:38:34 +0200913 && b0p->b0_id[1] != BLOCK0_ID1_C1
914 && b0p->b0_id[1] != BLOCK0_ID1_C2)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200915 )
916 return FAIL;
917 return OK;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000918}
919
920/*
921 * Update the timestamp or the B0_SAME_DIR flag of the .swp file.
922 */
923 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100924ml_upd_block0(buf_T *buf, upd_block0_T what)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000925{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000926 memfile_T *mfp;
927 bhdr_T *hp;
928 ZERO_BL *b0p;
929
930 mfp = buf->b_ml.ml_mfp;
Bram Moolenaar2be79502014-08-13 21:58:28 +0200931 if (mfp == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000932 return;
Bram Moolenaar2be79502014-08-13 21:58:28 +0200933 hp = mf_get(mfp, (blocknr_T)0, 1);
934 if (hp == NULL)
935 {
936#ifdef FEAT_CRYPT
937 /* Possibly update the seed in the memfile before there is a block0. */
938 if (what == UB_CRYPT)
939 ml_set_mfp_crypt(buf);
940#endif
941 return;
942 }
943
Bram Moolenaar071d4272004-06-13 20:20:40 +0000944 b0p = (ZERO_BL *)(hp->bh_data);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200945 if (ml_check_b0_id(b0p) == FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100946 iemsg(_("E304: ml_upd_block0(): Didn't get block 0??"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000947 else
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000948 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200949 if (what == UB_FNAME)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000950 set_b0_fname(b0p, buf);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200951#ifdef FEAT_CRYPT
952 else if (what == UB_CRYPT)
953 ml_set_b0_crypt(buf, b0p);
954#endif
955 else /* what == UB_SAME_DIR */
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000956 set_b0_dir_flag(b0p, buf);
957 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000958 mf_put(mfp, hp, TRUE, FALSE);
959}
960
961/*
962 * Write file name and timestamp into block 0 of a swap file.
963 * Also set buf->b_mtime.
964 * Don't use NameBuff[]!!!
965 */
966 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +0100967set_b0_fname(ZERO_BL *b0p, buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000968{
Bram Moolenaar8767f522016-07-01 17:17:39 +0200969 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970
971 if (buf->b_ffname == NULL)
972 b0p->b0_fname[0] = NUL;
973 else
974 {
Bram Moolenaar48e330a2016-02-23 14:53:34 +0100975#if defined(MSWIN) || defined(AMIGA)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000976 /* Systems that cannot translate "~user" back into a path: copy the
977 * file name unmodified. Do use slashes instead of backslashes for
978 * portability. */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200979 vim_strncpy(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE_CRYPT - 1);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +0000980# ifdef BACKSLASH_IN_FILENAME
981 forward_slash(b0p->b0_fname);
982# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000983#else
984 size_t flen, ulen;
985 char_u uname[B0_UNAME_SIZE];
986
987 /*
988 * For a file under the home directory of the current user, we try to
989 * replace the home directory path with "~user". This helps when
990 * editing the same file on different machines over a network.
991 * First replace home dir path with "~/" with home_replace().
992 * Then insert the user name to get "~user/".
993 */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +0200994 home_replace(NULL, buf->b_ffname, b0p->b0_fname,
995 B0_FNAME_SIZE_CRYPT, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000996 if (b0p->b0_fname[0] == '~')
997 {
998 flen = STRLEN(b0p->b0_fname);
999 /* If there is no user name or it is too long, don't use "~/" */
1000 if (get_user_name(uname, B0_UNAME_SIZE) == FAIL
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001001 || (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE_CRYPT - 1)
1002 vim_strncpy(b0p->b0_fname, buf->b_ffname,
1003 B0_FNAME_SIZE_CRYPT - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001004 else
1005 {
1006 mch_memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen);
1007 mch_memmove(b0p->b0_fname + 1, uname, ulen);
1008 }
1009 }
1010#endif
1011 if (mch_stat((char *)buf->b_ffname, &st) >= 0)
1012 {
1013 long_to_char((long)st.st_mtime, b0p->b0_mtime);
1014#ifdef CHECK_INODE
1015 long_to_char((long)st.st_ino, b0p->b0_ino);
1016#endif
1017 buf_store_time(buf, &st, buf->b_ffname);
1018 buf->b_mtime_read = buf->b_mtime;
1019 }
1020 else
1021 {
1022 long_to_char(0L, b0p->b0_mtime);
1023#ifdef CHECK_INODE
1024 long_to_char(0L, b0p->b0_ino);
1025#endif
1026 buf->b_mtime = 0;
1027 buf->b_mtime_read = 0;
1028 buf->b_orig_size = 0;
1029 buf->b_orig_mode = 0;
1030 }
1031 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001032
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001033 /* Also add the 'fileencoding' if there is room. */
1034 add_b0_fenc(b0p, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001035}
1036
1037/*
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001038 * Update the B0_SAME_DIR flag of the swap file. It's set if the file and the
1039 * swapfile for "buf" are in the same directory.
1040 * This is fail safe: if we are not sure the directories are equal the flag is
1041 * not set.
1042 */
1043 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01001044set_b0_dir_flag(ZERO_BL *b0p, buf_T *buf)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001045{
1046 if (same_directory(buf->b_ml.ml_mfp->mf_fname, buf->b_ffname))
1047 b0p->b0_flags |= B0_SAME_DIR;
1048 else
1049 b0p->b0_flags &= ~B0_SAME_DIR;
1050}
1051
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001052/*
1053 * When there is room, add the 'fileencoding' to block zero.
1054 */
1055 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01001056add_b0_fenc(
1057 ZERO_BL *b0p,
1058 buf_T *buf)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001059{
1060 int n;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001061 int size = B0_FNAME_SIZE_NOCRYPT;
1062
Bram Moolenaarfc3abf42019-01-24 15:54:21 +01001063#ifdef FEAT_CRYPT
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001064 /* Without encryption use the same offset as in Vim 7.2 to be compatible.
1065 * With encryption it's OK to move elsewhere, the swap file is not
1066 * compatible anyway. */
1067 if (*buf->b_p_key != NUL)
1068 size = B0_FNAME_SIZE_CRYPT;
Bram Moolenaarfc3abf42019-01-24 15:54:21 +01001069#endif
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001070
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00001071 n = (int)STRLEN(buf->b_p_fenc);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001072 if ((int)STRLEN(b0p->b0_fname) + n + 1 > size)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001073 b0p->b0_flags &= ~B0_HAS_FENC;
1074 else
1075 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001076 mch_memmove((char *)b0p->b0_fname + size - n,
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001077 (char *)buf->b_p_fenc, (size_t)n);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001078 *(b0p->b0_fname + size - n - 1) = NUL;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001079 b0p->b0_flags |= B0_HAS_FENC;
1080 }
1081}
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001082
1083
1084/*
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001085 * Try to recover curbuf from the .swp file.
Bram Moolenaar99499b12019-05-23 21:35:48 +02001086 * If "checkext" is TRUE, check the extension and detect whether it is
1087 * a swap file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001088 */
1089 void
Bram Moolenaar99499b12019-05-23 21:35:48 +02001090ml_recover(int checkext)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001091{
1092 buf_T *buf = NULL;
1093 memfile_T *mfp = NULL;
1094 char_u *fname;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001095 char_u *fname_used = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001096 bhdr_T *hp = NULL;
1097 ZERO_BL *b0p;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001098 int b0_ff;
1099 char_u *b0_fenc = NULL;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001100#ifdef FEAT_CRYPT
1101 int b0_cm = -1;
1102#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001103 PTR_BL *pp;
1104 DATA_BL *dp;
1105 infoptr_T *ip;
1106 blocknr_T bnum;
1107 int page_count;
Bram Moolenaar8767f522016-07-01 17:17:39 +02001108 stat_T org_stat, swp_stat;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001109 int len;
1110 int directly;
1111 linenr_T lnum;
1112 char_u *p;
1113 int i;
1114 long error;
1115 int cannot_open;
1116 linenr_T line_count;
1117 int has_error;
1118 int idx;
1119 int top;
1120 int txt_start;
Bram Moolenaar8767f522016-07-01 17:17:39 +02001121 off_T size;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001122 int called_from_main;
1123 int serious_error = TRUE;
1124 long mtime;
1125 int attr;
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001126 int orig_file_status = NOTDONE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001127
1128 recoverymode = TRUE;
1129 called_from_main = (curbuf->b_ml.ml_mfp == NULL);
Bram Moolenaar8820b482017-03-16 17:23:31 +01001130 attr = HL_ATTR(HLF_E);
Bram Moolenaard0ba34a2009-11-03 12:06:23 +00001131
1132 /*
Bram Moolenaaraf903e52017-12-02 15:11:22 +01001133 * If the file name ends in ".s[a-w][a-z]" we assume this is the swap file.
Bram Moolenaard0ba34a2009-11-03 12:06:23 +00001134 * Otherwise a search is done to find the swap file(s).
1135 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001136 fname = curbuf->b_fname;
1137 if (fname == NULL) /* When there is no file name */
1138 fname = (char_u *)"";
1139 len = (int)STRLEN(fname);
Bram Moolenaar99499b12019-05-23 21:35:48 +02001140 if (checkext && len >= 4 &&
Bram Moolenaare60acc12011-05-10 16:41:25 +02001141#if defined(VMS)
Bram Moolenaar79518e22017-02-17 16:31:35 +01001142 STRNICMP(fname + len - 4, "_s", 2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001143#else
Bram Moolenaar79518e22017-02-17 16:31:35 +01001144 STRNICMP(fname + len - 4, ".s", 2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001145#endif
Bram Moolenaar79518e22017-02-17 16:31:35 +01001146 == 0
Bram Moolenaaraf903e52017-12-02 15:11:22 +01001147 && vim_strchr((char_u *)"abcdefghijklmnopqrstuvw",
1148 TOLOWER_ASC(fname[len - 2])) != NULL
Bram Moolenaard0ba34a2009-11-03 12:06:23 +00001149 && ASCII_ISALPHA(fname[len - 1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001150 {
1151 directly = TRUE;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001152 fname_used = vim_strsave(fname); /* make a copy for mf_open() */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001153 }
1154 else
1155 {
1156 directly = FALSE;
1157
1158 /* count the number of matching swap files */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001159 len = recover_names(fname, FALSE, 0, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001160 if (len == 0) /* no swap files found */
1161 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001162 semsg(_("E305: No swap file found for %s"), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001163 goto theend;
1164 }
1165 if (len == 1) /* one swap file found, use it */
1166 i = 1;
1167 else /* several swap files found, choose */
1168 {
1169 /* list the names of the swap files */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001170 (void)recover_names(fname, TRUE, 0, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171 msg_putchar('\n');
Bram Moolenaar32526b32019-01-19 17:43:09 +01001172 msg_puts(_("Enter number of swap file to use (0 to quit): "));
Bram Moolenaar24bbcfe2005-06-28 23:32:02 +00001173 i = get_number(FALSE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001174 if (i < 1 || i > len)
1175 goto theend;
1176 }
1177 /* get the swap file name that will be used */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001178 (void)recover_names(fname, FALSE, i, &fname_used);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001179 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001180 if (fname_used == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001181 goto theend; /* out of memory */
1182
1183 /* When called from main() still need to initialize storage structure */
Bram Moolenaar4770d092006-01-12 23:22:24 +00001184 if (called_from_main && ml_open(curbuf) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001185 getout(1);
1186
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001187 /*
1188 * Allocate a buffer structure for the swap file that is used for recovery.
Bram Moolenaar0ad014c2010-07-25 14:00:46 +02001189 * Only the memline and crypt information in it are really used.
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001190 */
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001191 buf = ALLOC_ONE(buf_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001192 if (buf == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001193 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001194
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001195 /*
1196 * init fields in memline struct
1197 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001198 buf->b_ml.ml_stack_size = 0; /* no stack yet */
1199 buf->b_ml.ml_stack = NULL; /* no stack yet */
1200 buf->b_ml.ml_stack_top = 0; /* nothing in the stack */
1201 buf->b_ml.ml_line_lnum = 0; /* no cached line */
1202 buf->b_ml.ml_locked = NULL; /* no locked block */
1203 buf->b_ml.ml_flags = 0;
Bram Moolenaar0fe849a2010-07-25 15:11:11 +02001204#ifdef FEAT_CRYPT
1205 buf->b_p_key = empty_option;
1206 buf->b_p_cm = empty_option;
1207#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001208
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001209 /*
1210 * open the memfile from the old swap file
1211 */
1212 p = vim_strsave(fname_used); /* save "fname_used" for the message:
1213 mf_open() will consume "fname_used"! */
1214 mfp = mf_open(fname_used, O_RDONLY);
1215 fname_used = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001216 if (mfp == NULL || mfp->mf_fd < 0)
1217 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001218 if (fname_used != NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001219 semsg(_("E306: Cannot open %s"), fname_used);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001220 goto theend;
1221 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001222 buf->b_ml.ml_mfp = mfp;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001223#ifdef FEAT_CRYPT
1224 mfp->mf_buffer = buf;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001225#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226
1227 /*
1228 * The page size set in mf_open() might be different from the page size
1229 * used in the swap file, we must get it from block 0. But to read block
1230 * 0 we need a page size. Use the minimal size for block 0 here, it will
1231 * be set to the real value below.
1232 */
1233 mfp->mf_page_size = MIN_SWAP_PAGE_SIZE;
1234
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001235 /*
1236 * try to read block 0
1237 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001238 if ((hp = mf_get(mfp, (blocknr_T)0, 1)) == NULL)
1239 {
1240 msg_start();
Bram Moolenaar32526b32019-01-19 17:43:09 +01001241 msg_puts_attr(_("Unable to read block 0 from "), attr | MSG_HIST);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001242 msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001243 msg_puts_attr(_("\nMaybe no changes were made or Vim did not update the swap file."),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001244 attr | MSG_HIST);
1245 msg_end();
1246 goto theend;
1247 }
1248 b0p = (ZERO_BL *)(hp->bh_data);
1249 if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0)
1250 {
1251 msg_start();
1252 msg_outtrans_attr(mfp->mf_fname, MSG_HIST);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001253 msg_puts_attr(_(" cannot be used with this version of Vim.\n"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001254 MSG_HIST);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001255 msg_puts_attr(_("Use Vim version 3.0.\n"), MSG_HIST);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256 msg_end();
1257 goto theend;
1258 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001259 if (ml_check_b0_id(b0p) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001260 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001261 semsg(_("E307: %s does not look like a Vim swap file"), mfp->mf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001262 goto theend;
1263 }
1264 if (b0_magic_wrong(b0p))
1265 {
1266 msg_start();
1267 msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
Bram Moolenaar48e330a2016-02-23 14:53:34 +01001268#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269 if (STRNCMP(b0p->b0_hname, "PC ", 3) == 0)
Bram Moolenaar32526b32019-01-19 17:43:09 +01001270 msg_puts_attr(_(" cannot be used with this version of Vim.\n"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001271 attr | MSG_HIST);
1272 else
1273#endif
Bram Moolenaar32526b32019-01-19 17:43:09 +01001274 msg_puts_attr(_(" cannot be used on this computer.\n"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001275 attr | MSG_HIST);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001276 msg_puts_attr(_("The file was created on "), attr | MSG_HIST);
Bram Moolenaare242b832010-06-24 05:39:03 +02001277 /* avoid going past the end of a corrupted hostname */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001278 b0p->b0_fname[0] = NUL;
Bram Moolenaar32526b32019-01-19 17:43:09 +01001279 msg_puts_attr((char *)b0p->b0_hname, attr | MSG_HIST);
1280 msg_puts_attr(_(",\nor the file has been damaged."), attr | MSG_HIST);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001281 msg_end();
1282 goto theend;
1283 }
Bram Moolenaar1c536282007-04-26 15:21:56 +00001284
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001285#ifdef FEAT_CRYPT
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02001286 for (i = 0; i < (int)(sizeof(id1_codes) / sizeof(int)); ++i)
1287 if (id1_codes[i] == b0p->b0_id[1])
1288 b0_cm = i;
1289 if (b0_cm > 0)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001290 mch_memmove(mfp->mf_seed, &b0p->b0_seed, MF_SEED_LEN);
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02001291 crypt_set_cm_option(buf, b0_cm < 0 ? 0 : b0_cm);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001292#else
1293 if (b0p->b0_id[1] != BLOCK0_ID1)
1294 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001295 semsg(_("E833: %s is encrypted and this version of Vim does not support encryption"), mfp->mf_fname);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001296 goto theend;
1297 }
1298#endif
1299
Bram Moolenaar071d4272004-06-13 20:20:40 +00001300 /*
1301 * If we guessed the wrong page size, we have to recalculate the
1302 * highest block number in the file.
1303 */
1304 if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size))
1305 {
Bram Moolenaar1c536282007-04-26 15:21:56 +00001306 unsigned previous_page_size = mfp->mf_page_size;
1307
Bram Moolenaar071d4272004-06-13 20:20:40 +00001308 mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size));
Bram Moolenaar1c536282007-04-26 15:21:56 +00001309 if (mfp->mf_page_size < previous_page_size)
1310 {
1311 msg_start();
1312 msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001313 msg_puts_attr(_(" has been damaged (page size is smaller than minimum value).\n"),
Bram Moolenaar1c536282007-04-26 15:21:56 +00001314 attr | MSG_HIST);
1315 msg_end();
1316 goto theend;
1317 }
Bram Moolenaar8767f522016-07-01 17:17:39 +02001318 if ((size = vim_lseek(mfp->mf_fd, (off_T)0L, SEEK_END)) <= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001319 mfp->mf_blocknr_max = 0; /* no file or empty file */
1320 else
1321 mfp->mf_blocknr_max = (blocknr_T)(size / mfp->mf_page_size);
1322 mfp->mf_infile_count = mfp->mf_blocknr_max;
Bram Moolenaar1c536282007-04-26 15:21:56 +00001323
1324 /* need to reallocate the memory used to store the data */
1325 p = alloc(mfp->mf_page_size);
1326 if (p == NULL)
1327 goto theend;
1328 mch_memmove(p, hp->bh_data, previous_page_size);
1329 vim_free(hp->bh_data);
1330 hp->bh_data = p;
1331 b0p = (ZERO_BL *)(hp->bh_data);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001332 }
1333
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001334 /*
1335 * If .swp file name given directly, use name from swap file for buffer.
1336 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001337 if (directly)
1338 {
1339 expand_env(b0p->b0_fname, NameBuff, MAXPATHL);
1340 if (setfname(curbuf, NameBuff, NULL, TRUE) == FAIL)
1341 goto theend;
1342 }
1343
1344 home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL, TRUE);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001345 smsg(_("Using swap file \"%s\""), NameBuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001346
1347 if (buf_spname(curbuf) != NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02001348 vim_strncpy(NameBuff, buf_spname(curbuf), MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001349 else
1350 home_replace(NULL, curbuf->b_ffname, NameBuff, MAXPATHL, TRUE);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001351 smsg(_("Original file \"%s\""), NameBuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001352 msg_putchar('\n');
1353
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001354 /*
1355 * check date of swap file and original file
1356 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001357 mtime = char_to_long(b0p->b0_mtime);
1358 if (curbuf->b_ffname != NULL
1359 && mch_stat((char *)curbuf->b_ffname, &org_stat) != -1
1360 && ((mch_stat((char *)mfp->mf_fname, &swp_stat) != -1
1361 && org_stat.st_mtime > swp_stat.st_mtime)
1362 || org_stat.st_mtime != mtime))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001363 emsg(_("E308: Warning: Original file may have been changed"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001364 out_flush();
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001365
1366 /* Get the 'fileformat' and 'fileencoding' from block zero. */
1367 b0_ff = (b0p->b0_flags & B0_FF_MASK);
1368 if (b0p->b0_flags & B0_HAS_FENC)
1369 {
Bram Moolenaarf506c5b2010-06-22 06:28:58 +02001370 int fnsize = B0_FNAME_SIZE_NOCRYPT;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001371
1372#ifdef FEAT_CRYPT
1373 /* Use the same size as in add_b0_fenc(). */
1374 if (b0p->b0_id[1] != BLOCK0_ID1)
Bram Moolenaarf506c5b2010-06-22 06:28:58 +02001375 fnsize = B0_FNAME_SIZE_CRYPT;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001376#endif
Bram Moolenaarf506c5b2010-06-22 06:28:58 +02001377 for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; --p)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001378 ;
Bram Moolenaarf506c5b2010-06-22 06:28:58 +02001379 b0_fenc = vim_strnsave(p, (int)(b0p->b0_fname + fnsize - p));
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001380 }
1381
Bram Moolenaar071d4272004-06-13 20:20:40 +00001382 mf_put(mfp, hp, FALSE, FALSE); /* release block 0 */
1383 hp = NULL;
1384
1385 /*
1386 * Now that we are sure that the file is going to be recovered, clear the
1387 * contents of the current buffer.
1388 */
1389 while (!(curbuf->b_ml.ml_flags & ML_EMPTY))
1390 ml_delete((linenr_T)1, FALSE);
1391
1392 /*
1393 * Try reading the original file to obtain the values of 'fileformat',
1394 * 'fileencoding', etc. Ignore errors. The text itself is not used.
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001395 * When the file is encrypted the user is asked to enter the key.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001396 */
1397 if (curbuf->b_ffname != NULL)
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001398 orig_file_status = readfile(curbuf->b_ffname, NULL, (linenr_T)0,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001399 (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001400
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001401#ifdef FEAT_CRYPT
1402 if (b0_cm >= 0)
1403 {
1404 /* Need to ask the user for the crypt key. If this fails we continue
1405 * without a key, will probably get garbage text. */
1406 if (*curbuf->b_p_key != NUL)
1407 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001408 smsg(_("Swap file is encrypted: \"%s\""), fname_used);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001409 msg_puts(_("\nIf you entered a new crypt key but did not write the text file,"));
1410 msg_puts(_("\nenter the new crypt key."));
1411 msg_puts(_("\nIf you wrote the text file after changing the crypt key press enter"));
1412 msg_puts(_("\nto use the same key for text file and swap file"));
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001413 }
1414 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001415 smsg(_(need_key_msg), fname_used);
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02001416 buf->b_p_key = crypt_get_key(FALSE, FALSE);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001417 if (buf->b_p_key == NULL)
1418 buf->b_p_key = curbuf->b_p_key;
1419 else if (*buf->b_p_key == NUL)
1420 {
1421 vim_free(buf->b_p_key);
1422 buf->b_p_key = curbuf->b_p_key;
1423 }
1424 if (buf->b_p_key == NULL)
1425 buf->b_p_key = empty_option;
1426 }
1427#endif
1428
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001429 /* Use the 'fileformat' and 'fileencoding' as stored in the swap file. */
1430 if (b0_ff != 0)
1431 set_fileformat(b0_ff - 1, OPT_LOCAL);
1432 if (b0_fenc != NULL)
1433 {
1434 set_option_value((char_u *)"fenc", 0L, b0_fenc, OPT_LOCAL);
1435 vim_free(b0_fenc);
1436 }
Bram Moolenaarc024b462019-06-08 18:07:21 +02001437 unchanged(curbuf, TRUE, TRUE);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00001438
Bram Moolenaar071d4272004-06-13 20:20:40 +00001439 bnum = 1; /* start with block 1 */
1440 page_count = 1; /* which is 1 page */
1441 lnum = 0; /* append after line 0 in curbuf */
1442 line_count = 0;
1443 idx = 0; /* start with first index in block 1 */
1444 error = 0;
1445 buf->b_ml.ml_stack_top = 0;
1446 buf->b_ml.ml_stack = NULL;
1447 buf->b_ml.ml_stack_size = 0; /* no stack yet */
1448
1449 if (curbuf->b_ffname == NULL)
1450 cannot_open = TRUE;
1451 else
1452 cannot_open = FALSE;
1453
1454 serious_error = FALSE;
1455 for ( ; !got_int; line_breakcheck())
1456 {
1457 if (hp != NULL)
1458 mf_put(mfp, hp, FALSE, FALSE); /* release previous block */
1459
1460 /*
1461 * get block
1462 */
1463 if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL)
1464 {
1465 if (bnum == 1)
1466 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001467 semsg(_("E309: Unable to read block 1 from %s"), mfp->mf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 goto theend;
1469 }
1470 ++error;
1471 ml_append(lnum++, (char_u *)_("???MANY LINES MISSING"),
1472 (colnr_T)0, TRUE);
1473 }
1474 else /* there is a block */
1475 {
1476 pp = (PTR_BL *)(hp->bh_data);
1477 if (pp->pb_id == PTR_ID) /* it is a pointer block */
1478 {
1479 /* check line count when using pointer block first time */
1480 if (idx == 0 && line_count != 0)
1481 {
1482 for (i = 0; i < (int)pp->pb_count; ++i)
1483 line_count -= pp->pb_pointer[i].pe_line_count;
1484 if (line_count != 0)
1485 {
1486 ++error;
1487 ml_append(lnum++, (char_u *)_("???LINE COUNT WRONG"),
1488 (colnr_T)0, TRUE);
1489 }
1490 }
1491
1492 if (pp->pb_count == 0)
1493 {
1494 ml_append(lnum++, (char_u *)_("???EMPTY BLOCK"),
1495 (colnr_T)0, TRUE);
1496 ++error;
1497 }
1498 else if (idx < (int)pp->pb_count) /* go a block deeper */
1499 {
1500 if (pp->pb_pointer[idx].pe_bnum < 0)
1501 {
1502 /*
1503 * Data block with negative block number.
1504 * Try to read lines from the original file.
1505 * This is slow, but it works.
1506 */
1507 if (!cannot_open)
1508 {
1509 line_count = pp->pb_pointer[idx].pe_line_count;
1510 if (readfile(curbuf->b_ffname, NULL, lnum,
1511 pp->pb_pointer[idx].pe_old_lnum - 1,
Bram Moolenaare13b9af2017-01-13 22:01:02 +01001512 line_count, NULL, 0) != OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001513 cannot_open = TRUE;
1514 else
1515 lnum += line_count;
1516 }
1517 if (cannot_open)
1518 {
1519 ++error;
1520 ml_append(lnum++, (char_u *)_("???LINES MISSING"),
1521 (colnr_T)0, TRUE);
1522 }
1523 ++idx; /* get same block again for next index */
1524 continue;
1525 }
1526
1527 /*
1528 * going one block deeper in the tree
1529 */
1530 if ((top = ml_add_stack(buf)) < 0) /* new entry in stack */
1531 {
1532 ++error;
1533 break; /* out of memory */
1534 }
1535 ip = &(buf->b_ml.ml_stack[top]);
1536 ip->ip_bnum = bnum;
1537 ip->ip_index = idx;
1538
1539 bnum = pp->pb_pointer[idx].pe_bnum;
1540 line_count = pp->pb_pointer[idx].pe_line_count;
1541 page_count = pp->pb_pointer[idx].pe_page_count;
Bram Moolenaar986a0032011-06-13 01:07:27 +02001542 idx = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001543 continue;
1544 }
1545 }
1546 else /* not a pointer block */
1547 {
1548 dp = (DATA_BL *)(hp->bh_data);
1549 if (dp->db_id != DATA_ID) /* block id wrong */
1550 {
1551 if (bnum == 1)
1552 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001553 semsg(_("E310: Block 1 ID wrong (%s not a .swp file?)"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001554 mfp->mf_fname);
1555 goto theend;
1556 }
1557 ++error;
1558 ml_append(lnum++, (char_u *)_("???BLOCK MISSING"),
1559 (colnr_T)0, TRUE);
1560 }
1561 else
1562 {
1563 /*
1564 * it is a data block
1565 * Append all the lines in this block
1566 */
1567 has_error = FALSE;
1568 /*
1569 * check length of block
1570 * if wrong, use length in pointer block
1571 */
1572 if (page_count * mfp->mf_page_size != dp->db_txt_end)
1573 {
1574 ml_append(lnum++, (char_u *)_("??? from here until ???END lines may be messed up"),
1575 (colnr_T)0, TRUE);
1576 ++error;
1577 has_error = TRUE;
1578 dp->db_txt_end = page_count * mfp->mf_page_size;
1579 }
1580
1581 /* make sure there is a NUL at the end of the block */
1582 *((char_u *)dp + dp->db_txt_end - 1) = NUL;
1583
1584 /*
1585 * check number of lines in block
1586 * if wrong, use count in data block
1587 */
1588 if (line_count != dp->db_line_count)
1589 {
1590 ml_append(lnum++, (char_u *)_("??? from here until ???END lines may have been inserted/deleted"),
1591 (colnr_T)0, TRUE);
1592 ++error;
1593 has_error = TRUE;
1594 }
1595
1596 for (i = 0; i < dp->db_line_count; ++i)
1597 {
1598 txt_start = (dp->db_index[i] & DB_INDEX_MASK);
Bram Moolenaar740885b2009-11-03 14:33:17 +00001599 if (txt_start <= (int)HEADER_SIZE
Bram Moolenaar071d4272004-06-13 20:20:40 +00001600 || txt_start >= (int)dp->db_txt_end)
1601 {
1602 p = (char_u *)"???";
1603 ++error;
1604 }
1605 else
1606 p = (char_u *)dp + txt_start;
1607 ml_append(lnum++, p, (colnr_T)0, TRUE);
1608 }
1609 if (has_error)
Bram Moolenaar740885b2009-11-03 14:33:17 +00001610 ml_append(lnum++, (char_u *)_("???END"),
1611 (colnr_T)0, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001612 }
1613 }
1614 }
1615
1616 if (buf->b_ml.ml_stack_top == 0) /* finished */
1617 break;
1618
1619 /*
1620 * go one block up in the tree
1621 */
1622 ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
1623 bnum = ip->ip_bnum;
1624 idx = ip->ip_index + 1; /* go to next index */
1625 page_count = 1;
1626 }
1627
1628 /*
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001629 * Compare the buffer contents with the original file. When they differ
1630 * set the 'modified' flag.
1631 * Lines 1 - lnum are the new contents.
1632 * Lines lnum + 1 to ml_line_count are the original contents.
1633 * Line ml_line_count + 1 in the dummy empty line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001634 */
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001635 if (orig_file_status != OK || curbuf->b_ml.ml_line_count != lnum * 2 + 1)
1636 {
1637 /* Recovering an empty file results in two lines and the first line is
1638 * empty. Don't set the modified flag then. */
1639 if (!(curbuf->b_ml.ml_line_count == 2 && *ml_get(1) == NUL))
1640 {
Bram Moolenaarec28d152019-05-11 18:36:34 +02001641 changed_internal();
Bram Moolenaar95c526e2017-02-25 14:59:34 +01001642 ++CHANGEDTICK(curbuf);
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001643 }
1644 }
1645 else
1646 {
1647 for (idx = 1; idx <= lnum; ++idx)
1648 {
1649 /* Need to copy one line, fetching the other one may flush it. */
1650 p = vim_strsave(ml_get(idx));
1651 i = STRCMP(p, ml_get(idx + lnum));
1652 vim_free(p);
1653 if (i != 0)
1654 {
Bram Moolenaarec28d152019-05-11 18:36:34 +02001655 changed_internal();
Bram Moolenaar95c526e2017-02-25 14:59:34 +01001656 ++CHANGEDTICK(curbuf);
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001657 break;
1658 }
1659 }
1660 }
1661
1662 /*
1663 * Delete the lines from the original file and the dummy line from the
1664 * empty buffer. These will now be after the last line in the buffer.
1665 */
1666 while (curbuf->b_ml.ml_line_count > lnum
1667 && !(curbuf->b_ml.ml_flags & ML_EMPTY))
1668 ml_delete(curbuf->b_ml.ml_line_count, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001669 curbuf->b_flags |= BF_RECOVERED;
1670
1671 recoverymode = FALSE;
1672 if (got_int)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001673 emsg(_("E311: Recovery Interrupted"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001674 else if (error)
1675 {
1676 ++no_wait_return;
Bram Moolenaar32526b32019-01-19 17:43:09 +01001677 msg(">>>>>>>>>>>>>");
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001678 emsg(_("E312: Errors detected while recovering; look for lines starting with ???"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001679 --no_wait_return;
Bram Moolenaar32526b32019-01-19 17:43:09 +01001680 msg(_("See \":help E312\" for more information."));
1681 msg(">>>>>>>>>>>>>");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001682 }
1683 else
1684 {
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001685 if (curbuf->b_changed)
1686 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01001687 msg(_("Recovery completed. You should check if everything is OK."));
1688 msg_puts(_("\n(You might want to write out this file under another name\n"));
1689 msg_puts(_("and run diff with the original file to check for changes)"));
Bram Moolenaarfc2d5bd2010-05-15 17:06:53 +02001690 }
1691 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01001692 msg(_("Recovery completed. Buffer contents equals file contents."));
1693 msg_puts(_("\nYou may want to delete the .swp file now.\n\n"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001694 cmdline_row = msg_row;
1695 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001696#ifdef FEAT_CRYPT
1697 if (*buf->b_p_key != NUL && STRCMP(curbuf->b_p_key, buf->b_p_key) != 0)
1698 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01001699 msg_puts(_("Using crypt key from swap file for the text file.\n"));
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001700 set_option_value((char_u *)"key", 0L, buf->b_p_key, OPT_LOCAL);
1701 }
1702#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001703 redraw_curbuf_later(NOT_VALID);
1704
1705theend:
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001706 vim_free(fname_used);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001707 recoverymode = FALSE;
1708 if (mfp != NULL)
1709 {
1710 if (hp != NULL)
1711 mf_put(mfp, hp, FALSE, FALSE);
1712 mf_close(mfp, FALSE); /* will also vim_free(mfp->mf_fname) */
1713 }
Bram Moolenaardf88dda2007-01-09 13:34:50 +00001714 if (buf != NULL)
1715 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001716#ifdef FEAT_CRYPT
1717 if (buf->b_p_key != curbuf->b_p_key)
1718 free_string_option(buf->b_p_key);
Bram Moolenaar0ad014c2010-07-25 14:00:46 +02001719 free_string_option(buf->b_p_cm);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001720#endif
Bram Moolenaardf88dda2007-01-09 13:34:50 +00001721 vim_free(buf->b_ml.ml_stack);
1722 vim_free(buf);
1723 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001724 if (serious_error && called_from_main)
1725 ml_close(curbuf, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001726 else
1727 {
1728 apply_autocmds(EVENT_BUFREADPOST, NULL, curbuf->b_fname, FALSE, curbuf);
1729 apply_autocmds(EVENT_BUFWINENTER, NULL, curbuf->b_fname, FALSE, curbuf);
1730 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001731 return;
1732}
1733
1734/*
1735 * Find the names of swap files in current directory and the directory given
1736 * with the 'directory' option.
1737 *
1738 * Used to:
1739 * - list the swap files for "vim -r"
1740 * - count the number of swap files when recovering
1741 * - list the swap files when recovering
1742 * - find the name of the n'th swap file when recovering
1743 */
1744 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01001745recover_names(
1746 char_u *fname, /* base for swap file name */
1747 int list, /* when TRUE, list the swap file names */
1748 int nr, /* when non-zero, return nr'th swap file name */
1749 char_u **fname_out) /* result when "nr" > 0 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001750{
1751 int num_names;
1752 char_u *(names[6]);
1753 char_u *tail;
1754 char_u *p;
1755 int num_files;
1756 int file_count = 0;
1757 char_u **files;
1758 int i;
1759 char_u *dirp;
1760 char_u *dir_name;
Bram Moolenaar64354da2010-05-25 21:37:17 +02001761 char_u *fname_res = NULL;
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001762#ifdef HAVE_READLINK
1763 char_u fname_buf[MAXPATHL];
Bram Moolenaar64354da2010-05-25 21:37:17 +02001764#endif
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001765
Bram Moolenaar64354da2010-05-25 21:37:17 +02001766 if (fname != NULL)
1767 {
1768#ifdef HAVE_READLINK
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001769 /* Expand symlink in the file name, because the swap file is created
1770 * with the actual file instead of with the symlink. */
1771 if (resolve_symlink(fname, fname_buf) == OK)
1772 fname_res = fname_buf;
1773 else
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001774#endif
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001775 fname_res = fname;
Bram Moolenaar64354da2010-05-25 21:37:17 +02001776 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001777
1778 if (list)
1779 {
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001780 /* use msg() to start the scrolling properly */
Bram Moolenaar32526b32019-01-19 17:43:09 +01001781 msg(_("Swap files found:"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001782 msg_putchar('\n');
1783 }
1784
1785 /*
1786 * Do the loop for every directory in 'directory'.
1787 * First allocate some memory to put the directory name in.
1788 */
Bram Moolenaar964b3742019-05-24 18:54:09 +02001789 dir_name = alloc(STRLEN(p_dir) + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001790 dirp = p_dir;
1791 while (dir_name != NULL && *dirp)
1792 {
1793 /*
1794 * Isolate a directory name from *dirp and put it in dir_name (we know
1795 * it is large enough, so use 31000 for length).
1796 * Advance dirp to next directory name.
1797 */
1798 (void)copy_option_part(&dirp, dir_name, 31000, ",");
1799
1800 if (dir_name[0] == '.' && dir_name[1] == NUL) /* check current dir */
1801 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001802 if (fname == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001803 {
1804#ifdef VMS
1805 names[0] = vim_strsave((char_u *)"*_sw%");
1806#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001807 names[0] = vim_strsave((char_u *)"*.sw?");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001808#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01001809#if defined(UNIX) || defined(MSWIN)
Bram Moolenaar2cc93182006-10-10 19:56:03 +00001810 /* For Unix names starting with a dot are special. MS-Windows
1811 * supports this too, on some file systems. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001812 names[1] = vim_strsave((char_u *)".*.sw?");
1813 names[2] = vim_strsave((char_u *)".sw?");
1814 num_names = 3;
1815#else
1816# ifdef VMS
1817 names[1] = vim_strsave((char_u *)".*_sw%");
1818 num_names = 2;
1819# else
1820 num_names = 1;
1821# endif
1822#endif
1823 }
1824 else
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001825 num_names = recov_file_names(names, fname_res, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001826 }
1827 else /* check directory dir_name */
1828 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001829 if (fname == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001830 {
1831#ifdef VMS
1832 names[0] = concat_fnames(dir_name, (char_u *)"*_sw%", TRUE);
1833#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001834 names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001835#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01001836#if defined(UNIX) || defined(MSWIN)
Bram Moolenaar2cc93182006-10-10 19:56:03 +00001837 /* For Unix names starting with a dot are special. MS-Windows
1838 * supports this too, on some file systems. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001839 names[1] = concat_fnames(dir_name, (char_u *)".*.sw?", TRUE);
1840 names[2] = concat_fnames(dir_name, (char_u *)".sw?", TRUE);
1841 num_names = 3;
1842#else
1843# ifdef VMS
1844 names[1] = concat_fnames(dir_name, (char_u *)".*_sw%", TRUE);
1845 num_names = 2;
1846# else
1847 num_names = 1;
1848# endif
1849#endif
1850 }
1851 else
1852 {
Bram Moolenaar4f974752019-02-17 17:44:42 +01001853#if defined(UNIX) || defined(MSWIN)
Bram Moolenaarb113c3a2017-02-28 21:26:17 +01001854 int len = (int)STRLEN(dir_name);
Bram Moolenaarc525e3a2017-02-18 16:59:02 +01001855
1856 p = dir_name + len;
1857 if (after_pathsep(dir_name, p) && len > 1 && p[-1] == p[-2])
Bram Moolenaar071d4272004-06-13 20:20:40 +00001858 {
1859 /* Ends with '//', Use Full path for swap name */
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001860 tail = make_percent_swname(dir_name, fname_res);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001861 }
1862 else
1863#endif
1864 {
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001865 tail = gettail(fname_res);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001866 tail = concat_fnames(dir_name, tail, TRUE);
1867 }
1868 if (tail == NULL)
1869 num_names = 0;
1870 else
1871 {
1872 num_names = recov_file_names(names, tail, FALSE);
1873 vim_free(tail);
1874 }
1875 }
1876 }
1877
Bram Moolenaar0d3cb732019-05-18 13:05:18 +02001878 // check for out-of-memory
Bram Moolenaar071d4272004-06-13 20:20:40 +00001879 for (i = 0; i < num_names; ++i)
1880 {
1881 if (names[i] == NULL)
1882 {
1883 for (i = 0; i < num_names; ++i)
1884 vim_free(names[i]);
1885 num_names = 0;
1886 }
1887 }
1888 if (num_names == 0)
1889 num_files = 0;
1890 else if (expand_wildcards(num_names, names, &num_files, &files,
Bram Moolenaar99499b12019-05-23 21:35:48 +02001891 EW_NOTENV|EW_KEEPALL|EW_FILE|EW_SILENT) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001892 num_files = 0;
1893
1894 /*
1895 * When no swap file found, wildcard expansion might have failed (e.g.
1896 * not able to execute the shell).
1897 * Try finding a swap file by simply adding ".swp" to the file name.
1898 */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001899 if (*dirp == NUL && file_count + num_files == 0 && fname != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001900 {
Bram Moolenaar8767f522016-07-01 17:17:39 +02001901 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001902 char_u *swapname;
1903
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001904 swapname = modname(fname_res,
Bram Moolenaare60acc12011-05-10 16:41:25 +02001905#if defined(VMS)
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001906 (char_u *)"_swp", FALSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00001907#else
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001908 (char_u *)".swp", TRUE
Bram Moolenaar071d4272004-06-13 20:20:40 +00001909#endif
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02001910 );
Bram Moolenaar071d4272004-06-13 20:20:40 +00001911 if (swapname != NULL)
1912 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001913 if (mch_stat((char *)swapname, &st) != -1) // It exists!
Bram Moolenaar071d4272004-06-13 20:20:40 +00001914 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001915 files = ALLOC_ONE(char_u *);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001916 if (files != NULL)
1917 {
1918 files[0] = swapname;
1919 swapname = NULL;
1920 num_files = 1;
1921 }
1922 }
1923 vim_free(swapname);
1924 }
1925 }
1926
1927 /*
1928 * remove swapfile name of the current buffer, it must be ignored
1929 */
1930 if (curbuf->b_ml.ml_mfp != NULL
1931 && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL)
1932 {
1933 for (i = 0; i < num_files; ++i)
Bram Moolenaar99499b12019-05-23 21:35:48 +02001934 // Do not expand wildcards, on windows would try to expand
1935 // "%tmp%" in "%tmp%file".
1936 if (fullpathcmp(p, files[i], TRUE, FALSE) & FPC_SAME)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001937 {
Bram Moolenaar99499b12019-05-23 21:35:48 +02001938 // Remove the name from files[i]. Move further entries
1939 // down. When the array becomes empty free it here, since
1940 // FreeWild() won't be called below.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001941 vim_free(files[i]);
Bram Moolenaar9439cdd2009-04-22 13:39:36 +00001942 if (--num_files == 0)
1943 vim_free(files);
1944 else
1945 for ( ; i < num_files; ++i)
1946 files[i] = files[i + 1];
Bram Moolenaar071d4272004-06-13 20:20:40 +00001947 }
1948 }
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001949 if (nr > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001950 {
1951 file_count += num_files;
1952 if (nr <= file_count)
1953 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001954 *fname_out = vim_strsave(
1955 files[nr - 1 + num_files - file_count]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001956 dirp = (char_u *)""; /* stop searching */
1957 }
1958 }
1959 else if (list)
1960 {
1961 if (dir_name[0] == '.' && dir_name[1] == NUL)
1962 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02001963 if (fname == NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01001964 msg_puts(_(" In current directory:\n"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001965 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01001966 msg_puts(_(" Using specified name:\n"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001967 }
1968 else
1969 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01001970 msg_puts(_(" In directory "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001971 msg_home_replace(dir_name);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001972 msg_puts(":\n");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001973 }
1974
1975 if (num_files)
1976 {
1977 for (i = 0; i < num_files; ++i)
1978 {
1979 /* print the swap file name */
1980 msg_outnum((long)++file_count);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001981 msg_puts(". ");
1982 msg_puts((char *)gettail(files[i]));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001983 msg_putchar('\n');
1984 (void)swapfile_info(files[i]);
1985 }
1986 }
1987 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01001988 msg_puts(_(" -- none --\n"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001989 out_flush();
1990 }
1991 else
1992 file_count += num_files;
1993
1994 for (i = 0; i < num_names; ++i)
1995 vim_free(names[i]);
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00001996 if (num_files > 0)
1997 FreeWild(num_files, files);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001998 }
1999 vim_free(dir_name);
2000 return file_count;
2001}
2002
Bram Moolenaar4f974752019-02-17 17:44:42 +01002003#if defined(UNIX) || defined(MSWIN) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002004/*
Bram Moolenaarb782ba42018-08-07 21:39:28 +02002005 * Need _very_ long file names.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002006 * Append the full path to name with path separators made into percent
2007 * signs, to dir. An unnamed buffer is handled as "" (<currentdir>/"")
2008 */
Bram Moolenaarb782ba42018-08-07 21:39:28 +02002009 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002010make_percent_swname(char_u *dir, char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002011{
Bram Moolenaarb782ba42018-08-07 21:39:28 +02002012 char_u *d = NULL, *s, *f;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002013
Bram Moolenaarb782ba42018-08-07 21:39:28 +02002014 f = fix_fname(name != NULL ? name : (char_u *)"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00002015 if (f != NULL)
2016 {
Bram Moolenaar964b3742019-05-24 18:54:09 +02002017 s = alloc(STRLEN(f) + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002018 if (s != NULL)
2019 {
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002020 STRCPY(s, f);
Bram Moolenaar91acfff2017-03-12 19:22:36 +01002021 for (d = s; *d != NUL; MB_PTR_ADV(d))
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002022 if (vim_ispathsep(*d))
2023 *d = '%';
Bram Moolenaar071d4272004-06-13 20:20:40 +00002024 d = concat_fnames(dir, s, TRUE);
2025 vim_free(s);
2026 }
2027 vim_free(f);
2028 }
2029 return d;
2030}
2031#endif
2032
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02002033#if (defined(UNIX) || defined(VMS) || defined(MSWIN)) \
2034 && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG))
2035# define HAVE_PROCESS_STILL_RUNNING
Bram Moolenaar071d4272004-06-13 20:20:40 +00002036static int process_still_running;
2037#endif
2038
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002039#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002040/*
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002041 * Return information found in swapfile "fname" in dictionary "d".
2042 * This is used by the swapinfo() function.
2043 */
2044 void
2045get_b0_dict(char_u *fname, dict_T *d)
2046{
2047 int fd;
2048 struct block0 b0;
2049
2050 if ((fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) >= 0)
2051 {
2052 if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0))
2053 {
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002054 if (ml_check_b0_id(&b0) == FAIL)
Bram Moolenaare6fdf792018-12-26 22:57:42 +01002055 dict_add_string(d, "error", (char_u *)"Not a swap file");
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002056 else if (b0_magic_wrong(&b0))
Bram Moolenaare6fdf792018-12-26 22:57:42 +01002057 dict_add_string(d, "error", (char_u *)"Magic number mismatch");
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002058 else
2059 {
2060 /* we have swap information */
Bram Moolenaare6fdf792018-12-26 22:57:42 +01002061 dict_add_string_len(d, "version", b0.b0_version, 10);
2062 dict_add_string_len(d, "user", b0.b0_uname, B0_UNAME_SIZE);
2063 dict_add_string_len(d, "host", b0.b0_hname, B0_HNAME_SIZE);
2064 dict_add_string_len(d, "fname", b0.b0_fname, B0_FNAME_SIZE_ORG);
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002065
2066 dict_add_number(d, "pid", char_to_long(b0.b0_pid));
2067 dict_add_number(d, "mtime", char_to_long(b0.b0_mtime));
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002068 dict_add_number(d, "dirty", b0.b0_dirty ? 1 : 0);
2069# ifdef CHECK_INODE
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002070 dict_add_number(d, "inode", char_to_long(b0.b0_ino));
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002071# endif
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002072 }
2073 }
2074 else
Bram Moolenaare6fdf792018-12-26 22:57:42 +01002075 dict_add_string(d, "error", (char_u *)"Cannot read file");
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002076 close(fd);
2077 }
2078 else
Bram Moolenaare6fdf792018-12-26 22:57:42 +01002079 dict_add_string(d, "error", (char_u *)"Cannot open file");
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002080}
Bram Moolenaar47ad5652018-08-21 21:09:07 +02002081#endif
Bram Moolenaar00f123a2018-08-21 20:28:54 +02002082
2083/*
Bram Moolenaardb517302019-06-18 22:53:24 +02002084 * Cache of the current timezone name as retrieved from TZ, or an empty string
2085 * where unset, up to 64 octets long including trailing null byte.
2086 */
2087#if defined(HAVE_LOCALTIME_R) && defined(HAVE_TZSET)
2088static char tz_cache[64];
2089#endif
2090
2091/*
2092 * Call either localtime(3) or localtime_r(3) from POSIX libc time.h, with the
2093 * latter version preferred for reentrancy.
2094 *
2095 * If we use localtime_r(3) and we have tzset(3) available, check to see if the
2096 * environment variable TZ has changed since the last run, and call tzset(3) to
2097 * update the global timezone variables if it has. This is because the POSIX
2098 * standard doesn't require localtime_r(3) implementations to do that as it
2099 * does with localtime(3), and we don't want to call tzset(3) every time.
2100 */
2101 struct tm *
2102vim_localtime(
2103 const time_t *timep, // timestamp for local representation
2104 struct tm *result) // pointer to caller return buffer
2105{
2106#ifdef HAVE_LOCALTIME_R
2107# ifdef HAVE_TZSET
2108 char *tz; // pointer for TZ environment var
2109
2110 tz = (char *)mch_getenv((char_u *)"TZ");
2111 if (tz == NULL)
2112 tz = "";
2113 if (STRNCMP(tz_cache, tz, sizeof(tz_cache) - 1) != 0)
2114 {
2115 tzset();
2116 vim_strncpy((char_u *)tz_cache, (char_u *)tz, sizeof(tz_cache) - 1);
2117 }
2118# endif // HAVE_TZSET
2119 return localtime_r(timep, result);
2120#else
2121 return localtime(timep);
2122#endif // HAVE_LOCALTIME_R
2123}
2124
2125/*
Bram Moolenaar63d25552019-05-10 21:28:38 +02002126 * Replacement for ctime(), which is not safe to use.
2127 * Requires strftime(), otherwise returns "(unknown)".
2128 * If "thetime" is invalid returns "(invalid)". Never returns NULL.
2129 * When "add_newline" is TRUE add a newline like ctime() does.
2130 * Uses a static buffer.
2131 */
2132 char *
2133get_ctime(time_t thetime, int add_newline)
2134{
2135 static char buf[50];
2136#ifdef HAVE_STRFTIME
Bram Moolenaar63d25552019-05-10 21:28:38 +02002137 struct tm tmval;
Bram Moolenaar63d25552019-05-10 21:28:38 +02002138 struct tm *curtime;
2139
Bram Moolenaardb517302019-06-18 22:53:24 +02002140 curtime = vim_localtime(&thetime, &tmval);
Bram Moolenaar63d25552019-05-10 21:28:38 +02002141 /* MSVC returns NULL for an invalid value of seconds. */
2142 if (curtime == NULL)
Bram Moolenaar0d3cb732019-05-18 13:05:18 +02002143 vim_strncpy((char_u *)buf, (char_u *)_("(Invalid)"), sizeof(buf) - 1);
Bram Moolenaar63d25552019-05-10 21:28:38 +02002144 else
Bram Moolenaar663bbc02019-07-21 15:23:35 +02002145 {
2146 (void)strftime(buf, sizeof(buf) - 1, _("%a %b %d %H:%M:%S %Y"),
2147 curtime);
2148# ifdef MSWIN
2149 if (enc_codepage >= 0 && (int)GetACP() != enc_codepage)
2150 {
2151 char_u *to_free = NULL;
2152 int len;
2153
2154 acp_to_enc((char_u *)buf, (int)strlen(buf), &to_free, &len);
2155 if (to_free != NULL)
2156 {
2157 STRCPY(buf, to_free);
2158 vim_free(to_free);
2159 }
2160 }
2161# endif
2162 }
Bram Moolenaar63d25552019-05-10 21:28:38 +02002163#else
2164 STRCPY(buf, "(unknown)");
2165#endif
2166 if (add_newline)
2167 STRCAT(buf, "\n");
2168 return buf;
2169}
2170
2171/*
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00002172 * Give information about an existing swap file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002173 * Returns timestamp (0 when unknown).
2174 */
2175 static time_t
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002176swapfile_info(char_u *fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002177{
Bram Moolenaar8767f522016-07-01 17:17:39 +02002178 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002179 int fd;
2180 struct block0 b0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002181#ifdef UNIX
2182 char_u uname[B0_UNAME_SIZE];
2183#endif
2184
Bram Moolenaar63d25552019-05-10 21:28:38 +02002185 // print the swap file date
Bram Moolenaar071d4272004-06-13 20:20:40 +00002186 if (mch_stat((char *)fname, &st) != -1)
2187 {
2188#ifdef UNIX
Bram Moolenaar63d25552019-05-10 21:28:38 +02002189 // print name of owner of the file
Bram Moolenaar071d4272004-06-13 20:20:40 +00002190 if (mch_get_uname(st.st_uid, uname, B0_UNAME_SIZE) == OK)
2191 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002192 msg_puts(_(" owned by: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002193 msg_outtrans(uname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01002194 msg_puts(_(" dated: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002195 }
2196 else
2197#endif
Bram Moolenaar32526b32019-01-19 17:43:09 +01002198 msg_puts(_(" dated: "));
Bram Moolenaar63d25552019-05-10 21:28:38 +02002199 msg_puts(get_ctime(st.st_mtime, TRUE));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002200 }
Bram Moolenaar63d25552019-05-10 21:28:38 +02002201 else
2202 st.st_mtime = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002203
2204 /*
2205 * print the original file name
2206 */
2207 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
2208 if (fd >= 0)
2209 {
Bram Moolenaar540fc6f2010-12-17 16:27:16 +01002210 if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002211 {
2212 if (STRNCMP(b0.b0_version, "VIM 3.0", 7) == 0)
2213 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002214 msg_puts(_(" [from Vim version 3.0]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002215 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02002216 else if (ml_check_b0_id(&b0) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002217 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002218 msg_puts(_(" [does not look like a Vim swap file]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002219 }
2220 else
2221 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002222 msg_puts(_(" file name: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002223 if (b0.b0_fname[0] == NUL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01002224 msg_puts(_("[No Name]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002225 else
2226 msg_outtrans(b0.b0_fname);
2227
Bram Moolenaar32526b32019-01-19 17:43:09 +01002228 msg_puts(_("\n modified: "));
2229 msg_puts(b0.b0_dirty ? _("YES") : _("no"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002230
2231 if (*(b0.b0_uname) != NUL)
2232 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002233 msg_puts(_("\n user name: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002234 msg_outtrans(b0.b0_uname);
2235 }
2236
2237 if (*(b0.b0_hname) != NUL)
2238 {
2239 if (*(b0.b0_uname) != NUL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01002240 msg_puts(_(" host name: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002241 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01002242 msg_puts(_("\n host name: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002243 msg_outtrans(b0.b0_hname);
2244 }
2245
2246 if (char_to_long(b0.b0_pid) != 0L)
2247 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002248 msg_puts(_("\n process ID: "));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002249 msg_outnum(char_to_long(b0.b0_pid));
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02002250#if defined(UNIX) || defined(MSWIN)
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02002251 if (mch_process_running(char_to_long(b0.b0_pid)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002252 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01002253 msg_puts(_(" (STILL RUNNING)"));
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02002254# ifdef HAVE_PROCESS_STILL_RUNNING
Bram Moolenaar071d4272004-06-13 20:20:40 +00002255 process_still_running = TRUE;
2256# endif
2257 }
2258#endif
2259 }
2260
2261 if (b0_magic_wrong(&b0))
2262 {
Bram Moolenaar48e330a2016-02-23 14:53:34 +01002263#if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002264 if (STRNCMP(b0.b0_hname, "PC ", 3) == 0)
Bram Moolenaar32526b32019-01-19 17:43:09 +01002265 msg_puts(_("\n [not usable with this version of Vim]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002266 else
2267#endif
Bram Moolenaar32526b32019-01-19 17:43:09 +01002268 msg_puts(_("\n [not usable on this computer]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002269 }
2270 }
2271 }
2272 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01002273 msg_puts(_(" [cannot be read]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002274 close(fd);
2275 }
2276 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01002277 msg_puts(_(" [cannot be opened]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002278 msg_putchar('\n');
2279
Bram Moolenaar63d25552019-05-10 21:28:38 +02002280 return st.st_mtime;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002281}
2282
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02002283/*
2284 * Return TRUE if the swap file looks OK and there are no changes, thus it can
2285 * be safely deleted.
2286 */
2287 static time_t
2288swapfile_unchanged(char_u *fname)
2289{
2290 stat_T st;
2291 int fd;
2292 struct block0 b0;
2293 int ret = TRUE;
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02002294#if defined(UNIX) || defined(MSWIN)
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02002295 long pid;
2296#endif
2297
2298 // must be able to stat the swap file
2299 if (mch_stat((char *)fname, &st) == -1)
2300 return FALSE;
2301
2302 // must be able to read the first block
2303 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
2304 if (fd < 0)
2305 return FALSE;
2306 if (read_eintr(fd, &b0, sizeof(b0)) != sizeof(b0))
2307 {
2308 close(fd);
2309 return FALSE;
2310 }
2311
2312 // the ID and magic number must be correct
2313 if (ml_check_b0_id(&b0) == FAIL|| b0_magic_wrong(&b0))
2314 ret = FALSE;
2315
2316 // must be unchanged
2317 if (b0.b0_dirty)
2318 ret = FALSE;
2319
2320#if defined(UNIX) || defined(MSWIN)
2321 // process must known and not be running
2322 pid = char_to_long(b0.b0_pid);
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02002323 if (pid == 0L || mch_process_running(pid))
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02002324 ret = FALSE;
2325#endif
2326
2327 // TODO: Should we check if the swap file was created on the current
2328 // system? And the current user?
2329
2330 close(fd);
2331 return ret;
2332}
2333
Bram Moolenaar071d4272004-06-13 20:20:40 +00002334 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002335recov_file_names(char_u **names, char_u *path, int prepend_dot)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002336{
2337 int num_names;
2338
Bram Moolenaar071d4272004-06-13 20:20:40 +00002339 /*
2340 * (Win32 and Win64) never short names, but do prepend a dot.
2341 * (Not MS-DOS or Win32 or Win64) maybe short name, maybe not: Try both.
2342 * Only use the short name if it is different.
2343 */
2344 char_u *p;
2345 int i;
Bram Moolenaar4f974752019-02-17 17:44:42 +01002346# ifndef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00002347 int shortname = curbuf->b_shortname;
2348
2349 curbuf->b_shortname = FALSE;
2350# endif
2351
2352 num_names = 0;
2353
2354 /*
2355 * May also add the file name with a dot prepended, for swap file in same
2356 * dir as original file.
2357 */
2358 if (prepend_dot)
2359 {
2360 names[num_names] = modname(path, (char_u *)".sw?", TRUE);
2361 if (names[num_names] == NULL)
2362 goto end;
2363 ++num_names;
2364 }
2365
2366 /*
2367 * Form the normal swap file name pattern by appending ".sw?".
2368 */
2369#ifdef VMS
2370 names[num_names] = concat_fnames(path, (char_u *)"_sw%", FALSE);
2371#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002372 names[num_names] = concat_fnames(path, (char_u *)".sw?", FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002373#endif
2374 if (names[num_names] == NULL)
2375 goto end;
2376 if (num_names >= 1) /* check if we have the same name twice */
2377 {
2378 p = names[num_names - 1];
2379 i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]);
2380 if (i > 0)
2381 p += i; /* file name has been expanded to full path */
2382
2383 if (STRCMP(p, names[num_names]) != 0)
2384 ++num_names;
2385 else
2386 vim_free(names[num_names]);
2387 }
2388 else
2389 ++num_names;
2390
Bram Moolenaar4f974752019-02-17 17:44:42 +01002391# ifndef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00002392 /*
2393 * Also try with 'shortname' set, in case the file is on a DOS filesystem.
2394 */
2395 curbuf->b_shortname = TRUE;
2396#ifdef VMS
2397 names[num_names] = modname(path, (char_u *)"_sw%", FALSE);
2398#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002399 names[num_names] = modname(path, (char_u *)".sw?", FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002400#endif
2401 if (names[num_names] == NULL)
2402 goto end;
2403
2404 /*
2405 * Remove the one from 'shortname', if it's the same as with 'noshortname'.
2406 */
2407 p = names[num_names];
2408 i = STRLEN(names[num_names]) - STRLEN(names[num_names - 1]);
2409 if (i > 0)
2410 p += i; /* file name has been expanded to full path */
2411 if (STRCMP(names[num_names - 1], p) == 0)
2412 vim_free(names[num_names]);
2413 else
2414 ++num_names;
2415# endif
2416
2417end:
Bram Moolenaar4f974752019-02-17 17:44:42 +01002418# ifndef MSWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00002419 curbuf->b_shortname = shortname;
2420# endif
2421
Bram Moolenaar071d4272004-06-13 20:20:40 +00002422 return num_names;
2423}
2424
2425/*
2426 * sync all memlines
2427 *
2428 * If 'check_file' is TRUE, check if original file exists and was not changed.
2429 * If 'check_char' is TRUE, stop syncing when character becomes available, but
2430 * always sync at least one block.
2431 */
2432 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002433ml_sync_all(int check_file, int check_char)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002434{
2435 buf_T *buf;
Bram Moolenaar8767f522016-07-01 17:17:39 +02002436 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002437
Bram Moolenaar29323592016-07-24 22:04:11 +02002438 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002439 {
2440 if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL)
2441 continue; /* no file */
2442
2443 ml_flush_line(buf); /* flush buffered line */
2444 /* flush locked block */
2445 (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);
2446 if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp)
2447 && buf->b_ffname != NULL)
2448 {
2449 /*
2450 * If the original file does not exist anymore or has been changed
2451 * call ml_preserve() to get rid of all negative numbered blocks.
2452 */
2453 if (mch_stat((char *)buf->b_ffname, &st) == -1
2454 || st.st_mtime != buf->b_mtime_read
Bram Moolenaar914703b2010-05-31 21:59:46 +02002455 || st.st_size != buf->b_orig_size)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002456 {
2457 ml_preserve(buf, FALSE);
2458 did_check_timestamps = FALSE;
2459 need_check_timestamps = TRUE; /* give message later */
2460 }
2461 }
2462 if (buf->b_ml.ml_mfp->mf_dirty)
2463 {
2464 (void)mf_sync(buf->b_ml.ml_mfp, (check_char ? MFS_STOP : 0)
2465 | (bufIsChanged(buf) ? MFS_FLUSH : 0));
2466 if (check_char && ui_char_avail()) /* character available now */
2467 break;
2468 }
2469 }
2470}
2471
2472/*
2473 * sync one buffer, including negative blocks
2474 *
2475 * after this all the blocks are in the swap file
2476 *
2477 * Used for the :preserve command and when the original file has been
2478 * changed or deleted.
2479 *
2480 * when message is TRUE the success of preserving is reported
2481 */
2482 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002483ml_preserve(buf_T *buf, int message)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002484{
2485 bhdr_T *hp;
2486 linenr_T lnum;
2487 memfile_T *mfp = buf->b_ml.ml_mfp;
2488 int status;
2489 int got_int_save = got_int;
2490
2491 if (mfp == NULL || mfp->mf_fname == NULL)
2492 {
2493 if (message)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002494 emsg(_("E313: Cannot preserve, there is no swap file"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002495 return;
2496 }
2497
2498 /* We only want to stop when interrupted here, not when interrupted
2499 * before. */
2500 got_int = FALSE;
2501
2502 ml_flush_line(buf); /* flush buffered line */
2503 (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
2504 status = mf_sync(mfp, MFS_ALL | MFS_FLUSH);
2505
2506 /* stack is invalid after mf_sync(.., MFS_ALL) */
2507 buf->b_ml.ml_stack_top = 0;
2508
2509 /*
2510 * Some of the data blocks may have been changed from negative to
2511 * positive block number. In that case the pointer blocks need to be
2512 * updated.
2513 *
2514 * We don't know in which pointer block the references are, so we visit
2515 * all data blocks until there are no more translations to be done (or
2516 * we hit the end of the file, which can only happen in case a write fails,
2517 * e.g. when file system if full).
2518 * ml_find_line() does the work by translating the negative block numbers
2519 * when getting the first line of each data block.
2520 */
2521 if (mf_need_trans(mfp) && !got_int)
2522 {
2523 lnum = 1;
2524 while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count)
2525 {
2526 hp = ml_find_line(buf, lnum, ML_FIND);
2527 if (hp == NULL)
2528 {
2529 status = FAIL;
2530 goto theend;
2531 }
2532 CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum");
2533 lnum = buf->b_ml.ml_locked_high + 1;
2534 }
2535 (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
2536 /* sync the updated pointer blocks */
2537 if (mf_sync(mfp, MFS_ALL | MFS_FLUSH) == FAIL)
2538 status = FAIL;
2539 buf->b_ml.ml_stack_top = 0; /* stack is invalid now */
2540 }
2541theend:
2542 got_int |= got_int_save;
2543
2544 if (message)
2545 {
2546 if (status == OK)
Bram Moolenaar32526b32019-01-19 17:43:09 +01002547 msg(_("File preserved"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002548 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002549 emsg(_("E314: Preserve failed"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002550 }
2551}
2552
2553/*
2554 * NOTE: The pointer returned by the ml_get_*() functions only remains valid
2555 * until the next call!
2556 * line1 = ml_get(1);
2557 * line2 = ml_get(2); // line1 is now invalid!
2558 * Make a copy of the line if necessary.
2559 */
2560/*
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +01002561 * Return a pointer to a (read-only copy of a) line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002562 *
2563 * On failure an error message is given and IObuff is returned (to avoid
2564 * having to check for error everywhere).
2565 */
2566 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002567ml_get(linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002568{
2569 return ml_get_buf(curbuf, lnum, FALSE);
2570}
2571
2572/*
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +01002573 * Return pointer to position "pos".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002574 */
2575 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002576ml_get_pos(pos_T *pos)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002577{
2578 return (ml_get_buf(curbuf, pos->lnum, FALSE) + pos->col);
2579}
2580
2581/*
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +01002582 * Return pointer to cursor line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002583 */
2584 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002585ml_get_curline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002586{
2587 return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE);
2588}
2589
2590/*
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +01002591 * Return pointer to cursor position.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002592 */
2593 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002594ml_get_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002595{
2596 return (ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE) +
2597 curwin->w_cursor.col);
2598}
2599
2600/*
Bram Moolenaar2e2e13c2010-12-08 13:17:03 +01002601 * Return a pointer to a line in a specific buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00002602 *
2603 * "will_change": if TRUE mark the buffer dirty (chars in the line will be
2604 * changed)
2605 */
2606 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002607ml_get_buf(
2608 buf_T *buf,
2609 linenr_T lnum,
2610 int will_change) /* line will be changed */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002611{
Bram Moolenaarad40f022007-02-13 03:01:39 +00002612 bhdr_T *hp;
2613 DATA_BL *dp;
Bram Moolenaarad40f022007-02-13 03:01:39 +00002614 static int recursive = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002615
2616 if (lnum > buf->b_ml.ml_line_count) /* invalid line number */
2617 {
Bram Moolenaarad40f022007-02-13 03:01:39 +00002618 if (recursive == 0)
2619 {
2620 /* Avoid giving this message for a recursive call, may happen when
2621 * the GUI redraws part of the text. */
2622 ++recursive;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002623 siemsg(_("E315: ml_get: invalid lnum: %ld"), lnum);
Bram Moolenaarad40f022007-02-13 03:01:39 +00002624 --recursive;
2625 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002626errorret:
2627 STRCPY(IObuff, "???");
Bram Moolenaaradfde112019-05-25 22:11:45 +02002628 buf->b_ml.ml_line_len = 4;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002629 return IObuff;
2630 }
Bram Moolenaaradfde112019-05-25 22:11:45 +02002631 if (lnum <= 0) // pretend line 0 is line 1
Bram Moolenaar071d4272004-06-13 20:20:40 +00002632 lnum = 1;
2633
Bram Moolenaaradfde112019-05-25 22:11:45 +02002634 if (buf->b_ml.ml_mfp == NULL) // there are no lines
2635 {
2636 buf->b_ml.ml_line_len = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002637 return (char_u *)"";
Bram Moolenaaradfde112019-05-25 22:11:45 +02002638 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002639
Bram Moolenaar37d619f2010-03-10 14:46:26 +01002640 /*
2641 * See if it is the same line as requested last time.
2642 * Otherwise may need to flush last used line.
2643 * Don't use the last used line when 'swapfile' is reset, need to load all
2644 * blocks.
2645 */
Bram Moolenaar47b8b152007-02-07 02:41:57 +00002646 if (buf->b_ml.ml_line_lnum != lnum || mf_dont_release)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002647 {
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002648 unsigned start, end;
2649 colnr_T len;
2650 int idx;
2651
Bram Moolenaar071d4272004-06-13 20:20:40 +00002652 ml_flush_line(buf);
2653
2654 /*
2655 * Find the data block containing the line.
2656 * This also fills the stack with the blocks from the root to the data
2657 * block and releases any locked block.
2658 */
2659 if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
2660 {
Bram Moolenaarad40f022007-02-13 03:01:39 +00002661 if (recursive == 0)
2662 {
2663 /* Avoid giving this message for a recursive call, may happen
2664 * when the GUI redraws part of the text. */
2665 ++recursive;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002666 siemsg(_("E316: ml_get: cannot find line %ld"), lnum);
Bram Moolenaarad40f022007-02-13 03:01:39 +00002667 --recursive;
2668 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002669 goto errorret;
2670 }
2671
2672 dp = (DATA_BL *)(hp->bh_data);
2673
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002674 idx = lnum - buf->b_ml.ml_locked_low;
2675 start = ((dp->db_index[idx]) & DB_INDEX_MASK);
2676 // The text ends where the previous line starts. The first line ends
2677 // at the end of the block.
2678 if (idx == 0)
2679 end = dp->db_txt_end;
2680 else
2681 end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
2682 len = end - start;
2683
2684 buf->b_ml.ml_line_ptr = (char_u *)dp + start;
2685 buf->b_ml.ml_line_len = len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002686 buf->b_ml.ml_line_lnum = lnum;
2687 buf->b_ml.ml_flags &= ~ML_LINE_DIRTY;
2688 }
2689 if (will_change)
2690 buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
2691
2692 return buf->b_ml.ml_line_ptr;
2693}
2694
2695/*
2696 * Check if a line that was just obtained by a call to ml_get
2697 * is in allocated memory.
2698 */
2699 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002700ml_line_alloced(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002701{
2702 return (curbuf->b_ml.ml_flags & ML_LINE_DIRTY);
2703}
2704
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002705#ifdef FEAT_TEXT_PROP
2706 static void
2707add_text_props_for_append(
2708 buf_T *buf,
2709 linenr_T lnum,
2710 char_u **line,
2711 int *len,
2712 char_u **tofree)
2713{
2714 int round;
2715 int new_prop_count = 0;
2716 int count;
2717 int n;
2718 char_u *props;
2719 int new_len;
2720 char_u *new_line;
2721 textprop_T prop;
2722
2723 // Make two rounds:
2724 // 1. calculate the extra space needed
2725 // 2. allocate the space and fill it
2726 for (round = 1; round <= 2; ++round)
2727 {
2728 if (round == 2)
2729 {
2730 if (new_prop_count == 0)
2731 return; // nothing to do
2732 new_len = *len + new_prop_count * sizeof(textprop_T);
Bram Moolenaar964b3742019-05-24 18:54:09 +02002733 new_line = alloc(new_len);
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002734 if (new_line == NULL)
2735 return;
2736 mch_memmove(new_line, *line, *len);
2737 new_prop_count = 0;
2738 }
2739
2740 // Get the line above to find any props that continue in the next
2741 // line.
2742 count = get_text_props(buf, lnum, &props, FALSE);
2743 for (n = 0; n < count; ++n)
2744 {
2745 mch_memmove(&prop, props + n * sizeof(textprop_T), sizeof(textprop_T));
2746 if (prop.tp_flags & TP_FLAG_CONT_NEXT)
2747 {
2748 if (round == 2)
2749 {
2750 prop.tp_flags |= TP_FLAG_CONT_PREV;
2751 prop.tp_col = 1;
2752 prop.tp_len = *len;
2753 mch_memmove(new_line + *len + new_prop_count * sizeof(textprop_T), &prop, sizeof(textprop_T));
2754 }
2755 ++new_prop_count;
2756 }
2757 }
2758 }
2759 *line = new_line;
2760 *tofree = new_line;
2761 *len = new_len;
2762}
2763#endif
2764
Bram Moolenaar071d4272004-06-13 20:20:40 +00002765 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01002766ml_append_int(
2767 buf_T *buf,
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002768 linenr_T lnum, // append after this line (can be 0)
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002769 char_u *line_arg, // text of the new line
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002770 colnr_T len_arg, // length of line, including NUL, or 0
2771 int newfile, // flag, see above
2772 int mark) // mark the new line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002773{
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002774 char_u *line = line_arg;
2775 colnr_T len = len_arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 int i;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002777 int line_count; // number of indexes in current block
Bram Moolenaar071d4272004-06-13 20:20:40 +00002778 int offset;
2779 int from, to;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002780 int space_needed; // space needed for new line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002781 int page_size;
2782 int page_count;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002783 int db_idx; // index for lnum in data block
Bram Moolenaar071d4272004-06-13 20:20:40 +00002784 bhdr_T *hp;
2785 memfile_T *mfp;
2786 DATA_BL *dp;
2787 PTR_BL *pp;
2788 infoptr_T *ip;
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002789#ifdef FEAT_TEXT_PROP
2790 char_u *tofree = NULL;
2791#endif
2792 int ret = FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002793
Bram Moolenaar071d4272004-06-13 20:20:40 +00002794 if (lnum > buf->b_ml.ml_line_count || buf->b_ml.ml_mfp == NULL)
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002795 return FAIL; // lnum out of range
Bram Moolenaar071d4272004-06-13 20:20:40 +00002796
2797 if (lowest_marked && lowest_marked > lnum)
2798 lowest_marked = lnum + 1;
2799
2800 if (len == 0)
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002801 len = (colnr_T)STRLEN(line) + 1; // space needed for the text
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002802
2803#ifdef FEAT_TEXT_PROP
2804 if (curbuf->b_has_textprop && lnum > 0)
2805 // Add text properties that continue from the previous line.
2806 add_text_props_for_append(buf, lnum, &line, &len, &tofree);
2807#endif
2808
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002809 space_needed = len + INDEX_SIZE; // space needed for text + index
Bram Moolenaar071d4272004-06-13 20:20:40 +00002810
2811 mfp = buf->b_ml.ml_mfp;
2812 page_size = mfp->mf_page_size;
2813
2814/*
2815 * find the data block containing the previous line
2816 * This also fills the stack with the blocks from the root to the data block
2817 * This also releases any locked block.
2818 */
2819 if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_T)1 : lnum,
2820 ML_INSERT)) == NULL)
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002821 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002822
2823 buf->b_ml.ml_flags &= ~ML_EMPTY;
2824
2825 if (lnum == 0) /* got line one instead, correct db_idx */
2826 db_idx = -1; /* careful, it is negative! */
2827 else
2828 db_idx = lnum - buf->b_ml.ml_locked_low;
2829 /* get line count before the insertion */
2830 line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
2831
2832 dp = (DATA_BL *)(hp->bh_data);
2833
2834/*
2835 * If
2836 * - there is not enough room in the current block
2837 * - appending to the last line in the block
2838 * - not appending to the last line in the file
2839 * insert in front of the next block.
2840 */
2841 if ((int)dp->db_free < space_needed && db_idx == line_count - 1
2842 && lnum < buf->b_ml.ml_line_count)
2843 {
2844 /*
2845 * Now that the line is not going to be inserted in the block that we
2846 * expected, the line count has to be adjusted in the pointer blocks
2847 * by using ml_locked_lineadd.
2848 */
2849 --(buf->b_ml.ml_locked_lineadd);
2850 --(buf->b_ml.ml_locked_high);
2851 if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL)
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002852 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002853
2854 db_idx = -1; /* careful, it is negative! */
2855 /* get line count before the insertion */
2856 line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
2857 CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1");
2858
2859 dp = (DATA_BL *)(hp->bh_data);
2860 }
2861
2862 ++buf->b_ml.ml_line_count;
2863
2864 if ((int)dp->db_free >= space_needed) /* enough room in data block */
2865 {
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002866 /*
2867 * Insert the new line in an existing data block, or in the data block
2868 * allocated above.
2869 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002870 dp->db_txt_start -= len;
2871 dp->db_free -= space_needed;
2872 ++(dp->db_line_count);
2873
2874 /*
2875 * move the text of the lines that follow to the front
2876 * adjust the indexes of the lines that follow
2877 */
2878 if (line_count > db_idx + 1) /* if there are following lines */
2879 {
2880 /*
2881 * Offset is the start of the previous line.
2882 * This will become the character just after the new line.
2883 */
2884 if (db_idx < 0)
2885 offset = dp->db_txt_end;
2886 else
2887 offset = ((dp->db_index[db_idx]) & DB_INDEX_MASK);
2888 mch_memmove((char *)dp + dp->db_txt_start,
2889 (char *)dp + dp->db_txt_start + len,
2890 (size_t)(offset - (dp->db_txt_start + len)));
2891 for (i = line_count - 1; i > db_idx; --i)
2892 dp->db_index[i + 1] = dp->db_index[i] - len;
2893 dp->db_index[db_idx + 1] = offset - len;
2894 }
Bram Moolenaar98aefe72018-12-13 22:20:09 +01002895 else
2896 // add line at the end (which is the start of the text)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002897 dp->db_index[db_idx + 1] = dp->db_txt_start;
2898
2899 /*
2900 * copy the text into the block
2901 */
2902 mch_memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len);
2903 if (mark)
2904 dp->db_index[db_idx + 1] |= DB_MARKED;
2905
2906 /*
2907 * Mark the block dirty.
2908 */
2909 buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
2910 if (!newfile)
2911 buf->b_ml.ml_flags |= ML_LOCKED_POS;
2912 }
2913 else /* not enough space in data block */
2914 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002915 long line_count_left, line_count_right;
2916 int page_count_left, page_count_right;
2917 bhdr_T *hp_left;
2918 bhdr_T *hp_right;
2919 bhdr_T *hp_new;
2920 int lines_moved;
2921 int data_moved = 0; /* init to shut up gcc */
2922 int total_moved = 0; /* init to shut up gcc */
2923 DATA_BL *dp_right, *dp_left;
2924 int stack_idx;
2925 int in_left;
2926 int lineadd;
2927 blocknr_T bnum_left, bnum_right;
2928 linenr_T lnum_left, lnum_right;
2929 int pb_idx;
2930 PTR_BL *pp_new;
2931
2932 /*
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002933 * There is not enough room, we have to create a new data block and
2934 * copy some lines into it.
2935 * Then we have to insert an entry in the pointer block.
2936 * If this pointer block also is full, we go up another block, and so
2937 * on, up to the root if necessary.
2938 * The line counts in the pointer blocks have already been adjusted by
2939 * ml_find_line().
2940 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00002941 * We are going to allocate a new data block. Depending on the
2942 * situation it will be put to the left or right of the existing
2943 * block. If possible we put the new line in the left block and move
2944 * the lines after it to the right block. Otherwise the new line is
2945 * also put in the right block. This method is more efficient when
2946 * inserting a lot of lines at one place.
2947 */
2948 if (db_idx < 0) /* left block is new, right block is existing */
2949 {
2950 lines_moved = 0;
2951 in_left = TRUE;
2952 /* space_needed does not change */
2953 }
2954 else /* left block is existing, right block is new */
2955 {
2956 lines_moved = line_count - db_idx - 1;
2957 if (lines_moved == 0)
2958 in_left = FALSE; /* put new line in right block */
2959 /* space_needed does not change */
2960 else
2961 {
2962 data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) -
2963 dp->db_txt_start;
2964 total_moved = data_moved + lines_moved * INDEX_SIZE;
2965 if ((int)dp->db_free + total_moved >= space_needed)
2966 {
2967 in_left = TRUE; /* put new line in left block */
2968 space_needed = total_moved;
2969 }
2970 else
2971 {
2972 in_left = FALSE; /* put new line in right block */
2973 space_needed += total_moved;
2974 }
2975 }
2976 }
2977
2978 page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size;
2979 if ((hp_new = ml_new_data(mfp, newfile, page_count)) == NULL)
2980 {
2981 /* correct line counts in pointer blocks */
2982 --(buf->b_ml.ml_locked_lineadd);
2983 --(buf->b_ml.ml_locked_high);
Bram Moolenaarb56ac042018-12-28 23:22:40 +01002984 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002985 }
2986 if (db_idx < 0) /* left block is new */
2987 {
2988 hp_left = hp_new;
2989 hp_right = hp;
2990 line_count_left = 0;
2991 line_count_right = line_count;
2992 }
2993 else /* right block is new */
2994 {
2995 hp_left = hp;
2996 hp_right = hp_new;
2997 line_count_left = line_count;
2998 line_count_right = 0;
2999 }
3000 dp_right = (DATA_BL *)(hp_right->bh_data);
3001 dp_left = (DATA_BL *)(hp_left->bh_data);
3002 bnum_left = hp_left->bh_bnum;
3003 bnum_right = hp_right->bh_bnum;
3004 page_count_left = hp_left->bh_page_count;
3005 page_count_right = hp_right->bh_page_count;
3006
3007 /*
3008 * May move the new line into the right/new block.
3009 */
3010 if (!in_left)
3011 {
3012 dp_right->db_txt_start -= len;
3013 dp_right->db_free -= len + INDEX_SIZE;
3014 dp_right->db_index[0] = dp_right->db_txt_start;
3015 if (mark)
3016 dp_right->db_index[0] |= DB_MARKED;
3017
3018 mch_memmove((char *)dp_right + dp_right->db_txt_start,
3019 line, (size_t)len);
3020 ++line_count_right;
3021 }
3022 /*
3023 * may move lines from the left/old block to the right/new one.
3024 */
3025 if (lines_moved)
3026 {
3027 /*
3028 */
3029 dp_right->db_txt_start -= data_moved;
3030 dp_right->db_free -= total_moved;
3031 mch_memmove((char *)dp_right + dp_right->db_txt_start,
3032 (char *)dp_left + dp_left->db_txt_start,
3033 (size_t)data_moved);
3034 offset = dp_right->db_txt_start - dp_left->db_txt_start;
3035 dp_left->db_txt_start += data_moved;
3036 dp_left->db_free += total_moved;
3037
3038 /*
3039 * update indexes in the new block
3040 */
3041 for (to = line_count_right, from = db_idx + 1;
3042 from < line_count_left; ++from, ++to)
3043 dp_right->db_index[to] = dp->db_index[from] + offset;
3044 line_count_right += lines_moved;
3045 line_count_left -= lines_moved;
3046 }
3047
3048 /*
3049 * May move the new line into the left (old or new) block.
3050 */
3051 if (in_left)
3052 {
3053 dp_left->db_txt_start -= len;
3054 dp_left->db_free -= len + INDEX_SIZE;
3055 dp_left->db_index[line_count_left] = dp_left->db_txt_start;
3056 if (mark)
3057 dp_left->db_index[line_count_left] |= DB_MARKED;
3058 mch_memmove((char *)dp_left + dp_left->db_txt_start,
3059 line, (size_t)len);
3060 ++line_count_left;
3061 }
3062
3063 if (db_idx < 0) /* left block is new */
3064 {
3065 lnum_left = lnum + 1;
3066 lnum_right = 0;
3067 }
3068 else /* right block is new */
3069 {
3070 lnum_left = 0;
3071 if (in_left)
3072 lnum_right = lnum + 2;
3073 else
3074 lnum_right = lnum + 1;
3075 }
3076 dp_left->db_line_count = line_count_left;
3077 dp_right->db_line_count = line_count_right;
3078
3079 /*
3080 * release the two data blocks
3081 * The new one (hp_new) already has a correct blocknumber.
3082 * The old one (hp, in ml_locked) gets a positive blocknumber if
3083 * we changed it and we are not editing a new file.
3084 */
3085 if (lines_moved || in_left)
3086 buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
3087 if (!newfile && db_idx >= 0 && in_left)
3088 buf->b_ml.ml_flags |= ML_LOCKED_POS;
3089 mf_put(mfp, hp_new, TRUE, FALSE);
3090
3091 /*
3092 * flush the old data block
3093 * set ml_locked_lineadd to 0, because the updating of the
3094 * pointer blocks is done below
3095 */
3096 lineadd = buf->b_ml.ml_locked_lineadd;
3097 buf->b_ml.ml_locked_lineadd = 0;
3098 ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush data block */
3099
3100 /*
3101 * update pointer blocks for the new data block
3102 */
3103 for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
3104 --stack_idx)
3105 {
3106 ip = &(buf->b_ml.ml_stack[stack_idx]);
3107 pb_idx = ip->ip_index;
3108 if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
Bram Moolenaarb56ac042018-12-28 23:22:40 +01003109 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003110 pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
3111 if (pp->pb_id != PTR_ID)
3112 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003113 iemsg(_("E317: pointer block id wrong 3"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003114 mf_put(mfp, hp, FALSE, FALSE);
Bram Moolenaarb56ac042018-12-28 23:22:40 +01003115 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003116 }
3117 /*
3118 * TODO: If the pointer block is full and we are adding at the end
3119 * try to insert in front of the next block
3120 */
3121 /* block not full, add one entry */
3122 if (pp->pb_count < pp->pb_count_max)
3123 {
3124 if (pb_idx + 1 < (int)pp->pb_count)
3125 mch_memmove(&pp->pb_pointer[pb_idx + 2],
3126 &pp->pb_pointer[pb_idx + 1],
3127 (size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN));
3128 ++pp->pb_count;
3129 pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
3130 pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
3131 pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
3132 pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
3133 pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
3134 pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
3135
3136 if (lnum_left != 0)
3137 pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
3138 if (lnum_right != 0)
3139 pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
3140
3141 mf_put(mfp, hp, TRUE, FALSE);
3142 buf->b_ml.ml_stack_top = stack_idx + 1; /* truncate stack */
3143
3144 if (lineadd)
3145 {
3146 --(buf->b_ml.ml_stack_top);
Bram Moolenaar6b803a72007-05-06 14:25:46 +00003147 /* fix line count for rest of blocks in the stack */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003148 ml_lineadd(buf, lineadd);
3149 /* fix stack itself */
3150 buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
3151 lineadd;
3152 ++(buf->b_ml.ml_stack_top);
3153 }
3154
3155 /*
3156 * We are finished, break the loop here.
3157 */
3158 break;
3159 }
3160 else /* pointer block full */
3161 {
3162 /*
3163 * split the pointer block
3164 * allocate a new pointer block
3165 * move some of the pointer into the new block
3166 * prepare for updating the parent block
3167 */
3168 for (;;) /* do this twice when splitting block 1 */
3169 {
3170 hp_new = ml_new_ptr(mfp);
3171 if (hp_new == NULL) /* TODO: try to fix tree */
Bram Moolenaarb56ac042018-12-28 23:22:40 +01003172 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003173 pp_new = (PTR_BL *)(hp_new->bh_data);
3174
3175 if (hp->bh_bnum != 1)
3176 break;
3177
3178 /*
3179 * if block 1 becomes full the tree is given an extra level
3180 * The pointers from block 1 are moved into the new block.
3181 * block 1 is updated to point to the new block
3182 * then continue to split the new block
3183 */
3184 mch_memmove(pp_new, pp, (size_t)page_size);
3185 pp->pb_count = 1;
3186 pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum;
3187 pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count;
3188 pp->pb_pointer[0].pe_old_lnum = 1;
3189 pp->pb_pointer[0].pe_page_count = 1;
3190 mf_put(mfp, hp, TRUE, FALSE); /* release block 1 */
3191 hp = hp_new; /* new block is to be split */
3192 pp = pp_new;
3193 CHECK(stack_idx != 0, _("stack_idx should be 0"));
3194 ip->ip_index = 0;
3195 ++stack_idx; /* do block 1 again later */
3196 }
3197 /*
3198 * move the pointers after the current one to the new block
3199 * If there are none, the new entry will be in the new block.
3200 */
3201 total_moved = pp->pb_count - pb_idx - 1;
3202 if (total_moved)
3203 {
3204 mch_memmove(&pp_new->pb_pointer[0],
3205 &pp->pb_pointer[pb_idx + 1],
3206 (size_t)(total_moved) * sizeof(PTR_EN));
3207 pp_new->pb_count = total_moved;
3208 pp->pb_count -= total_moved - 1;
3209 pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
3210 pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
3211 pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
3212 if (lnum_right)
3213 pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
3214 }
3215 else
3216 {
3217 pp_new->pb_count = 1;
3218 pp_new->pb_pointer[0].pe_bnum = bnum_right;
3219 pp_new->pb_pointer[0].pe_line_count = line_count_right;
3220 pp_new->pb_pointer[0].pe_page_count = page_count_right;
3221 pp_new->pb_pointer[0].pe_old_lnum = lnum_right;
3222 }
3223 pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
3224 pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
3225 pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
3226 if (lnum_left)
3227 pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
3228 lnum_left = 0;
3229 lnum_right = 0;
3230
3231 /*
3232 * recompute line counts
3233 */
3234 line_count_right = 0;
3235 for (i = 0; i < (int)pp_new->pb_count; ++i)
3236 line_count_right += pp_new->pb_pointer[i].pe_line_count;
3237 line_count_left = 0;
3238 for (i = 0; i < (int)pp->pb_count; ++i)
3239 line_count_left += pp->pb_pointer[i].pe_line_count;
3240
3241 bnum_left = hp->bh_bnum;
3242 bnum_right = hp_new->bh_bnum;
3243 page_count_left = 1;
3244 page_count_right = 1;
3245 mf_put(mfp, hp, TRUE, FALSE);
3246 mf_put(mfp, hp_new, TRUE, FALSE);
3247 }
3248 }
3249
3250 /*
3251 * Safety check: fallen out of for loop?
3252 */
3253 if (stack_idx < 0)
3254 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003255 iemsg(_("E318: Updated too many blocks?"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003256 buf->b_ml.ml_stack_top = 0; /* invalidate stack */
3257 }
3258 }
3259
3260#ifdef FEAT_BYTEOFF
3261 /* The line was inserted below 'lnum' */
3262 ml_updatechunk(buf, lnum + 1, (long)len, ML_CHNK_ADDLINE);
3263#endif
3264#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +02003265 if (netbeans_active())
Bram Moolenaar071d4272004-06-13 20:20:40 +00003266 {
3267 if (STRLEN(line) > 0)
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003268 netbeans_inserted(buf, lnum+1, (colnr_T)0, line, (int)STRLEN(line));
Bram Moolenaar35a9aaa2004-10-24 19:23:07 +00003269 netbeans_inserted(buf, lnum+1, (colnr_T)STRLEN(line),
Bram Moolenaar071d4272004-06-13 20:20:40 +00003270 (char_u *)"\n", 1);
3271 }
3272#endif
Bram Moolenaar509ce2a2016-03-11 22:52:15 +01003273#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar99ef0622016-03-06 20:22:25 +01003274 if (buf->b_write_to_channel)
3275 channel_write_new_lines(buf);
3276#endif
Bram Moolenaarb56ac042018-12-28 23:22:40 +01003277 ret = OK;
Bram Moolenaar99ef0622016-03-06 20:22:25 +01003278
Bram Moolenaarb56ac042018-12-28 23:22:40 +01003279theend:
3280#ifdef FEAT_TEXT_PROP
3281 vim_free(tofree);
3282#endif
3283 return ret;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003284}
3285
3286/*
Bram Moolenaar250e3112019-07-15 23:02:14 +02003287 * Flush any pending change and call ml_append_int()
3288 */
3289 static int
3290ml_append_flush(
3291 buf_T *buf,
3292 linenr_T lnum, // append after this line (can be 0)
3293 char_u *line, // text of the new line
3294 colnr_T len, // length of line, including NUL, or 0
3295 int newfile) // flag, see above
3296{
3297 if (lnum > buf->b_ml.ml_line_count)
3298 return FAIL; // lnum out of range
3299
3300 if (buf->b_ml.ml_line_lnum != 0)
3301 // This may also invoke ml_append_int().
3302 ml_flush_line(buf);
3303
3304#ifdef FEAT_EVAL
3305 // When inserting above recorded changes: flush the changes before changing
3306 // the text. Then flush the cached line, it may become invalid.
3307 may_invoke_listeners(buf, lnum + 1, lnum + 1, 1);
3308 if (buf->b_ml.ml_line_lnum != 0)
3309 ml_flush_line(buf);
3310#endif
3311
3312 return ml_append_int(buf, lnum, line, len, newfile, FALSE);
3313}
3314
3315/*
3316 * Append a line after lnum (may be 0 to insert a line in front of the file).
3317 * "line" does not need to be allocated, but can't be another line in a
3318 * buffer, unlocking may make it invalid.
3319 *
3320 * newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
3321 * will be set for recovery
3322 * Check: The caller of this function should probably also call
3323 * appended_lines().
3324 *
3325 * return FAIL for failure, OK otherwise
3326 */
3327 int
3328ml_append(
3329 linenr_T lnum, /* append after this line (can be 0) */
3330 char_u *line, /* text of the new line */
3331 colnr_T len, /* length of new line, including NUL, or 0 */
3332 int newfile) /* flag, see above */
3333{
3334 /* When starting up, we might still need to create the memfile */
3335 if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
3336 return FAIL;
3337 return ml_append_flush(curbuf, lnum, line, len, newfile);
3338}
3339
3340#if defined(FEAT_SPELL) || defined(FEAT_QUICKFIX) || defined(PROTO)
3341/*
3342 * Like ml_append() but for an arbitrary buffer. The buffer must already have
3343 * a memline.
3344 */
3345 int
3346ml_append_buf(
3347 buf_T *buf,
3348 linenr_T lnum, /* append after this line (can be 0) */
3349 char_u *line, /* text of the new line */
3350 colnr_T len, /* length of new line, including NUL, or 0 */
3351 int newfile) /* flag, see above */
3352{
3353 if (buf->b_ml.ml_mfp == NULL)
3354 return FAIL;
3355 return ml_append_flush(buf, lnum, line, len, newfile);
3356}
3357#endif
3358
3359/*
Bram Moolenaar4770d092006-01-12 23:22:24 +00003360 * Replace line lnum, with buffering, in current buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003361 *
Bram Moolenaar1056d982006-03-09 22:37:52 +00003362 * If "copy" is TRUE, make a copy of the line, otherwise the line has been
Bram Moolenaar071d4272004-06-13 20:20:40 +00003363 * copied to allocated memory already.
3364 *
3365 * Check: The caller of this function should probably also call
3366 * changed_lines(), unless update_screen(NOT_VALID) is used.
3367 *
3368 * return FAIL for failure, OK otherwise
3369 */
3370 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003371ml_replace(linenr_T lnum, char_u *line, int copy)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003372{
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003373 colnr_T len = -1;
3374
3375 if (line != NULL)
Bram Moolenaar4efe73b2018-12-16 14:37:39 +01003376 len = (colnr_T)STRLEN(line);
Bram Moolenaarccae4672019-01-04 15:09:57 +01003377 return ml_replace_len(lnum, line, len, FALSE, copy);
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003378}
3379
Bram Moolenaarccae4672019-01-04 15:09:57 +01003380/*
3381 * Replace a line for the current buffer. Like ml_replace() with:
3382 * "len_arg" is the length of the text, excluding NUL.
3383 * If "has_props" is TRUE then "line_arg" includes the text properties and
3384 * "len_arg" includes the NUL of the text.
3385 */
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003386 int
Bram Moolenaarccae4672019-01-04 15:09:57 +01003387ml_replace_len(
3388 linenr_T lnum,
3389 char_u *line_arg,
3390 colnr_T len_arg,
3391 int has_props,
3392 int copy)
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003393{
3394 char_u *line = line_arg;
3395 colnr_T len = len_arg;
3396
Bram Moolenaar071d4272004-06-13 20:20:40 +00003397 if (line == NULL) /* just checking... */
3398 return FAIL;
3399
3400 /* When starting up, we might still need to create the memfile */
Bram Moolenaar59f931e2010-07-24 20:27:03 +02003401 if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003402 return FAIL;
3403
Bram Moolenaarccae4672019-01-04 15:09:57 +01003404 if (!has_props)
3405 ++len; // include the NUL after the text
3406 if (copy)
3407 {
3408 // copy the line to allocated memory
3409#ifdef FEAT_TEXT_PROP
3410 if (has_props)
3411 line = vim_memsave(line, len);
3412 else
3413#endif
3414 line = vim_strnsave(line, len - 1);
3415 if (line == NULL)
3416 return FAIL;
3417 }
3418
Bram Moolenaar071d4272004-06-13 20:20:40 +00003419#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +02003420 if (netbeans_active())
Bram Moolenaar071d4272004-06-13 20:20:40 +00003421 {
3422 netbeans_removed(curbuf, lnum, 0, (long)STRLEN(ml_get(lnum)));
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003423 netbeans_inserted(curbuf, lnum, 0, line, (int)STRLEN(line));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003424 }
3425#endif
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003426 if (curbuf->b_ml.ml_line_lnum != lnum)
3427 {
3428 // another line is buffered, flush it
3429 ml_flush_line(curbuf);
Bram Moolenaarca79a5f2018-12-13 23:16:36 +01003430 curbuf->b_ml.ml_flags &= ~ML_LINE_DIRTY;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003431
3432#ifdef FEAT_TEXT_PROP
Bram Moolenaarccae4672019-01-04 15:09:57 +01003433 if (curbuf->b_has_textprop && !has_props)
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003434 // Need to fetch the old line to copy over any text properties.
3435 ml_get_buf(curbuf, lnum, TRUE);
3436#endif
3437 }
3438
3439#ifdef FEAT_TEXT_PROP
Bram Moolenaarccae4672019-01-04 15:09:57 +01003440 if (curbuf->b_has_textprop && !has_props)
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003441 {
3442 size_t oldtextlen = STRLEN(curbuf->b_ml.ml_line_ptr) + 1;
3443
3444 if (oldtextlen < (size_t)curbuf->b_ml.ml_line_len)
3445 {
3446 char_u *newline;
3447 size_t textproplen = curbuf->b_ml.ml_line_len - oldtextlen;
3448
3449 // Need to copy over text properties, stored after the text.
Bram Moolenaarccae4672019-01-04 15:09:57 +01003450 newline = alloc(len + (int)textproplen);
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003451 if (newline != NULL)
3452 {
Bram Moolenaarccae4672019-01-04 15:09:57 +01003453 mch_memmove(newline, line, len);
Bram Moolenaar0d3cb732019-05-18 13:05:18 +02003454 mch_memmove(newline + len, curbuf->b_ml.ml_line_ptr
3455 + oldtextlen, textproplen);
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003456 vim_free(line);
3457 line = newline;
Bram Moolenaar4efe73b2018-12-16 14:37:39 +01003458 len += (colnr_T)textproplen;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003459 }
3460 }
3461 }
3462#endif
3463
Bram Moolenaarccae4672019-01-04 15:09:57 +01003464 if (curbuf->b_ml.ml_flags & ML_LINE_DIRTY) // same line allocated
3465 vim_free(curbuf->b_ml.ml_line_ptr); // free it
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003466
Bram Moolenaar071d4272004-06-13 20:20:40 +00003467 curbuf->b_ml.ml_line_ptr = line;
Bram Moolenaarccae4672019-01-04 15:09:57 +01003468 curbuf->b_ml.ml_line_len = len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003469 curbuf->b_ml.ml_line_lnum = lnum;
3470 curbuf->b_ml.ml_flags = (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
3471
3472 return OK;
3473}
3474
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003475#ifdef FEAT_TEXT_PROP
3476/*
3477 * Adjust text properties in line "lnum" for a deleted line.
3478 * When "above" is true this is the line above the deleted line.
3479 * "del_props" are the properties of the deleted line.
3480 */
3481 static void
3482adjust_text_props_for_delete(
3483 buf_T *buf,
3484 linenr_T lnum,
3485 char_u *del_props,
3486 int del_props_len,
3487 int above)
3488{
3489 int did_get_line = FALSE;
3490 int done_del;
3491 int done_this;
3492 textprop_T prop_del;
3493 textprop_T prop_this;
3494 bhdr_T *hp;
3495 DATA_BL *dp;
3496 int idx;
3497 int line_start;
3498 long line_size;
3499 int this_props_len;
3500 char_u *text;
3501 size_t textlen;
3502 int found;
3503
3504 for (done_del = 0; done_del < del_props_len; done_del += sizeof(textprop_T))
3505 {
3506 mch_memmove(&prop_del, del_props + done_del, sizeof(textprop_T));
3507 if ((above && (prop_del.tp_flags & TP_FLAG_CONT_PREV)
3508 && !(prop_del.tp_flags & TP_FLAG_CONT_NEXT))
3509 || (!above && (prop_del.tp_flags & TP_FLAG_CONT_NEXT)
3510 && !(prop_del.tp_flags & TP_FLAG_CONT_PREV)))
3511 {
3512 if (!did_get_line)
3513 {
3514 did_get_line = TRUE;
3515 if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
3516 return;
3517
3518 dp = (DATA_BL *)(hp->bh_data);
3519 idx = lnum - buf->b_ml.ml_locked_low;
3520 line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
3521 if (idx == 0) // first line in block, text at the end
3522 line_size = dp->db_txt_end - line_start;
3523 else
3524 line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start;
3525 text = (char_u *)dp + line_start;
3526 textlen = STRLEN(text) + 1;
3527 if ((long)textlen >= line_size)
3528 {
3529 if (above)
3530 internal_error("no text property above deleted line");
3531 else
3532 internal_error("no text property below deleted line");
3533 return;
3534 }
Bram Moolenaar4b7214e2019-01-03 21:55:32 +01003535 this_props_len = line_size - (int)textlen;
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003536 }
3537
3538 found = FALSE;
3539 for (done_this = 0; done_this < this_props_len; done_this += sizeof(textprop_T))
3540 {
3541 mch_memmove(&prop_this, text + textlen + done_del, sizeof(textprop_T));
3542 if (prop_del.tp_id == prop_this.tp_id
3543 && prop_del.tp_type == prop_this.tp_type)
3544 {
3545 int flag = above ? TP_FLAG_CONT_NEXT : TP_FLAG_CONT_PREV;
3546
3547 found = TRUE;
3548 if (prop_this.tp_flags & flag)
3549 {
3550 prop_this.tp_flags &= ~flag;
3551 mch_memmove(text + textlen + done_del, &prop_this, sizeof(textprop_T));
3552 }
3553 else if (above)
3554 internal_error("text property above deleted line does not continue");
3555 else
3556 internal_error("text property below deleted line does not continue");
3557 }
3558 }
3559 if (!found)
3560 {
3561 if (above)
3562 internal_error("text property above deleted line not found");
3563 else
3564 internal_error("text property below deleted line not found");
3565 }
3566
3567 buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
3568 }
3569 }
3570}
3571#endif
3572
Bram Moolenaar071d4272004-06-13 20:20:40 +00003573/*
Bram Moolenaar4033c552017-09-16 20:54:51 +02003574 * Delete line "lnum" in the current buffer.
3575 * When "message" is TRUE may give a "No lines in buffer" message.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003576 *
3577 * Check: The caller of this function should probably also call
3578 * deleted_lines() after this.
3579 *
3580 * return FAIL for failure, OK otherwise
3581 */
3582 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003583ml_delete(linenr_T lnum, int message)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003584{
3585 ml_flush_line(curbuf);
Bram Moolenaaracf75442019-07-17 22:55:35 +02003586 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
3587 return FAIL;
3588
3589#ifdef FEAT_EVAL
3590 // When inserting above recorded changes: flush the changes before changing
3591 // the text.
3592 may_invoke_listeners(curbuf, lnum, lnum + 1, -1);
3593#endif
3594
Bram Moolenaar071d4272004-06-13 20:20:40 +00003595 return ml_delete_int(curbuf, lnum, message);
3596}
3597
3598 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003599ml_delete_int(buf_T *buf, linenr_T lnum, int message)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003600{
3601 bhdr_T *hp;
3602 memfile_T *mfp;
3603 DATA_BL *dp;
3604 PTR_BL *pp;
3605 infoptr_T *ip;
3606 int count; /* number of entries in block */
3607 int idx;
3608 int stack_idx;
3609 int text_start;
3610 int line_start;
3611 long line_size;
3612 int i;
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003613 int ret = FAIL;
3614#ifdef FEAT_TEXT_PROP
3615 char_u *textprop_save = NULL;
3616 int textprop_save_len;
3617#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003618
Bram Moolenaar071d4272004-06-13 20:20:40 +00003619 if (lowest_marked && lowest_marked > lnum)
3620 lowest_marked--;
3621
3622/*
3623 * If the file becomes empty the last line is replaced by an empty line.
3624 */
3625 if (buf->b_ml.ml_line_count == 1) /* file becomes empty */
3626 {
3627 if (message
3628#ifdef FEAT_NETBEANS_INTG
3629 && !netbeansSuppressNoLines
3630#endif
3631 )
Bram Moolenaar238a5642006-02-21 22:12:05 +00003632 set_keep_msg((char_u *)_(no_lines_msg), 0);
3633
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02003634 /* FEAT_BYTEOFF already handled in there, don't worry 'bout it below */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003635 i = ml_replace((linenr_T)1, (char_u *)"", TRUE);
3636 buf->b_ml.ml_flags |= ML_EMPTY;
3637
3638 return i;
3639 }
3640
3641/*
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003642 * Find the data block containing the line.
3643 * This also fills the stack with the blocks from the root to the data block.
3644 * This also releases any locked block..
Bram Moolenaar071d4272004-06-13 20:20:40 +00003645 */
3646 mfp = buf->b_ml.ml_mfp;
3647 if (mfp == NULL)
3648 return FAIL;
3649
3650 if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL)
3651 return FAIL;
3652
3653 dp = (DATA_BL *)(hp->bh_data);
3654 /* compute line count before the delete */
3655 count = (long)(buf->b_ml.ml_locked_high)
3656 - (long)(buf->b_ml.ml_locked_low) + 2;
3657 idx = lnum - buf->b_ml.ml_locked_low;
3658
3659 --buf->b_ml.ml_line_count;
3660
3661 line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
3662 if (idx == 0) /* first line in block, text at the end */
3663 line_size = dp->db_txt_end - line_start;
3664 else
3665 line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start;
3666
3667#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +02003668 if (netbeans_active())
Bram Moolenaar35a9aaa2004-10-24 19:23:07 +00003669 netbeans_removed(buf, lnum, 0, (long)line_size);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003670#endif
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003671#ifdef FEAT_TEXT_PROP
3672 // If there are text properties, make a copy, so that we can update
3673 // properties in preceding and following lines.
3674 if (buf->b_has_textprop)
3675 {
3676 size_t textlen = STRLEN((char_u *)dp + line_start) + 1;
3677
3678 if ((long)textlen < line_size)
3679 {
Bram Moolenaar4b7214e2019-01-03 21:55:32 +01003680 textprop_save_len = line_size - (int)textlen;
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003681 textprop_save = vim_memsave((char_u *)dp + line_start + textlen,
3682 textprop_save_len);
3683 }
3684 }
3685#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003686
3687/*
3688 * special case: If there is only one line in the data block it becomes empty.
3689 * Then we have to remove the entry, pointing to this data block, from the
3690 * pointer block. If this pointer block also becomes empty, we go up another
3691 * block, and so on, up to the root if necessary.
3692 * The line counts in the pointer blocks have already been adjusted by
3693 * ml_find_line().
3694 */
3695 if (count == 1)
3696 {
3697 mf_free(mfp, hp); /* free the data block */
3698 buf->b_ml.ml_locked = NULL;
3699
Bram Moolenaare60acc12011-05-10 16:41:25 +02003700 for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
3701 --stack_idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003702 {
3703 buf->b_ml.ml_stack_top = 0; /* stack is invalid when failing */
3704 ip = &(buf->b_ml.ml_stack[stack_idx]);
3705 idx = ip->ip_index;
3706 if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003707 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003708 pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
3709 if (pp->pb_id != PTR_ID)
3710 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003711 iemsg(_("E317: pointer block id wrong 4"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003712 mf_put(mfp, hp, FALSE, FALSE);
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003713 goto theend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003714 }
3715 count = --(pp->pb_count);
3716 if (count == 0) /* the pointer block becomes empty! */
3717 mf_free(mfp, hp);
3718 else
3719 {
3720 if (count != idx) /* move entries after the deleted one */
3721 mch_memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1],
3722 (size_t)(count - idx) * sizeof(PTR_EN));
3723 mf_put(mfp, hp, TRUE, FALSE);
3724
3725 buf->b_ml.ml_stack_top = stack_idx; /* truncate stack */
Bram Moolenaar6b803a72007-05-06 14:25:46 +00003726 /* fix line count for rest of blocks in the stack */
3727 if (buf->b_ml.ml_locked_lineadd != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003728 {
3729 ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
3730 buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
Bram Moolenaar6b803a72007-05-06 14:25:46 +00003731 buf->b_ml.ml_locked_lineadd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003732 }
3733 ++(buf->b_ml.ml_stack_top);
3734
3735 break;
3736 }
3737 }
3738 CHECK(stack_idx < 0, _("deleted block 1?"));
3739 }
3740 else
3741 {
3742 /*
3743 * delete the text by moving the next lines forwards
3744 */
3745 text_start = dp->db_txt_start;
3746 mch_memmove((char *)dp + text_start + line_size,
3747 (char *)dp + text_start, (size_t)(line_start - text_start));
3748
3749 /*
3750 * delete the index by moving the next indexes backwards
3751 * Adjust the indexes for the text movement.
3752 */
3753 for (i = idx; i < count - 1; ++i)
3754 dp->db_index[i] = dp->db_index[i + 1] + line_size;
3755
3756 dp->db_free += line_size + INDEX_SIZE;
3757 dp->db_txt_start += line_size;
3758 --(dp->db_line_count);
3759
3760 /*
3761 * mark the block dirty and make sure it is in the file (for recovery)
3762 */
3763 buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
3764 }
3765
3766#ifdef FEAT_BYTEOFF
3767 ml_updatechunk(buf, lnum, line_size, ML_CHNK_DELLINE);
3768#endif
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003769 ret = OK;
3770
3771theend:
3772#ifdef FEAT_TEXT_PROP
3773 if (textprop_save != NULL)
3774 {
3775 // Adjust text properties in the line above and below.
3776 if (lnum > 1)
3777 adjust_text_props_for_delete(buf, lnum - 1, textprop_save, textprop_save_len, TRUE);
3778 if (lnum <= buf->b_ml.ml_line_count)
3779 adjust_text_props_for_delete(buf, lnum, textprop_save, textprop_save_len, FALSE);
3780 }
3781 vim_free(textprop_save);
3782#endif
3783 return ret;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003784}
3785
3786/*
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003787 * set the DB_MARKED flag for line 'lnum'
Bram Moolenaar071d4272004-06-13 20:20:40 +00003788 */
3789 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003790ml_setmarked(linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003791{
3792 bhdr_T *hp;
3793 DATA_BL *dp;
3794 /* invalid line number */
3795 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count
3796 || curbuf->b_ml.ml_mfp == NULL)
3797 return; /* give error message? */
3798
3799 if (lowest_marked == 0 || lowest_marked > lnum)
3800 lowest_marked = lnum;
3801
3802 /*
3803 * find the data block containing the line
3804 * This also fills the stack with the blocks from the root to the data block
3805 * This also releases any locked block.
3806 */
3807 if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
3808 return; /* give error message? */
3809
3810 dp = (DATA_BL *)(hp->bh_data);
3811 dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED;
3812 curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
3813}
3814
3815/*
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01003816 * find the first line with its DB_MARKED flag set
Bram Moolenaar071d4272004-06-13 20:20:40 +00003817 */
3818 linenr_T
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003819ml_firstmarked(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003820{
3821 bhdr_T *hp;
3822 DATA_BL *dp;
3823 linenr_T lnum;
3824 int i;
3825
3826 if (curbuf->b_ml.ml_mfp == NULL)
3827 return (linenr_T) 0;
3828
3829 /*
3830 * The search starts with lowest_marked line. This is the last line where
3831 * a mark was found, adjusted by inserting/deleting lines.
3832 */
3833 for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
3834 {
3835 /*
3836 * Find the data block containing the line.
3837 * This also fills the stack with the blocks from the root to the data
3838 * block This also releases any locked block.
3839 */
3840 if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
3841 return (linenr_T)0; /* give error message? */
3842
3843 dp = (DATA_BL *)(hp->bh_data);
3844
3845 for (i = lnum - curbuf->b_ml.ml_locked_low;
3846 lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
3847 if ((dp->db_index[i]) & DB_MARKED)
3848 {
3849 (dp->db_index[i]) &= DB_INDEX_MASK;
3850 curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
3851 lowest_marked = lnum + 1;
3852 return lnum;
3853 }
3854 }
3855
3856 return (linenr_T) 0;
3857}
3858
Bram Moolenaar071d4272004-06-13 20:20:40 +00003859/*
3860 * clear all DB_MARKED flags
3861 */
3862 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003863ml_clearmarked(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003864{
3865 bhdr_T *hp;
3866 DATA_BL *dp;
3867 linenr_T lnum;
3868 int i;
3869
3870 if (curbuf->b_ml.ml_mfp == NULL) /* nothing to do */
3871 return;
3872
3873 /*
3874 * The search starts with line lowest_marked.
3875 */
3876 for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
3877 {
3878 /*
3879 * Find the data block containing the line.
3880 * This also fills the stack with the blocks from the root to the data
3881 * block and releases any locked block.
3882 */
3883 if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
3884 return; /* give error message? */
3885
3886 dp = (DATA_BL *)(hp->bh_data);
3887
3888 for (i = lnum - curbuf->b_ml.ml_locked_low;
3889 lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
3890 if ((dp->db_index[i]) & DB_MARKED)
3891 {
3892 (dp->db_index[i]) &= DB_INDEX_MASK;
3893 curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
3894 }
3895 }
3896
3897 lowest_marked = 0;
3898 return;
3899}
3900
3901/*
3902 * flush ml_line if necessary
3903 */
3904 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01003905ml_flush_line(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003906{
3907 bhdr_T *hp;
3908 DATA_BL *dp;
3909 linenr_T lnum;
3910 char_u *new_line;
3911 char_u *old_line;
3912 colnr_T new_len;
3913 int old_len;
3914 int extra;
3915 int idx;
3916 int start;
3917 int count;
3918 int i;
Bram Moolenaar0ca4b352010-02-11 18:54:43 +01003919 static int entered = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003920
3921 if (buf->b_ml.ml_line_lnum == 0 || buf->b_ml.ml_mfp == NULL)
3922 return; /* nothing to do */
3923
3924 if (buf->b_ml.ml_flags & ML_LINE_DIRTY)
3925 {
Bram Moolenaar0ca4b352010-02-11 18:54:43 +01003926 /* This code doesn't work recursively, but Netbeans may call back here
3927 * when obtaining the cursor position. */
3928 if (entered)
3929 return;
3930 entered = TRUE;
3931
Bram Moolenaar071d4272004-06-13 20:20:40 +00003932 lnum = buf->b_ml.ml_line_lnum;
3933 new_line = buf->b_ml.ml_line_ptr;
3934
3935 hp = ml_find_line(buf, lnum, ML_FIND);
3936 if (hp == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003937 siemsg(_("E320: Cannot find line %ld"), lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003938 else
3939 {
3940 dp = (DATA_BL *)(hp->bh_data);
3941 idx = lnum - buf->b_ml.ml_locked_low;
3942 start = ((dp->db_index[idx]) & DB_INDEX_MASK);
3943 old_line = (char_u *)dp + start;
3944 if (idx == 0) /* line is last in block */
3945 old_len = dp->db_txt_end - start;
3946 else /* text of previous line follows */
3947 old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01003948 new_len = buf->b_ml.ml_line_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003949 extra = new_len - old_len; /* negative if lines gets smaller */
3950
3951 /*
3952 * if new line fits in data block, replace directly
3953 */
3954 if ((int)dp->db_free >= extra)
3955 {
3956 /* if the length changes and there are following lines */
3957 count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1;
3958 if (extra != 0 && idx < count - 1)
3959 {
3960 /* move text of following lines */
3961 mch_memmove((char *)dp + dp->db_txt_start - extra,
3962 (char *)dp + dp->db_txt_start,
3963 (size_t)(start - dp->db_txt_start));
3964
3965 /* adjust pointers of this and following lines */
3966 for (i = idx + 1; i < count; ++i)
3967 dp->db_index[i] -= extra;
3968 }
3969 dp->db_index[idx] -= extra;
3970
3971 /* adjust free space */
3972 dp->db_free -= extra;
3973 dp->db_txt_start -= extra;
3974
3975 /* copy new line into the data block */
3976 mch_memmove(old_line - extra, new_line, (size_t)new_len);
3977 buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
3978#ifdef FEAT_BYTEOFF
3979 /* The else case is already covered by the insert and delete */
3980 ml_updatechunk(buf, lnum, (long)extra, ML_CHNK_UPDLINE);
3981#endif
3982 }
3983 else
3984 {
3985 /*
3986 * Cannot do it in one data block: Delete and append.
3987 * Append first, because ml_delete_int() cannot delete the
3988 * last line in a buffer, which causes trouble for a buffer
3989 * that has only one line.
3990 * Don't forget to copy the mark!
3991 */
3992 /* How about handling errors??? */
3993 (void)ml_append_int(buf, lnum, new_line, new_len, FALSE,
3994 (dp->db_index[idx] & DB_MARKED));
3995 (void)ml_delete_int(buf, lnum, FALSE);
3996 }
3997 }
3998 vim_free(new_line);
Bram Moolenaar0ca4b352010-02-11 18:54:43 +01003999
4000 entered = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004001 }
4002
4003 buf->b_ml.ml_line_lnum = 0;
4004}
4005
4006/*
4007 * create a new, empty, data block
4008 */
4009 static bhdr_T *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004010ml_new_data(memfile_T *mfp, int negative, int page_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004011{
4012 bhdr_T *hp;
4013 DATA_BL *dp;
4014
4015 if ((hp = mf_new(mfp, negative, page_count)) == NULL)
4016 return NULL;
4017
4018 dp = (DATA_BL *)(hp->bh_data);
4019 dp->db_id = DATA_ID;
4020 dp->db_txt_start = dp->db_txt_end = page_count * mfp->mf_page_size;
4021 dp->db_free = dp->db_txt_start - HEADER_SIZE;
4022 dp->db_line_count = 0;
4023
4024 return hp;
4025}
4026
4027/*
4028 * create a new, empty, pointer block
4029 */
4030 static bhdr_T *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004031ml_new_ptr(memfile_T *mfp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004032{
4033 bhdr_T *hp;
4034 PTR_BL *pp;
4035
4036 if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
4037 return NULL;
4038
4039 pp = (PTR_BL *)(hp->bh_data);
4040 pp->pb_id = PTR_ID;
4041 pp->pb_count = 0;
Bram Moolenaar20a825a2010-05-31 21:27:30 +02004042 pp->pb_count_max = (short_u)((mfp->mf_page_size - sizeof(PTR_BL))
4043 / sizeof(PTR_EN) + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004044
4045 return hp;
4046}
4047
4048/*
Bram Moolenaarc1a9bc12018-12-28 21:59:29 +01004049 * Lookup line 'lnum' in a memline.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004050 *
4051 * action: if ML_DELETE or ML_INSERT the line count is updated while searching
4052 * if ML_FLUSH only flush a locked block
4053 * if ML_FIND just find the line
4054 *
4055 * If the block was found it is locked and put in ml_locked.
4056 * The stack is updated to lead to the locked block. The ip_high field in
4057 * the stack is updated to reflect the last line in the block AFTER the
4058 * insert or delete, also if the pointer block has not been updated yet. But
Bram Moolenaar6b803a72007-05-06 14:25:46 +00004059 * if ml_locked != NULL ml_locked_lineadd must be added to ip_high.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004060 *
4061 * return: NULL for failure, pointer to block header otherwise
4062 */
4063 static bhdr_T *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004064ml_find_line(buf_T *buf, linenr_T lnum, int action)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004065{
4066 DATA_BL *dp;
4067 PTR_BL *pp;
4068 infoptr_T *ip;
4069 bhdr_T *hp;
4070 memfile_T *mfp;
4071 linenr_T t;
4072 blocknr_T bnum, bnum2;
4073 int dirty;
4074 linenr_T low, high;
4075 int top;
4076 int page_count;
4077 int idx;
4078
4079 mfp = buf->b_ml.ml_mfp;
4080
4081 /*
4082 * If there is a locked block check if the wanted line is in it.
4083 * If not, flush and release the locked block.
4084 * Don't do this for ML_INSERT_SAME, because the stack need to be updated.
4085 * Don't do this for ML_FLUSH, because we want to flush the locked block.
Bram Moolenaar47b8b152007-02-07 02:41:57 +00004086 * Don't do this when 'swapfile' is reset, we want to load all the blocks.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004087 */
4088 if (buf->b_ml.ml_locked)
4089 {
Bram Moolenaar47b8b152007-02-07 02:41:57 +00004090 if (ML_SIMPLE(action)
4091 && buf->b_ml.ml_locked_low <= lnum
4092 && buf->b_ml.ml_locked_high >= lnum
4093 && !mf_dont_release)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004094 {
Bram Moolenaar47b8b152007-02-07 02:41:57 +00004095 /* remember to update pointer blocks and stack later */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004096 if (action == ML_INSERT)
4097 {
4098 ++(buf->b_ml.ml_locked_lineadd);
4099 ++(buf->b_ml.ml_locked_high);
4100 }
4101 else if (action == ML_DELETE)
4102 {
4103 --(buf->b_ml.ml_locked_lineadd);
4104 --(buf->b_ml.ml_locked_high);
4105 }
4106 return (buf->b_ml.ml_locked);
4107 }
4108
4109 mf_put(mfp, buf->b_ml.ml_locked, buf->b_ml.ml_flags & ML_LOCKED_DIRTY,
4110 buf->b_ml.ml_flags & ML_LOCKED_POS);
4111 buf->b_ml.ml_locked = NULL;
4112
Bram Moolenaar6b803a72007-05-06 14:25:46 +00004113 /*
4114 * If lines have been added or deleted in the locked block, need to
4115 * update the line count in pointer blocks.
4116 */
4117 if (buf->b_ml.ml_locked_lineadd != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004118 ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
4119 }
4120
4121 if (action == ML_FLUSH) /* nothing else to do */
4122 return NULL;
4123
4124 bnum = 1; /* start at the root of the tree */
4125 page_count = 1;
4126 low = 1;
4127 high = buf->b_ml.ml_line_count;
4128
4129 if (action == ML_FIND) /* first try stack entries */
4130 {
4131 for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top)
4132 {
4133 ip = &(buf->b_ml.ml_stack[top]);
4134 if (ip->ip_low <= lnum && ip->ip_high >= lnum)
4135 {
4136 bnum = ip->ip_bnum;
4137 low = ip->ip_low;
4138 high = ip->ip_high;
4139 buf->b_ml.ml_stack_top = top; /* truncate stack at prev entry */
4140 break;
4141 }
4142 }
4143 if (top < 0)
4144 buf->b_ml.ml_stack_top = 0; /* not found, start at the root */
4145 }
4146 else /* ML_DELETE or ML_INSERT */
4147 buf->b_ml.ml_stack_top = 0; /* start at the root */
4148
4149/*
4150 * search downwards in the tree until a data block is found
4151 */
4152 for (;;)
4153 {
4154 if ((hp = mf_get(mfp, bnum, page_count)) == NULL)
4155 goto error_noblock;
4156
4157 /*
4158 * update high for insert/delete
4159 */
4160 if (action == ML_INSERT)
4161 ++high;
4162 else if (action == ML_DELETE)
4163 --high;
4164
4165 dp = (DATA_BL *)(hp->bh_data);
4166 if (dp->db_id == DATA_ID) /* data block */
4167 {
4168 buf->b_ml.ml_locked = hp;
4169 buf->b_ml.ml_locked_low = low;
4170 buf->b_ml.ml_locked_high = high;
4171 buf->b_ml.ml_locked_lineadd = 0;
4172 buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS);
4173 return hp;
4174 }
4175
4176 pp = (PTR_BL *)(dp); /* must be pointer block */
4177 if (pp->pb_id != PTR_ID)
4178 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004179 iemsg(_("E317: pointer block id wrong"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004180 goto error_block;
4181 }
4182
4183 if ((top = ml_add_stack(buf)) < 0) /* add new entry to stack */
4184 goto error_block;
4185 ip = &(buf->b_ml.ml_stack[top]);
4186 ip->ip_bnum = bnum;
4187 ip->ip_low = low;
4188 ip->ip_high = high;
4189 ip->ip_index = -1; /* index not known yet */
4190
4191 dirty = FALSE;
4192 for (idx = 0; idx < (int)pp->pb_count; ++idx)
4193 {
4194 t = pp->pb_pointer[idx].pe_line_count;
4195 CHECK(t == 0, _("pe_line_count is zero"));
4196 if ((low += t) > lnum)
4197 {
4198 ip->ip_index = idx;
4199 bnum = pp->pb_pointer[idx].pe_bnum;
4200 page_count = pp->pb_pointer[idx].pe_page_count;
4201 high = low - 1;
4202 low -= t;
4203
4204 /*
4205 * a negative block number may have been changed
4206 */
4207 if (bnum < 0)
4208 {
4209 bnum2 = mf_trans_del(mfp, bnum);
4210 if (bnum != bnum2)
4211 {
4212 bnum = bnum2;
4213 pp->pb_pointer[idx].pe_bnum = bnum;
4214 dirty = TRUE;
4215 }
4216 }
4217
4218 break;
4219 }
4220 }
4221 if (idx >= (int)pp->pb_count) /* past the end: something wrong! */
4222 {
4223 if (lnum > buf->b_ml.ml_line_count)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004224 siemsg(_("E322: line number out of range: %ld past the end"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00004225 lnum - buf->b_ml.ml_line_count);
4226
4227 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004228 siemsg(_("E323: line count wrong in block %ld"), bnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004229 goto error_block;
4230 }
4231 if (action == ML_DELETE)
4232 {
4233 pp->pb_pointer[idx].pe_line_count--;
4234 dirty = TRUE;
4235 }
4236 else if (action == ML_INSERT)
4237 {
4238 pp->pb_pointer[idx].pe_line_count++;
4239 dirty = TRUE;
4240 }
4241 mf_put(mfp, hp, dirty, FALSE);
4242 }
4243
4244error_block:
4245 mf_put(mfp, hp, FALSE, FALSE);
4246error_noblock:
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02004247 /*
4248 * If action is ML_DELETE or ML_INSERT we have to correct the tree for
4249 * the incremented/decremented line counts, because there won't be a line
4250 * inserted/deleted after all.
4251 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004252 if (action == ML_DELETE)
4253 ml_lineadd(buf, 1);
4254 else if (action == ML_INSERT)
4255 ml_lineadd(buf, -1);
4256 buf->b_ml.ml_stack_top = 0;
4257 return NULL;
4258}
4259
4260/*
4261 * add an entry to the info pointer stack
4262 *
4263 * return -1 for failure, number of the new entry otherwise
4264 */
4265 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004266ml_add_stack(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004267{
4268 int top;
4269 infoptr_T *newstack;
4270
4271 top = buf->b_ml.ml_stack_top;
4272
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02004273 /* may have to increase the stack size */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004274 if (top == buf->b_ml.ml_stack_size)
4275 {
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02004276 CHECK(top > 0, _("Stack size increases")); /* more than 5 levels??? */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004277
Bram Moolenaarc799fe22019-05-28 23:08:19 +02004278 newstack = ALLOC_MULT(infoptr_T, buf->b_ml.ml_stack_size + STACK_INCR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004279 if (newstack == NULL)
4280 return -1;
Bram Moolenaarfbd302f2015-08-08 18:23:46 +02004281 if (top > 0)
4282 mch_memmove(newstack, buf->b_ml.ml_stack,
Bram Moolenaar8c8de832008-06-24 22:58:06 +00004283 (size_t)top * sizeof(infoptr_T));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004284 vim_free(buf->b_ml.ml_stack);
4285 buf->b_ml.ml_stack = newstack;
4286 buf->b_ml.ml_stack_size += STACK_INCR;
4287 }
4288
4289 buf->b_ml.ml_stack_top++;
4290 return top;
4291}
4292
4293/*
4294 * Update the pointer blocks on the stack for inserted/deleted lines.
4295 * The stack itself is also updated.
4296 *
4297 * When a insert/delete line action fails, the line is not inserted/deleted,
4298 * but the pointer blocks have already been updated. That is fixed here by
4299 * walking through the stack.
4300 *
4301 * Count is the number of lines added, negative if lines have been deleted.
4302 */
4303 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004304ml_lineadd(buf_T *buf, int count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004305{
4306 int idx;
4307 infoptr_T *ip;
4308 PTR_BL *pp;
4309 memfile_T *mfp = buf->b_ml.ml_mfp;
4310 bhdr_T *hp;
4311
4312 for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx)
4313 {
4314 ip = &(buf->b_ml.ml_stack[idx]);
4315 if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
4316 break;
4317 pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
4318 if (pp->pb_id != PTR_ID)
4319 {
4320 mf_put(mfp, hp, FALSE, FALSE);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004321 iemsg(_("E317: pointer block id wrong 2"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004322 break;
4323 }
4324 pp->pb_pointer[ip->ip_index].pe_line_count += count;
4325 ip->ip_high += count;
4326 mf_put(mfp, hp, TRUE, FALSE);
4327 }
4328}
4329
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004330#if defined(HAVE_READLINK) || defined(PROTO)
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004331/*
4332 * Resolve a symlink in the last component of a file name.
4333 * Note that f_resolve() does it for every part of the path, we don't do that
4334 * here.
4335 * If it worked returns OK and the resolved link in "buf[MAXPATHL]".
4336 * Otherwise returns FAIL.
4337 */
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004338 int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004339resolve_symlink(char_u *fname, char_u *buf)
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004340{
4341 char_u tmp[MAXPATHL];
4342 int ret;
4343 int depth = 0;
4344
4345 if (fname == NULL)
4346 return FAIL;
4347
4348 /* Put the result so far in tmp[], starting with the original name. */
4349 vim_strncpy(tmp, fname, MAXPATHL - 1);
4350
4351 for (;;)
4352 {
4353 /* Limit symlink depth to 100, catch recursive loops. */
4354 if (++depth == 100)
4355 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004356 semsg(_("E773: Symlink loop for \"%s\""), fname);
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004357 return FAIL;
4358 }
4359
4360 ret = readlink((char *)tmp, (char *)buf, MAXPATHL - 1);
4361 if (ret <= 0)
4362 {
Bram Moolenaarcc984262005-12-23 22:19:46 +00004363 if (errno == EINVAL || errno == ENOENT)
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004364 {
Bram Moolenaarcc984262005-12-23 22:19:46 +00004365 /* Found non-symlink or not existing file, stop here.
Bram Moolenaar9439cdd2009-04-22 13:39:36 +00004366 * When at the first level use the unmodified name, skip the
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004367 * call to vim_FullName(). */
4368 if (depth == 1)
4369 return FAIL;
4370
4371 /* Use the resolved name in tmp[]. */
4372 break;
4373 }
4374
4375 /* There must be some error reading links, use original name. */
4376 return FAIL;
4377 }
4378 buf[ret] = NUL;
4379
4380 /*
4381 * Check whether the symlink is relative or absolute.
4382 * If it's relative, build a new path based on the directory
4383 * portion of the filename (if any) and the path the symlink
4384 * points to.
4385 */
4386 if (mch_isFullName(buf))
4387 STRCPY(tmp, buf);
4388 else
4389 {
4390 char_u *tail;
4391
4392 tail = gettail(tmp);
4393 if (STRLEN(tail) + STRLEN(buf) >= MAXPATHL)
4394 return FAIL;
4395 STRCPY(tail, buf);
4396 }
4397 }
4398
4399 /*
4400 * Try to resolve the full name of the file so that the swapfile name will
4401 * be consistent even when opening a relative symlink from different
4402 * working directories.
4403 */
4404 return vim_FullName(tmp, buf, MAXPATHL, TRUE);
4405}
4406#endif
4407
Bram Moolenaar071d4272004-06-13 20:20:40 +00004408/*
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004409 * Make swap file name out of the file name and a directory name.
4410 * Returns pointer to allocated memory or NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004411 */
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004412 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004413makeswapname(
4414 char_u *fname,
4415 char_u *ffname UNUSED,
4416 buf_T *buf,
4417 char_u *dir_name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004418{
4419 char_u *r, *s;
Bram Moolenaar9dbe4752010-05-14 17:52:42 +02004420 char_u *fname_res = fname;
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004421#ifdef HAVE_READLINK
4422 char_u fname_buf[MAXPATHL];
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004423#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004424
Bram Moolenaar4f974752019-02-17 17:44:42 +01004425#if defined(UNIX) || defined(MSWIN) // Need _very_ long file names
Bram Moolenaarb113c3a2017-02-28 21:26:17 +01004426 int len = (int)STRLEN(dir_name);
Bram Moolenaarc525e3a2017-02-18 16:59:02 +01004427
4428 s = dir_name + len;
4429 if (after_pathsep(dir_name, s) && len > 1 && s[-1] == s[-2])
Bram Moolenaar071d4272004-06-13 20:20:40 +00004430 { /* Ends with '//', Use Full path */
4431 r = NULL;
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004432 if ((s = make_percent_swname(dir_name, fname)) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004433 {
4434 r = modname(s, (char_u *)".swp", FALSE);
4435 vim_free(s);
4436 }
4437 return r;
4438 }
4439#endif
4440
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004441#ifdef HAVE_READLINK
4442 /* Expand symlink in the file name, so that we put the swap file with the
4443 * actual file instead of with the symlink. */
4444 if (resolve_symlink(fname, fname_buf) == OK)
4445 fname_res = fname_buf;
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004446#endif
4447
Bram Moolenaar071d4272004-06-13 20:20:40 +00004448 r = buf_modname(
Bram Moolenaar071d4272004-06-13 20:20:40 +00004449 (buf->b_p_sn || buf->b_shortname),
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004450 fname_res,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004451 (char_u *)
Bram Moolenaare60acc12011-05-10 16:41:25 +02004452#if defined(VMS)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004453 "_swp",
4454#else
4455 ".swp",
4456#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004457 /* Prepend a '.' to the swap file name for the current directory. */
Bram Moolenaar48e330a2016-02-23 14:53:34 +01004458 dir_name[0] == '.' && dir_name[1] == NUL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004459 if (r == NULL) /* out of memory */
4460 return NULL;
4461
4462 s = get_file_in_dir(r, dir_name);
4463 vim_free(r);
4464 return s;
4465}
4466
4467/*
4468 * Get file name to use for swap file or backup file.
4469 * Use the name of the edited file "fname" and an entry in the 'dir' or 'bdir'
4470 * option "dname".
4471 * - If "dname" is ".", return "fname" (swap file in dir of file).
4472 * - If "dname" starts with "./", insert "dname" in "fname" (swap file
4473 * relative to dir of file).
4474 * - Otherwise, prepend "dname" to the tail of "fname" (swap file in specific
4475 * dir).
4476 *
4477 * The return value is an allocated string and can be NULL.
4478 */
4479 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004480get_file_in_dir(
4481 char_u *fname,
4482 char_u *dname) /* don't use "dirname", it is a global for Alpha */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004483{
4484 char_u *t;
4485 char_u *tail;
4486 char_u *retval;
4487 int save_char;
4488
4489 tail = gettail(fname);
4490
4491 if (dname[0] == '.' && dname[1] == NUL)
4492 retval = vim_strsave(fname);
4493 else if (dname[0] == '.' && vim_ispathsep(dname[1]))
4494 {
4495 if (tail == fname) /* no path before file name */
4496 retval = concat_fnames(dname + 2, tail, TRUE);
4497 else
4498 {
4499 save_char = *tail;
4500 *tail = NUL;
4501 t = concat_fnames(fname, dname + 2, TRUE);
4502 *tail = save_char;
4503 if (t == NULL) /* out of memory */
4504 retval = NULL;
4505 else
4506 {
4507 retval = concat_fnames(t, tail, TRUE);
4508 vim_free(t);
4509 }
4510 }
4511 }
4512 else
4513 retval = concat_fnames(dname, tail, TRUE);
4514
Bram Moolenaar4f974752019-02-17 17:44:42 +01004515#ifdef MSWIN
Bram Moolenaar69c35002013-11-04 02:54:12 +01004516 if (retval != NULL)
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004517 for (t = gettail(retval); *t != NUL; MB_PTR_ADV(t))
Bram Moolenaar69c35002013-11-04 02:54:12 +01004518 if (*t == ':')
4519 *t = '%';
4520#endif
4521
Bram Moolenaar071d4272004-06-13 20:20:40 +00004522 return retval;
4523}
4524
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004525/*
4526 * Print the ATTENTION message: info about an existing swap file.
4527 */
4528 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004529attention_message(
4530 buf_T *buf, /* buffer being edited */
4531 char_u *fname) /* swap file name */
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004532{
Bram Moolenaar8767f522016-07-01 17:17:39 +02004533 stat_T st;
Bram Moolenaar63d25552019-05-10 21:28:38 +02004534 time_t swap_mtime;
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004535
4536 ++no_wait_return;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004537 (void)emsg(_("E325: ATTENTION"));
Bram Moolenaar32526b32019-01-19 17:43:09 +01004538 msg_puts(_("\nFound a swap file by the name \""));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004539 msg_home_replace(fname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01004540 msg_puts("\"\n");
Bram Moolenaar63d25552019-05-10 21:28:38 +02004541 swap_mtime = swapfile_info(fname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01004542 msg_puts(_("While opening file \""));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004543 msg_outtrans(buf->b_fname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01004544 msg_puts("\"\n");
Bram Moolenaard6105cb2018-10-13 19:06:27 +02004545 if (mch_stat((char *)buf->b_fname, &st) == -1)
4546 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01004547 msg_puts(_(" CANNOT BE FOUND"));
Bram Moolenaard6105cb2018-10-13 19:06:27 +02004548 }
4549 else
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004550 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01004551 msg_puts(_(" dated: "));
Bram Moolenaar63d25552019-05-10 21:28:38 +02004552 msg_puts(get_ctime(st.st_mtime, TRUE));
4553 if (swap_mtime != 0 && st.st_mtime > swap_mtime)
Bram Moolenaar32526b32019-01-19 17:43:09 +01004554 msg_puts(_(" NEWER than swap file!\n"));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004555 }
4556 /* Some of these messages are long to allow translation to
4557 * other languages. */
Bram Moolenaar32526b32019-01-19 17:43:09 +01004558 msg_puts(_("\n(1) Another program may be editing the same file. If this is the case,\n be careful not to end up with two different instances of the same\n file when making changes. Quit, or continue with caution.\n"));
4559 msg_puts(_("(2) An edit session for this file crashed.\n"));
4560 msg_puts(_(" If this is the case, use \":recover\" or \"vim -r "));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004561 msg_outtrans(buf->b_fname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01004562 msg_puts(_("\"\n to recover the changes (see \":help recovery\").\n"));
4563 msg_puts(_(" If you did this already, delete the swap file \""));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004564 msg_outtrans(fname);
Bram Moolenaar32526b32019-01-19 17:43:09 +01004565 msg_puts(_("\"\n to avoid this message.\n"));
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004566 cmdline_row = msg_row;
4567 --no_wait_return;
4568}
4569
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004570#if defined(FEAT_EVAL)
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004571/*
4572 * Trigger the SwapExists autocommands.
4573 * Returns a value for equivalent to do_dialog() (see below):
4574 * 0: still need to ask for a choice
4575 * 1: open read-only
4576 * 2: edit anyway
4577 * 3: recover
4578 * 4: delete it
4579 * 5: quit
4580 * 6: abort
4581 */
4582 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004583do_swapexists(buf_T *buf, char_u *fname)
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004584{
4585 set_vim_var_string(VV_SWAPNAME, fname, -1);
4586 set_vim_var_string(VV_SWAPCHOICE, NULL, -1);
4587
4588 /* Trigger SwapExists autocommands with <afile> set to the file being
Bram Moolenaar12c22ce2009-04-22 13:58:46 +00004589 * edited. Disallow changing directory here. */
4590 ++allbuf_lock;
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004591 apply_autocmds(EVENT_SWAPEXISTS, buf->b_fname, NULL, FALSE, NULL);
Bram Moolenaar12c22ce2009-04-22 13:58:46 +00004592 --allbuf_lock;
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004593
4594 set_vim_var_string(VV_SWAPNAME, NULL, -1);
4595
4596 switch (*get_vim_var_str(VV_SWAPCHOICE))
4597 {
4598 case 'o': return 1;
4599 case 'e': return 2;
4600 case 'r': return 3;
4601 case 'd': return 4;
4602 case 'q': return 5;
4603 case 'a': return 6;
4604 }
4605
4606 return 0;
4607}
4608#endif
4609
Bram Moolenaar071d4272004-06-13 20:20:40 +00004610/*
4611 * Find out what name to use for the swap file for buffer 'buf'.
4612 *
4613 * Several names are tried to find one that does not exist
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004614 * Returns the name in allocated memory or NULL.
Bram Moolenaarf541c362011-10-26 11:44:18 +02004615 * When out of memory "dirp" is set to NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004616 *
4617 * Note: If BASENAMELEN is not correct, you will get error messages for
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004618 * not being able to open the swap or undo file
Bram Moolenaar12c22ce2009-04-22 13:58:46 +00004619 * Note: May trigger SwapExists autocmd, pointers may change!
Bram Moolenaar071d4272004-06-13 20:20:40 +00004620 */
4621 static char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01004622findswapname(
4623 buf_T *buf,
4624 char_u **dirp, /* pointer to list of directories */
4625 char_u *old_fname) /* don't give warning for this file name */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004626{
4627 char_u *fname;
4628 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004629 char_u *dir_name;
4630#ifdef AMIGA
4631 BPTR fh;
4632#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004633 int r;
Bram Moolenaar69c35002013-11-04 02:54:12 +01004634 char_u *buf_fname = buf->b_fname;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004635
Bram Moolenaar48e330a2016-02-23 14:53:34 +01004636#if !defined(UNIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004637# define CREATE_DUMMY_FILE
4638 FILE *dummyfd = NULL;
4639
Bram Moolenaar4f974752019-02-17 17:44:42 +01004640# ifdef MSWIN
Bram Moolenaar69c35002013-11-04 02:54:12 +01004641 if (buf_fname != NULL && !mch_isFullName(buf_fname)
4642 && vim_strchr(gettail(buf_fname), ':'))
4643 {
4644 char_u *t;
4645
4646 buf_fname = vim_strsave(buf_fname);
4647 if (buf_fname == NULL)
4648 buf_fname = buf->b_fname;
4649 else
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004650 for (t = gettail(buf_fname); *t != NUL; MB_PTR_ADV(t))
Bram Moolenaar69c35002013-11-04 02:54:12 +01004651 if (*t == ':')
4652 *t = '%';
4653 }
4654# endif
4655
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004656 /*
4657 * If we start editing a new file, e.g. "test.doc", which resides on an
4658 * MSDOS compatible filesystem, it is possible that the file
4659 * "test.doc.swp" which we create will be exactly the same file. To avoid
4660 * this problem we temporarily create "test.doc". Don't do this when the
4661 * check below for a 8.3 file name is used.
4662 */
Bram Moolenaar69c35002013-11-04 02:54:12 +01004663 if (!(buf->b_p_sn || buf->b_shortname) && buf_fname != NULL
4664 && mch_getperm(buf_fname) < 0)
4665 dummyfd = mch_fopen((char *)buf_fname, "w");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004666#endif
4667
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004668 /*
4669 * Isolate a directory name from *dirp and put it in dir_name.
4670 * First allocate some memory to put the directory name in.
4671 */
Bram Moolenaar964b3742019-05-24 18:54:09 +02004672 dir_name = alloc(STRLEN(*dirp) + 1);
Bram Moolenaarf541c362011-10-26 11:44:18 +02004673 if (dir_name == NULL)
4674 *dirp = NULL;
4675 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004676 (void)copy_option_part(dirp, dir_name, 31000, ",");
4677
Bram Moolenaar55debbe2010-05-23 23:34:36 +02004678 /*
4679 * we try different names until we find one that does not exist yet
4680 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004681 if (dir_name == NULL) /* out of memory */
4682 fname = NULL;
4683 else
Bram Moolenaar69c35002013-11-04 02:54:12 +01004684 fname = makeswapname(buf_fname, buf->b_ffname, buf, dir_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004685
4686 for (;;)
4687 {
4688 if (fname == NULL) /* must be out of memory */
4689 break;
4690 if ((n = (int)STRLEN(fname)) == 0) /* safety check */
4691 {
Bram Moolenaard23a8232018-02-10 18:45:26 +01004692 VIM_CLEAR(fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004693 break;
4694 }
Bram Moolenaar48e330a2016-02-23 14:53:34 +01004695#if defined(UNIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004696/*
4697 * Some systems have a MS-DOS compatible filesystem that use 8.3 character
4698 * file names. If this is the first try and the swap file name does not fit in
4699 * 8.3, detect if this is the case, set shortname and try again.
4700 */
4701 if (fname[n - 2] == 'w' && fname[n - 1] == 'p'
4702 && !(buf->b_p_sn || buf->b_shortname))
4703 {
4704 char_u *tail;
4705 char_u *fname2;
Bram Moolenaar8767f522016-07-01 17:17:39 +02004706 stat_T s1, s2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004707 int f1, f2;
4708 int created1 = FALSE, created2 = FALSE;
4709 int same = FALSE;
4710
4711 /*
4712 * Check if swapfile name does not fit in 8.3:
4713 * It either contains two dots, is longer than 8 chars, or starts
4714 * with a dot.
4715 */
Bram Moolenaar69c35002013-11-04 02:54:12 +01004716 tail = gettail(buf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004717 if ( vim_strchr(tail, '.') != NULL
4718 || STRLEN(tail) > (size_t)8
4719 || *gettail(fname) == '.')
4720 {
4721 fname2 = alloc(n + 2);
4722 if (fname2 != NULL)
4723 {
4724 STRCPY(fname2, fname);
4725 /* if fname == "xx.xx.swp", fname2 = "xx.xx.swx"
4726 * if fname == ".xx.swp", fname2 = ".xx.swpx"
4727 * if fname == "123456789.swp", fname2 = "12345678x.swp"
4728 */
4729 if (vim_strchr(tail, '.') != NULL)
4730 fname2[n - 1] = 'x';
4731 else if (*gettail(fname) == '.')
4732 {
4733 fname2[n] = 'x';
4734 fname2[n + 1] = NUL;
4735 }
4736 else
4737 fname2[n - 5] += 1;
4738 /*
4739 * may need to create the files to be able to use mch_stat()
4740 */
4741 f1 = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
4742 if (f1 < 0)
4743 {
4744 f1 = mch_open_rw((char *)fname,
4745 O_RDWR|O_CREAT|O_EXCL|O_EXTRA);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004746 created1 = TRUE;
4747 }
4748 if (f1 >= 0)
4749 {
4750 f2 = mch_open((char *)fname2, O_RDONLY | O_EXTRA, 0);
4751 if (f2 < 0)
4752 {
4753 f2 = mch_open_rw((char *)fname2,
4754 O_RDWR|O_CREAT|O_EXCL|O_EXTRA);
4755 created2 = TRUE;
4756 }
4757 if (f2 >= 0)
4758 {
4759 /*
4760 * Both files exist now. If mch_stat() returns the
4761 * same device and inode they are the same file.
4762 */
4763 if (mch_fstat(f1, &s1) != -1
4764 && mch_fstat(f2, &s2) != -1
4765 && s1.st_dev == s2.st_dev
4766 && s1.st_ino == s2.st_ino)
4767 same = TRUE;
4768 close(f2);
4769 if (created2)
4770 mch_remove(fname2);
4771 }
4772 close(f1);
4773 if (created1)
4774 mch_remove(fname);
4775 }
4776 vim_free(fname2);
4777 if (same)
4778 {
4779 buf->b_shortname = TRUE;
4780 vim_free(fname);
Bram Moolenaar69c35002013-11-04 02:54:12 +01004781 fname = makeswapname(buf_fname, buf->b_ffname,
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004782 buf, dir_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004783 continue; /* try again with b_shortname set */
4784 }
4785 }
4786 }
4787 }
4788#endif
4789 /*
4790 * check if the swapfile already exists
4791 */
4792 if (mch_getperm(fname) < 0) /* it does not exist */
4793 {
4794#ifdef HAVE_LSTAT
Bram Moolenaar8767f522016-07-01 17:17:39 +02004795 stat_T sb;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004796
4797 /*
4798 * Extra security check: When a swap file is a symbolic link, this
4799 * is most likely a symlink attack.
4800 */
4801 if (mch_lstat((char *)fname, &sb) < 0)
4802#else
4803# ifdef AMIGA
4804 fh = Open((UBYTE *)fname, (long)MODE_NEWFILE);
4805 /*
4806 * on the Amiga mch_getperm() will return -1 when the file exists
4807 * but is being used by another program. This happens if you edit
4808 * a file twice.
4809 */
4810 if (fh != (BPTR)NULL) /* can open file, OK */
4811 {
4812 Close(fh);
4813 mch_remove(fname);
4814 break;
4815 }
4816 if (IoErr() != ERROR_OBJECT_IN_USE
4817 && IoErr() != ERROR_OBJECT_EXISTS)
4818# endif
4819#endif
4820 break;
4821 }
4822
4823 /*
4824 * A file name equal to old_fname is OK to use.
4825 */
4826 if (old_fname != NULL && fnamecmp(fname, old_fname) == 0)
4827 break;
4828
4829 /*
4830 * get here when file already exists
4831 */
4832 if (fname[n - 2] == 'w' && fname[n - 1] == 'p') /* first try */
4833 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004834 /*
4835 * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp
4836 * and file.doc are the same file. To guess if this problem is
4837 * present try if file.doc.swx exists. If it does, we set
4838 * buf->b_shortname and try file_doc.swp (dots replaced by
4839 * underscores for this file), and try again. If it doesn't we
4840 * assume that "file.doc.swp" already exists.
4841 */
4842 if (!(buf->b_p_sn || buf->b_shortname)) /* not tried yet */
4843 {
4844 fname[n - 1] = 'x';
4845 r = mch_getperm(fname); /* try "file.swx" */
4846 fname[n - 1] = 'p';
4847 if (r >= 0) /* "file.swx" seems to exist */
4848 {
4849 buf->b_shortname = TRUE;
4850 vim_free(fname);
Bram Moolenaar69c35002013-11-04 02:54:12 +01004851 fname = makeswapname(buf_fname, buf->b_ffname,
Bram Moolenaar04a09c12005-08-01 22:02:32 +00004852 buf, dir_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004853 continue; /* try again with '.' replaced with '_' */
4854 }
4855 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004856 /*
4857 * If we get here the ".swp" file really exists.
4858 * Give an error message, unless recovering, no file name, we are
4859 * viewing a help file or when the path of the file is different
4860 * (happens when all .swp files are in one directory).
4861 */
Bram Moolenaar69c35002013-11-04 02:54:12 +01004862 if (!recoverymode && buf_fname != NULL
Bram Moolenaar2debf1c2019-08-04 20:44:19 +02004863 && !buf->b_help
4864 && !(buf->b_flags & (BF_DUMMY | BF_NO_SEA)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004865 {
4866 int fd;
4867 struct block0 b0;
4868 int differ = FALSE;
4869
4870 /*
4871 * Try to read block 0 from the swap file to get the original
4872 * file name (and inode number).
4873 */
4874 fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
4875 if (fd >= 0)
4876 {
Bram Moolenaar540fc6f2010-12-17 16:27:16 +01004877 if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004878 {
4879 /*
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004880 * If the swapfile has the same directory as the
4881 * buffer don't compare the directory names, they can
4882 * have a different mountpoint.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004883 */
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004884 if (b0.b0_flags & B0_SAME_DIR)
4885 {
4886 if (fnamecmp(gettail(buf->b_ffname),
4887 gettail(b0.b0_fname)) != 0
4888 || !same_directory(fname, buf->b_ffname))
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004889 {
4890#ifdef CHECK_INODE
4891 /* Symlinks may point to the same file even
4892 * when the name differs, need to check the
4893 * inode too. */
4894 expand_env(b0.b0_fname, NameBuff, MAXPATHL);
4895 if (fnamecmp_ino(buf->b_ffname, NameBuff,
4896 char_to_long(b0.b0_ino)))
4897#endif
4898 differ = TRUE;
4899 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004900 }
4901 else
4902 {
4903 /*
4904 * The name in the swap file may be
4905 * "~user/path/file". Expand it first.
4906 */
4907 expand_env(b0.b0_fname, NameBuff, MAXPATHL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004908#ifdef CHECK_INODE
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004909 if (fnamecmp_ino(buf->b_ffname, NameBuff,
Bram Moolenaar900b4d72005-12-12 22:05:50 +00004910 char_to_long(b0.b0_ino)))
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004911 differ = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004912#else
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004913 if (fnamecmp(NameBuff, buf->b_ffname) != 0)
4914 differ = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004915#endif
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004916 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004917 }
4918 close(fd);
4919 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920
4921 /* give the ATTENTION message when there is an old swap file
4922 * for the current file, and the buffer was not recovered. */
4923 if (differ == FALSE && !(curbuf->b_flags & BF_RECOVERED)
4924 && vim_strchr(p_shm, SHM_ATTENTION) == NULL)
4925 {
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004926 int choice = 0;
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02004927 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004928#ifdef CREATE_DUMMY_FILE
4929 int did_use_dummy = FALSE;
4930
4931 /* Avoid getting a warning for the file being created
4932 * outside of Vim, it was created at the start of this
4933 * function. Delete the file now, because Vim might exit
4934 * here if the window is closed. */
4935 if (dummyfd != NULL)
4936 {
4937 fclose(dummyfd);
4938 dummyfd = NULL;
Bram Moolenaar69c35002013-11-04 02:54:12 +01004939 mch_remove(buf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004940 did_use_dummy = TRUE;
4941 }
4942#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004943
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02004944#ifdef HAVE_PROCESS_STILL_RUNNING
Bram Moolenaar071d4272004-06-13 20:20:40 +00004945 process_still_running = FALSE;
4946#endif
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02004947 // It's safe to delete the swap file if all these are true:
4948 // - the edited file exists
4949 // - the swap file has no changes and looks OK
4950 if (mch_stat((char *)buf->b_fname, &st) == 0
4951 && swapfile_unchanged(fname))
4952 {
4953 choice = 4;
4954 if (p_verbose > 0)
4955 verb_msg(_("Found a swap file that is not useful, deleting it"));
4956 }
4957
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01004958#if defined(FEAT_EVAL)
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004959 /*
4960 * If there is an SwapExists autocommand and we can handle
4961 * the response, trigger it. It may return 0 to ask the
4962 * user anyway.
4963 */
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02004964 if (choice == 0
4965 && swap_exists_action != SEA_NONE
Bram Moolenaar69c35002013-11-04 02:54:12 +01004966 && has_autocmd(EVENT_SWAPEXISTS, buf_fname, buf))
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004967 choice = do_swapexists(buf, fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004968
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004969 if (choice == 0)
4970#endif
4971 {
4972#ifdef FEAT_GUI
Bram Moolenaar798184c2018-10-07 20:48:39 +02004973 // If we are supposed to start the GUI but it wasn't
4974 // completely started yet, start it now. This makes
4975 // the messages displayed in the Vim window when
4976 // loading a session from the .gvimrc file.
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004977 if (gui.starting && !gui.in_use)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02004978 gui_start(NULL);
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004979#endif
Bram Moolenaar798184c2018-10-07 20:48:39 +02004980 // Show info about the existing swap file.
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004981 attention_message(buf, fname);
4982
Bram Moolenaar798184c2018-10-07 20:48:39 +02004983 // We don't want a 'q' typed at the more-prompt
4984 // interrupt loading a file.
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004985 got_int = FALSE;
Bram Moolenaar798184c2018-10-07 20:48:39 +02004986
4987 // If vimrc has "simalt ~x" we don't want it to
4988 // interfere with the prompt here.
Bram Moolenaar6a2633b2018-10-07 23:16:36 +02004989 flush_buffers(FLUSH_TYPEAHEAD);
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004990 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004991
4992#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00004993 if (swap_exists_action != SEA_NONE && choice == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004994 {
4995 char_u *name;
4996
Bram Moolenaar964b3742019-05-24 18:54:09 +02004997 name = alloc(STRLEN(fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004998 + STRLEN(_("Swap file \""))
Bram Moolenaar964b3742019-05-24 18:54:09 +02004999 + STRLEN(_("\" already exists!")) + 5);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005000 if (name != NULL)
5001 {
5002 STRCPY(name, _("Swap file \""));
5003 home_replace(NULL, fname, name + STRLEN(name),
5004 1000, TRUE);
5005 STRCAT(name, _("\" already exists!"));
5006 }
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005007 choice = do_dialog(VIM_WARNING,
Bram Moolenaar071d4272004-06-13 20:20:40 +00005008 (char_u *)_("VIM - ATTENTION"),
5009 name == NULL
5010 ? (char_u *)_("Swap file already exists!")
5011 : name,
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02005012# ifdef HAVE_PROCESS_STILL_RUNNING
Bram Moolenaar071d4272004-06-13 20:20:40 +00005013 process_still_running
5014 ? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort") :
5015# endif
Bram Moolenaard2c340a2011-01-17 20:08:11 +01005016 (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Delete it\n&Quit\n&Abort"), 1, NULL, FALSE);
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005017
Bram Moolenaar1b243ea2019-04-28 22:50:40 +02005018# ifdef HAVE_PROCESS_STILL_RUNNING
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005019 if (process_still_running && choice >= 4)
5020 choice++; /* Skip missing "Delete it" button */
5021# endif
5022 vim_free(name);
5023
5024 /* pretend screen didn't scroll, need redraw anyway */
5025 msg_scrolled = 0;
5026 redraw_all_later(NOT_VALID);
5027 }
5028#endif
5029
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005030 if (choice > 0)
5031 {
5032 switch (choice)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005033 {
5034 case 1:
5035 buf->b_p_ro = TRUE;
5036 break;
5037 case 2:
5038 break;
5039 case 3:
5040 swap_exists_action = SEA_RECOVER;
5041 break;
5042 case 4:
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005043 mch_remove(fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005044 break;
5045 case 5:
5046 swap_exists_action = SEA_QUIT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005047 break;
5048 case 6:
Bram Moolenaard5bc83f2005-12-07 21:07:59 +00005049 swap_exists_action = SEA_QUIT;
5050 got_int = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005051 break;
5052 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005053
5054 /* If the file was deleted this fname can be used. */
5055 if (mch_getperm(fname) < 0)
5056 break;
5057 }
5058 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005059 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005060 msg_puts("\n");
Bram Moolenaar4770d092006-01-12 23:22:24 +00005061 if (msg_silent == 0)
5062 /* call wait_return() later */
5063 need_wait_return = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005064 }
5065
5066#ifdef CREATE_DUMMY_FILE
5067 /* Going to try another name, need the dummy file again. */
5068 if (did_use_dummy)
Bram Moolenaar69c35002013-11-04 02:54:12 +01005069 dummyfd = mch_fopen((char *)buf_fname, "w");
Bram Moolenaar071d4272004-06-13 20:20:40 +00005070#endif
5071 }
5072 }
5073 }
5074
5075 /*
5076 * Change the ".swp" extension to find another file that can be used.
5077 * First decrement the last char: ".swo", ".swn", etc.
5078 * If that still isn't enough decrement the last but one char: ".svz"
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005079 * Can happen when editing many "No Name" buffers.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005080 */
5081 if (fname[n - 1] == 'a') /* ".s?a" */
5082 {
5083 if (fname[n - 2] == 'a') /* ".saa": tried enough, give up */
5084 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005085 emsg(_("E326: Too many swap files found"));
Bram Moolenaard23a8232018-02-10 18:45:26 +01005086 VIM_CLEAR(fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005087 break;
5088 }
5089 --fname[n - 2]; /* ".svz", ".suz", etc. */
5090 fname[n - 1] = 'z' + 1;
5091 }
5092 --fname[n - 1]; /* ".swo", ".swn", etc. */
5093 }
5094
5095 vim_free(dir_name);
5096#ifdef CREATE_DUMMY_FILE
5097 if (dummyfd != NULL) /* file has been created temporarily */
5098 {
5099 fclose(dummyfd);
Bram Moolenaar69c35002013-11-04 02:54:12 +01005100 mch_remove(buf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005101 }
5102#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +01005103#ifdef MSWIN
Bram Moolenaar69c35002013-11-04 02:54:12 +01005104 if (buf_fname != buf->b_fname)
5105 vim_free(buf_fname);
5106#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005107 return fname;
5108}
5109
5110 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005111b0_magic_wrong(ZERO_BL *b0p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005112{
5113 return (b0p->b0_magic_long != (long)B0_MAGIC_LONG
5114 || b0p->b0_magic_int != (int)B0_MAGIC_INT
5115 || b0p->b0_magic_short != (short)B0_MAGIC_SHORT
5116 || b0p->b0_magic_char != B0_MAGIC_CHAR);
5117}
5118
5119#ifdef CHECK_INODE
5120/*
5121 * Compare current file name with file name from swap file.
5122 * Try to use inode numbers when possible.
5123 * Return non-zero when files are different.
5124 *
5125 * When comparing file names a few things have to be taken into consideration:
5126 * - When working over a network the full path of a file depends on the host.
5127 * We check the inode number if possible. It is not 100% reliable though,
5128 * because the device number cannot be used over a network.
5129 * - When a file does not exist yet (editing a new file) there is no inode
5130 * number.
5131 * - The file name in a swap file may not be valid on the current host. The
5132 * "~user" form is used whenever possible to avoid this.
5133 *
5134 * This is getting complicated, let's make a table:
5135 *
5136 * ino_c ino_s fname_c fname_s differ =
5137 *
5138 * both files exist -> compare inode numbers:
5139 * != 0 != 0 X X ino_c != ino_s
5140 *
5141 * inode number(s) unknown, file names available -> compare file names
5142 * == 0 X OK OK fname_c != fname_s
5143 * X == 0 OK OK fname_c != fname_s
5144 *
5145 * current file doesn't exist, file for swap file exist, file name(s) not
5146 * available -> probably different
5147 * == 0 != 0 FAIL X TRUE
5148 * == 0 != 0 X FAIL TRUE
5149 *
5150 * current file exists, inode for swap unknown, file name(s) not
5151 * available -> probably different
5152 * != 0 == 0 FAIL X TRUE
5153 * != 0 == 0 X FAIL TRUE
5154 *
5155 * current file doesn't exist, inode for swap unknown, one file name not
5156 * available -> probably different
5157 * == 0 == 0 FAIL OK TRUE
5158 * == 0 == 0 OK FAIL TRUE
5159 *
5160 * current file doesn't exist, inode for swap unknown, both file names not
Bram Moolenaar8c3169c2018-05-12 17:04:12 +02005161 * available -> compare file names
5162 * == 0 == 0 FAIL FAIL fname_c != fname_s
Bram Moolenaar071d4272004-06-13 20:20:40 +00005163 *
5164 * Note that when the ino_t is 64 bits, only the last 32 will be used. This
5165 * can't be changed without making the block 0 incompatible with 32 bit
5166 * versions.
5167 */
5168
5169 static int
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005170fnamecmp_ino(
5171 char_u *fname_c, /* current file name */
5172 char_u *fname_s, /* file name from swap file */
5173 long ino_block0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005174{
Bram Moolenaar8767f522016-07-01 17:17:39 +02005175 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005176 ino_t ino_c = 0; /* ino of current file */
5177 ino_t ino_s; /* ino of file from swap file */
5178 char_u buf_c[MAXPATHL]; /* full path of fname_c */
5179 char_u buf_s[MAXPATHL]; /* full path of fname_s */
5180 int retval_c; /* flag: buf_c valid */
5181 int retval_s; /* flag: buf_s valid */
5182
5183 if (mch_stat((char *)fname_c, &st) == 0)
5184 ino_c = (ino_t)st.st_ino;
5185
5186 /*
5187 * First we try to get the inode from the file name, because the inode in
5188 * the swap file may be outdated. If that fails (e.g. this path is not
5189 * valid on this machine), use the inode from block 0.
5190 */
5191 if (mch_stat((char *)fname_s, &st) == 0)
5192 ino_s = (ino_t)st.st_ino;
5193 else
5194 ino_s = (ino_t)ino_block0;
5195
5196 if (ino_c && ino_s)
5197 return (ino_c != ino_s);
5198
5199 /*
5200 * One of the inode numbers is unknown, try a forced vim_FullName() and
5201 * compare the file names.
5202 */
5203 retval_c = vim_FullName(fname_c, buf_c, MAXPATHL, TRUE);
5204 retval_s = vim_FullName(fname_s, buf_s, MAXPATHL, TRUE);
5205 if (retval_c == OK && retval_s == OK)
Bram Moolenaar8c3169c2018-05-12 17:04:12 +02005206 return STRCMP(buf_c, buf_s) != 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005207
5208 /*
5209 * Can't compare inodes or file names, guess that the files are different,
Bram Moolenaar8c3169c2018-05-12 17:04:12 +02005210 * unless both appear not to exist at all, then compare with the file name
5211 * in the swap file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005212 */
5213 if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL)
Bram Moolenaar8c3169c2018-05-12 17:04:12 +02005214 return STRCMP(fname_c, fname_s) != 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005215 return TRUE;
5216}
5217#endif /* CHECK_INODE */
5218
5219/*
5220 * Move a long integer into a four byte character array.
5221 * Used for machine independency in block zero.
5222 */
5223 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005224long_to_char(long n, char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005225{
5226 s[0] = (char_u)(n & 0xff);
5227 n = (unsigned)n >> 8;
5228 s[1] = (char_u)(n & 0xff);
5229 n = (unsigned)n >> 8;
5230 s[2] = (char_u)(n & 0xff);
5231 n = (unsigned)n >> 8;
5232 s[3] = (char_u)(n & 0xff);
5233}
5234
5235 static long
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005236char_to_long(char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005237{
5238 long retval;
5239
5240 retval = s[3];
5241 retval <<= 8;
5242 retval |= s[2];
5243 retval <<= 8;
5244 retval |= s[1];
5245 retval <<= 8;
5246 retval |= s[0];
5247
5248 return retval;
5249}
5250
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00005251/*
5252 * Set the flags in the first block of the swap file:
5253 * - file is modified or not: buf->b_changed
5254 * - 'fileformat'
5255 * - 'fileencoding'
5256 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005257 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005258ml_setflags(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005259{
5260 bhdr_T *hp;
5261 ZERO_BL *b0p;
5262
5263 if (!buf->b_ml.ml_mfp)
5264 return;
5265 for (hp = buf->b_ml.ml_mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
5266 {
5267 if (hp->bh_bnum == 0)
5268 {
5269 b0p = (ZERO_BL *)(hp->bh_data);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00005270 b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0;
5271 b0p->b0_flags = (b0p->b0_flags & ~B0_FF_MASK)
5272 | (get_fileformat(buf) + 1);
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00005273 add_b0_fenc(b0p, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005274 hp->bh_flags |= BH_DIRTY;
5275 mf_sync(buf->b_ml.ml_mfp, MFS_ZERO);
5276 break;
5277 }
5278 }
5279}
5280
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005281#if defined(FEAT_CRYPT) || defined(PROTO)
5282/*
5283 * If "data" points to a data block encrypt the text in it and return a copy
5284 * in allocated memory. Return NULL when out of memory.
5285 * Otherwise return "data".
5286 */
5287 char_u *
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005288ml_encrypt_data(
5289 memfile_T *mfp,
5290 char_u *data,
Bram Moolenaar8767f522016-07-01 17:17:39 +02005291 off_T offset,
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005292 unsigned size)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005293{
5294 DATA_BL *dp = (DATA_BL *)data;
5295 char_u *head_end;
5296 char_u *text_start;
5297 char_u *new_data;
5298 int text_len;
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005299 cryptstate_T *state;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005300
5301 if (dp->db_id != DATA_ID)
5302 return data;
5303
Bram Moolenaarbc563362015-06-09 18:35:25 +02005304 state = ml_crypt_prepare(mfp, offset, FALSE);
5305 if (state == NULL)
5306 return data;
5307
Bram Moolenaarc799fe22019-05-28 23:08:19 +02005308 new_data = alloc(size);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005309 if (new_data == NULL)
5310 return NULL;
5311 head_end = (char_u *)(&dp->db_index[dp->db_line_count]);
5312 text_start = (char_u *)dp + dp->db_txt_start;
5313 text_len = size - dp->db_txt_start;
5314
5315 /* Copy the header and the text. */
5316 mch_memmove(new_data, dp, head_end - (char_u *)dp);
5317
5318 /* Encrypt the text. */
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005319 crypt_encode(state, text_start, text_len, new_data + dp->db_txt_start);
5320 crypt_free_state(state);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005321
5322 /* Clear the gap. */
5323 if (head_end < text_start)
5324 vim_memset(new_data + (head_end - data), 0, text_start - head_end);
5325
5326 return new_data;
5327}
5328
5329/*
Bram Moolenaarbc563362015-06-09 18:35:25 +02005330 * Decrypt the text in "data" if it points to an encrypted data block.
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005331 */
5332 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005333ml_decrypt_data(
5334 memfile_T *mfp,
5335 char_u *data,
Bram Moolenaar8767f522016-07-01 17:17:39 +02005336 off_T offset,
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005337 unsigned size)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005338{
5339 DATA_BL *dp = (DATA_BL *)data;
5340 char_u *head_end;
5341 char_u *text_start;
5342 int text_len;
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005343 cryptstate_T *state;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005344
5345 if (dp->db_id == DATA_ID)
5346 {
5347 head_end = (char_u *)(&dp->db_index[dp->db_line_count]);
5348 text_start = (char_u *)dp + dp->db_txt_start;
5349 text_len = dp->db_txt_end - dp->db_txt_start;
5350
5351 if (head_end > text_start || dp->db_txt_start > size
5352 || dp->db_txt_end > size)
5353 return; /* data was messed up */
5354
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005355 state = ml_crypt_prepare(mfp, offset, TRUE);
Bram Moolenaarbc563362015-06-09 18:35:25 +02005356 if (state != NULL)
5357 {
5358 /* Decrypt the text in place. */
5359 crypt_decode_inplace(state, text_start, text_len);
5360 crypt_free_state(state);
5361 }
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005362 }
5363}
5364
5365/*
5366 * Prepare for encryption/decryption, using the key, seed and offset.
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005367 * Return an allocated cryptstate_T *.
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005368 */
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005369 static cryptstate_T *
Bram Moolenaar8767f522016-07-01 17:17:39 +02005370ml_crypt_prepare(memfile_T *mfp, off_T offset, int reading)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005371{
5372 buf_T *buf = mfp->mf_buffer;
5373 char_u salt[50];
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005374 int method_nr;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005375 char_u *key;
5376 char_u *seed;
5377
5378 if (reading && mfp->mf_old_key != NULL)
5379 {
5380 /* Reading back blocks with the previous key/method/seed. */
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005381 method_nr = mfp->mf_old_cm;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005382 key = mfp->mf_old_key;
5383 seed = mfp->mf_old_seed;
5384 }
5385 else
5386 {
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005387 method_nr = crypt_get_method_nr(buf);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005388 key = buf->b_p_key;
5389 seed = mfp->mf_seed;
5390 }
Bram Moolenaarbc563362015-06-09 18:35:25 +02005391 if (*key == NUL)
5392 return NULL;
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005393
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005394 if (method_nr == CRYPT_M_ZIP)
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005395 {
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005396 /* For PKzip: Append the offset to the key, so that we use a different
5397 * key for every block. */
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005398 vim_snprintf((char *)salt, sizeof(salt), "%s%ld", key, (long)offset);
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005399 return crypt_create(method_nr, salt, NULL, 0, NULL, 0);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005400 }
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02005401
5402 /* Using blowfish or better: add salt and seed. We use the byte offset
5403 * of the block for the salt. */
5404 vim_snprintf((char *)salt, sizeof(salt), "%ld", (long)offset);
5405 return crypt_create(method_nr, key, salt, (int)STRLEN(salt),
5406 seed, MF_SEED_LEN);
Bram Moolenaara8ffcbb2010-06-21 06:15:46 +02005407}
5408
5409#endif
5410
5411
Bram Moolenaar071d4272004-06-13 20:20:40 +00005412#if defined(FEAT_BYTEOFF) || defined(PROTO)
5413
5414#define MLCS_MAXL 800 /* max no of lines in chunk */
5415#define MLCS_MINL 400 /* should be half of MLCS_MAXL */
5416
5417/*
Bram Moolenaar0ad014c2010-07-25 14:00:46 +02005418 * Keep information for finding byte offset of a line, updtype may be one of:
Bram Moolenaar071d4272004-06-13 20:20:40 +00005419 * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it
5420 * Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called.
5421 * ML_CHNK_DELLINE: Subtract len from parent chunk, possibly deleting it
5422 * ML_CHNK_UPDLINE: Add len to parent chunk, as a signed entity.
5423 */
5424 static void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005425ml_updatechunk(
5426 buf_T *buf,
5427 linenr_T line,
5428 long len,
5429 int updtype)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005430{
5431 static buf_T *ml_upd_lastbuf = NULL;
5432 static linenr_T ml_upd_lastline;
5433 static linenr_T ml_upd_lastcurline;
5434 static int ml_upd_lastcurix;
5435
5436 linenr_T curline = ml_upd_lastcurline;
5437 int curix = ml_upd_lastcurix;
5438 long size;
5439 chunksize_T *curchnk;
5440 int rest;
5441 bhdr_T *hp;
5442 DATA_BL *dp;
5443
5444 if (buf->b_ml.ml_usedchunks == -1 || len == 0)
5445 return;
5446 if (buf->b_ml.ml_chunksize == NULL)
5447 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02005448 buf->b_ml.ml_chunksize = ALLOC_MULT(chunksize_T, 100);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005449 if (buf->b_ml.ml_chunksize == NULL)
5450 {
5451 buf->b_ml.ml_usedchunks = -1;
5452 return;
5453 }
5454 buf->b_ml.ml_numchunks = 100;
5455 buf->b_ml.ml_usedchunks = 1;
5456 buf->b_ml.ml_chunksize[0].mlcs_numlines = 1;
5457 buf->b_ml.ml_chunksize[0].mlcs_totalsize = 1;
5458 }
5459
5460 if (updtype == ML_CHNK_UPDLINE && buf->b_ml.ml_line_count == 1)
5461 {
5462 /*
5463 * First line in empty buffer from ml_flush_line() -- reset
5464 */
5465 buf->b_ml.ml_usedchunks = 1;
5466 buf->b_ml.ml_chunksize[0].mlcs_numlines = 1;
Bram Moolenaar98aefe72018-12-13 22:20:09 +01005467 buf->b_ml.ml_chunksize[0].mlcs_totalsize = (long)buf->b_ml.ml_line_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005468 return;
5469 }
5470
5471 /*
5472 * Find chunk that our line belongs to, curline will be at start of the
5473 * chunk.
5474 */
5475 if (buf != ml_upd_lastbuf || line != ml_upd_lastline + 1
5476 || updtype != ML_CHNK_ADDLINE)
5477 {
5478 for (curline = 1, curix = 0;
5479 curix < buf->b_ml.ml_usedchunks - 1
5480 && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines;
5481 curix++)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005482 curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005483 }
Bram Moolenaara9a8e042018-10-30 22:15:55 +01005484 else if (curix < buf->b_ml.ml_usedchunks - 1
5485 && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005486 {
5487 /* Adjust cached curix & curline */
5488 curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
5489 curix++;
5490 }
5491 curchnk = buf->b_ml.ml_chunksize + curix;
5492
5493 if (updtype == ML_CHNK_DELLINE)
Bram Moolenaar5a6404c2006-11-01 17:12:57 +00005494 len = -len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005495 curchnk->mlcs_totalsize += len;
5496 if (updtype == ML_CHNK_ADDLINE)
5497 {
5498 curchnk->mlcs_numlines++;
5499
5500 /* May resize here so we don't have to do it in both cases below */
5501 if (buf->b_ml.ml_usedchunks + 1 >= buf->b_ml.ml_numchunks)
5502 {
Bram Moolenaar9abd5c62015-02-10 18:34:01 +01005503 chunksize_T *t_chunksize = buf->b_ml.ml_chunksize;
5504
Bram Moolenaar071d4272004-06-13 20:20:40 +00005505 buf->b_ml.ml_numchunks = buf->b_ml.ml_numchunks * 3 / 2;
5506 buf->b_ml.ml_chunksize = (chunksize_T *)
5507 vim_realloc(buf->b_ml.ml_chunksize,
5508 sizeof(chunksize_T) * buf->b_ml.ml_numchunks);
5509 if (buf->b_ml.ml_chunksize == NULL)
5510 {
5511 /* Hmmmm, Give up on offset for this buffer */
Bram Moolenaar9abd5c62015-02-10 18:34:01 +01005512 vim_free(t_chunksize);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005513 buf->b_ml.ml_usedchunks = -1;
5514 return;
5515 }
5516 }
5517
5518 if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MAXL)
5519 {
5520 int count; /* number of entries in block */
5521 int idx;
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005522 int end_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005523 int text_end;
5524 int linecnt;
5525
5526 mch_memmove(buf->b_ml.ml_chunksize + curix + 1,
5527 buf->b_ml.ml_chunksize + curix,
5528 (buf->b_ml.ml_usedchunks - curix) *
5529 sizeof(chunksize_T));
Bram Moolenaar9439cdd2009-04-22 13:39:36 +00005530 /* Compute length of first half of lines in the split chunk */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005531 size = 0;
5532 linecnt = 0;
5533 while (curline < buf->b_ml.ml_line_count
5534 && linecnt < MLCS_MINL)
5535 {
5536 if ((hp = ml_find_line(buf, curline, ML_FIND)) == NULL)
5537 {
5538 buf->b_ml.ml_usedchunks = -1;
5539 return;
5540 }
5541 dp = (DATA_BL *)(hp->bh_data);
5542 count = (long)(buf->b_ml.ml_locked_high) -
5543 (long)(buf->b_ml.ml_locked_low) + 1;
5544 idx = curline - buf->b_ml.ml_locked_low;
5545 curline = buf->b_ml.ml_locked_high + 1;
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005546
5547 // compute index of last line to use in this MEMLINE
Bram Moolenaar071d4272004-06-13 20:20:40 +00005548 rest = count - idx;
5549 if (linecnt + rest > MLCS_MINL)
5550 {
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005551 end_idx = idx + MLCS_MINL - linecnt - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005552 linecnt = MLCS_MINL;
5553 }
5554 else
5555 {
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005556 end_idx = count - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005557 linecnt += rest;
5558 }
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005559#ifdef FEAT_TEXT_PROP
5560 if (buf->b_has_textprop)
5561 {
5562 int i;
5563
5564 // We cannot use the text pointers to get the text length,
5565 // the text prop info would also be counted. Go over the
5566 // lines.
5567 for (i = end_idx; i < idx; ++i)
Bram Moolenaar4b7214e2019-01-03 21:55:32 +01005568 size += (int)STRLEN((char_u *)dp + (dp->db_index[i] & DB_INDEX_MASK)) + 1;
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005569 }
5570 else
5571#endif
5572 {
5573 if (idx == 0)/* first line in block, text at the end */
5574 text_end = dp->db_txt_end;
5575 else
5576 text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
5577 size += text_end - ((dp->db_index[end_idx]) & DB_INDEX_MASK);
5578 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005579 }
5580 buf->b_ml.ml_chunksize[curix].mlcs_numlines = linecnt;
5581 buf->b_ml.ml_chunksize[curix + 1].mlcs_numlines -= linecnt;
5582 buf->b_ml.ml_chunksize[curix].mlcs_totalsize = size;
5583 buf->b_ml.ml_chunksize[curix + 1].mlcs_totalsize -= size;
5584 buf->b_ml.ml_usedchunks++;
5585 ml_upd_lastbuf = NULL; /* Force recalc of curix & curline */
5586 return;
5587 }
5588 else if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MINL
5589 && curix == buf->b_ml.ml_usedchunks - 1
5590 && buf->b_ml.ml_line_count - line <= 1)
5591 {
5592 /*
5593 * We are in the last chunk and it is cheap to crate a new one
5594 * after this. Do it now to avoid the loop above later on
5595 */
5596 curchnk = buf->b_ml.ml_chunksize + curix + 1;
5597 buf->b_ml.ml_usedchunks++;
5598 if (line == buf->b_ml.ml_line_count)
5599 {
5600 curchnk->mlcs_numlines = 0;
5601 curchnk->mlcs_totalsize = 0;
5602 }
5603 else
5604 {
5605 /*
5606 * Line is just prior to last, move count for last
5607 * This is the common case when loading a new file
5608 */
5609 hp = ml_find_line(buf, buf->b_ml.ml_line_count, ML_FIND);
5610 if (hp == NULL)
5611 {
5612 buf->b_ml.ml_usedchunks = -1;
5613 return;
5614 }
5615 dp = (DATA_BL *)(hp->bh_data);
5616 if (dp->db_line_count == 1)
5617 rest = dp->db_txt_end - dp->db_txt_start;
5618 else
5619 rest =
5620 ((dp->db_index[dp->db_line_count - 2]) & DB_INDEX_MASK)
5621 - dp->db_txt_start;
5622 curchnk->mlcs_totalsize = rest;
5623 curchnk->mlcs_numlines = 1;
5624 curchnk[-1].mlcs_totalsize -= rest;
5625 curchnk[-1].mlcs_numlines -= 1;
5626 }
5627 }
5628 }
5629 else if (updtype == ML_CHNK_DELLINE)
5630 {
5631 curchnk->mlcs_numlines--;
5632 ml_upd_lastbuf = NULL; /* Force recalc of curix & curline */
5633 if (curix < (buf->b_ml.ml_usedchunks - 1)
5634 && (curchnk->mlcs_numlines + curchnk[1].mlcs_numlines)
5635 <= MLCS_MINL)
5636 {
5637 curix++;
5638 curchnk = buf->b_ml.ml_chunksize + curix;
5639 }
5640 else if (curix == 0 && curchnk->mlcs_numlines <= 0)
5641 {
5642 buf->b_ml.ml_usedchunks--;
5643 mch_memmove(buf->b_ml.ml_chunksize, buf->b_ml.ml_chunksize + 1,
5644 buf->b_ml.ml_usedchunks * sizeof(chunksize_T));
5645 return;
5646 }
5647 else if (curix == 0 || (curchnk->mlcs_numlines > 10
5648 && (curchnk->mlcs_numlines + curchnk[-1].mlcs_numlines)
5649 > MLCS_MINL))
5650 {
5651 return;
5652 }
5653
5654 /* Collapse chunks */
5655 curchnk[-1].mlcs_numlines += curchnk->mlcs_numlines;
5656 curchnk[-1].mlcs_totalsize += curchnk->mlcs_totalsize;
5657 buf->b_ml.ml_usedchunks--;
5658 if (curix < buf->b_ml.ml_usedchunks)
5659 {
5660 mch_memmove(buf->b_ml.ml_chunksize + curix,
5661 buf->b_ml.ml_chunksize + curix + 1,
5662 (buf->b_ml.ml_usedchunks - curix) *
5663 sizeof(chunksize_T));
5664 }
5665 return;
5666 }
5667 ml_upd_lastbuf = buf;
5668 ml_upd_lastline = line;
5669 ml_upd_lastcurline = curline;
5670 ml_upd_lastcurix = curix;
5671}
5672
5673/*
5674 * Find offset for line or line with offset.
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005675 * Find line with offset if "lnum" is 0; return remaining offset in offp
5676 * Find offset of line if "lnum" > 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00005677 * return -1 if information is not available
5678 */
5679 long
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005680ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005681{
5682 linenr_T curline;
5683 int curix;
5684 long size;
5685 bhdr_T *hp;
5686 DATA_BL *dp;
5687 int count; /* number of entries in block */
5688 int idx;
5689 int start_idx;
5690 int text_end;
5691 long offset;
5692 int len;
5693 int ffdos = (get_fileformat(buf) == EOL_DOS);
5694 int extra = 0;
5695
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005696 /* take care of cached line first */
5697 ml_flush_line(curbuf);
5698
Bram Moolenaar071d4272004-06-13 20:20:40 +00005699 if (buf->b_ml.ml_usedchunks == -1
5700 || buf->b_ml.ml_chunksize == NULL
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005701 || lnum < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005702 return -1;
5703
5704 if (offp == NULL)
5705 offset = 0;
5706 else
5707 offset = *offp;
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005708 if (lnum == 0 && offset <= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005709 return 1; /* Not a "find offset" and offset 0 _must_ be in line 1 */
5710 /*
5711 * Find the last chunk before the one containing our line. Last chunk is
5712 * special because it will never qualify
5713 */
5714 curline = 1;
5715 curix = size = 0;
5716 while (curix < buf->b_ml.ml_usedchunks - 1
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005717 && ((lnum != 0
5718 && lnum >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005719 || (offset != 0
5720 && offset > size + buf->b_ml.ml_chunksize[curix].mlcs_totalsize
5721 + ffdos * buf->b_ml.ml_chunksize[curix].mlcs_numlines)))
5722 {
5723 curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
5724 size += buf->b_ml.ml_chunksize[curix].mlcs_totalsize;
5725 if (offset && ffdos)
5726 size += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
5727 curix++;
5728 }
5729
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005730 while ((lnum != 0 && curline < lnum) || (offset != 0 && size < offset))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005731 {
5732 if (curline > buf->b_ml.ml_line_count
5733 || (hp = ml_find_line(buf, curline, ML_FIND)) == NULL)
5734 return -1;
5735 dp = (DATA_BL *)(hp->bh_data);
5736 count = (long)(buf->b_ml.ml_locked_high) -
5737 (long)(buf->b_ml.ml_locked_low) + 1;
5738 start_idx = idx = curline - buf->b_ml.ml_locked_low;
5739 if (idx == 0)/* first line in block, text at the end */
5740 text_end = dp->db_txt_end;
5741 else
5742 text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
5743 /* Compute index of last line to use in this MEMLINE */
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005744 if (lnum != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005745 {
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005746 if (curline + (count - idx) >= lnum)
5747 idx += lnum - curline - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005748 else
5749 idx = count - 1;
5750 }
5751 else
5752 {
5753 extra = 0;
5754 while (offset >= size
5755 + text_end - (int)((dp->db_index[idx]) & DB_INDEX_MASK)
5756 + ffdos)
5757 {
5758 if (ffdos)
5759 size++;
5760 if (idx == count - 1)
5761 {
5762 extra = 1;
5763 break;
5764 }
5765 idx++;
5766 }
5767 }
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005768#ifdef FEAT_TEXT_PROP
5769 if (buf->b_has_textprop)
5770 {
5771 int i;
5772
5773 // cannot use the db_index pointer, need to get the actual text
5774 // lengths.
5775 len = 0;
5776 for (i = start_idx; i <= idx; ++i)
Bram Moolenaar4b7214e2019-01-03 21:55:32 +01005777 len += (int)STRLEN((char_u *)dp + ((dp->db_index[i]) & DB_INDEX_MASK)) + 1;
Bram Moolenaarb413d2e2018-12-25 23:15:46 +01005778 }
5779 else
5780#endif
5781 len = text_end - ((dp->db_index[idx]) & DB_INDEX_MASK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005782 size += len;
5783 if (offset != 0 && size >= offset)
5784 {
5785 if (size + ffdos == offset)
5786 *offp = 0;
5787 else if (idx == start_idx)
5788 *offp = offset - size + len;
5789 else
5790 *offp = offset - size + len
5791 - (text_end - ((dp->db_index[idx - 1]) & DB_INDEX_MASK));
5792 curline += idx - start_idx + extra;
5793 if (curline > buf->b_ml.ml_line_count)
5794 return -1; /* exactly one byte beyond the end */
5795 return curline;
5796 }
5797 curline = buf->b_ml.ml_locked_high + 1;
5798 }
5799
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005800 if (lnum != 0)
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005801 {
5802 /* Count extra CR characters. */
5803 if (ffdos)
Bram Moolenaar5313dcb2005-02-22 08:56:13 +00005804 size += lnum - 1;
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005805
Bram Moolenaar34d72d42015-07-17 14:18:08 +02005806 /* Don't count the last line break if 'noeol' and ('bin' or
5807 * 'nofixeol'). */
5808 if ((!buf->b_p_fixeol || buf->b_p_bin) && !buf->b_p_eol
Bram Moolenaarc26f7c62018-08-20 22:53:04 +02005809 && lnum > buf->b_ml.ml_line_count)
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005810 size -= ffdos + 1;
5811 }
5812
Bram Moolenaar071d4272004-06-13 20:20:40 +00005813 return size;
5814}
5815
5816/*
5817 * Goto byte in buffer with offset 'cnt'.
5818 */
5819 void
Bram Moolenaar52ea13d2016-01-30 18:51:09 +01005820goto_byte(long cnt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005821{
5822 long boff = cnt;
5823 linenr_T lnum;
5824
5825 ml_flush_line(curbuf); /* cached line may be dirty */
5826 setpcmark();
5827 if (boff)
5828 --boff;
5829 lnum = ml_find_line_or_offset(curbuf, (linenr_T)0, &boff);
5830 if (lnum < 1) /* past the end */
5831 {
5832 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
5833 curwin->w_curswant = MAXCOL;
5834 coladvance((colnr_T)MAXCOL);
5835 }
5836 else
5837 {
5838 curwin->w_cursor.lnum = lnum;
5839 curwin->w_cursor.col = (colnr_T)boff;
Bram Moolenaar943d2b52005-12-02 00:50:49 +00005840 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005841 curwin->w_set_curswant = TRUE;
5842 }
5843 check_cursor();
5844
Bram Moolenaar071d4272004-06-13 20:20:40 +00005845 /* Make sure the cursor is on the first byte of a multi-byte char. */
5846 if (has_mbyte)
5847 mb_adjust_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005848}
5849#endif