blob: d190bdfab03c713c38550088bdf3ae34f510cc42 [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/*
11 * buffer.c: functions for dealing with the buffer structure
12 */
13
14/*
15 * The buffer list is a double linked list of all buffers.
16 * Each buffer can be in one of these states:
17 * never loaded: BF_NEVERLOADED is set, only the file name is valid
18 * not loaded: b_ml.ml_mfp == NULL, no memfile allocated
19 * hidden: b_nwindows == 0, loaded but not displayed in a window
20 * normal: loaded and displayed in a window
21 *
22 * Instead of storing file names all over the place, each file name is
23 * stored in the buffer list. It can be referenced by a number.
24 *
25 * The current implementation remembers all file names ever used.
26 */
27
Bram Moolenaar071d4272004-06-13 20:20:40 +000028#include "vim.h"
29
Bram Moolenaar5843f5f2019-08-20 20:13:45 +020030static void enter_buffer(buf_T *buf);
31static void buflist_getfpos(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010032static char_u *buflist_match(regmatch_T *rmp, buf_T *buf, int ignore_case);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010033static char_u *fname_match(regmatch_T *rmp, char_u *name, int ignore_case);
Bram Moolenaar071d4272004-06-13 20:20:40 +000034#ifdef UNIX
Bram Moolenaar8767f522016-07-01 17:17:39 +020035static buf_T *buflist_findname_stat(char_u *ffname, stat_T *st);
36static int otherfile_buf(buf_T *buf, char_u *ffname, stat_T *stp);
37static int buf_same_ino(buf_T *buf, stat_T *stp);
Bram Moolenaar071d4272004-06-13 20:20:40 +000038#else
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010039static int otherfile_buf(buf_T *buf, char_u *ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +000040#endif
41#ifdef FEAT_TITLE
Bram Moolenaar84a93082018-06-16 22:58:15 +020042static int value_changed(char_u *str, char_u **last);
Bram Moolenaar071d4272004-06-13 20:20:40 +000043#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010044static int append_arg_number(win_T *wp, char_u *buf, int buflen, int add_file);
45static void free_buffer(buf_T *);
46static void free_buffer_stuff(buf_T *buf, int free_options);
47static void clear_wininfo(buf_T *buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +000048
49#ifdef UNIX
50# define dev_T dev_t
51#else
52# define dev_T unsigned
53#endif
54
Bram Moolenaar4033c552017-09-16 20:54:51 +020055#if defined(FEAT_QUICKFIX)
Bram Moolenaar7fd73202010-07-25 16:58:46 +020056static char *msg_loclist = N_("[Location List]");
57static char *msg_qflist = N_("[Quickfix List]");
58#endif
Bram Moolenaar42ec6562012-02-22 14:58:37 +010059static char *e_auabort = N_("E855: Autocommands caused command to abort");
Bram Moolenaar7fd73202010-07-25 16:58:46 +020060
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +020061// Number of times free_buffer() was called.
Bram Moolenaarb25f9a92016-07-10 18:21:50 +020062static int buf_free_count = 0;
63
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +020064static int top_file_num = 1; // highest file number
65static garray_T buf_reuse = GA_EMPTY; // file numbers to recycle
66
67/*
68 * Return the highest possible buffer number.
69 */
70 int
71get_highest_fnum(void)
72{
73 return top_file_num - 1;
74}
75
Bram Moolenaarc024b462019-06-08 18:07:21 +020076/*
77 * Read data from buffer for retrying.
78 */
Bram Moolenaarf71d7b92016-08-09 22:14:05 +020079 static int
80read_buffer(
81 int read_stdin, /* read file from stdin, otherwise fifo */
82 exarg_T *eap, /* for forced 'ff' and 'fenc' or NULL */
83 int flags) /* extra flags for readfile() */
84{
85 int retval = OK;
86 linenr_T line_count;
87
88 /*
89 * Read from the buffer which the text is already filled in and append at
90 * the end. This makes it possible to retry when 'fileformat' or
91 * 'fileencoding' was guessed wrong.
92 */
93 line_count = curbuf->b_ml.ml_line_count;
94 retval = readfile(
95 read_stdin ? NULL : curbuf->b_ffname,
96 read_stdin ? NULL : curbuf->b_fname,
97 (linenr_T)line_count, (linenr_T)0, (linenr_T)MAXLNUM, eap,
98 flags | READ_BUFFER);
99 if (retval == OK)
100 {
101 /* Delete the binary lines. */
102 while (--line_count >= 0)
103 ml_delete((linenr_T)1, FALSE);
104 }
105 else
106 {
107 /* Delete the converted lines. */
108 while (curbuf->b_ml.ml_line_count > line_count)
109 ml_delete(line_count, FALSE);
110 }
111 /* Put the cursor on the first line. */
112 curwin->w_cursor.lnum = 1;
113 curwin->w_cursor.col = 0;
114
115 if (read_stdin)
116 {
117 /* Set or reset 'modified' before executing autocommands, so that
118 * it can be changed there. */
Bram Moolenaarb5aedf32017-03-12 18:23:53 +0100119 if (!readonlymode && !BUFEMPTY())
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200120 changed();
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100121 else if (retval == OK)
Bram Moolenaarc024b462019-06-08 18:07:21 +0200122 unchanged(curbuf, FALSE, TRUE);
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200123
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100124 if (retval == OK)
125 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100126#ifdef FEAT_EVAL
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100127 apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE,
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100128 curbuf, &retval);
129#else
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100130 apply_autocmds(EVENT_STDINREADPOST, NULL, NULL, FALSE, curbuf);
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200131#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100132 }
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200133 }
134 return retval;
135}
136
Bram Moolenaar071d4272004-06-13 20:20:40 +0000137/*
Bram Moolenaar5b8cfed2019-06-30 22:16:10 +0200138 * Ensure buffer "buf" is loaded. Does not trigger the swap-exists action.
139 */
140 void
141buffer_ensure_loaded(buf_T *buf)
142{
143 if (buf->b_ml.ml_mfp == NULL)
144 {
145 aco_save_T aco;
146
147 aucmd_prepbuf(&aco, buf);
148 swap_exists_action = SEA_NONE;
149 open_buffer(FALSE, NULL, 0);
150 aucmd_restbuf(&aco);
151 }
152}
153
154/*
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200155 * Open current buffer, that is: open the memfile and read the file into
156 * memory.
157 * Return FAIL for failure, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000158 */
159 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100160open_buffer(
161 int read_stdin, /* read file from stdin */
162 exarg_T *eap, /* for forced 'ff' and 'fenc' or NULL */
163 int flags) /* extra flags for readfile() */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000164{
165 int retval = OK;
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200166 bufref_T old_curbuf;
Bram Moolenaar6d47df72013-02-17 15:45:37 +0100167#ifdef FEAT_SYN_HL
168 long old_tw = curbuf->b_p_tw;
169#endif
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200170 int read_fifo = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000171
172 /*
173 * The 'readonly' flag is only set when BF_NEVERLOADED is being reset.
174 * When re-entering the same buffer, it should not change, because the
175 * user may have reset the flag by hand.
176 */
177 if (readonlymode && curbuf->b_ffname != NULL
178 && (curbuf->b_flags & BF_NEVERLOADED))
179 curbuf->b_p_ro = TRUE;
180
Bram Moolenaar4770d092006-01-12 23:22:24 +0000181 if (ml_open(curbuf) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000182 {
183 /*
184 * There MUST be a memfile, otherwise we can't do anything
185 * If we can't create one for the current buffer, take another buffer
186 */
Bram Moolenaar42ec6562012-02-22 14:58:37 +0100187 close_buffer(NULL, curbuf, 0, FALSE);
Bram Moolenaar29323592016-07-24 22:04:11 +0200188 FOR_ALL_BUFFERS(curbuf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000189 if (curbuf->b_ml.ml_mfp != NULL)
190 break;
191 /*
Bram Moolenaar6f10c702019-08-20 22:58:37 +0200192 * If there is no memfile at all, exit.
Bram Moolenaare37d50a2008-08-06 17:06:04 +0000193 * This is OK, since there are no changes to lose.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000194 */
195 if (curbuf == NULL)
196 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100197 emsg(_("E82: Cannot allocate any buffer, exiting..."));
Bram Moolenaar6f10c702019-08-20 22:58:37 +0200198
199 // Don't try to do any saving, with "curbuf" NULL almost nothing
200 // will work.
201 v_dying = 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000202 getout(2);
203 }
Bram Moolenaar6f10c702019-08-20 22:58:37 +0200204
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100205 emsg(_("E83: Cannot allocate buffer, using other one..."));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000206 enter_buffer(curbuf);
Bram Moolenaar6d47df72013-02-17 15:45:37 +0100207#ifdef FEAT_SYN_HL
208 if (old_tw != curbuf->b_p_tw)
209 check_colorcolumn(curwin);
210#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000211 return FAIL;
212 }
213
Bram Moolenaar071d4272004-06-13 20:20:40 +0000214 /* The autocommands in readfile() may change the buffer, but only AFTER
215 * reading the file. */
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200216 set_bufref(&old_curbuf, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000217 modified_was_set = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000218
219 /* mark cursor position as being invalid */
Bram Moolenaar89c0ea42010-02-24 16:58:36 +0100220 curwin->w_valid = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000221
222 if (curbuf->b_ffname != NULL
223#ifdef FEAT_NETBEANS_INTG
224 && netbeansReadFile
225#endif
226 )
227 {
Bram Moolenaar426dd022016-03-15 15:09:29 +0100228 int old_msg_silent = msg_silent;
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200229#ifdef UNIX
230 int save_bin = curbuf->b_p_bin;
231 int perm;
232#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000233#ifdef FEAT_NETBEANS_INTG
234 int oldFire = netbeansFireChanges;
235
236 netbeansFireChanges = 0;
237#endif
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200238#ifdef UNIX
239 perm = mch_getperm(curbuf->b_ffname);
Bram Moolenaard569bb02018-08-11 13:57:20 +0200240 if (perm >= 0 && (S_ISFIFO(perm)
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200241 || S_ISSOCK(perm)
Bram Moolenaarf04507d2016-08-20 15:05:39 +0200242# ifdef OPEN_CHR_FILES
243 || (S_ISCHR(perm) && is_dev_fd_file(curbuf->b_ffname))
244# endif
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200245 ))
246 read_fifo = TRUE;
247 if (read_fifo)
248 curbuf->b_p_bin = TRUE;
249#endif
Bram Moolenaar426dd022016-03-15 15:09:29 +0100250 if (shortmess(SHM_FILEINFO))
251 msg_silent = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000252 retval = readfile(curbuf->b_ffname, curbuf->b_fname,
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200253 (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, eap,
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200254 flags | READ_NEW | (read_fifo ? READ_FIFO : 0));
255#ifdef UNIX
256 if (read_fifo)
257 {
258 curbuf->b_p_bin = save_bin;
259 if (retval == OK)
260 retval = read_buffer(FALSE, eap, flags);
261 }
262#endif
Bram Moolenaar426dd022016-03-15 15:09:29 +0100263 msg_silent = old_msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000264#ifdef FEAT_NETBEANS_INTG
265 netbeansFireChanges = oldFire;
266#endif
267 /* Help buffer is filtered. */
Bram Moolenaard28cc3f2017-07-27 22:03:50 +0200268 if (bt_help(curbuf))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000269 fix_help_buffer();
270 }
271 else if (read_stdin)
272 {
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200273 int save_bin = curbuf->b_p_bin;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000274
275 /*
276 * First read the text in binary mode into the buffer.
277 * Then read from that same buffer and append at the end. This makes
278 * it possible to retry when 'fileformat' or 'fileencoding' was
279 * guessed wrong.
280 */
281 curbuf->b_p_bin = TRUE;
282 retval = readfile(NULL, NULL, (linenr_T)0,
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200283 (linenr_T)0, (linenr_T)MAXLNUM, NULL,
284 flags | (READ_NEW + READ_STDIN));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000285 curbuf->b_p_bin = save_bin;
286 if (retval == OK)
Bram Moolenaarf71d7b92016-08-09 22:14:05 +0200287 retval = read_buffer(TRUE, eap, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000288 }
289
290 /* if first time loading this buffer, init b_chartab[] */
291 if (curbuf->b_flags & BF_NEVERLOADED)
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +0100292 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000293 (void)buf_init_chartab(curbuf, FALSE);
Bram Moolenaardce7c912013-11-05 17:40:52 +0100294#ifdef FEAT_CINDENT
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +0100295 parse_cino(curbuf);
Bram Moolenaardce7c912013-11-05 17:40:52 +0100296#endif
Bram Moolenaar6bcbcc52013-11-05 07:13:41 +0100297 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000298
299 /*
300 * Set/reset the Changed flag first, autocmds may change the buffer.
301 * Apply the automatic commands, before processing the modelines.
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200302 * So the modelines have priority over autocommands.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000303 */
304 /* When reading stdin, the buffer contents always needs writing, so set
305 * the changed flag. Unless in readonly mode: "ls | gview -".
306 * When interrupted and 'cpoptions' contains 'i' set changed flag. */
Bram Moolenaar512e6b82007-06-19 13:36:52 +0000307 if ((got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000308 || modified_was_set /* ":set modified" used in autocmd */
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100309#ifdef FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310 || (aborting() && vim_strchr(p_cpo, CPO_INTMOD) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000311#endif
Bram Moolenaar512e6b82007-06-19 13:36:52 +0000312 )
Bram Moolenaar071d4272004-06-13 20:20:40 +0000313 changed();
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100314 else if (retval == OK && !read_stdin && !read_fifo)
Bram Moolenaarc024b462019-06-08 18:07:21 +0200315 unchanged(curbuf, FALSE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000316 save_file_ff(curbuf); /* keep this fileformat */
317
Bram Moolenaar8c64a362018-03-23 22:39:31 +0100318 /* Set last_changedtick to avoid triggering a TextChanged autocommand right
319 * after it was added. */
320 curbuf->b_last_changedtick = CHANGEDTICK(curbuf);
Bram Moolenaar8c64a362018-03-23 22:39:31 +0100321 curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf);
Bram Moolenaar8c64a362018-03-23 22:39:31 +0100322
Bram Moolenaar071d4272004-06-13 20:20:40 +0000323 /* require "!" to overwrite the file, because it wasn't read completely */
324#ifdef FEAT_EVAL
325 if (aborting())
326#else
327 if (got_int)
328#endif
329 curbuf->b_flags |= BF_READERR;
330
Bram Moolenaar5eb86f92004-07-26 12:53:41 +0000331#ifdef FEAT_FOLDING
332 /* Need to update automatic folding. Do this before the autocommands,
333 * they may use the fold info. */
334 foldUpdateAll(curwin);
335#endif
336
Bram Moolenaar071d4272004-06-13 20:20:40 +0000337 /* need to set w_topline, unless some autocommand already did that. */
338 if (!(curwin->w_valid & VALID_TOPLINE))
339 {
340 curwin->w_topline = 1;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100341#ifdef FEAT_DIFF
Bram Moolenaar071d4272004-06-13 20:20:40 +0000342 curwin->w_topfill = 0;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100343#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000344 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100345#ifdef FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000346 apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf, &retval);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100347#else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000348 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000349#endif
350
Bram Moolenaare13b9af2017-01-13 22:01:02 +0100351 if (retval == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000352 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000353 /*
354 * The autocommands may have changed the current buffer. Apply the
355 * modelines to the correct buffer, if it still exists and is loaded.
356 */
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200357 if (bufref_valid(&old_curbuf) && old_curbuf.br_buf->b_ml.ml_mfp != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000358 {
359 aco_save_T aco;
360
361 /* Go to the buffer that was opened. */
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +0200362 aucmd_prepbuf(&aco, old_curbuf.br_buf);
Bram Moolenaara3227e22006-03-08 21:32:40 +0000363 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000364 curbuf->b_flags &= ~(BF_CHECK_RO | BF_NEVERLOADED);
365
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100366#ifdef FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000367 apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf,
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100368 &retval);
369#else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000370 apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100371#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000372
373 /* restore curwin/curbuf and a few other things */
374 aucmd_restbuf(&aco);
375 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000376 }
377
Bram Moolenaar071d4272004-06-13 20:20:40 +0000378 return retval;
379}
380
381/*
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200382 * Store "buf" in "bufref" and set the free count.
383 */
384 void
385set_bufref(bufref_T *bufref, buf_T *buf)
386{
387 bufref->br_buf = buf;
Bram Moolenaarfadacf02017-06-19 20:35:32 +0200388 bufref->br_fnum = buf == NULL ? 0 : buf->b_fnum;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200389 bufref->br_buf_free_count = buf_free_count;
390}
391
392/*
Bram Moolenaar45e5fd12017-06-04 14:58:02 +0200393 * Return TRUE if "bufref->br_buf" points to the same buffer as when
394 * set_bufref() was called and it is a valid buffer.
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200395 * Only goes through the buffer list if buf_free_count changed.
Bram Moolenaar45e5fd12017-06-04 14:58:02 +0200396 * Also checks if b_fnum is still the same, a :bwipe followed by :new might get
397 * the same allocated memory, but it's a different buffer.
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200398 */
399 int
400bufref_valid(bufref_T *bufref)
401{
402 return bufref->br_buf_free_count == buf_free_count
Bram Moolenaar45e5fd12017-06-04 14:58:02 +0200403 ? TRUE : buf_valid(bufref->br_buf)
404 && bufref->br_fnum == bufref->br_buf->b_fnum;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200405}
406
407/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000408 * Return TRUE if "buf" points to a valid buffer (in the buffer list).
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200409 * This can be slow if there are many buffers, prefer using bufref_valid().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000410 */
411 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100412buf_valid(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000413{
414 buf_T *bp;
415
Bram Moolenaar82404332016-07-10 17:00:38 +0200416 /* Assume that we more often have a recent buffer, start with the last
417 * one. */
418 for (bp = lastbuf; bp != NULL; bp = bp->b_prev)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000419 if (bp == buf)
420 return TRUE;
421 return FALSE;
422}
423
424/*
Bram Moolenaar480778b2016-07-14 22:09:39 +0200425 * A hash table used to quickly lookup a buffer by its number.
426 */
427static hashtab_T buf_hashtab;
428
429 static void
430buf_hashtab_add(buf_T *buf)
431{
432 sprintf((char *)buf->b_key, "%x", buf->b_fnum);
433 if (hash_add(&buf_hashtab, buf->b_key) == FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100434 emsg(_("E931: Buffer cannot be registered"));
Bram Moolenaar480778b2016-07-14 22:09:39 +0200435}
436
437 static void
438buf_hashtab_remove(buf_T *buf)
439{
440 hashitem_T *hi = hash_find(&buf_hashtab, buf->b_key);
441
442 if (!HASHITEM_EMPTY(hi))
443 hash_remove(&buf_hashtab, hi);
444}
445
Bram Moolenaar94f01952018-09-01 15:30:03 +0200446/*
447 * Return TRUE when buffer "buf" can be unloaded.
448 * Give an error message and return FALSE when the buffer is locked or the
449 * screen is being redrawn and the buffer is in a window.
450 */
451 static int
452can_unload_buffer(buf_T *buf)
453{
454 int can_unload = !buf->b_locked;
455
456 if (can_unload && updating_screen)
457 {
458 win_T *wp;
459
460 FOR_ALL_WINDOWS(wp)
461 if (wp->w_buffer == buf)
Bram Moolenaar9cea87c2018-09-21 16:59:45 +0200462 {
Bram Moolenaar94f01952018-09-01 15:30:03 +0200463 can_unload = FALSE;
Bram Moolenaar9cea87c2018-09-21 16:59:45 +0200464 break;
465 }
Bram Moolenaar94f01952018-09-01 15:30:03 +0200466 }
467 if (!can_unload)
Bram Moolenaardefa0672019-07-21 19:25:37 +0200468 semsg(_("E937: Attempt to delete a buffer that is in use: %s"),
469 buf->b_fname);
Bram Moolenaar94f01952018-09-01 15:30:03 +0200470 return can_unload;
471}
Bram Moolenaara997b452018-04-17 23:24:06 +0200472
Bram Moolenaar480778b2016-07-14 22:09:39 +0200473/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000474 * Close the link to a buffer.
475 * "action" is used when there is no longer a window for the buffer.
476 * It can be:
477 * 0 buffer becomes hidden
478 * DOBUF_UNLOAD buffer is unloaded
479 * DOBUF_DELETE buffer is unloaded and removed from buffer list
480 * DOBUF_WIPE buffer is unloaded and really deleted
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +0200481 * DOBUF_WIPE_REUSE idem, and add to buf_reuse list
Bram Moolenaar071d4272004-06-13 20:20:40 +0000482 * When doing all but the first one on the current buffer, the caller should
483 * get a new buffer very soon!
484 *
485 * The 'bufhidden' option can force freeing and deleting.
Bram Moolenaar42ec6562012-02-22 14:58:37 +0100486 *
487 * When "abort_if_last" is TRUE then do not close the buffer if autocommands
488 * cause there to be only one window with this buffer. e.g. when ":quit" is
489 * supposed to close the window but autocommands close all other windows.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000490 */
491 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100492close_buffer(
493 win_T *win, /* if not NULL, set b_last_cursor */
494 buf_T *buf,
495 int action,
Bram Moolenaar4d784b22019-05-25 19:51:39 +0200496 int abort_if_last)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000497{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000498 int is_curbuf;
Bram Moolenaar2660c0e2010-01-19 14:59:56 +0100499 int nwindows;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200500 bufref_T bufref;
Bram Moolenaar3a117e12016-10-30 21:57:52 +0100501 int is_curwin = (curwin != NULL && curwin->w_buffer == buf);
Bram Moolenaarf9e687e2016-09-04 21:33:09 +0200502 win_T *the_curwin = curwin;
503 tabpage_T *the_curtab = curtab;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000504 int unload_buf = (action != 0);
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +0200505 int wipe_buf = (action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE);
506 int del_buf = (action == DOBUF_DEL || wipe_buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000507
Bram Moolenaar8adb0d02017-09-17 19:08:02 +0200508 /*
509 * Force unloading or deleting when 'bufhidden' says so.
510 * The caller must take care of NOT deleting/freeing when 'bufhidden' is
511 * "hide" (otherwise we could never free or delete a buffer).
512 */
513 if (buf->b_p_bh[0] == 'd') /* 'bufhidden' == "delete" */
514 {
515 del_buf = TRUE;
516 unload_buf = TRUE;
517 }
518 else if (buf->b_p_bh[0] == 'w') /* 'bufhidden' == "wipe" */
519 {
520 del_buf = TRUE;
521 unload_buf = TRUE;
522 wipe_buf = TRUE;
523 }
524 else if (buf->b_p_bh[0] == 'u') /* 'bufhidden' == "unload" */
525 unload_buf = TRUE;
526
Bram Moolenaar94053a52017-08-01 21:44:33 +0200527#ifdef FEAT_TERMINAL
Bram Moolenaar8adb0d02017-09-17 19:08:02 +0200528 if (bt_terminal(buf) && (buf->b_nwindows == 1 || del_buf))
Bram Moolenaar94053a52017-08-01 21:44:33 +0200529 {
530 if (term_job_running(buf->b_term))
531 {
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +0200532 if (wipe_buf || unload_buf)
Bram Moolenaara997b452018-04-17 23:24:06 +0200533 {
Bram Moolenaar94f01952018-09-01 15:30:03 +0200534 if (!can_unload_buffer(buf))
Bram Moolenaara997b452018-04-17 23:24:06 +0200535 return;
Bram Moolenaar94f01952018-09-01 15:30:03 +0200536
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +0200537 /* Wiping out or unloading a terminal buffer kills the job. */
Bram Moolenaar94053a52017-08-01 21:44:33 +0200538 free_terminal(buf);
Bram Moolenaara997b452018-04-17 23:24:06 +0200539 }
Bram Moolenaar94053a52017-08-01 21:44:33 +0200540 else
541 {
542 /* The job keeps running, hide the buffer. */
543 del_buf = FALSE;
544 unload_buf = FALSE;
545 }
546 }
547 else
548 {
549 /* A terminal buffer is wiped out if the job has finished. */
550 del_buf = TRUE;
551 unload_buf = TRUE;
552 wipe_buf = TRUE;
553 }
554 }
Bram Moolenaar94053a52017-08-01 21:44:33 +0200555#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000556
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200557 /* Disallow deleting the buffer when it is locked (already being closed or
558 * halfway a command that relies on it). Unloading is allowed. */
Bram Moolenaar94f01952018-09-01 15:30:03 +0200559 if ((del_buf || wipe_buf) && !can_unload_buffer(buf))
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200560 return;
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200561
Bram Moolenaar4033c552017-09-16 20:54:51 +0200562 /* check no autocommands closed the window */
563 if (win != NULL && win_valid_any_tab(win))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000564 {
565 /* Set b_last_cursor when closing the last window for the buffer.
566 * Remember the last cursor position and window options of the buffer.
567 * This used to be only for the current window, but then options like
568 * 'foldmethod' may be lost with a ":only" command. */
569 if (buf->b_nwindows == 1)
570 set_last_cursor(win);
571 buflist_setfpos(buf, win,
572 win->w_cursor.lnum == 1 ? 0 : win->w_cursor.lnum,
573 win->w_cursor.col, TRUE);
574 }
575
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200576 set_bufref(&bufref, buf);
577
Bram Moolenaar071d4272004-06-13 20:20:40 +0000578 /* When the buffer is no longer in a window, trigger BufWinLeave */
579 if (buf->b_nwindows == 1)
580 {
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200581 ++buf->b_locked;
Bram Moolenaar82404332016-07-10 17:00:38 +0200582 if (apply_autocmds(EVENT_BUFWINLEAVE, buf->b_fname, buf->b_fname,
583 FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200584 && !bufref_valid(&bufref))
Bram Moolenaar42ec6562012-02-22 14:58:37 +0100585 {
Bram Moolenaar362ce482012-06-06 19:02:45 +0200586 /* Autocommands deleted the buffer. */
587aucmd_abort:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100588 emsg(_(e_auabort));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000589 return;
Bram Moolenaar42ec6562012-02-22 14:58:37 +0100590 }
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200591 --buf->b_locked;
Bram Moolenaar362ce482012-06-06 19:02:45 +0200592 if (abort_if_last && one_window())
593 /* Autocommands made this the only window. */
594 goto aucmd_abort;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000595
596 /* When the buffer becomes hidden, but is not unloaded, trigger
597 * BufHidden */
598 if (!unload_buf)
599 {
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200600 ++buf->b_locked;
Bram Moolenaar82404332016-07-10 17:00:38 +0200601 if (apply_autocmds(EVENT_BUFHIDDEN, buf->b_fname, buf->b_fname,
602 FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200603 && !bufref_valid(&bufref))
Bram Moolenaar362ce482012-06-06 19:02:45 +0200604 /* Autocommands deleted the buffer. */
605 goto aucmd_abort;
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200606 --buf->b_locked;
Bram Moolenaar362ce482012-06-06 19:02:45 +0200607 if (abort_if_last && one_window())
608 /* Autocommands made this the only window. */
609 goto aucmd_abort;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000610 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100611#ifdef FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612 if (aborting()) /* autocmds may abort script processing */
613 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100614#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000615 }
Bram Moolenaarf9e687e2016-09-04 21:33:09 +0200616
Bram Moolenaarf9e687e2016-09-04 21:33:09 +0200617 /* If the buffer was in curwin and the window has changed, go back to that
618 * window, if it still exists. This avoids that ":edit x" triggering a
619 * "tabnext" BufUnload autocmd leaves a window behind without a buffer. */
620 if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin))
621 {
622 block_autocmds();
623 goto_tabpage_win(the_curtab, the_curwin);
624 unblock_autocmds();
625 }
Bram Moolenaarf9e687e2016-09-04 21:33:09 +0200626
Bram Moolenaar071d4272004-06-13 20:20:40 +0000627 nwindows = buf->b_nwindows;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000628
629 /* decrease the link count from windows (unless not in any window) */
630 if (buf->b_nwindows > 0)
631 --buf->b_nwindows;
632
Bram Moolenaar97ce4192017-12-01 20:35:58 +0100633#ifdef FEAT_DIFF
634 if (diffopt_hiddenoff() && !unload_buf && buf->b_nwindows == 0)
Bram Moolenaarb7407d32018-02-03 17:36:27 +0100635 diff_buf_delete(buf); /* Clear 'diff' for hidden buffer. */
Bram Moolenaar97ce4192017-12-01 20:35:58 +0100636#endif
637
Bram Moolenaar071d4272004-06-13 20:20:40 +0000638 /* Return when a window is displaying the buffer or when it's not
639 * unloaded. */
640 if (buf->b_nwindows > 0 || !unload_buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000641 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000642
643 /* Always remove the buffer when there is no file name. */
644 if (buf->b_ffname == NULL)
645 del_buf = TRUE;
646
Bram Moolenaarc4a908e2016-09-08 23:35:30 +0200647 /* When closing the current buffer stop Visual mode before freeing
648 * anything. */
Bram Moolenaar4930a762016-09-11 14:39:53 +0200649 if (buf == curbuf && VIsual_active
Bram Moolenaar9a27c7f2016-09-09 12:57:09 +0200650#if defined(EXITFREE)
651 && !entered_free_all_mem
652#endif
653 )
Bram Moolenaarc4a908e2016-09-08 23:35:30 +0200654 end_visual_mode();
655
Bram Moolenaar071d4272004-06-13 20:20:40 +0000656 /*
657 * Free all things allocated for this buffer.
658 * Also calls the "BufDelete" autocommands when del_buf is TRUE.
659 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000660 /* Remember if we are closing the current buffer. Restore the number of
661 * windows, so that autocommands in buf_freeall() don't get confused. */
662 is_curbuf = (buf == curbuf);
663 buf->b_nwindows = nwindows;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000664
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200665 buf_freeall(buf, (del_buf ? BFA_DEL : 0) + (wipe_buf ? BFA_WIPE : 0));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000666
Bram Moolenaar071d4272004-06-13 20:20:40 +0000667 /* Autocommands may have deleted the buffer. */
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200668 if (!bufref_valid(&bufref))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000669 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100670#ifdef FEAT_EVAL
Bram Moolenaar5eb86f92004-07-26 12:53:41 +0000671 if (aborting()) /* autocmds may abort script processing */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000672 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100673#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000674
Bram Moolenaar071d4272004-06-13 20:20:40 +0000675 /*
676 * It's possible that autocommands change curbuf to the one being deleted.
677 * This might cause the previous curbuf to be deleted unexpectedly. But
678 * in some cases it's OK to delete the curbuf, because a new one is
679 * obtained anyway. Therefore only return if curbuf changed to the
680 * deleted buffer.
681 */
682 if (buf == curbuf && !is_curbuf)
683 return;
Bram Moolenaar30445cb2016-07-09 15:21:02 +0200684
Bram Moolenaar4033c552017-09-16 20:54:51 +0200685 if (win_valid_any_tab(win) && win->w_buffer == buf)
Bram Moolenaar30445cb2016-07-09 15:21:02 +0200686 win->w_buffer = NULL; /* make sure we don't use the buffer now */
687
688 /* Autocommands may have opened or closed windows for this buffer.
689 * Decrement the count for the close we do here. */
690 if (buf->b_nwindows > 0)
691 --buf->b_nwindows;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000692
Bram Moolenaar071d4272004-06-13 20:20:40 +0000693 /*
694 * Remove the buffer from the list.
695 */
696 if (wipe_buf)
697 {
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +0200698 if (action == DOBUF_WIPE_REUSE)
699 {
700 // we can re-use this buffer number, store it
701 if (buf_reuse.ga_itemsize == 0)
702 ga_init2(&buf_reuse, sizeof(int), 50);
703 if (ga_grow(&buf_reuse, 1) == OK)
704 ((int *)buf_reuse.ga_data)[buf_reuse.ga_len++] = buf->b_fnum;
705 }
Bram Moolenaar3d6014f2018-10-11 19:27:47 +0200706 if (buf->b_sfname != buf->b_ffname)
707 VIM_CLEAR(buf->b_sfname);
708 else
709 buf->b_sfname = NULL;
710 VIM_CLEAR(buf->b_ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000711 if (buf->b_prev == NULL)
712 firstbuf = buf->b_next;
713 else
714 buf->b_prev->b_next = buf->b_next;
715 if (buf->b_next == NULL)
716 lastbuf = buf->b_prev;
717 else
718 buf->b_next->b_prev = buf->b_prev;
719 free_buffer(buf);
720 }
721 else
722 {
723 if (del_buf)
724 {
725 /* Free all internal variables and reset option values, to make
726 * ":bdel" compatible with Vim 5.7. */
727 free_buffer_stuff(buf, TRUE);
728
729 /* Make it look like a new buffer. */
730 buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED;
731
732 /* Init the options when loaded again. */
733 buf->b_p_initialized = FALSE;
734 }
735 buf_clear_file(buf);
736 if (del_buf)
737 buf->b_p_bl = FALSE;
738 }
739}
740
741/*
742 * Make buffer not contain a file.
743 */
744 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100745buf_clear_file(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000746{
747 buf->b_ml.ml_line_count = 1;
Bram Moolenaarc024b462019-06-08 18:07:21 +0200748 unchanged(buf, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000749 buf->b_shortname = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000750 buf->b_p_eol = TRUE;
751 buf->b_start_eol = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000752 buf->b_p_bomb = FALSE;
Bram Moolenaar83eb8852007-08-12 13:51:26 +0000753 buf->b_start_bomb = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000754 buf->b_ml.ml_mfp = NULL;
755 buf->b_ml.ml_flags = ML_EMPTY; /* empty buffer */
756#ifdef FEAT_NETBEANS_INTG
757 netbeans_deleted_all_lines(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000758#endif
759}
760
761/*
762 * buf_freeall() - free all things allocated for a buffer that are related to
Bram Moolenaar5a497892016-09-03 16:29:04 +0200763 * the file. Careful: get here with "curwin" NULL when exiting.
764 * flags:
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200765 * BFA_DEL buffer is going to be deleted
766 * BFA_WIPE buffer is going to be wiped out
767 * BFA_KEEP_UNDO do not free undo information
Bram Moolenaar071d4272004-06-13 20:20:40 +0000768 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000769 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100770buf_freeall(buf_T *buf, int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000771{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000772 int is_curbuf = (buf == curbuf);
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200773 bufref_T bufref;
Bram Moolenaar030cddc2016-09-04 23:41:42 +0200774 int is_curwin = (curwin != NULL && curwin->w_buffer == buf);
Bram Moolenaar5a497892016-09-03 16:29:04 +0200775 win_T *the_curwin = curwin;
776 tabpage_T *the_curtab = curtab;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000777
Bram Moolenaar5a497892016-09-03 16:29:04 +0200778 /* Make sure the buffer isn't closed by autocommands. */
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200779 ++buf->b_locked;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200780 set_bufref(&bufref, buf);
Bram Moolenaarc67e8922016-05-24 16:07:40 +0200781 if (buf->b_ml.ml_mfp != NULL)
782 {
Bram Moolenaar82404332016-07-10 17:00:38 +0200783 if (apply_autocmds(EVENT_BUFUNLOAD, buf->b_fname, buf->b_fname,
784 FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200785 && !bufref_valid(&bufref))
786 /* autocommands deleted the buffer */
Bram Moolenaarc67e8922016-05-24 16:07:40 +0200787 return;
788 }
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200789 if ((flags & BFA_DEL) && buf->b_p_bl)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000790 {
Bram Moolenaar82404332016-07-10 17:00:38 +0200791 if (apply_autocmds(EVENT_BUFDELETE, buf->b_fname, buf->b_fname,
792 FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200793 && !bufref_valid(&bufref))
794 /* autocommands deleted the buffer */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000795 return;
796 }
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200797 if (flags & BFA_WIPE)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000798 {
Bram Moolenaar82404332016-07-10 17:00:38 +0200799 if (apply_autocmds(EVENT_BUFWIPEOUT, buf->b_fname, buf->b_fname,
800 FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200801 && !bufref_valid(&bufref))
802 /* autocommands deleted the buffer */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000803 return;
804 }
Bram Moolenaare0ab94e2016-09-04 19:50:54 +0200805 --buf->b_locked;
Bram Moolenaar5a497892016-09-03 16:29:04 +0200806
Bram Moolenaar5a497892016-09-03 16:29:04 +0200807 /* If the buffer was in curwin and the window has changed, go back to that
808 * window, if it still exists. This avoids that ":edit x" triggering a
809 * "tabnext" BufUnload autocmd leaves a window behind without a buffer. */
810 if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin))
811 {
812 block_autocmds();
813 goto_tabpage_win(the_curtab, the_curwin);
814 unblock_autocmds();
815 }
Bram Moolenaar5a497892016-09-03 16:29:04 +0200816
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100817#ifdef FEAT_EVAL
Bram Moolenaar293ee4d2004-12-09 21:34:53 +0000818 if (aborting()) /* autocmds may abort script processing */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000819 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +0100820#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000821
822 /*
823 * It's possible that autocommands change curbuf to the one being deleted.
824 * This might cause curbuf to be deleted unexpectedly. But in some cases
825 * it's OK to delete the curbuf, because a new one is obtained anyway.
826 * Therefore only return if curbuf changed to the deleted buffer.
827 */
828 if (buf == curbuf && !is_curbuf)
829 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000830#ifdef FEAT_DIFF
831 diff_buf_delete(buf); /* Can't use 'diff' for unloaded buffer. */
832#endif
Bram Moolenaara971b822011-09-14 14:43:25 +0200833#ifdef FEAT_SYN_HL
Bram Moolenaar89c71222011-11-30 15:40:56 +0100834 /* Remove any ownsyntax, unless exiting. */
Bram Moolenaar030cddc2016-09-04 23:41:42 +0200835 if (curwin != NULL && curwin->w_buffer == buf)
Bram Moolenaar89c71222011-11-30 15:40:56 +0100836 reset_synblock(curwin);
Bram Moolenaara971b822011-09-14 14:43:25 +0200837#endif
Bram Moolenaarb6799ac2007-05-10 16:44:05 +0000838
839#ifdef FEAT_FOLDING
840 /* No folds in an empty buffer. */
Bram Moolenaarb6799ac2007-05-10 16:44:05 +0000841 {
842 win_T *win;
843 tabpage_T *tp;
844
845 FOR_ALL_TAB_WINDOWS(tp, win)
846 if (win->w_buffer == buf)
847 clearFolding(win);
848 }
Bram Moolenaarb6799ac2007-05-10 16:44:05 +0000849#endif
850
Bram Moolenaar071d4272004-06-13 20:20:40 +0000851#ifdef FEAT_TCL
852 tcl_buffer_free(buf);
853#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000854 ml_close(buf, TRUE); /* close and delete the memline/memfile */
855 buf->b_ml.ml_line_count = 0; /* no lines in buffer */
Bram Moolenaar59f931e2010-07-24 20:27:03 +0200856 if ((flags & BFA_KEEP_UNDO) == 0)
857 {
858 u_blockfree(buf); /* free the memory allocated for undo */
859 u_clearall(buf); /* reset all undo information */
860 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000861#ifdef FEAT_SYN_HL
Bram Moolenaar860cae12010-06-05 23:22:07 +0200862 syntax_clear(&buf->b_s); /* reset syntax info */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000863#endif
Bram Moolenaar98aefe72018-12-13 22:20:09 +0100864#ifdef FEAT_TEXT_PROP
865 clear_buf_prop_types(buf);
866#endif
Bram Moolenaarc0197e22004-09-13 20:26:32 +0000867 buf->b_flags &= ~BF_READERR; /* a read error is no longer relevant */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000868}
869
870/*
871 * Free a buffer structure and the things it contains related to the buffer
872 * itself (not the file, that must have been done already).
873 */
874 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100875free_buffer(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000876{
Bram Moolenaarb25f9a92016-07-10 18:21:50 +0200877 ++buf_free_count;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000878 free_buffer_stuff(buf, TRUE);
Bram Moolenaar429fa852013-04-15 12:27:36 +0200879#ifdef FEAT_EVAL
Bram Moolenaarb2c87502017-10-14 21:15:58 +0200880 /* b:changedtick uses an item in buf_T, remove it now */
881 dictitem_remove(buf->b_vars, (dictitem_T *)&buf->b_ct_di);
Bram Moolenaar429fa852013-04-15 12:27:36 +0200882 unref_var_dict(buf->b_vars);
Bram Moolenaar86173482019-10-01 17:02:16 +0200883 remove_listeners(buf);
Bram Moolenaar429fa852013-04-15 12:27:36 +0200884#endif
Bram Moolenaar0ba04292010-07-14 23:23:17 +0200885#ifdef FEAT_LUA
886 lua_buffer_free(buf);
887#endif
Bram Moolenaar325b7a22004-07-05 15:58:32 +0000888#ifdef FEAT_MZSCHEME
889 mzscheme_buffer_free(buf);
890#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000891#ifdef FEAT_PERL
892 perl_buf_free(buf);
893#endif
894#ifdef FEAT_PYTHON
895 python_buffer_free(buf);
896#endif
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200897#ifdef FEAT_PYTHON3
898 python3_buffer_free(buf);
899#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000900#ifdef FEAT_RUBY
901 ruby_buffer_free(buf);
902#endif
Bram Moolenaare0f76d02016-05-09 20:38:53 +0200903#ifdef FEAT_JOB_CHANNEL
904 channel_buffer_free(buf);
905#endif
Bram Moolenaar96ca27a2017-07-17 23:20:24 +0200906#ifdef FEAT_TERMINAL
Bram Moolenaard85f2712017-07-28 21:51:57 +0200907 free_terminal(buf);
Bram Moolenaar96ca27a2017-07-17 23:20:24 +0200908#endif
Bram Moolenaarf2732452018-06-03 14:47:35 +0200909#ifdef FEAT_JOB_CHANNEL
910 vim_free(buf->b_prompt_text);
Bram Moolenaar3a97bb32019-06-01 13:28:35 +0200911 free_callback(&buf->b_prompt_callback);
Bram Moolenaar86173482019-10-01 17:02:16 +0200912 free_callback(&buf->b_prompt_interrupt);
Bram Moolenaarf2732452018-06-03 14:47:35 +0200913#endif
Bram Moolenaar480778b2016-07-14 22:09:39 +0200914
915 buf_hashtab_remove(buf);
916
Bram Moolenaar9280e3f2016-07-14 23:03:19 +0200917 aubuflocal_remove(buf);
918
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +0200919 if (autocmd_busy)
920 {
921 /* Do not free the buffer structure while autocommands are executing,
922 * it's still needed. Free it when autocmd_busy is reset. */
923 buf->b_next = au_pending_free_buf;
924 au_pending_free_buf = buf;
925 }
926 else
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +0200927 vim_free(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928}
929
930/*
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100931 * Initializes b:changedtick.
Bram Moolenaar79518e22017-02-17 16:31:35 +0100932 */
933 static void
934init_changedtick(buf_T *buf)
935{
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100936 dictitem_T *di = (dictitem_T *)&buf->b_ct_di;
Bram Moolenaar79518e22017-02-17 16:31:35 +0100937
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100938 di->di_flags = DI_FLAGS_FIX | DI_FLAGS_RO;
939 di->di_tv.v_type = VAR_NUMBER;
940 di->di_tv.v_lock = VAR_FIXED;
941 di->di_tv.vval.v_number = 0;
942
Bram Moolenaar92769c32017-02-25 15:41:37 +0100943#ifdef FEAT_EVAL
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100944 STRCPY(buf->b_ct_di.di_key, "changedtick");
945 (void)dict_add(buf->b_vars, di);
Bram Moolenaar92769c32017-02-25 15:41:37 +0100946#endif
Bram Moolenaar79518e22017-02-17 16:31:35 +0100947}
948
949/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000950 * Free stuff in the buffer for ":bdel" and when wiping out the buffer.
951 */
952 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100953free_buffer_stuff(
954 buf_T *buf,
955 int free_options) /* free options as well */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000956{
957 if (free_options)
958 {
959 clear_wininfo(buf); /* including window-local options */
960 free_buf_options(buf, TRUE);
Bram Moolenaarbeca0552010-10-27 16:18:00 +0200961#ifdef FEAT_SPELL
962 ga_clear(&buf->b_s.b_langp);
963#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000964 }
965#ifdef FEAT_EVAL
Bram Moolenaar79518e22017-02-17 16:31:35 +0100966 {
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100967 varnumber_T tick = CHANGEDTICK(buf);
Bram Moolenaar79518e22017-02-17 16:31:35 +0100968
969 vars_clear(&buf->b_vars->dv_hashtab); /* free all buffer variables */
970 hash_init(&buf->b_vars->dv_hashtab);
971 init_changedtick(buf);
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100972 CHANGEDTICK(buf) = tick;
Bram Moolenaar79518e22017-02-17 16:31:35 +0100973 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000974#endif
Bram Moolenaarac9fb182019-04-27 13:04:13 +0200975 uc_clear(&buf->b_ucmds); // clear local user commands
Bram Moolenaar071d4272004-06-13 20:20:40 +0000976#ifdef FEAT_SIGNS
Bram Moolenaarac9fb182019-04-27 13:04:13 +0200977 buf_delete_signs(buf, (char_u *)"*"); // delete any signs
Bram Moolenaar071d4272004-06-13 20:20:40 +0000978#endif
Bram Moolenaard7f8f5c2009-01-06 15:14:30 +0000979#ifdef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +0200980 netbeans_file_killed(buf);
Bram Moolenaard7f8f5c2009-01-06 15:14:30 +0000981#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000982 map_clear_int(buf, MAP_ALL_MODES, TRUE, FALSE); /* clear local mappings */
983 map_clear_int(buf, MAP_ALL_MODES, TRUE, TRUE); /* clear local abbrevs */
Bram Moolenaard23a8232018-02-10 18:45:26 +0100984 VIM_CLEAR(buf->b_start_fenc);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000985}
986
987/*
988 * Free the b_wininfo list for buffer "buf".
989 */
990 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100991clear_wininfo(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000992{
993 wininfo_T *wip;
994
995 while (buf->b_wininfo != NULL)
996 {
997 wip = buf->b_wininfo;
998 buf->b_wininfo = wip->wi_next;
999 if (wip->wi_optset)
1000 {
1001 clear_winopt(&wip->wi_opt);
1002#ifdef FEAT_FOLDING
1003 deleteFoldRecurse(&wip->wi_folds);
1004#endif
1005 }
1006 vim_free(wip);
1007 }
1008}
1009
Bram Moolenaar071d4272004-06-13 20:20:40 +00001010/*
1011 * Go to another buffer. Handles the result of the ATTENTION dialog.
1012 */
1013 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001014goto_buffer(
1015 exarg_T *eap,
1016 int start,
1017 int dir,
1018 int count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001019{
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001020 bufref_T old_curbuf;
1021
1022 set_bufref(&old_curbuf, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001023
1024 swap_exists_action = SEA_DIALOG;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001025 (void)do_buffer(*eap->cmd == 's' ? DOBUF_SPLIT : DOBUF_GOTO,
1026 start, dir, count, eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001027 if (swap_exists_action == SEA_QUIT && *eap->cmd == 's')
1028 {
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001029#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001030 cleanup_T cs;
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00001031
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001032 /* Reset the error/interrupt/exception state here so that
1033 * aborting() returns FALSE when closing a window. */
1034 enter_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001035#endif
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00001036
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001037 /* Quitting means closing the split window, nothing else. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001038 win_close(curwin, TRUE);
1039 swap_exists_action = SEA_NONE;
Bram Moolenaar12033fb2005-12-16 21:49:31 +00001040 swap_exists_did_quit = TRUE;
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001041
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001042#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001043 /* Restore the error/interrupt/exception state if not discarded by a
1044 * new aborting error, interrupt, or uncaught exception. */
1045 leave_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001046#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001047 }
1048 else
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001049 handle_swap_exists(&old_curbuf);
Bram Moolenaar0c72fe42018-03-29 16:04:08 +02001050}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001051
Bram Moolenaar071d4272004-06-13 20:20:40 +00001052/*
1053 * Handle the situation of swap_exists_action being set.
1054 * It is allowed for "old_curbuf" to be NULL or invalid.
1055 */
1056 void
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001057handle_swap_exists(bufref_T *old_curbuf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001058{
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001059#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001060 cleanup_T cs;
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001061#endif
1062#ifdef FEAT_SYN_HL
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001063 long old_tw = curbuf->b_p_tw;
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001064#endif
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001065 buf_T *buf;
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00001066
Bram Moolenaar071d4272004-06-13 20:20:40 +00001067 if (swap_exists_action == SEA_QUIT)
1068 {
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001069#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001070 /* Reset the error/interrupt/exception state here so that
1071 * aborting() returns FALSE when closing a buffer. */
1072 enter_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001073#endif
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001074
Bram Moolenaar071d4272004-06-13 20:20:40 +00001075 /* User selected Quit at ATTENTION prompt. Go back to previous
1076 * buffer. If that buffer is gone or the same as the current one,
1077 * open a new, empty buffer. */
1078 swap_exists_action = SEA_NONE; /* don't want it again */
Bram Moolenaar12033fb2005-12-16 21:49:31 +00001079 swap_exists_did_quit = TRUE;
Bram Moolenaar42ec6562012-02-22 14:58:37 +01001080 close_buffer(curwin, curbuf, DOBUF_UNLOAD, FALSE);
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001081 if (old_curbuf == NULL || !bufref_valid(old_curbuf)
1082 || old_curbuf->br_buf == curbuf)
1083 buf = buflist_new(NULL, NULL, 1L, BLN_CURBUF | BLN_LISTED);
1084 else
1085 buf = old_curbuf->br_buf;
1086 if (buf != NULL)
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001087 {
Bram Moolenaar2f0f8712018-08-21 18:50:18 +02001088 int old_msg_silent = msg_silent;
1089
1090 if (shortmess(SHM_FILEINFO))
1091 msg_silent = 1; // prevent fileinfo message
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02001092 enter_buffer(buf);
Bram Moolenaar2f0f8712018-08-21 18:50:18 +02001093 // restore msg_silent, so that the command line will be shown
1094 msg_silent = old_msg_silent;
1095
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001096#ifdef FEAT_SYN_HL
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001097 if (old_tw != curbuf->b_p_tw)
1098 check_colorcolumn(curwin);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001099#endif
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001100 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001101 /* If "old_curbuf" is NULL we are in big trouble here... */
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001102
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001103#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001104 /* Restore the error/interrupt/exception state if not discarded by a
1105 * new aborting error, interrupt, or uncaught exception. */
1106 leave_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001107#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001108 }
1109 else if (swap_exists_action == SEA_RECOVER)
1110 {
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001111#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001112 /* Reset the error/interrupt/exception state here so that
1113 * aborting() returns FALSE when closing a buffer. */
1114 enter_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001115#endif
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001116
Bram Moolenaar071d4272004-06-13 20:20:40 +00001117 /* User selected Recover at ATTENTION prompt. */
1118 msg_scroll = TRUE;
Bram Moolenaar99499b12019-05-23 21:35:48 +02001119 ml_recover(FALSE);
Bram Moolenaar32526b32019-01-19 17:43:09 +01001120 msg_puts("\n"); /* don't overwrite the last message */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001121 cmdline_row = msg_row;
Bram Moolenaara3227e22006-03-08 21:32:40 +00001122 do_modelines(0);
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001123
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001124#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00001125 /* Restore the error/interrupt/exception state if not discarded by a
1126 * new aborting error, interrupt, or uncaught exception. */
1127 leave_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02001128#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001129 }
1130 swap_exists_action = SEA_NONE;
1131}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001132
Bram Moolenaar071d4272004-06-13 20:20:40 +00001133/*
1134 * do_bufdel() - delete or unload buffer(s)
1135 *
1136 * addr_count == 0: ":bdel" - delete current buffer
1137 * addr_count == 1: ":N bdel" or ":bdel N [N ..]" - first delete
1138 * buffer "end_bnr", then any other arguments.
1139 * addr_count == 2: ":N,N bdel" - delete buffers in range
1140 *
1141 * command can be DOBUF_UNLOAD (":bunload"), DOBUF_WIPE (":bwipeout") or
1142 * DOBUF_DEL (":bdel")
1143 *
1144 * Returns error message or NULL
1145 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001146 char *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001147do_bufdel(
1148 int command,
1149 char_u *arg, /* pointer to extra arguments */
1150 int addr_count,
1151 int start_bnr, /* first buffer number in a range */
1152 int end_bnr, /* buffer nr or last buffer nr in a range */
1153 int forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001154{
1155 int do_current = 0; /* delete current buffer? */
1156 int deleted = 0; /* number of buffers deleted */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001157 char *errormsg = NULL; /* return value */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001158 int bnr; /* buffer number */
1159 char_u *p;
1160
Bram Moolenaar071d4272004-06-13 20:20:40 +00001161 if (addr_count == 0)
1162 {
1163 (void)do_buffer(command, DOBUF_CURRENT, FORWARD, 0, forceit);
1164 }
1165 else
1166 {
1167 if (addr_count == 2)
1168 {
1169 if (*arg) /* both range and argument is not allowed */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001170 return _(e_trailing);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171 bnr = start_bnr;
1172 }
1173 else /* addr_count == 1 */
1174 bnr = end_bnr;
1175
1176 for ( ;!got_int; ui_breakcheck())
1177 {
1178 /*
1179 * delete the current buffer last, otherwise when the
1180 * current buffer is deleted, the next buffer becomes
1181 * the current one and will be loaded, which may then
1182 * also be deleted, etc.
1183 */
1184 if (bnr == curbuf->b_fnum)
1185 do_current = bnr;
1186 else if (do_buffer(command, DOBUF_FIRST, FORWARD, (int)bnr,
1187 forceit) == OK)
1188 ++deleted;
1189
1190 /*
1191 * find next buffer number to delete/unload
1192 */
1193 if (addr_count == 2)
1194 {
1195 if (++bnr > end_bnr)
1196 break;
1197 }
1198 else /* addr_count == 1 */
1199 {
1200 arg = skipwhite(arg);
1201 if (*arg == NUL)
1202 break;
1203 if (!VIM_ISDIGIT(*arg))
1204 {
1205 p = skiptowhite_esc(arg);
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001206 bnr = buflist_findpat(arg, p,
1207 command == DOBUF_WIPE || command == DOBUF_WIPE_REUSE,
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01001208 FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001209 if (bnr < 0) /* failed */
1210 break;
1211 arg = p;
1212 }
1213 else
1214 bnr = getdigits(&arg);
1215 }
1216 }
1217 if (!got_int && do_current && do_buffer(command, DOBUF_FIRST,
1218 FORWARD, do_current, forceit) == OK)
1219 ++deleted;
1220
1221 if (deleted == 0)
1222 {
1223 if (command == DOBUF_UNLOAD)
Bram Moolenaar51485f02005-06-04 21:55:20 +00001224 STRCPY(IObuff, _("E515: No buffers were unloaded"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001225 else if (command == DOBUF_DEL)
Bram Moolenaar51485f02005-06-04 21:55:20 +00001226 STRCPY(IObuff, _("E516: No buffers were deleted"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001227 else
Bram Moolenaar51485f02005-06-04 21:55:20 +00001228 STRCPY(IObuff, _("E517: No buffers were wiped out"));
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001229 errormsg = (char *)IObuff;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 }
1231 else if (deleted >= p_report)
1232 {
1233 if (command == DOBUF_UNLOAD)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001234 smsg(NGETTEXT("%d buffer unloaded",
Bram Moolenaarda6e8912018-08-21 15:12:14 +02001235 "%d buffers unloaded", deleted), deleted);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001236 else if (command == DOBUF_DEL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001237 smsg(NGETTEXT("%d buffer deleted",
Bram Moolenaarda6e8912018-08-21 15:12:14 +02001238 "%d buffers deleted", deleted), deleted);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001239 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001240 smsg(NGETTEXT("%d buffer wiped out",
Bram Moolenaarda6e8912018-08-21 15:12:14 +02001241 "%d buffers wiped out", deleted), deleted);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001242 }
1243 }
1244
Bram Moolenaar071d4272004-06-13 20:20:40 +00001245
1246 return errormsg;
1247}
1248
Bram Moolenaara02471e2014-01-10 16:43:14 +01001249/*
1250 * Make the current buffer empty.
1251 * Used when it is wiped out and it's the last buffer.
1252 */
1253 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001254empty_curbuf(
1255 int close_others,
1256 int forceit,
1257 int action)
Bram Moolenaara02471e2014-01-10 16:43:14 +01001258{
1259 int retval;
1260 buf_T *buf = curbuf;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001261 bufref_T bufref;
Bram Moolenaara02471e2014-01-10 16:43:14 +01001262
1263 if (action == DOBUF_UNLOAD)
1264 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001265 emsg(_("E90: Cannot unload last buffer"));
Bram Moolenaara02471e2014-01-10 16:43:14 +01001266 return FAIL;
1267 }
1268
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001269 set_bufref(&bufref, buf);
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001270 if (close_others)
1271 /* Close any other windows on this buffer, then make it empty. */
Bram Moolenaara02471e2014-01-10 16:43:14 +01001272 close_windows(buf, TRUE);
Bram Moolenaara02471e2014-01-10 16:43:14 +01001273
1274 setpcmark();
1275 retval = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE,
1276 forceit ? ECMD_FORCEIT : 0, curwin);
1277
1278 /*
1279 * do_ecmd() may create a new buffer, then we have to delete
1280 * the old one. But do_ecmd() may have done that already, check
1281 * if the buffer still exists.
1282 */
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001283 if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows == 0)
Bram Moolenaara02471e2014-01-10 16:43:14 +01001284 close_buffer(NULL, buf, action, FALSE);
1285 if (!close_others)
1286 need_fileinfo = FALSE;
1287 return retval;
1288}
Bram Moolenaar94f01952018-09-01 15:30:03 +02001289
Bram Moolenaar071d4272004-06-13 20:20:40 +00001290/*
1291 * Implementation of the commands for the buffer list.
1292 *
1293 * action == DOBUF_GOTO go to specified buffer
1294 * action == DOBUF_SPLIT split window and go to specified buffer
1295 * action == DOBUF_UNLOAD unload specified buffer(s)
1296 * action == DOBUF_DEL delete specified buffer(s) from buffer list
1297 * action == DOBUF_WIPE delete specified buffer(s) really
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001298 * action == DOBUF_WIPE_REUSE idem, and add number to "buf_reuse"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299 *
1300 * start == DOBUF_CURRENT go to "count" buffer from current buffer
1301 * start == DOBUF_FIRST go to "count" buffer from first buffer
1302 * start == DOBUF_LAST go to "count" buffer from last buffer
1303 * start == DOBUF_MOD go to "count" modified buffer from current buffer
1304 *
1305 * Return FAIL or OK.
1306 */
1307 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001308do_buffer(
1309 int action,
1310 int start,
1311 int dir, /* FORWARD or BACKWARD */
1312 int count, /* buffer number or number of buffers */
1313 int forceit) /* TRUE for :...! */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001314{
1315 buf_T *buf;
1316 buf_T *bp;
1317 int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001318 || action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001319
1320 switch (start)
1321 {
1322 case DOBUF_FIRST: buf = firstbuf; break;
1323 case DOBUF_LAST: buf = lastbuf; break;
1324 default: buf = curbuf; break;
1325 }
1326 if (start == DOBUF_MOD) /* find next modified buffer */
1327 {
1328 while (count-- > 0)
1329 {
1330 do
1331 {
1332 buf = buf->b_next;
1333 if (buf == NULL)
1334 buf = firstbuf;
1335 }
1336 while (buf != curbuf && !bufIsChanged(buf));
1337 }
1338 if (!bufIsChanged(buf))
1339 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001340 emsg(_("E84: No modified buffer found"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001341 return FAIL;
1342 }
1343 }
1344 else if (start == DOBUF_FIRST && count) /* find specified buffer number */
1345 {
1346 while (buf != NULL && buf->b_fnum != count)
1347 buf = buf->b_next;
1348 }
1349 else
1350 {
1351 bp = NULL;
1352 while (count > 0 || (!unload && !buf->b_p_bl && bp != buf))
1353 {
1354 /* remember the buffer where we start, we come back there when all
1355 * buffers are unlisted. */
1356 if (bp == NULL)
1357 bp = buf;
1358 if (dir == FORWARD)
1359 {
1360 buf = buf->b_next;
1361 if (buf == NULL)
1362 buf = firstbuf;
1363 }
1364 else
1365 {
1366 buf = buf->b_prev;
1367 if (buf == NULL)
1368 buf = lastbuf;
1369 }
1370 /* don't count unlisted buffers */
1371 if (unload || buf->b_p_bl)
1372 {
1373 --count;
1374 bp = NULL; /* use this buffer as new starting point */
1375 }
1376 if (bp == buf)
1377 {
1378 /* back where we started, didn't find anything. */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001379 emsg(_("E85: There is no listed buffer"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001380 return FAIL;
1381 }
1382 }
1383 }
1384
1385 if (buf == NULL) /* could not find it */
1386 {
1387 if (start == DOBUF_FIRST)
1388 {
1389 /* don't warn when deleting */
1390 if (!unload)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001391 semsg(_(e_nobufnr), count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001392 }
1393 else if (dir == FORWARD)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001394 emsg(_("E87: Cannot go beyond last buffer"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001395 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001396 emsg(_("E88: Cannot go before first buffer"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001397 return FAIL;
1398 }
1399
1400#ifdef FEAT_GUI
1401 need_mouse_correct = TRUE;
1402#endif
1403
Bram Moolenaar071d4272004-06-13 20:20:40 +00001404 /*
1405 * delete buffer buf from memory and/or the list
1406 */
1407 if (unload)
1408 {
1409 int forward;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001410 bufref_T bufref;
1411
Bram Moolenaar94f01952018-09-01 15:30:03 +02001412 if (!can_unload_buffer(buf))
Bram Moolenaara997b452018-04-17 23:24:06 +02001413 return FAIL;
Bram Moolenaara997b452018-04-17 23:24:06 +02001414
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001415 set_bufref(&bufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001416
1417 /* When unloading or deleting a buffer that's already unloaded and
1418 * unlisted: fail silently. */
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001419 if (action != DOBUF_WIPE && action != DOBUF_WIPE_REUSE
1420 && buf->b_ml.ml_mfp == NULL && !buf->b_p_bl)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001421 return FAIL;
1422
1423 if (!forceit && bufIsChanged(buf))
1424 {
Bram Moolenaar0c72fe42018-03-29 16:04:08 +02001425#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001426 if ((p_confirm || cmdmod.confirm) && p_write)
1427 {
1428 dialog_changed(buf, FALSE);
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001429 if (!bufref_valid(&bufref))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001430 /* Autocommand deleted buffer, oops! It's not changed
1431 * now. */
1432 return FAIL;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001433 /* If it's still changed fail silently, the dialog already
1434 * mentioned why it fails. */
1435 if (bufIsChanged(buf))
1436 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001437 }
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001438 else
Bram Moolenaar0c72fe42018-03-29 16:04:08 +02001439#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001440 {
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01001441 semsg(_("E89: No write since last change for buffer %d (add ! to override)"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001442 buf->b_fnum);
1443 return FAIL;
1444 }
1445 }
1446
Bram Moolenaarc4a908e2016-09-08 23:35:30 +02001447 /* When closing the current buffer stop Visual mode. */
Bram Moolenaar4930a762016-09-11 14:39:53 +02001448 if (buf == curbuf && VIsual_active)
Bram Moolenaarc4a908e2016-09-08 23:35:30 +02001449 end_visual_mode();
1450
Bram Moolenaar071d4272004-06-13 20:20:40 +00001451 /*
1452 * If deleting the last (listed) buffer, make it empty.
1453 * The last (listed) buffer cannot be unloaded.
1454 */
Bram Moolenaar29323592016-07-24 22:04:11 +02001455 FOR_ALL_BUFFERS(bp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001456 if (bp->b_p_bl && bp != buf)
1457 break;
1458 if (bp == NULL && buf == curbuf)
Bram Moolenaara02471e2014-01-10 16:43:14 +01001459 return empty_curbuf(TRUE, forceit, action);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001460
Bram Moolenaar071d4272004-06-13 20:20:40 +00001461 /*
1462 * If the deleted buffer is the current one, close the current window
Bram Moolenaarf740b292006-02-16 22:11:02 +00001463 * (unless it's the only window). Repeat this so long as we end up in
1464 * a window with this buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001465 */
Bram Moolenaarf740b292006-02-16 22:11:02 +00001466 while (buf == curbuf
Bram Moolenaare0ab94e2016-09-04 19:50:54 +02001467 && !(curwin->w_closing || curwin->w_buffer->b_locked > 0)
Bram Moolenaar459ca562016-11-10 18:16:33 +01001468 && (!ONE_WINDOW || first_tabpage->tp_next != NULL))
Bram Moolenaarc93df6b2013-08-14 17:11:20 +02001469 {
1470 if (win_close(curwin, FALSE) == FAIL)
1471 break;
1472 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001473
1474 /*
1475 * If the buffer to be deleted is not the current one, delete it here.
1476 */
1477 if (buf != curbuf)
1478 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00001479 close_windows(buf, FALSE);
Bram Moolenaar4033c552017-09-16 20:54:51 +02001480 if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows <= 0)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001481 close_buffer(NULL, buf, action, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001482 return OK;
1483 }
1484
1485 /*
1486 * Deleting the current buffer: Need to find another buffer to go to.
Bram Moolenaara02471e2014-01-10 16:43:14 +01001487 * There should be another, otherwise it would have been handled
1488 * above. However, autocommands may have deleted all buffers.
Bram Moolenaar19ff9bf2016-07-10 19:03:57 +02001489 * First use au_new_curbuf.br_buf, if it is valid.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001490 * Then prefer the buffer we most recently visited.
1491 * Else try to find one that is loaded, after the current buffer,
1492 * then before the current buffer.
1493 * Finally use any buffer.
1494 */
1495 buf = NULL; /* selected buffer */
1496 bp = NULL; /* used when no loaded buffer found */
Bram Moolenaar19ff9bf2016-07-10 19:03:57 +02001497 if (au_new_curbuf.br_buf != NULL && bufref_valid(&au_new_curbuf))
1498 buf = au_new_curbuf.br_buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001499#ifdef FEAT_JUMPLIST
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001500 else if (curwin->w_jumplistlen > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001501 {
1502 int jumpidx;
1503
1504 jumpidx = curwin->w_jumplistidx - 1;
1505 if (jumpidx < 0)
1506 jumpidx = curwin->w_jumplistlen - 1;
1507
1508 forward = jumpidx;
1509 while (jumpidx != curwin->w_jumplistidx)
1510 {
1511 buf = buflist_findnr(curwin->w_jumplist[jumpidx].fmark.fnum);
1512 if (buf != NULL)
1513 {
1514 if (buf == curbuf || !buf->b_p_bl)
1515 buf = NULL; /* skip current and unlisted bufs */
1516 else if (buf->b_ml.ml_mfp == NULL)
1517 {
1518 /* skip unloaded buf, but may keep it for later */
1519 if (bp == NULL)
1520 bp = buf;
1521 buf = NULL;
1522 }
1523 }
1524 if (buf != NULL) /* found a valid buffer: stop searching */
1525 break;
1526 /* advance to older entry in jump list */
1527 if (!jumpidx && curwin->w_jumplistidx == curwin->w_jumplistlen)
1528 break;
1529 if (--jumpidx < 0)
1530 jumpidx = curwin->w_jumplistlen - 1;
1531 if (jumpidx == forward) /* List exhausted for sure */
1532 break;
1533 }
1534 }
1535#endif
1536
1537 if (buf == NULL) /* No previous buffer, Try 2'nd approach */
1538 {
1539 forward = TRUE;
1540 buf = curbuf->b_next;
1541 for (;;)
1542 {
1543 if (buf == NULL)
1544 {
1545 if (!forward) /* tried both directions */
1546 break;
1547 buf = curbuf->b_prev;
1548 forward = FALSE;
1549 continue;
1550 }
1551 /* in non-help buffer, try to skip help buffers, and vv */
1552 if (buf->b_help == curbuf->b_help && buf->b_p_bl)
1553 {
1554 if (buf->b_ml.ml_mfp != NULL) /* found loaded buffer */
1555 break;
1556 if (bp == NULL) /* remember unloaded buf for later */
1557 bp = buf;
1558 }
1559 if (forward)
1560 buf = buf->b_next;
1561 else
1562 buf = buf->b_prev;
1563 }
1564 }
1565 if (buf == NULL) /* No loaded buffer, use unloaded one */
1566 buf = bp;
1567 if (buf == NULL) /* No loaded buffer, find listed one */
1568 {
Bram Moolenaar29323592016-07-24 22:04:11 +02001569 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001570 if (buf->b_p_bl && buf != curbuf)
1571 break;
1572 }
1573 if (buf == NULL) /* Still no buffer, just take one */
1574 {
1575 if (curbuf->b_next != NULL)
1576 buf = curbuf->b_next;
1577 else
1578 buf = curbuf->b_prev;
1579 }
1580 }
1581
Bram Moolenaara02471e2014-01-10 16:43:14 +01001582 if (buf == NULL)
1583 {
1584 /* Autocommands must have wiped out all other buffers. Only option
1585 * now is to make the current buffer empty. */
1586 return empty_curbuf(FALSE, forceit, action);
1587 }
1588
Bram Moolenaar071d4272004-06-13 20:20:40 +00001589 /*
1590 * make buf current buffer
1591 */
1592 if (action == DOBUF_SPLIT) /* split window first */
1593 {
Bram Moolenaarf2330482008-06-24 20:19:36 +00001594 /* If 'switchbuf' contains "useopen": jump to first window containing
1595 * "buf" if one exists */
1596 if ((swb_flags & SWB_USEOPEN) && buf_jump_open_win(buf))
Bram Moolenaar779b74b2006-04-10 14:55:34 +00001597 return OK;
Bram Moolenaar9381ab72008-11-12 11:52:19 +00001598 /* If 'switchbuf' contains "usetab": jump to first window in any tab
Bram Moolenaarf2330482008-06-24 20:19:36 +00001599 * page containing "buf" if one exists */
1600 if ((swb_flags & SWB_USETAB) && buf_jump_open_tab(buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001601 return OK;
1602 if (win_split(0, 0) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001603 return FAIL;
1604 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001605
1606 /* go to current buffer - nothing to do */
1607 if (buf == curbuf)
1608 return OK;
1609
1610 /*
1611 * Check if the current buffer may be abandoned.
1612 */
1613 if (action == DOBUF_GOTO && !can_abandon(curbuf, forceit))
1614 {
1615#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
1616 if ((p_confirm || cmdmod.confirm) && p_write)
1617 {
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001618 bufref_T bufref;
1619
1620 set_bufref(&bufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001621 dialog_changed(curbuf, FALSE);
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001622 if (!bufref_valid(&bufref))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001623 /* Autocommand deleted buffer, oops! */
1624 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001625 }
1626 if (bufIsChanged(curbuf))
1627#endif
1628 {
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001629 no_write_message();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001630 return FAIL;
1631 }
1632 }
1633
1634 /* Go to the other buffer. */
1635 set_curbuf(buf, action);
1636
Bram Moolenaar071d4272004-06-13 20:20:40 +00001637 if (action == DOBUF_SPLIT)
Bram Moolenaar3368ea22010-09-21 16:56:35 +02001638 RESET_BINDING(curwin); /* reset 'scrollbind' and 'cursorbind' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001639
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001640#if defined(FEAT_EVAL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001641 if (aborting()) /* autocmds may abort script processing */
1642 return FAIL;
1643#endif
1644
1645 return OK;
1646}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001647
1648/*
1649 * Set current buffer to "buf". Executes autocommands and closes current
1650 * buffer. "action" tells how to close the current buffer:
1651 * DOBUF_GOTO free or hide it
1652 * DOBUF_SPLIT nothing
1653 * DOBUF_UNLOAD unload it
1654 * DOBUF_DEL delete it
1655 * DOBUF_WIPE wipe it out
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001656 * DOBUF_WIPE_REUSE wipe it out and add to "buf_reuse"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001657 */
1658 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001659set_curbuf(buf_T *buf, int action)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001660{
1661 buf_T *prevbuf;
1662 int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001663 || action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE);
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001664#ifdef FEAT_SYN_HL
1665 long old_tw = curbuf->b_p_tw;
1666#endif
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001667 bufref_T newbufref;
1668 bufref_T prevbufref;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001669
1670 setpcmark();
Bram Moolenaard4755bb2004-09-02 19:12:26 +00001671 if (!cmdmod.keepalt)
1672 curwin->w_alt_fnum = curbuf->b_fnum; /* remember alternate file */
Bram Moolenaar701f7af2008-11-15 13:12:07 +00001673 buflist_altfpos(curwin); /* remember curpos */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001674
Bram Moolenaar071d4272004-06-13 20:20:40 +00001675 /* Don't restart Select mode after switching to another buffer. */
1676 VIsual_reselect = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001677
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001678 /* close_windows() or apply_autocmds() may change curbuf and wipe out "buf"
1679 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001680 prevbuf = curbuf;
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001681 set_bufref(&prevbufref, prevbuf);
1682 set_bufref(&newbufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001683
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001684 /* Autocommands may delete the curren buffer and/or the buffer we wan to go
1685 * to. In those cases don't close the buffer. */
Bram Moolenaar82404332016-07-10 17:00:38 +02001686 if (!apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf)
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001687 || (bufref_valid(&prevbufref)
1688 && bufref_valid(&newbufref)
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001689#ifdef FEAT_EVAL
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001690 && !aborting()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001691#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001692 ))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693 {
Bram Moolenaara971b822011-09-14 14:43:25 +02001694#ifdef FEAT_SYN_HL
1695 if (prevbuf == curwin->w_buffer)
1696 reset_synblock(curwin);
1697#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001698 if (unload)
Bram Moolenaarf740b292006-02-16 22:11:02 +00001699 close_windows(prevbuf, FALSE);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001700#if defined(FEAT_EVAL)
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001701 if (bufref_valid(&prevbufref) && !aborting())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001702#else
Bram Moolenaar9bca8052017-12-18 12:37:55 +01001703 if (bufref_valid(&prevbufref))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001704#endif
Bram Moolenaar607a95ed2006-03-28 20:57:42 +00001705 {
Bram Moolenaare25865a2012-07-06 16:22:02 +02001706 win_T *previouswin = curwin;
Bram Moolenaar607a95ed2006-03-28 20:57:42 +00001707 if (prevbuf == curbuf)
Bram Moolenaar779b74b2006-04-10 14:55:34 +00001708 u_sync(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001709 close_buffer(prevbuf == curwin->w_buffer ? curwin : NULL, prevbuf,
1710 unload ? action : (action == DOBUF_GOTO
Bram Moolenaareb44a682017-08-03 22:44:55 +02001711 && !buf_hide(prevbuf)
Bram Moolenaar42ec6562012-02-22 14:58:37 +01001712 && !bufIsChanged(prevbuf)) ? DOBUF_UNLOAD : 0, FALSE);
Bram Moolenaare25865a2012-07-06 16:22:02 +02001713 if (curwin != previouswin && win_valid(previouswin))
Bram Moolenaar9e931222012-06-20 11:55:01 +02001714 /* autocommands changed curwin, Grr! */
Bram Moolenaare25865a2012-07-06 16:22:02 +02001715 curwin = previouswin;
Bram Moolenaar607a95ed2006-03-28 20:57:42 +00001716 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001717 }
Bram Moolenaar5bd266c2008-09-01 15:33:17 +00001718 /* An autocommand may have deleted "buf", already entered it (e.g., when
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001719 * it did ":bunload") or aborted the script processing.
Bram Moolenaar9e931222012-06-20 11:55:01 +02001720 * If curwin->w_buffer is null, enter_buffer() will make it valid again */
1721 if ((buf_valid(buf) && buf != curbuf
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001722#ifdef FEAT_EVAL
Bram Moolenaar4033c552017-09-16 20:54:51 +02001723 && !aborting()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001724#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001725 ) || curwin->w_buffer == NULL)
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001726 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727 enter_buffer(buf);
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001728#ifdef FEAT_SYN_HL
1729 if (old_tw != curbuf->b_p_tw)
1730 check_colorcolumn(curwin);
1731#endif
1732 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001733}
1734
1735/*
1736 * Enter a new current buffer.
Bram Moolenaar6d47df72013-02-17 15:45:37 +01001737 * Old curbuf must have been abandoned already! This also means "curbuf" may
1738 * be pointing to freed memory.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001739 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001740 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001741enter_buffer(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001742{
Bram Moolenaar010ee962019-09-25 20:37:36 +02001743 // Get the buffer in the current window.
1744 curwin->w_buffer = buf;
1745 curbuf = buf;
1746 ++curbuf->b_nwindows;
1747
1748 // Copy buffer and window local option values. Not for a help buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001749 buf_copy_options(buf, BCO_ENTER | BCO_NOHELP);
1750 if (!buf->b_help)
1751 get_winopts(buf);
1752#ifdef FEAT_FOLDING
1753 else
Bram Moolenaar010ee962019-09-25 20:37:36 +02001754 // Remove all folds in the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001755 clearFolding(curwin);
Bram Moolenaar010ee962019-09-25 20:37:36 +02001756 foldUpdateAll(curwin); // update folds (later).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001757#endif
1758
Bram Moolenaar071d4272004-06-13 20:20:40 +00001759#ifdef FEAT_DIFF
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00001760 if (curwin->w_p_diff)
1761 diff_buf_add(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001762#endif
1763
Bram Moolenaara971b822011-09-14 14:43:25 +02001764#ifdef FEAT_SYN_HL
Bram Moolenaar96ca27a2017-07-17 23:20:24 +02001765 curwin->w_s = &(curbuf->b_s);
Bram Moolenaara971b822011-09-14 14:43:25 +02001766#endif
1767
Bram Moolenaar071d4272004-06-13 20:20:40 +00001768 /* Cursor on first line by default. */
1769 curwin->w_cursor.lnum = 1;
1770 curwin->w_cursor.col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001771 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001772 curwin->w_set_curswant = TRUE;
Bram Moolenaard4153d42008-11-15 15:06:17 +00001773 curwin->w_topline_was_set = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001774
Bram Moolenaar89c0ea42010-02-24 16:58:36 +01001775 /* mark cursor position as being invalid */
1776 curwin->w_valid = 0;
1777
Bram Moolenaar9cea87c2018-09-21 16:59:45 +02001778 buflist_setfpos(curbuf, curwin, curbuf->b_last_cursor.lnum,
1779 curbuf->b_last_cursor.col, TRUE);
1780
Bram Moolenaar071d4272004-06-13 20:20:40 +00001781 /* Make sure the buffer is loaded. */
1782 if (curbuf->b_ml.ml_mfp == NULL) /* need to load the file */
Bram Moolenaard4755bb2004-09-02 19:12:26 +00001783 {
1784 /* If there is no filetype, allow for detecting one. Esp. useful for
1785 * ":ball" used in a autocommand. If there already is a filetype we
1786 * might prefer to keep it. */
1787 if (*curbuf->b_p_ft == NUL)
1788 did_filetype = FALSE;
1789
Bram Moolenaar59f931e2010-07-24 20:27:03 +02001790 open_buffer(FALSE, NULL, 0);
Bram Moolenaard4755bb2004-09-02 19:12:26 +00001791 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001792 else
1793 {
Bram Moolenaareda65222019-05-16 20:29:44 +02001794 if (!msg_silent && !shortmess(SHM_FILEINFO))
1795 need_fileinfo = TRUE; // display file info after redraw
1796
1797 // check if file changed
1798 (void)buf_check_timestamp(curbuf, FALSE);
1799
Bram Moolenaar071d4272004-06-13 20:20:40 +00001800 curwin->w_topline = 1;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001801#ifdef FEAT_DIFF
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802 curwin->w_topfill = 0;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001803#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001804 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
1805 apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001806 }
1807
1808 /* If autocommands did not change the cursor position, restore cursor lnum
1809 * and possibly cursor col. */
1810 if (curwin->w_cursor.lnum == 1 && inindent(0))
1811 buflist_getfpos();
1812
1813 check_arg_idx(curwin); /* check for valid arg_idx */
1814#ifdef FEAT_TITLE
1815 maketitle();
1816#endif
Bram Moolenaard4153d42008-11-15 15:06:17 +00001817 /* when autocmds didn't change it */
1818 if (curwin->w_topline == 1 && !curwin->w_topline_was_set)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001819 scroll_cursor_halfway(FALSE); /* redisplay at correct position */
1820
Bram Moolenaar009b2592004-10-24 19:18:58 +00001821#ifdef FEAT_NETBEANS_INTG
1822 /* Send fileOpened event because we've changed buffers. */
Bram Moolenaarb26e6322010-05-22 21:34:09 +02001823 netbeans_file_activated(curbuf);
Bram Moolenaar009b2592004-10-24 19:18:58 +00001824#endif
1825
Bram Moolenaar498efdb2006-09-05 14:31:54 +00001826 /* Change directories when the 'acd' option is set. */
Bram Moolenaar6f470022018-04-10 18:47:20 +02001827 DO_AUTOCHDIR;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001828
1829#ifdef FEAT_KEYMAP
1830 if (curbuf->b_kmap_state & KEYMAP_INIT)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001831 (void)keymap_init();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001832#endif
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00001833#ifdef FEAT_SPELL
1834 /* May need to set the spell language. Can only do this after the buffer
1835 * has been properly setup. */
Bram Moolenaar860cae12010-06-05 23:22:07 +02001836 if (!curbuf->b_help && curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL)
1837 (void)did_set_spelllang(curwin);
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00001838#endif
Bram Moolenaarab9c89b2016-07-03 17:47:26 +02001839#ifdef FEAT_VIMINFO
1840 curbuf->b_last_used = vim_time();
1841#endif
Bram Moolenaar706cdeb2007-05-06 21:55:31 +00001842
Bram Moolenaar071d4272004-06-13 20:20:40 +00001843 redraw_later(NOT_VALID);
1844}
1845
Bram Moolenaar498efdb2006-09-05 14:31:54 +00001846#if defined(FEAT_AUTOCHDIR) || defined(PROTO)
1847/*
1848 * Change to the directory of the current buffer.
Bram Moolenaar6bd364e2016-02-23 16:19:07 +01001849 * Don't do this while still starting up.
Bram Moolenaar498efdb2006-09-05 14:31:54 +00001850 */
1851 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001852do_autochdir(void)
Bram Moolenaar498efdb2006-09-05 14:31:54 +00001853{
Bram Moolenaar5c719942016-07-09 23:40:45 +02001854 if ((starting == 0 || test_autochdir)
Bram Moolenaar6bd364e2016-02-23 16:19:07 +01001855 && curbuf->b_ffname != NULL
Bram Moolenaarb7407d32018-02-03 17:36:27 +01001856 && vim_chdirfile(curbuf->b_ffname, "auto") == OK)
Bram Moolenaar498efdb2006-09-05 14:31:54 +00001857 shorten_fnames(TRUE);
1858}
1859#endif
1860
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001861 void
1862no_write_message(void)
1863{
1864#ifdef FEAT_TERMINAL
1865 if (term_job_running(curbuf->b_term))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001866 emsg(_("E948: Job still running (add ! to end the job)"));
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001867 else
1868#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001869 emsg(_("E37: No write since last change (add ! to override)"));
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001870}
1871
1872 void
Bram Moolenaar7a760922018-02-19 23:10:02 +01001873no_write_message_nobang(buf_T *buf UNUSED)
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001874{
1875#ifdef FEAT_TERMINAL
Bram Moolenaar7a760922018-02-19 23:10:02 +01001876 if (term_job_running(buf->b_term))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001877 emsg(_("E948: Job still running"));
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001878 else
1879#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001880 emsg(_("E37: No write since last change"));
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02001881}
1882
Bram Moolenaar071d4272004-06-13 20:20:40 +00001883/*
1884 * functions for dealing with the buffer list
1885 */
1886
1887/*
Bram Moolenaar46a53df2018-04-24 21:58:51 +02001888 * Return TRUE if the current buffer is empty, unnamed, unmodified and used in
1889 * only one window. That means it can be re-used.
1890 */
1891 int
1892curbuf_reusable(void)
1893{
1894 return (curbuf != NULL
1895 && curbuf->b_ffname == NULL
1896 && curbuf->b_nwindows <= 1
1897 && (curbuf->b_ml.ml_mfp == NULL || BUFEMPTY())
Bram Moolenaard85c3962019-04-07 14:19:14 +02001898#if defined(FEAT_QUICKFIX)
Bram Moolenaar39803d82019-04-07 12:04:51 +02001899 && !bt_quickfix(curbuf)
Bram Moolenaard85c3962019-04-07 14:19:14 +02001900#endif
Bram Moolenaar46a53df2018-04-24 21:58:51 +02001901 && !curbufIsChanged());
1902}
1903
1904/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001905 * Add a file name to the buffer list. Return a pointer to the buffer.
1906 * If the same file name already exists return a pointer to that buffer.
1907 * If it does not exist, or if fname == NULL, a new entry is created.
1908 * If (flags & BLN_CURBUF) is TRUE, may use current buffer.
1909 * If (flags & BLN_LISTED) is TRUE, add new buffer to buffer list.
1910 * If (flags & BLN_DUMMY) is TRUE, don't count it as a real buffer.
Bram Moolenaarb127cfd2016-05-29 16:24:50 +02001911 * If (flags & BLN_NEW) is TRUE, don't use an existing buffer.
Bram Moolenaar82404332016-07-10 17:00:38 +02001912 * If (flags & BLN_NOOPT) is TRUE, don't copy options from the current buffer
1913 * if the buffer already exists.
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02001914 * If (flags & BLN_REUSE) is TRUE, may use buffer number from "buf_reuse".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001915 * This is the ONLY way to create a new buffer.
1916 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001917 buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001918buflist_new(
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02001919 char_u *ffname_arg, // full path of fname or relative
1920 char_u *sfname_arg, // short fname or NULL
1921 linenr_T lnum, // preferred cursor line
1922 int flags) // BLN_ defines
Bram Moolenaar071d4272004-06-13 20:20:40 +00001923{
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02001924 char_u *ffname = ffname_arg;
1925 char_u *sfname = sfname_arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001926 buf_T *buf;
1927#ifdef UNIX
Bram Moolenaar8767f522016-07-01 17:17:39 +02001928 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001929#endif
1930
Bram Moolenaar480778b2016-07-14 22:09:39 +02001931 if (top_file_num == 1)
1932 hash_init(&buf_hashtab);
1933
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02001934 fname_expand(curbuf, &ffname, &sfname); // will allocate ffname
Bram Moolenaar071d4272004-06-13 20:20:40 +00001935
1936 /*
1937 * If file name already exists in the list, update the entry.
1938 */
1939#ifdef UNIX
1940 /* On Unix we can use inode numbers when the file exists. Works better
1941 * for hard links. */
1942 if (sfname == NULL || mch_stat((char *)sfname, &st) < 0)
1943 st.st_dev = (dev_T)-1;
1944#endif
Bram Moolenaarb127cfd2016-05-29 16:24:50 +02001945 if (ffname != NULL && !(flags & (BLN_DUMMY | BLN_NEW)) && (buf =
Bram Moolenaar071d4272004-06-13 20:20:40 +00001946#ifdef UNIX
1947 buflist_findname_stat(ffname, &st)
1948#else
1949 buflist_findname(ffname)
1950#endif
1951 ) != NULL)
1952 {
1953 vim_free(ffname);
1954 if (lnum != 0)
1955 buflist_setfpos(buf, curwin, lnum, (colnr_T)0, FALSE);
Bram Moolenaar82404332016-07-10 17:00:38 +02001956
1957 if ((flags & BLN_NOOPT) == 0)
1958 /* copy the options now, if 'cpo' doesn't have 's' and not done
1959 * already */
1960 buf_copy_options(buf, 0);
1961
Bram Moolenaar071d4272004-06-13 20:20:40 +00001962 if ((flags & BLN_LISTED) && !buf->b_p_bl)
1963 {
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001964 bufref_T bufref;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001965
Bram Moolenaar071d4272004-06-13 20:20:40 +00001966 buf->b_p_bl = TRUE;
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001967 set_bufref(&bufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001968 if (!(flags & BLN_DUMMY))
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +02001969 {
Bram Moolenaar82404332016-07-10 17:00:38 +02001970 if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02001971 && !bufref_valid(&bufref))
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +02001972 return NULL;
1973 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001974 }
1975 return buf;
1976 }
1977
1978 /*
1979 * If the current buffer has no name and no contents, use the current
1980 * buffer. Otherwise: Need to allocate a new buffer structure.
1981 *
1982 * This is the ONLY place where a new buffer structure is allocated!
Bram Moolenaar4770d092006-01-12 23:22:24 +00001983 * (A spell file buffer is allocated in spell.c, but that's not a normal
1984 * buffer.)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001985 */
1986 buf = NULL;
Bram Moolenaar46a53df2018-04-24 21:58:51 +02001987 if ((flags & BLN_CURBUF) && curbuf_reusable())
Bram Moolenaar071d4272004-06-13 20:20:40 +00001988 {
1989 buf = curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001990 /* It's like this buffer is deleted. Watch out for autocommands that
1991 * change curbuf! If that happens, allocate a new buffer anyway. */
1992 if (curbuf->b_p_bl)
1993 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
1994 if (buf == curbuf)
1995 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001996#ifdef FEAT_EVAL
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00001997 if (aborting()) /* autocmds may abort script processing */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001998 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001999#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002000 if (buf == curbuf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002001 {
2002 /* Make sure 'bufhidden' and 'buftype' are empty */
2003 clear_string_option(&buf->b_p_bh);
2004 clear_string_option(&buf->b_p_bt);
2005 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002006 }
2007 if (buf != curbuf || curbuf == NULL)
2008 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002009 buf = ALLOC_CLEAR_ONE(buf_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002010 if (buf == NULL)
2011 {
2012 vim_free(ffname);
2013 return NULL;
2014 }
Bram Moolenaar429fa852013-04-15 12:27:36 +02002015#ifdef FEAT_EVAL
2016 /* init b: variables */
2017 buf->b_vars = dict_alloc();
2018 if (buf->b_vars == NULL)
2019 {
2020 vim_free(ffname);
2021 vim_free(buf);
2022 return NULL;
2023 }
2024 init_var_dict(buf->b_vars, &buf->b_bufvar, VAR_SCOPE);
2025#endif
Bram Moolenaar79518e22017-02-17 16:31:35 +01002026 init_changedtick(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002027 }
2028
2029 if (ffname != NULL)
2030 {
2031 buf->b_ffname = ffname;
2032 buf->b_sfname = vim_strsave(sfname);
2033 }
2034
2035 clear_wininfo(buf);
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002036 buf->b_wininfo = ALLOC_CLEAR_ONE(wininfo_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002037
2038 if ((ffname != NULL && (buf->b_ffname == NULL || buf->b_sfname == NULL))
2039 || buf->b_wininfo == NULL)
2040 {
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02002041 if (buf->b_sfname != buf->b_ffname)
2042 VIM_CLEAR(buf->b_sfname);
2043 else
2044 buf->b_sfname = NULL;
Bram Moolenaard23a8232018-02-10 18:45:26 +01002045 VIM_CLEAR(buf->b_ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002046 if (buf != curbuf)
2047 free_buffer(buf);
2048 return NULL;
2049 }
2050
2051 if (buf == curbuf)
2052 {
2053 /* free all things allocated for this buffer */
Bram Moolenaar59f931e2010-07-24 20:27:03 +02002054 buf_freeall(buf, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002055 if (buf != curbuf) /* autocommands deleted the buffer! */
2056 return NULL;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002057#if defined(FEAT_EVAL)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002058 if (aborting()) /* autocmds may abort script processing */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002059 return NULL;
2060#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002061 free_buffer_stuff(buf, FALSE); /* delete local variables et al. */
Bram Moolenaar0ac24e12012-11-20 12:16:58 +01002062
2063 /* Init the options. */
2064 buf->b_p_initialized = FALSE;
2065 buf_copy_options(buf, BCO_ENTER);
2066
Bram Moolenaar071d4272004-06-13 20:20:40 +00002067#ifdef FEAT_KEYMAP
2068 /* need to reload lmaps and set b:keymap_name */
2069 curbuf->b_kmap_state |= KEYMAP_INIT;
2070#endif
2071 }
2072 else
2073 {
2074 /*
2075 * put new buffer at the end of the buffer list
2076 */
2077 buf->b_next = NULL;
2078 if (firstbuf == NULL) /* buffer list is empty */
2079 {
2080 buf->b_prev = NULL;
2081 firstbuf = buf;
2082 }
2083 else /* append new buffer at end of list */
2084 {
2085 lastbuf->b_next = buf;
2086 buf->b_prev = lastbuf;
2087 }
2088 lastbuf = buf;
2089
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02002090 if ((flags & BLN_REUSE) && buf_reuse.ga_len > 0)
2091 {
2092 // Recycle a previously used buffer number. Used for buffers which
2093 // are normally hidden, e.g. in a popup window. Avoids that the
2094 // buffer number grows rapidly.
2095 --buf_reuse.ga_len;
2096 buf->b_fnum = ((int *)buf_reuse.ga_data)[buf_reuse.ga_len];
2097 }
2098 else
2099 buf->b_fnum = top_file_num++;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002100 if (top_file_num < 0) /* wrap around (may cause duplicates) */
2101 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002102 emsg(_("W14: Warning: List of file names overflow"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002103 if (emsg_silent == 0)
2104 {
2105 out_flush();
2106 ui_delay(3000L, TRUE); /* make sure it is noticed */
2107 }
2108 top_file_num = 1;
2109 }
Bram Moolenaar480778b2016-07-14 22:09:39 +02002110 buf_hashtab_add(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002111
2112 /*
2113 * Always copy the options from the current buffer.
2114 */
2115 buf_copy_options(buf, BCO_ALWAYS);
2116 }
2117
2118 buf->b_wininfo->wi_fpos.lnum = lnum;
2119 buf->b_wininfo->wi_win = curwin;
2120
Bram Moolenaar1fad5d42005-01-25 21:44:33 +00002121#ifdef FEAT_SYN_HL
Bram Moolenaar860cae12010-06-05 23:22:07 +02002122 hash_init(&buf->b_s.b_keywtab);
2123 hash_init(&buf->b_s.b_keywtab_ic);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002124#endif
2125
2126 buf->b_fname = buf->b_sfname;
2127#ifdef UNIX
2128 if (st.st_dev == (dev_T)-1)
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00002129 buf->b_dev_valid = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002130 else
2131 {
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00002132 buf->b_dev_valid = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002133 buf->b_dev = st.st_dev;
2134 buf->b_ino = st.st_ino;
2135 }
2136#endif
2137 buf->b_u_synced = TRUE;
2138 buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED;
Bram Moolenaar81695252004-12-29 20:58:21 +00002139 if (flags & BLN_DUMMY)
2140 buf->b_flags |= BF_DUMMY;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002141 buf_clear_file(buf);
2142 clrallmarks(buf); /* clear marks */
2143 fmarks_check_names(buf); /* check file marks for this file */
2144 buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE; /* init 'buflisted' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002145 if (!(flags & BLN_DUMMY))
2146 {
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02002147 bufref_T bufref;
2148
Bram Moolenaar8da9bbf2015-02-27 19:34:56 +01002149 /* Tricky: these autocommands may change the buffer list. They could
2150 * also split the window with re-using the one empty buffer. This may
2151 * result in unexpectedly losing the empty buffer. */
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02002152 set_bufref(&bufref, buf);
Bram Moolenaar82404332016-07-10 17:00:38 +02002153 if (apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02002154 && !bufref_valid(&bufref))
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +02002155 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002156 if (flags & BLN_LISTED)
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +02002157 {
Bram Moolenaar82404332016-07-10 17:00:38 +02002158 if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf)
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02002159 && !bufref_valid(&bufref))
Bram Moolenaar4c7ab1b2014-04-06 20:45:43 +02002160 return NULL;
2161 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002162#ifdef FEAT_EVAL
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002163 if (aborting()) /* autocmds may abort script processing */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002164 return NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002165#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002166 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002167
2168 return buf;
2169}
2170
2171/*
2172 * Free the memory for the options of a buffer.
2173 * If "free_p_ff" is TRUE also free 'fileformat', 'buftype' and
2174 * 'fileencoding'.
2175 */
2176 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002177free_buf_options(
2178 buf_T *buf,
2179 int free_p_ff)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002180{
2181 if (free_p_ff)
2182 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002183 clear_string_option(&buf->b_p_fenc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002184 clear_string_option(&buf->b_p_ff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002185 clear_string_option(&buf->b_p_bh);
2186 clear_string_option(&buf->b_p_bt);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002187 }
2188#ifdef FEAT_FIND_ID
2189 clear_string_option(&buf->b_p_def);
2190 clear_string_option(&buf->b_p_inc);
2191# ifdef FEAT_EVAL
2192 clear_string_option(&buf->b_p_inex);
2193# endif
2194#endif
2195#if defined(FEAT_CINDENT) && defined(FEAT_EVAL)
2196 clear_string_option(&buf->b_p_inde);
2197 clear_string_option(&buf->b_p_indk);
2198#endif
Bram Moolenaar371d5402006-03-20 21:47:49 +00002199#if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
2200 clear_string_option(&buf->b_p_bexpr);
2201#endif
Bram Moolenaar49771f42010-07-20 17:32:38 +02002202#if defined(FEAT_CRYPT)
2203 clear_string_option(&buf->b_p_cm);
2204#endif
Bram Moolenaar24a2d412017-01-24 17:48:36 +01002205 clear_string_option(&buf->b_p_fp);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00002206#if defined(FEAT_EVAL)
2207 clear_string_option(&buf->b_p_fex);
2208#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209#ifdef FEAT_CRYPT
2210 clear_string_option(&buf->b_p_key);
2211#endif
2212 clear_string_option(&buf->b_p_kp);
2213 clear_string_option(&buf->b_p_mps);
2214 clear_string_option(&buf->b_p_fo);
Bram Moolenaar86b68352004-12-27 21:59:20 +00002215 clear_string_option(&buf->b_p_flp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002216 clear_string_option(&buf->b_p_isk);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002217#ifdef FEAT_VARTABS
2218 clear_string_option(&buf->b_p_vsts);
Bram Moolenaarbdace832019-03-02 10:13:42 +01002219 vim_free(buf->b_p_vsts_nopaste);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002220 buf->b_p_vsts_nopaste = NULL;
Bram Moolenaarbdace832019-03-02 10:13:42 +01002221 vim_free(buf->b_p_vsts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002222 buf->b_p_vsts_array = NULL;
2223 clear_string_option(&buf->b_p_vts);
Bram Moolenaar55c77cf2019-02-16 19:05:11 +01002224 VIM_CLEAR(buf->b_p_vts_array);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02002225#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002226#ifdef FEAT_KEYMAP
2227 clear_string_option(&buf->b_p_keymap);
Bram Moolenaar50138322018-01-28 17:05:16 +01002228 keymap_clear(&buf->b_kmap_ga);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002229 ga_clear(&buf->b_kmap_ga);
2230#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002231 clear_string_option(&buf->b_p_com);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002232#ifdef FEAT_FOLDING
2233 clear_string_option(&buf->b_p_cms);
2234#endif
2235 clear_string_option(&buf->b_p_nf);
2236#ifdef FEAT_SYN_HL
2237 clear_string_option(&buf->b_p_syn);
Bram Moolenaarb8060fe2016-01-19 22:29:28 +01002238 clear_string_option(&buf->b_s.b_syn_isk);
Bram Moolenaarf71a3db2006-03-12 21:50:18 +00002239#endif
2240#ifdef FEAT_SPELL
Bram Moolenaar860cae12010-06-05 23:22:07 +02002241 clear_string_option(&buf->b_s.b_p_spc);
2242 clear_string_option(&buf->b_s.b_p_spf);
Bram Moolenaar473de612013-06-08 18:19:48 +02002243 vim_regfree(buf->b_s.b_cap_prog);
Bram Moolenaar860cae12010-06-05 23:22:07 +02002244 buf->b_s.b_cap_prog = NULL;
2245 clear_string_option(&buf->b_s.b_p_spl);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002246#endif
2247#ifdef FEAT_SEARCHPATH
2248 clear_string_option(&buf->b_p_sua);
2249#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002250 clear_string_option(&buf->b_p_ft);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002251#ifdef FEAT_CINDENT
2252 clear_string_option(&buf->b_p_cink);
2253 clear_string_option(&buf->b_p_cino);
2254#endif
2255#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT)
2256 clear_string_option(&buf->b_p_cinw);
2257#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002258 clear_string_option(&buf->b_p_cpt);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00002259#ifdef FEAT_COMPL_FUNC
2260 clear_string_option(&buf->b_p_cfu);
Bram Moolenaare344bea2005-09-01 20:46:49 +00002261 clear_string_option(&buf->b_p_ofu);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00002262#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002263#ifdef FEAT_QUICKFIX
2264 clear_string_option(&buf->b_p_gp);
2265 clear_string_option(&buf->b_p_mp);
2266 clear_string_option(&buf->b_p_efm);
2267#endif
2268 clear_string_option(&buf->b_p_ep);
2269 clear_string_option(&buf->b_p_path);
2270 clear_string_option(&buf->b_p_tags);
Bram Moolenaar0f6562e2015-11-24 18:48:14 +01002271 clear_string_option(&buf->b_p_tc);
Bram Moolenaar45e18cb2019-04-28 18:05:35 +02002272#ifdef FEAT_EVAL
2273 clear_string_option(&buf->b_p_tfu);
2274#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002275 clear_string_option(&buf->b_p_dict);
2276 clear_string_option(&buf->b_p_tsr);
Bram Moolenaarcfbc5ee2004-07-02 15:38:35 +00002277#ifdef FEAT_TEXTOBJ
2278 clear_string_option(&buf->b_p_qe);
2279#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002280 buf->b_p_ar = -1;
Bram Moolenaarf5a2fd82013-11-06 05:26:15 +01002281 buf->b_p_ul = NO_LOCAL_UNDOLEVEL;
Bram Moolenaaraf6c1312014-03-12 18:55:58 +01002282#ifdef FEAT_LISP
2283 clear_string_option(&buf->b_p_lw);
2284#endif
Bram Moolenaarb8ee25a2014-09-23 15:45:08 +02002285 clear_string_option(&buf->b_p_bkc);
Bram Moolenaar2c7292d2017-03-05 17:43:31 +01002286 clear_string_option(&buf->b_p_menc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002287}
2288
2289/*
Bram Moolenaar45e5fd12017-06-04 14:58:02 +02002290 * Get alternate file "n".
2291 * Set linenr to "lnum" or altfpos.lnum if "lnum" == 0.
2292 * Also set cursor column to altfpos.col if 'startofline' is not set.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002293 * if (options & GETF_SETMARK) call setpcmark()
2294 * if (options & GETF_ALT) we are jumping to an alternate file.
2295 * if (options & GETF_SWITCH) respect 'switchbuf' settings when jumping
2296 *
Bram Moolenaar45e5fd12017-06-04 14:58:02 +02002297 * Return FAIL for failure, OK for success.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002298 */
2299 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002300buflist_getfile(
2301 int n,
2302 linenr_T lnum,
2303 int options,
2304 int forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002305{
2306 buf_T *buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002307 win_T *wp = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002308 pos_T *fpos;
2309 colnr_T col;
2310
2311 buf = buflist_findnr(n);
2312 if (buf == NULL)
2313 {
2314 if ((options & GETF_ALT) && n == 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002315 emsg(_(e_noalt));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002316 else
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01002317 semsg(_("E92: Buffer %d not found"), n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002318 return FAIL;
2319 }
2320
2321 /* if alternate file is the current buffer, nothing to do */
2322 if (buf == curbuf)
2323 return OK;
2324
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00002325 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002326 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00002327 text_locked_msg();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002328 return FAIL;
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002329 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002330 if (curbuf_locked())
2331 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002332
2333 /* altfpos may be changed by getfile(), get it now */
2334 if (lnum == 0)
2335 {
2336 fpos = buflist_findfpos(buf);
2337 lnum = fpos->lnum;
2338 col = fpos->col;
2339 }
2340 else
2341 col = 0;
2342
Bram Moolenaar071d4272004-06-13 20:20:40 +00002343 if (options & GETF_SWITCH)
2344 {
Bram Moolenaarf2330482008-06-24 20:19:36 +00002345 /* If 'switchbuf' contains "useopen": jump to first window containing
2346 * "buf" if one exists */
2347 if (swb_flags & SWB_USEOPEN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002348 wp = buf_jump_open_win(buf);
Bram Moolenaara594d772015-06-19 14:41:49 +02002349
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02002350 /* If 'switchbuf' contains "usetab": jump to first window in any tab
Bram Moolenaarf2330482008-06-24 20:19:36 +00002351 * page containing "buf" if one exists */
2352 if (wp == NULL && (swb_flags & SWB_USETAB))
Bram Moolenaar779b74b2006-04-10 14:55:34 +00002353 wp = buf_jump_open_tab(buf);
Bram Moolenaara594d772015-06-19 14:41:49 +02002354
2355 /* If 'switchbuf' contains "split", "vsplit" or "newtab" and the
2356 * current buffer isn't empty: open new tab or window */
2357 if (wp == NULL && (swb_flags & (SWB_VSPLIT | SWB_SPLIT | SWB_NEWTAB))
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01002358 && !BUFEMPTY())
Bram Moolenaar071d4272004-06-13 20:20:40 +00002359 {
Bram Moolenaara594d772015-06-19 14:41:49 +02002360 if (swb_flags & SWB_NEWTAB)
Bram Moolenaarf2330482008-06-24 20:19:36 +00002361 tabpage_new();
Bram Moolenaara594d772015-06-19 14:41:49 +02002362 else if (win_split(0, (swb_flags & SWB_VSPLIT) ? WSP_VERT : 0)
2363 == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002364 return FAIL;
Bram Moolenaar3368ea22010-09-21 16:56:35 +02002365 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002366 }
2367 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002368
2369 ++RedrawingDisabled;
Bram Moolenaar8ad80de2017-06-05 16:01:59 +02002370 if (GETFILE_SUCCESS(getfile(buf->b_fnum, NULL, NULL,
2371 (options & GETF_SETMARK), lnum, forceit)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002372 {
2373 --RedrawingDisabled;
2374
2375 /* cursor is at to BOL and w_cursor.lnum is checked due to getfile() */
2376 if (!p_sol && col != 0)
2377 {
2378 curwin->w_cursor.col = col;
2379 check_cursor_col();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002380 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002381 curwin->w_set_curswant = TRUE;
2382 }
2383 return OK;
2384 }
2385 --RedrawingDisabled;
2386 return FAIL;
2387}
2388
2389/*
2390 * go to the last know line number for the current buffer
2391 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02002392 static void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002393buflist_getfpos(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002394{
2395 pos_T *fpos;
2396
2397 fpos = buflist_findfpos(curbuf);
2398
2399 curwin->w_cursor.lnum = fpos->lnum;
2400 check_cursor_lnum();
2401
2402 if (p_sol)
2403 curwin->w_cursor.col = 0;
2404 else
2405 {
2406 curwin->w_cursor.col = fpos->col;
2407 check_cursor_col();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002408 curwin->w_cursor.coladd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002409 curwin->w_set_curswant = TRUE;
2410 }
2411}
2412
Bram Moolenaar81695252004-12-29 20:58:21 +00002413#if defined(FEAT_QUICKFIX) || defined(FEAT_EVAL) || defined(PROTO)
2414/*
2415 * Find file in buffer list by name (it has to be for the current window).
2416 * Returns NULL if not found.
2417 */
2418 buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002419buflist_findname_exp(char_u *fname)
Bram Moolenaar81695252004-12-29 20:58:21 +00002420{
2421 char_u *ffname;
2422 buf_T *buf = NULL;
2423
2424 /* First make the name into a full path name */
2425 ffname = FullName_save(fname,
2426#ifdef UNIX
2427 TRUE /* force expansion, get rid of symbolic links */
2428#else
2429 FALSE
2430#endif
2431 );
2432 if (ffname != NULL)
2433 {
2434 buf = buflist_findname(ffname);
2435 vim_free(ffname);
2436 }
2437 return buf;
2438}
2439#endif
2440
Bram Moolenaar071d4272004-06-13 20:20:40 +00002441/*
2442 * Find file in buffer list by name (it has to be for the current window).
2443 * "ffname" must have a full path.
Bram Moolenaar81695252004-12-29 20:58:21 +00002444 * Skips dummy buffers.
2445 * Returns NULL if not found.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002446 */
2447 buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002448buflist_findname(char_u *ffname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002449{
2450#ifdef UNIX
Bram Moolenaar8767f522016-07-01 17:17:39 +02002451 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002452
2453 if (mch_stat((char *)ffname, &st) < 0)
2454 st.st_dev = (dev_T)-1;
2455 return buflist_findname_stat(ffname, &st);
2456}
2457
2458/*
2459 * Same as buflist_findname(), but pass the stat structure to avoid getting it
2460 * twice for the same file.
Bram Moolenaar81695252004-12-29 20:58:21 +00002461 * Returns NULL if not found.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002462 */
2463 static buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002464buflist_findname_stat(
2465 char_u *ffname,
Bram Moolenaar8767f522016-07-01 17:17:39 +02002466 stat_T *stp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002467{
2468#endif
2469 buf_T *buf;
2470
Bram Moolenaarea3f2e72016-07-10 20:27:32 +02002471 /* Start at the last buffer, expect to find a match sooner. */
2472 for (buf = lastbuf; buf != NULL; buf = buf->b_prev)
Bram Moolenaar81695252004-12-29 20:58:21 +00002473 if ((buf->b_flags & BF_DUMMY) == 0 && !otherfile_buf(buf, ffname
Bram Moolenaar071d4272004-06-13 20:20:40 +00002474#ifdef UNIX
2475 , stp
2476#endif
2477 ))
2478 return buf;
2479 return NULL;
2480}
2481
Bram Moolenaar071d4272004-06-13 20:20:40 +00002482/*
2483 * Find file in buffer list by a regexp pattern.
2484 * Return fnum of the found buffer.
2485 * Return < 0 for error.
2486 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002487 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002488buflist_findpat(
2489 char_u *pattern,
2490 char_u *pattern_end, /* pointer to first char after pattern */
2491 int unlisted, /* find unlisted buffers */
2492 int diffmode UNUSED, /* find diff-mode buffers only */
2493 int curtab_only) /* find buffers in current tab only */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002494{
2495 buf_T *buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002496 int match = -1;
2497 int find_listed;
2498 char_u *pat;
2499 char_u *patend;
2500 int attempt;
2501 char_u *p;
2502 int toggledollar;
2503
2504 if (pattern_end == pattern + 1 && (*pattern == '%' || *pattern == '#'))
2505 {
2506 if (*pattern == '%')
2507 match = curbuf->b_fnum;
2508 else
2509 match = curwin->w_alt_fnum;
2510#ifdef FEAT_DIFF
2511 if (diffmode && !diff_mode_buf(buflist_findnr(match)))
2512 match = -1;
2513#endif
2514 }
2515
2516 /*
2517 * Try four ways of matching a listed buffer:
2518 * attempt == 0: without '^' or '$' (at any position)
Bram Moolenaarb6799ac2007-05-10 16:44:05 +00002519 * attempt == 1: with '^' at start (only at position 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002520 * attempt == 2: with '$' at end (only match at end)
2521 * attempt == 3: with '^' at start and '$' at end (only full match)
2522 * Repeat this for finding an unlisted buffer if there was no matching
2523 * listed buffer.
2524 */
2525 else
2526 {
2527 pat = file_pat_to_reg_pat(pattern, pattern_end, NULL, FALSE);
2528 if (pat == NULL)
2529 return -1;
2530 patend = pat + STRLEN(pat) - 1;
2531 toggledollar = (patend > pat && *patend == '$');
2532
2533 /* First try finding a listed buffer. If not found and "unlisted"
2534 * is TRUE, try finding an unlisted buffer. */
2535 find_listed = TRUE;
2536 for (;;)
2537 {
2538 for (attempt = 0; attempt <= 3; ++attempt)
2539 {
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002540 regmatch_T regmatch;
2541
Bram Moolenaar071d4272004-06-13 20:20:40 +00002542 /* may add '^' and '$' */
2543 if (toggledollar)
2544 *patend = (attempt < 2) ? NUL : '$'; /* add/remove '$' */
2545 p = pat;
2546 if (*p == '^' && !(attempt & 1)) /* add/remove '^' */
2547 ++p;
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002548 regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0);
2549 if (regmatch.regprog == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002550 {
2551 vim_free(pat);
2552 return -1;
2553 }
2554
Bram Moolenaarea3f2e72016-07-10 20:27:32 +02002555 for (buf = lastbuf; buf != NULL; buf = buf->b_prev)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002556 if (buf->b_p_bl == find_listed
2557#ifdef FEAT_DIFF
2558 && (!diffmode || diff_mode_buf(buf))
2559#endif
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002560 && buflist_match(&regmatch, buf, FALSE) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002561 {
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002562 if (curtab_only)
2563 {
2564 /* Ignore the match if the buffer is not open in
2565 * the current tab. */
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002566 win_T *wp;
2567
Bram Moolenaar29323592016-07-24 22:04:11 +02002568 FOR_ALL_WINDOWS(wp)
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002569 if (wp->w_buffer == buf)
2570 break;
2571 if (wp == NULL)
2572 continue;
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002573 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002574 if (match >= 0) /* already found a match */
2575 {
2576 match = -2;
2577 break;
2578 }
2579 match = buf->b_fnum; /* remember first match */
2580 }
2581
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002582 vim_regfree(regmatch.regprog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002583 if (match >= 0) /* found one match */
2584 break;
2585 }
2586
2587 /* Only search for unlisted buffers if there was no match with
2588 * a listed buffer. */
2589 if (!unlisted || !find_listed || match != -1)
2590 break;
2591 find_listed = FALSE;
2592 }
2593
2594 vim_free(pat);
2595 }
2596
2597 if (match == -2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002598 semsg(_("E93: More than one match for %s"), pattern);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002599 else if (match < 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002600 semsg(_("E94: No matching buffer for %s"), pattern);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002601 return match;
2602}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002603
Bram Moolenaar52410572019-10-27 05:12:45 +01002604#ifdef FEAT_VIMINFO
2605typedef struct {
2606 buf_T *buf;
2607 char_u *match;
2608} bufmatch_T;
2609#endif
2610
Bram Moolenaar071d4272004-06-13 20:20:40 +00002611/*
2612 * Find all buffer names that match.
2613 * For command line expansion of ":buf" and ":sbuf".
2614 * Return OK if matches found, FAIL otherwise.
2615 */
2616 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002617ExpandBufnames(
2618 char_u *pat,
2619 int *num_file,
2620 char_u ***file,
2621 int options)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002622{
2623 int count = 0;
2624 buf_T *buf;
2625 int round;
2626 char_u *p;
2627 int attempt;
Bram Moolenaar05159a02005-02-26 23:04:13 +00002628 char_u *patc;
Bram Moolenaar52410572019-10-27 05:12:45 +01002629#ifdef FEAT_VIMINFO
2630 bufmatch_T *matches = NULL;
2631#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002632
2633 *num_file = 0; /* return values in case of FAIL */
2634 *file = NULL;
2635
Bram Moolenaar05159a02005-02-26 23:04:13 +00002636 /* Make a copy of "pat" and change "^" to "\(^\|[\/]\)". */
2637 if (*pat == '^')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002638 {
Bram Moolenaar964b3742019-05-24 18:54:09 +02002639 patc = alloc(STRLEN(pat) + 11);
Bram Moolenaar05159a02005-02-26 23:04:13 +00002640 if (patc == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002641 return FAIL;
Bram Moolenaar05159a02005-02-26 23:04:13 +00002642 STRCPY(patc, "\\(^\\|[\\/]\\)");
2643 STRCPY(patc + 11, pat + 1);
2644 }
2645 else
2646 patc = pat;
2647
2648 /*
2649 * attempt == 0: try match with '\<', match at start of word
Bram Moolenaard8a4e562005-05-18 22:06:55 +00002650 * attempt == 1: try match without '\<', match anywhere
Bram Moolenaar05159a02005-02-26 23:04:13 +00002651 */
Bram Moolenaard8a4e562005-05-18 22:06:55 +00002652 for (attempt = 0; attempt <= 1; ++attempt)
Bram Moolenaar05159a02005-02-26 23:04:13 +00002653 {
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002654 regmatch_T regmatch;
2655
Bram Moolenaard8a4e562005-05-18 22:06:55 +00002656 if (attempt > 0 && patc == pat)
Bram Moolenaar05159a02005-02-26 23:04:13 +00002657 break; /* there was no anchor, no need to try again */
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002658 regmatch.regprog = vim_regcomp(patc + attempt * 11, RE_MAGIC);
2659 if (regmatch.regprog == NULL)
Bram Moolenaar05159a02005-02-26 23:04:13 +00002660 {
2661 if (patc != pat)
2662 vim_free(patc);
2663 return FAIL;
2664 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002665
2666 /*
2667 * round == 1: Count the matches.
2668 * round == 2: Build the array to keep the matches.
2669 */
2670 for (round = 1; round <= 2; ++round)
2671 {
2672 count = 0;
Bram Moolenaar29323592016-07-24 22:04:11 +02002673 FOR_ALL_BUFFERS(buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002674 {
2675 if (!buf->b_p_bl) /* skip unlisted buffers */
2676 continue;
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002677 p = buflist_match(&regmatch, buf, p_wic);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002678 if (p != NULL)
2679 {
2680 if (round == 1)
2681 ++count;
2682 else
2683 {
2684 if (options & WILD_HOME_REPLACE)
2685 p = home_replace_save(buf, p);
2686 else
2687 p = vim_strsave(p);
Bram Moolenaar52410572019-10-27 05:12:45 +01002688#ifdef FEAT_VIMINFO
2689 if (matches != NULL)
2690 {
2691 matches[count].buf = buf;
2692 matches[count].match = p;
2693 count++;
2694 }
2695 else
2696#endif
2697 (*file)[count++] = p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002698 }
2699 }
2700 }
2701 if (count == 0) /* no match found, break here */
2702 break;
2703 if (round == 1)
2704 {
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002705 *file = ALLOC_MULT(char_u *, count);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002706 if (*file == NULL)
2707 {
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002708 vim_regfree(regmatch.regprog);
Bram Moolenaar05159a02005-02-26 23:04:13 +00002709 if (patc != pat)
2710 vim_free(patc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002711 return FAIL;
2712 }
Bram Moolenaar52410572019-10-27 05:12:45 +01002713#ifdef FEAT_VIMINFO
2714 if (options & WILD_BUFLASTUSED)
2715 matches = ALLOC_MULT(bufmatch_T, count);
2716#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002717 }
2718 }
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002719 vim_regfree(regmatch.regprog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002720 if (count) /* match(es) found, break here */
2721 break;
2722 }
2723
Bram Moolenaar05159a02005-02-26 23:04:13 +00002724 if (patc != pat)
2725 vim_free(patc);
2726
Bram Moolenaar52410572019-10-27 05:12:45 +01002727#ifdef FEAT_VIMINFO
2728 if (matches != NULL)
2729 {
2730 int i;
2731 if (count > 1)
2732 qsort(matches, count, sizeof(bufmatch_T), buf_compare);
2733 // if the current buffer is first in the list, place it at the end
2734 if (matches[0].buf == curbuf)
2735 {
2736 for (i = 1; i < count; i++)
2737 (*file)[i-1] = matches[i].match;
2738 (*file)[count-1] = matches[0].match;
2739 }
2740 else
2741 {
2742 for (i = 0; i < count; i++)
2743 (*file)[i] = matches[i].match;
2744 }
2745 vim_free(matches);
2746 }
2747#endif
2748
Bram Moolenaar071d4272004-06-13 20:20:40 +00002749 *num_file = count;
2750 return (count == 0 ? FAIL : OK);
2751}
2752
Bram Moolenaar071d4272004-06-13 20:20:40 +00002753/*
2754 * Check for a match on the file name for buffer "buf" with regprog "prog".
2755 */
2756 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002757buflist_match(
2758 regmatch_T *rmp,
2759 buf_T *buf,
2760 int ignore_case) /* when TRUE ignore case, when FALSE use 'fic' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002761{
2762 char_u *match;
2763
2764 /* First try the short file name, then the long file name. */
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002765 match = fname_match(rmp, buf->b_sfname, ignore_case);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002766 if (match == NULL)
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002767 match = fname_match(rmp, buf->b_ffname, ignore_case);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002768
2769 return match;
2770}
2771
2772/*
2773 * Try matching the regexp in "prog" with file name "name".
2774 * Return "name" when there is a match, NULL when not.
2775 */
2776 static char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002777fname_match(
2778 regmatch_T *rmp,
2779 char_u *name,
2780 int ignore_case) /* when TRUE ignore case, when FALSE use 'fic' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002781{
2782 char_u *match = NULL;
2783 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002784
2785 if (name != NULL)
2786 {
Bram Moolenaar4b9d6372014-09-23 14:24:40 +02002787 /* Ignore case when 'fileignorecase' or the argument is set. */
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002788 rmp->rm_ic = p_fic || ignore_case;
2789 if (vim_regexec(rmp, name, (colnr_T)0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002790 match = name;
2791 else
2792 {
2793 /* Replace $(HOME) with '~' and try matching again. */
2794 p = home_replace_save(NULL, name);
Bram Moolenaardffa5b82014-11-19 16:38:07 +01002795 if (p != NULL && vim_regexec(rmp, p, (colnr_T)0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002796 match = name;
2797 vim_free(p);
2798 }
2799 }
2800
2801 return match;
2802}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002803
2804/*
Bram Moolenaar480778b2016-07-14 22:09:39 +02002805 * Find a file in the buffer list by buffer number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002806 */
2807 buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002808buflist_findnr(int nr)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002809{
Bram Moolenaar480778b2016-07-14 22:09:39 +02002810 char_u key[VIM_SIZEOF_INT * 2 + 1];
2811 hashitem_T *hi;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002812
2813 if (nr == 0)
2814 nr = curwin->w_alt_fnum;
Bram Moolenaar480778b2016-07-14 22:09:39 +02002815 sprintf((char *)key, "%x", nr);
2816 hi = hash_find(&buf_hashtab, key);
2817
2818 if (!HASHITEM_EMPTY(hi))
2819 return (buf_T *)(hi->hi_key
2820 - ((unsigned)(curbuf->b_key - (char_u *)curbuf)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002821 return NULL;
2822}
2823
2824/*
2825 * Get name of file 'n' in the buffer list.
2826 * When the file has no name an empty string is returned.
2827 * home_replace() is used to shorten the file name (used for marks).
2828 * Returns a pointer to allocated memory, of NULL when failed.
2829 */
2830 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002831buflist_nr2name(
2832 int n,
2833 int fullname,
2834 int helptail) /* for help buffers return tail only */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002835{
2836 buf_T *buf;
2837
2838 buf = buflist_findnr(n);
2839 if (buf == NULL)
2840 return NULL;
2841 return home_replace_save(helptail ? buf : NULL,
2842 fullname ? buf->b_ffname : buf->b_fname);
2843}
2844
2845/*
2846 * Set the "lnum" and "col" for the buffer "buf" and the current window.
2847 * When "copy_options" is TRUE save the local window option values.
2848 * When "lnum" is 0 only do the options.
2849 */
Bram Moolenaardefa0672019-07-21 19:25:37 +02002850 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002851buflist_setfpos(
2852 buf_T *buf,
2853 win_T *win,
2854 linenr_T lnum,
2855 colnr_T col,
2856 int copy_options)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002857{
2858 wininfo_T *wip;
2859
2860 for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next)
2861 if (wip->wi_win == win)
2862 break;
2863 if (wip == NULL)
2864 {
2865 /* allocate a new entry */
Bram Moolenaarc799fe22019-05-28 23:08:19 +02002866 wip = ALLOC_CLEAR_ONE(wininfo_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002867 if (wip == NULL)
2868 return;
2869 wip->wi_win = win;
2870 if (lnum == 0) /* set lnum even when it's 0 */
2871 lnum = 1;
2872 }
2873 else
2874 {
2875 /* remove the entry from the list */
2876 if (wip->wi_prev)
2877 wip->wi_prev->wi_next = wip->wi_next;
2878 else
2879 buf->b_wininfo = wip->wi_next;
2880 if (wip->wi_next)
2881 wip->wi_next->wi_prev = wip->wi_prev;
2882 if (copy_options && wip->wi_optset)
2883 {
2884 clear_winopt(&wip->wi_opt);
2885#ifdef FEAT_FOLDING
2886 deleteFoldRecurse(&wip->wi_folds);
2887#endif
2888 }
2889 }
2890 if (lnum != 0)
2891 {
2892 wip->wi_fpos.lnum = lnum;
2893 wip->wi_fpos.col = col;
2894 }
2895 if (copy_options)
2896 {
2897 /* Save the window-specific option values. */
2898 copy_winopt(&win->w_onebuf_opt, &wip->wi_opt);
2899#ifdef FEAT_FOLDING
2900 wip->wi_fold_manual = win->w_fold_manual;
2901 cloneFoldGrowArray(&win->w_folds, &wip->wi_folds);
2902#endif
2903 wip->wi_optset = TRUE;
2904 }
2905
2906 /* insert the entry in front of the list */
2907 wip->wi_next = buf->b_wininfo;
2908 buf->b_wininfo = wip;
2909 wip->wi_prev = NULL;
2910 if (wip->wi_next)
2911 wip->wi_next->wi_prev = wip;
2912
2913 return;
2914}
2915
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002916#ifdef FEAT_DIFF
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002917/*
2918 * Return TRUE when "wip" has 'diff' set and the diff is only for another tab
2919 * page. That's because a diff is local to a tab page.
2920 */
2921 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002922wininfo_other_tab_diff(wininfo_T *wip)
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002923{
2924 win_T *wp;
2925
2926 if (wip->wi_opt.wo_diff)
2927 {
Bram Moolenaar29323592016-07-24 22:04:11 +02002928 FOR_ALL_WINDOWS(wp)
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002929 /* return FALSE when it's a window in the current tab page, thus
2930 * the buffer was in diff mode here */
2931 if (wip->wi_win == wp)
2932 return FALSE;
2933 return TRUE;
2934 }
2935 return FALSE;
2936}
2937#endif
2938
Bram Moolenaar071d4272004-06-13 20:20:40 +00002939/*
2940 * Find info for the current window in buffer "buf".
2941 * If not found, return the info for the most recently used window.
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002942 * When "skip_diff_buffer" is TRUE avoid windows with 'diff' set that is in
2943 * another tab page.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002944 * Returns NULL when there isn't any info.
2945 */
2946 static wininfo_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002947find_wininfo(
2948 buf_T *buf,
2949 int skip_diff_buffer UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002950{
2951 wininfo_T *wip;
2952
2953 for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next)
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002954 if (wip->wi_win == curwin
2955#ifdef FEAT_DIFF
2956 && (!skip_diff_buffer || !wininfo_other_tab_diff(wip))
2957#endif
2958 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002959 break;
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002960
2961 /* If no wininfo for curwin, use the first in the list (that doesn't have
2962 * 'diff' set and is in another tab page). */
2963 if (wip == NULL)
2964 {
2965#ifdef FEAT_DIFF
2966 if (skip_diff_buffer)
2967 {
2968 for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next)
2969 if (!wininfo_other_tab_diff(wip))
2970 break;
2971 }
2972 else
2973#endif
2974 wip = buf->b_wininfo;
2975 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002976 return wip;
2977}
2978
2979/*
2980 * Reset the local window options to the values last used in this window.
2981 * If the buffer wasn't used in this window before, use the values from
2982 * the most recently used window. If the values were never set, use the
2983 * global values for the window.
2984 */
2985 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002986get_winopts(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002987{
2988 wininfo_T *wip;
2989
2990 clear_winopt(&curwin->w_onebuf_opt);
2991#ifdef FEAT_FOLDING
2992 clearFolding(curwin);
2993#endif
2994
Bram Moolenaar701f7af2008-11-15 13:12:07 +00002995 wip = find_wininfo(buf, TRUE);
Bram Moolenaar25782a72018-05-13 18:05:33 +02002996 if (wip != NULL && wip->wi_win != NULL
2997 && wip->wi_win != curwin && wip->wi_win->w_buffer == buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002998 {
Bram Moolenaar25782a72018-05-13 18:05:33 +02002999 /* The buffer is currently displayed in the window: use the actual
3000 * option values instead of the saved (possibly outdated) values. */
3001 win_T *wp = wip->wi_win;
3002
3003 copy_winopt(&wp->w_onebuf_opt, &curwin->w_onebuf_opt);
3004#ifdef FEAT_FOLDING
3005 curwin->w_fold_manual = wp->w_fold_manual;
3006 curwin->w_foldinvalid = TRUE;
3007 cloneFoldGrowArray(&wp->w_folds, &curwin->w_folds);
3008#endif
3009 }
3010 else if (wip != NULL && wip->wi_optset)
3011 {
3012 /* the buffer was displayed in the current window earlier */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003013 copy_winopt(&wip->wi_opt, &curwin->w_onebuf_opt);
3014#ifdef FEAT_FOLDING
3015 curwin->w_fold_manual = wip->wi_fold_manual;
3016 curwin->w_foldinvalid = TRUE;
3017 cloneFoldGrowArray(&wip->wi_folds, &curwin->w_folds);
3018#endif
3019 }
3020 else
3021 copy_winopt(&curwin->w_allbuf_opt, &curwin->w_onebuf_opt);
3022
3023#ifdef FEAT_FOLDING
3024 /* Set 'foldlevel' to 'foldlevelstart' if it's not negative. */
3025 if (p_fdls >= 0)
3026 curwin->w_p_fdl = p_fdls;
3027#endif
Bram Moolenaar010ee962019-09-25 20:37:36 +02003028 after_copy_winopt(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003029}
3030
3031/*
3032 * Find the position (lnum and col) for the buffer 'buf' for the current
3033 * window.
3034 * Returns a pointer to no_position if no position is found.
3035 */
3036 pos_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01003037buflist_findfpos(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003038{
3039 wininfo_T *wip;
Bram Moolenaar29ddebe2019-01-26 17:28:26 +01003040 static pos_T no_position = {1, 0, 0};
Bram Moolenaar071d4272004-06-13 20:20:40 +00003041
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003042 wip = find_wininfo(buf, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003043 if (wip != NULL)
3044 return &(wip->wi_fpos);
3045 else
3046 return &no_position;
3047}
3048
3049/*
3050 * Find the lnum for the buffer 'buf' for the current window.
3051 */
3052 linenr_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01003053buflist_findlnum(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003054{
3055 return buflist_findfpos(buf)->lnum;
3056}
3057
Bram Moolenaar071d4272004-06-13 20:20:40 +00003058/*
Bram Moolenaar45e5fd12017-06-04 14:58:02 +02003059 * List all known file names (for :files and :buffers command).
Bram Moolenaar071d4272004-06-13 20:20:40 +00003060 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003061 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003062buflist_list(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003063{
Bram Moolenaar52410572019-10-27 05:12:45 +01003064 buf_T *buf = firstbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003065 int len;
3066 int i;
Bram Moolenaar304b64c2017-08-13 20:43:48 +02003067 int ro_char;
3068 int changed_char;
Bram Moolenaar0751f512018-03-29 16:37:16 +02003069#ifdef FEAT_TERMINAL
3070 int job_running;
3071 int job_none_open;
3072#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003073
Bram Moolenaar52410572019-10-27 05:12:45 +01003074#ifdef FEAT_VIMINFO
3075 garray_T buflist;
3076 buf_T **buflist_data = NULL, **p;
3077
3078 if (vim_strchr(eap->arg, 't'))
3079 {
3080 ga_init2(&buflist, sizeof(buf_T *), 50);
3081 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
3082 {
3083 if (ga_grow(&buflist, 1) == OK)
3084 ((buf_T **)buflist.ga_data)[buflist.ga_len++] = buf;
3085 }
3086
3087 qsort(buflist.ga_data, (size_t)buflist.ga_len,
3088 sizeof(buf_T *), buf_compare);
3089
3090 p = buflist_data = (buf_T **)buflist.ga_data;
3091 buf = *p;
3092 }
3093
3094 for (; buf != NULL && !got_int; buf = buflist_data
3095 ? (++p < buflist_data + buflist.ga_len ? *p : NULL)
3096 : buf->b_next)
3097#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003098 for (buf = firstbuf; buf != NULL && !got_int; buf = buf->b_next)
Bram Moolenaar52410572019-10-27 05:12:45 +01003099#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003100 {
Bram Moolenaar0751f512018-03-29 16:37:16 +02003101#ifdef FEAT_TERMINAL
3102 job_running = term_job_running(buf->b_term);
3103 job_none_open = job_running && term_none_open(buf->b_term);
3104#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003105 /* skip unlisted buffers, unless ! was used */
Bram Moolenaard51cb702015-07-21 15:03:06 +02003106 if ((!buf->b_p_bl && !eap->forceit && !vim_strchr(eap->arg, 'u'))
3107 || (vim_strchr(eap->arg, 'u') && buf->b_p_bl)
3108 || (vim_strchr(eap->arg, '+')
3109 && ((buf->b_flags & BF_READERR) || !bufIsChanged(buf)))
3110 || (vim_strchr(eap->arg, 'a')
Bram Moolenaar0751f512018-03-29 16:37:16 +02003111 && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows == 0))
Bram Moolenaard51cb702015-07-21 15:03:06 +02003112 || (vim_strchr(eap->arg, 'h')
Bram Moolenaar0751f512018-03-29 16:37:16 +02003113 && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows != 0))
3114#ifdef FEAT_TERMINAL
3115 || (vim_strchr(eap->arg, 'R')
3116 && (!job_running || (job_running && job_none_open)))
3117 || (vim_strchr(eap->arg, '?')
3118 && (!job_running || (job_running && !job_none_open)))
3119 || (vim_strchr(eap->arg, 'F')
3120 && (job_running || buf->b_term == NULL))
3121#endif
Bram Moolenaard51cb702015-07-21 15:03:06 +02003122 || (vim_strchr(eap->arg, '-') && buf->b_p_ma)
3123 || (vim_strchr(eap->arg, '=') && !buf->b_p_ro)
3124 || (vim_strchr(eap->arg, 'x') && !(buf->b_flags & BF_READERR))
3125 || (vim_strchr(eap->arg, '%') && buf != curbuf)
3126 || (vim_strchr(eap->arg, '#')
3127 && (buf == curbuf || curwin->w_alt_fnum != buf->b_fnum)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003128 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003129 if (buf_spname(buf) != NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02003130 vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003131 else
3132 home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE);
Bram Moolenaar77401ad2016-08-24 00:12:12 +02003133 if (message_filtered(NameBuff))
3134 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003135
Bram Moolenaar304b64c2017-08-13 20:43:48 +02003136 changed_char = (buf->b_flags & BF_READERR) ? 'x'
3137 : (bufIsChanged(buf) ? '+' : ' ');
3138#ifdef FEAT_TERMINAL
3139 if (term_job_running(buf->b_term))
3140 {
Bram Moolenaar4033c552017-09-16 20:54:51 +02003141 if (term_none_open(buf->b_term))
3142 ro_char = '?';
3143 else
3144 ro_char = 'R';
Bram Moolenaar304b64c2017-08-13 20:43:48 +02003145 changed_char = ' '; /* bufIsChanged() returns TRUE to avoid
3146 * closing, but it's not actually changed. */
3147 }
3148 else if (buf->b_term != NULL)
3149 ro_char = 'F';
3150 else
3151#endif
3152 ro_char = !buf->b_p_ma ? '-' : (buf->b_p_ro ? '=' : ' ');
3153
Bram Moolenaar77401ad2016-08-24 00:12:12 +02003154 msg_putchar('\n');
Bram Moolenaar50cde822005-06-05 21:54:54 +00003155 len = vim_snprintf((char *)IObuff, IOSIZE - 20, "%3d%c%c%c%c%c \"%s\"",
Bram Moolenaar071d4272004-06-13 20:20:40 +00003156 buf->b_fnum,
3157 buf->b_p_bl ? ' ' : 'u',
3158 buf == curbuf ? '%' :
3159 (curwin->w_alt_fnum == buf->b_fnum ? '#' : ' '),
3160 buf->b_ml.ml_mfp == NULL ? ' ' :
3161 (buf->b_nwindows == 0 ? 'h' : 'a'),
Bram Moolenaar304b64c2017-08-13 20:43:48 +02003162 ro_char,
3163 changed_char,
Bram Moolenaar51485f02005-06-04 21:55:20 +00003164 NameBuff);
Bram Moolenaar507edf62016-01-10 20:54:17 +01003165 if (len > IOSIZE - 20)
3166 len = IOSIZE - 20;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003167
3168 /* put "line 999" in column 40 or after the file name */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003169 i = 40 - vim_strsize(IObuff);
3170 do
Bram Moolenaar071d4272004-06-13 20:20:40 +00003171 IObuff[len++] = ' ';
Bram Moolenaarabab0b02019-03-30 18:47:01 +01003172 while (--i > 0 && len < IOSIZE - 18);
Bram Moolenaar52410572019-10-27 05:12:45 +01003173#ifdef FEAT_VIMINFO
3174 if (vim_strchr(eap->arg, 't') && buf->b_last_used)
3175 add_time(IObuff + len, (size_t)(IOSIZE - len), buf->b_last_used);
3176 else
3177#endif
3178 vim_snprintf((char *)IObuff + len, (size_t)(IOSIZE - len),
3179 _("line %ld"), buf == curbuf ? curwin->w_cursor.lnum
Bram Moolenaar9c13b352005-05-19 20:53:52 +00003180 : (long)buflist_findlnum(buf));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003181 msg_outtrans(IObuff);
3182 out_flush(); /* output one line at a time */
3183 ui_breakcheck();
3184 }
Bram Moolenaar52410572019-10-27 05:12:45 +01003185
3186#ifdef FEAT_VIMINFO
3187 if (buflist_data)
3188 ga_clear(&buflist);
3189#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003190}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003191
3192/*
3193 * Get file name and line number for file 'fnum'.
3194 * Used by DoOneCmd() for translating '%' and '#'.
3195 * Used by insert_reg() and cmdline_paste() for '#' register.
3196 * Return FAIL if not found, OK for success.
3197 */
3198 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003199buflist_name_nr(
3200 int fnum,
3201 char_u **fname,
3202 linenr_T *lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003203{
3204 buf_T *buf;
3205
3206 buf = buflist_findnr(fnum);
3207 if (buf == NULL || buf->b_fname == NULL)
3208 return FAIL;
3209
3210 *fname = buf->b_fname;
3211 *lnum = buflist_findlnum(buf);
3212
3213 return OK;
3214}
3215
3216/*
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003217 * Set the file name for "buf"' to "ffname_arg", short file name to
3218 * "sfname_arg".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003219 * The file name with the full path is also remembered, for when :cd is used.
3220 * Returns FAIL for failure (file name already in use by other buffer)
3221 * OK otherwise.
3222 */
3223 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003224setfname(
3225 buf_T *buf,
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003226 char_u *ffname_arg,
3227 char_u *sfname_arg,
Bram Moolenaar7454a062016-01-30 15:14:10 +01003228 int message) /* give message when buffer already exists */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003229{
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003230 char_u *ffname = ffname_arg;
3231 char_u *sfname = sfname_arg;
Bram Moolenaar81695252004-12-29 20:58:21 +00003232 buf_T *obuf = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003233#ifdef UNIX
Bram Moolenaar8767f522016-07-01 17:17:39 +02003234 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003235#endif
3236
3237 if (ffname == NULL || *ffname == NUL)
3238 {
3239 /* Removing the name. */
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003240 if (buf->b_sfname != buf->b_ffname)
3241 VIM_CLEAR(buf->b_sfname);
3242 else
3243 buf->b_sfname = NULL;
Bram Moolenaard23a8232018-02-10 18:45:26 +01003244 VIM_CLEAR(buf->b_ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003245#ifdef UNIX
3246 st.st_dev = (dev_T)-1;
3247#endif
3248 }
3249 else
3250 {
3251 fname_expand(buf, &ffname, &sfname); /* will allocate ffname */
3252 if (ffname == NULL) /* out of memory */
3253 return FAIL;
3254
3255 /*
3256 * if the file name is already used in another buffer:
3257 * - if the buffer is loaded, fail
3258 * - if the buffer is not loaded, delete it from the list
3259 */
3260#ifdef UNIX
3261 if (mch_stat((char *)ffname, &st) < 0)
3262 st.st_dev = (dev_T)-1;
Bram Moolenaar81695252004-12-29 20:58:21 +00003263#endif
3264 if (!(buf->b_flags & BF_DUMMY))
3265#ifdef UNIX
3266 obuf = buflist_findname_stat(ffname, &st);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003267#else
Bram Moolenaar81695252004-12-29 20:58:21 +00003268 obuf = buflist_findname(ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003269#endif
3270 if (obuf != NULL && obuf != buf)
3271 {
3272 if (obuf->b_ml.ml_mfp != NULL) /* it's loaded, fail */
3273 {
3274 if (message)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003275 emsg(_("E95: Buffer with this name already exists"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003276 vim_free(ffname);
3277 return FAIL;
3278 }
Bram Moolenaar42ec6562012-02-22 14:58:37 +01003279 /* delete from the list */
3280 close_buffer(NULL, obuf, DOBUF_WIPE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003281 }
3282 sfname = vim_strsave(sfname);
3283 if (ffname == NULL || sfname == NULL)
3284 {
3285 vim_free(sfname);
3286 vim_free(ffname);
3287 return FAIL;
3288 }
3289#ifdef USE_FNAME_CASE
Bram Moolenaar00f148d2019-02-12 22:37:27 +01003290 fname_case(sfname, 0); /* set correct case for short file name */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003291#endif
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003292 if (buf->b_sfname != buf->b_ffname)
3293 vim_free(buf->b_sfname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003294 vim_free(buf->b_ffname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003295 buf->b_ffname = ffname;
3296 buf->b_sfname = sfname;
3297 }
3298 buf->b_fname = buf->b_sfname;
3299#ifdef UNIX
3300 if (st.st_dev == (dev_T)-1)
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003301 buf->b_dev_valid = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003302 else
3303 {
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003304 buf->b_dev_valid = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003305 buf->b_dev = st.st_dev;
3306 buf->b_ino = st.st_ino;
3307 }
3308#endif
3309
Bram Moolenaar071d4272004-06-13 20:20:40 +00003310 buf->b_shortname = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003311
3312 buf_name_changed(buf);
3313 return OK;
3314}
3315
3316/*
Bram Moolenaar86b68352004-12-27 21:59:20 +00003317 * Crude way of changing the name of a buffer. Use with care!
3318 * The name should be relative to the current directory.
3319 */
3320 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003321buf_set_name(int fnum, char_u *name)
Bram Moolenaar86b68352004-12-27 21:59:20 +00003322{
3323 buf_T *buf;
3324
3325 buf = buflist_findnr(fnum);
3326 if (buf != NULL)
3327 {
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02003328 if (buf->b_sfname != buf->b_ffname)
3329 vim_free(buf->b_sfname);
Bram Moolenaar86b68352004-12-27 21:59:20 +00003330 vim_free(buf->b_ffname);
Bram Moolenaarf193fff2006-04-27 00:02:13 +00003331 buf->b_ffname = vim_strsave(name);
3332 buf->b_sfname = NULL;
3333 /* Allocate ffname and expand into full path. Also resolves .lnk
3334 * files on Win32. */
3335 fname_expand(buf, &buf->b_ffname, &buf->b_sfname);
Bram Moolenaar86b68352004-12-27 21:59:20 +00003336 buf->b_fname = buf->b_sfname;
3337 }
3338}
3339
3340/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341 * Take care of what needs to be done when the name of buffer "buf" has
3342 * changed.
3343 */
3344 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003345buf_name_changed(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003346{
3347 /*
3348 * If the file name changed, also change the name of the swapfile
3349 */
3350 if (buf->b_ml.ml_mfp != NULL)
3351 ml_setname(buf);
3352
3353 if (curwin->w_buffer == buf)
3354 check_arg_idx(curwin); /* check file name for arg list */
3355#ifdef FEAT_TITLE
3356 maketitle(); /* set window title */
3357#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003358 status_redraw_all(); /* status lines need to be redrawn */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003359 fmarks_check_names(buf); /* check named file marks */
3360 ml_timestamp(buf); /* reset timestamp */
3361}
3362
3363/*
3364 * set alternate file name for current window
3365 *
3366 * Used by do_one_cmd(), do_write() and do_ecmd().
3367 * Return the buffer.
3368 */
3369 buf_T *
Bram Moolenaar7454a062016-01-30 15:14:10 +01003370setaltfname(
3371 char_u *ffname,
3372 char_u *sfname,
3373 linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003374{
3375 buf_T *buf;
3376
3377 /* Create a buffer. 'buflisted' is not set if it's a new buffer */
3378 buf = buflist_new(ffname, sfname, lnum, 0);
Bram Moolenaard4755bb2004-09-02 19:12:26 +00003379 if (buf != NULL && !cmdmod.keepalt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003380 curwin->w_alt_fnum = buf->b_fnum;
3381 return buf;
3382}
3383
3384/*
3385 * Get alternate file name for current window.
3386 * Return NULL if there isn't any, and give error message if requested.
3387 */
3388 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01003389getaltfname(
3390 int errmsg) /* give error message */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003391{
3392 char_u *fname;
3393 linenr_T dummy;
3394
3395 if (buflist_name_nr(0, &fname, &dummy) == FAIL)
3396 {
3397 if (errmsg)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003398 emsg(_(e_noalt));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003399 return NULL;
3400 }
3401 return fname;
3402}
3403
3404/*
3405 * Add a file name to the buflist and return its number.
3406 * Uses same flags as buflist_new(), except BLN_DUMMY.
3407 *
3408 * used by qf_init(), main() and doarglist()
3409 */
3410 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003411buflist_add(char_u *fname, int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003412{
3413 buf_T *buf;
3414
3415 buf = buflist_new(fname, NULL, (linenr_T)0, flags);
3416 if (buf != NULL)
3417 return buf->b_fnum;
3418 return 0;
3419}
3420
3421#if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
3422/*
3423 * Adjust slashes in file names. Called after 'shellslash' was set.
3424 */
3425 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003426buflist_slash_adjust(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003427{
3428 buf_T *bp;
3429
Bram Moolenaar29323592016-07-24 22:04:11 +02003430 FOR_ALL_BUFFERS(bp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003431 {
3432 if (bp->b_ffname != NULL)
3433 slash_adjust(bp->b_ffname);
3434 if (bp->b_sfname != NULL)
3435 slash_adjust(bp->b_sfname);
3436 }
3437}
3438#endif
3439
3440/*
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003441 * Set alternate cursor position for the current buffer and window "win".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003442 * Also save the local window option values.
3443 */
3444 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003445buflist_altfpos(win_T *win)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003446{
Bram Moolenaar701f7af2008-11-15 13:12:07 +00003447 buflist_setfpos(curbuf, win, win->w_cursor.lnum, win->w_cursor.col, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003448}
3449
3450/*
3451 * Return TRUE if 'ffname' is not the same file as current file.
3452 * Fname must have a full path (expanded by mch_FullName()).
3453 */
3454 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003455otherfile(char_u *ffname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003456{
3457 return otherfile_buf(curbuf, ffname
3458#ifdef UNIX
3459 , NULL
3460#endif
3461 );
3462}
3463
3464 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003465otherfile_buf(
3466 buf_T *buf,
3467 char_u *ffname
Bram Moolenaar071d4272004-06-13 20:20:40 +00003468#ifdef UNIX
Bram Moolenaar8767f522016-07-01 17:17:39 +02003469 , stat_T *stp
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470#endif
Bram Moolenaar7454a062016-01-30 15:14:10 +01003471 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00003472{
3473 /* no name is different */
3474 if (ffname == NULL || *ffname == NUL || buf->b_ffname == NULL)
3475 return TRUE;
3476 if (fnamecmp(ffname, buf->b_ffname) == 0)
3477 return FALSE;
3478#ifdef UNIX
3479 {
Bram Moolenaar8767f522016-07-01 17:17:39 +02003480 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003481
Bram Moolenaar8767f522016-07-01 17:17:39 +02003482 /* If no stat_T given, get it now */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003483 if (stp == NULL)
3484 {
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003485 if (!buf->b_dev_valid || mch_stat((char *)ffname, &st) < 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003486 st.st_dev = (dev_T)-1;
3487 stp = &st;
3488 }
3489 /* Use dev/ino to check if the files are the same, even when the names
3490 * are different (possible with links). Still need to compare the
3491 * name above, for when the file doesn't exist yet.
3492 * Problem: The dev/ino changes when a file is deleted (and created
3493 * again) and remains the same when renamed/moved. We don't want to
3494 * mch_stat() each buffer each time, that would be too slow. Get the
3495 * dev/ino again when they appear to match, but not when they appear
3496 * to be different: Could skip a buffer when it's actually the same
3497 * file. */
3498 if (buf_same_ino(buf, stp))
3499 {
3500 buf_setino(buf);
3501 if (buf_same_ino(buf, stp))
3502 return FALSE;
3503 }
3504 }
3505#endif
3506 return TRUE;
3507}
3508
3509#if defined(UNIX) || defined(PROTO)
3510/*
3511 * Set inode and device number for a buffer.
3512 * Must always be called when b_fname is changed!.
3513 */
3514 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003515buf_setino(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003516{
Bram Moolenaar8767f522016-07-01 17:17:39 +02003517 stat_T st;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003518
3519 if (buf->b_fname != NULL && mch_stat((char *)buf->b_fname, &st) >= 0)
3520 {
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003521 buf->b_dev_valid = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003522 buf->b_dev = st.st_dev;
3523 buf->b_ino = st.st_ino;
3524 }
3525 else
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003526 buf->b_dev_valid = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003527}
3528
3529/*
3530 * Return TRUE if dev/ino in buffer "buf" matches with "stp".
3531 */
3532 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003533buf_same_ino(
3534 buf_T *buf,
Bram Moolenaar8767f522016-07-01 17:17:39 +02003535 stat_T *stp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003536{
Bram Moolenaarf1726cc2009-05-13 18:48:16 +00003537 return (buf->b_dev_valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00003538 && stp->st_dev == buf->b_dev
3539 && stp->st_ino == buf->b_ino);
3540}
3541#endif
3542
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00003543/*
3544 * Print info about the current buffer.
3545 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003546 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003547fileinfo(
3548 int fullname, /* when non-zero print full path */
3549 int shorthelp,
3550 int dont_truncate)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003551{
3552 char_u *name;
3553 int n;
Bram Moolenaar32526b32019-01-19 17:43:09 +01003554 char *p;
3555 char *buffer;
Bram Moolenaar9c13b352005-05-19 20:53:52 +00003556 size_t len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003557
Bram Moolenaarc799fe22019-05-28 23:08:19 +02003558 buffer = alloc(IOSIZE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003559 if (buffer == NULL)
3560 return;
3561
3562 if (fullname > 1) /* 2 CTRL-G: include buffer number */
3563 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01003564 vim_snprintf(buffer, IOSIZE, "buf %d: ", curbuf->b_fnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003565 p = buffer + STRLEN(buffer);
3566 }
3567 else
3568 p = buffer;
3569
3570 *p++ = '"';
3571 if (buf_spname(curbuf) != NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01003572 vim_strncpy((char_u *)p, buf_spname(curbuf), IOSIZE - (p - buffer) - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003573 else
3574 {
3575 if (!fullname && curbuf->b_fname != NULL)
3576 name = curbuf->b_fname;
3577 else
3578 name = curbuf->b_ffname;
Bram Moolenaar32526b32019-01-19 17:43:09 +01003579 home_replace(shorthelp ? curbuf : NULL, name, (char_u *)p,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003580 (int)(IOSIZE - (p - buffer)), TRUE);
3581 }
3582
Bram Moolenaar32526b32019-01-19 17:43:09 +01003583 vim_snprintf_add(buffer, IOSIZE, "\"%s%s%s%s%s%s",
Bram Moolenaar071d4272004-06-13 20:20:40 +00003584 curbufIsChanged() ? (shortmess(SHM_MOD)
3585 ? " [+]" : _(" [Modified]")) : " ",
3586 (curbuf->b_flags & BF_NOTEDITED)
3587#ifdef FEAT_QUICKFIX
3588 && !bt_dontwrite(curbuf)
3589#endif
3590 ? _("[Not edited]") : "",
3591 (curbuf->b_flags & BF_NEW)
3592#ifdef FEAT_QUICKFIX
3593 && !bt_dontwrite(curbuf)
3594#endif
3595 ? _("[New file]") : "",
3596 (curbuf->b_flags & BF_READERR) ? _("[Read errors]") : "",
Bram Moolenaar23584032013-06-07 20:17:11 +02003597 curbuf->b_p_ro ? (shortmess(SHM_RO) ? _("[RO]")
Bram Moolenaar071d4272004-06-13 20:20:40 +00003598 : _("[readonly]")) : "",
3599 (curbufIsChanged() || (curbuf->b_flags & BF_WRITE_MASK)
3600 || curbuf->b_p_ro) ?
3601 " " : "");
3602 /* With 32 bit longs and more than 21,474,836 lines multiplying by 100
3603 * causes an overflow, thus for large numbers divide instead. */
3604 if (curwin->w_cursor.lnum > 1000000L)
3605 n = (int)(((long)curwin->w_cursor.lnum) /
3606 ((long)curbuf->b_ml.ml_line_count / 100L));
3607 else
3608 n = (int)(((long)curwin->w_cursor.lnum * 100L) /
3609 (long)curbuf->b_ml.ml_line_count);
3610 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaar32526b32019-01-19 17:43:09 +01003611 vim_snprintf_add(buffer, IOSIZE, "%s", _(no_lines_msg));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003612#ifdef FEAT_CMDL_INFO
3613 else if (p_ru)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003614 /* Current line and column are already on the screen -- webb */
Bram Moolenaar32526b32019-01-19 17:43:09 +01003615 vim_snprintf_add(buffer, IOSIZE,
Bram Moolenaarda6e8912018-08-21 15:12:14 +02003616 NGETTEXT("%ld line --%d%%--", "%ld lines --%d%%--",
3617 curbuf->b_ml.ml_line_count),
3618 (long)curbuf->b_ml.ml_line_count, n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003619#endif
3620 else
3621 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01003622 vim_snprintf_add(buffer, IOSIZE,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003623 _("line %ld of %ld --%d%%-- col "),
3624 (long)curwin->w_cursor.lnum,
3625 (long)curbuf->b_ml.ml_line_count,
3626 n);
3627 validate_virtcol();
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00003628 len = STRLEN(buffer);
Bram Moolenaar32526b32019-01-19 17:43:09 +01003629 col_print((char_u *)buffer + len, IOSIZE - len,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003630 (int)curwin->w_cursor.col + 1, (int)curwin->w_virtcol + 1);
3631 }
3632
Bram Moolenaar32526b32019-01-19 17:43:09 +01003633 (void)append_arg_number(curwin, (char_u *)buffer, IOSIZE,
3634 !shortmess(SHM_FILE));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003635
3636 if (dont_truncate)
3637 {
3638 /* Temporarily set msg_scroll to avoid the message being truncated.
3639 * First call msg_start() to get the message in the right place. */
3640 msg_start();
3641 n = msg_scroll;
3642 msg_scroll = TRUE;
3643 msg(buffer);
3644 msg_scroll = n;
3645 }
3646 else
3647 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01003648 p = (char *)msg_trunc_attr(buffer, FALSE, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003649 if (restart_edit != 0 || (msg_scrolled && !need_wait_return))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003650 /* Need to repeat the message after redrawing when:
3651 * - When restart_edit is set (otherwise there will be a delay
3652 * before redrawing).
3653 * - When the screen was scrolled but there is no wait-return
3654 * prompt. */
Bram Moolenaar32526b32019-01-19 17:43:09 +01003655 set_keep_msg((char_u *)p, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003656 }
3657
3658 vim_free(buffer);
3659}
3660
3661 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003662col_print(
3663 char_u *buf,
3664 size_t buflen,
3665 int col,
3666 int vcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003667{
3668 if (col == vcol)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00003669 vim_snprintf((char *)buf, buflen, "%d", col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003670 else
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00003671 vim_snprintf((char *)buf, buflen, "%d-%d", col, vcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003672}
3673
3674#if defined(FEAT_TITLE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003675static char_u *lasttitle = NULL;
3676static char_u *lasticon = NULL;
3677
Bram Moolenaar84a93082018-06-16 22:58:15 +02003678/*
3679 * Put the file name in the title bar and icon of the window.
3680 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003681 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003682maketitle(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003683{
3684 char_u *p;
Bram Moolenaar84a93082018-06-16 22:58:15 +02003685 char_u *title_str = NULL;
3686 char_u *icon_str = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003687 int maxlen = 0;
3688 int len;
3689 int mustset;
3690 char_u buf[IOSIZE];
3691 int off;
3692
3693 if (!redrawing())
3694 {
3695 /* Postpone updating the title when 'lazyredraw' is set. */
3696 need_maketitle = TRUE;
3697 return;
3698 }
3699
3700 need_maketitle = FALSE;
Bram Moolenaarbed7bec2010-07-25 13:42:29 +02003701 if (!p_title && !p_icon && lasttitle == NULL && lasticon == NULL)
Bram Moolenaar84a93082018-06-16 22:58:15 +02003702 return; // nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00003703
3704 if (p_title)
3705 {
3706 if (p_titlelen > 0)
3707 {
3708 maxlen = p_titlelen * Columns / 100;
3709 if (maxlen < 10)
3710 maxlen = 10;
3711 }
3712
Bram Moolenaar84a93082018-06-16 22:58:15 +02003713 title_str = buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003714 if (*p_titlestring != NUL)
3715 {
3716#ifdef FEAT_STL_OPT
Bram Moolenaard3667a22006-03-16 21:35:52 +00003717 if (stl_syntax & STL_IN_TITLE)
3718 {
3719 int use_sandbox = FALSE;
3720 int save_called_emsg = called_emsg;
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003721
3722# ifdef FEAT_EVAL
Bram Moolenaard3667a22006-03-16 21:35:52 +00003723 use_sandbox = was_set_insecurely((char_u *)"titlestring", 0);
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003724# endif
Bram Moolenaard3667a22006-03-16 21:35:52 +00003725 called_emsg = FALSE;
Bram Moolenaar84a93082018-06-16 22:58:15 +02003726 build_stl_str_hl(curwin, title_str, sizeof(buf),
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003727 p_titlestring, use_sandbox,
Bram Moolenaard1f56e62006-02-22 21:25:37 +00003728 0, maxlen, NULL, NULL);
Bram Moolenaard3667a22006-03-16 21:35:52 +00003729 if (called_emsg)
3730 set_string_option_direct((char_u *)"titlestring", -1,
3731 (char_u *)"", OPT_FREE, SID_ERROR);
3732 called_emsg |= save_called_emsg;
3733 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003734 else
3735#endif
Bram Moolenaar84a93082018-06-16 22:58:15 +02003736 title_str = p_titlestring;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003737 }
3738 else
3739 {
3740 /* format: "fname + (path) (1 of 2) - VIM" */
3741
Bram Moolenaar2c666692012-09-05 13:30:40 +02003742#define SPACE_FOR_FNAME (IOSIZE - 100)
3743#define SPACE_FOR_DIR (IOSIZE - 20)
3744#define SPACE_FOR_ARGNR (IOSIZE - 10) /* at least room for " - VIM" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003745 if (curbuf->b_fname == NULL)
Bram Moolenaar2c666692012-09-05 13:30:40 +02003746 vim_strncpy(buf, (char_u *)_("[No Name]"), SPACE_FOR_FNAME);
Bram Moolenaar21554412017-07-24 21:44:43 +02003747#ifdef FEAT_TERMINAL
3748 else if (curbuf->b_term != NULL)
3749 {
3750 vim_strncpy(buf, term_get_status_text(curbuf->b_term),
3751 SPACE_FOR_FNAME);
3752 }
3753#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003754 else
3755 {
3756 p = transstr(gettail(curbuf->b_fname));
Bram Moolenaar2c666692012-09-05 13:30:40 +02003757 vim_strncpy(buf, p, SPACE_FOR_FNAME);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003758 vim_free(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003759 }
3760
Bram Moolenaar21554412017-07-24 21:44:43 +02003761#ifdef FEAT_TERMINAL
3762 if (curbuf->b_term == NULL)
3763#endif
3764 switch (bufIsChanged(curbuf)
3765 + (curbuf->b_p_ro * 2)
3766 + (!curbuf->b_p_ma * 4))
3767 {
3768 case 1: STRCAT(buf, " +"); break;
3769 case 2: STRCAT(buf, " ="); break;
3770 case 3: STRCAT(buf, " =+"); break;
3771 case 4:
3772 case 6: STRCAT(buf, " -"); break;
3773 case 5:
3774 case 7: STRCAT(buf, " -+"); break;
3775 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003776
Bram Moolenaar21554412017-07-24 21:44:43 +02003777 if (curbuf->b_fname != NULL
3778#ifdef FEAT_TERMINAL
3779 && curbuf->b_term == NULL
3780#endif
3781 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00003782 {
3783 /* Get path of file, replace home dir with ~ */
3784 off = (int)STRLEN(buf);
3785 buf[off++] = ' ';
3786 buf[off++] = '(';
3787 home_replace(curbuf, curbuf->b_ffname,
Bram Moolenaar2c666692012-09-05 13:30:40 +02003788 buf + off, SPACE_FOR_DIR - off, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003789#ifdef BACKSLASH_IN_FILENAME
3790 /* avoid "c:/name" to be reduced to "c" */
3791 if (isalpha(buf[off]) && buf[off + 1] == ':')
3792 off += 2;
3793#endif
3794 /* remove the file name */
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00003795 p = gettail_sep(buf + off);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003796 if (p == buf + off)
Bram Moolenaar1f2903c2017-07-23 19:51:01 +02003797 {
Bram Moolenaar21554412017-07-24 21:44:43 +02003798 /* must be a help buffer */
3799 vim_strncpy(buf + off, (char_u *)_("help"),
Bram Moolenaar2c666692012-09-05 13:30:40 +02003800 (size_t)(SPACE_FOR_DIR - off - 1));
Bram Moolenaar1f2903c2017-07-23 19:51:01 +02003801 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003802 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003803 *p = NUL;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00003804
Bram Moolenaar2c666692012-09-05 13:30:40 +02003805 /* Translate unprintable chars and concatenate. Keep some
3806 * room for the server name. When there is no room (very long
3807 * file name) use (...). */
3808 if (off < SPACE_FOR_DIR)
3809 {
3810 p = transstr(buf + off);
3811 vim_strncpy(buf + off, p, (size_t)(SPACE_FOR_DIR - off));
3812 vim_free(p);
3813 }
3814 else
3815 {
3816 vim_strncpy(buf + off, (char_u *)"...",
3817 (size_t)(SPACE_FOR_ARGNR - off));
3818 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003819 STRCAT(buf, ")");
3820 }
3821
Bram Moolenaar2c666692012-09-05 13:30:40 +02003822 append_arg_number(curwin, buf, SPACE_FOR_ARGNR, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003823
3824#if defined(FEAT_CLIENTSERVER)
3825 if (serverName != NULL)
3826 {
3827 STRCAT(buf, " - ");
Bram Moolenaaref9d6aa2011-04-11 16:56:35 +02003828 vim_strcat(buf, serverName, IOSIZE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003829 }
3830 else
3831#endif
3832 STRCAT(buf, " - VIM");
3833
3834 if (maxlen > 0)
3835 {
3836 /* make it shorter by removing a bit in the middle */
Bram Moolenaarf31b7642012-01-20 20:44:43 +01003837 if (vim_strsize(buf) > maxlen)
3838 trunc_string(buf, buf, maxlen, IOSIZE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003839 }
3840 }
3841 }
Bram Moolenaar84a93082018-06-16 22:58:15 +02003842 mustset = value_changed(title_str, &lasttitle);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003843
3844 if (p_icon)
3845 {
Bram Moolenaar84a93082018-06-16 22:58:15 +02003846 icon_str = buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003847 if (*p_iconstring != NUL)
3848 {
3849#ifdef FEAT_STL_OPT
Bram Moolenaard3667a22006-03-16 21:35:52 +00003850 if (stl_syntax & STL_IN_ICON)
3851 {
3852 int use_sandbox = FALSE;
3853 int save_called_emsg = called_emsg;
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003854
3855# ifdef FEAT_EVAL
Bram Moolenaard3667a22006-03-16 21:35:52 +00003856 use_sandbox = was_set_insecurely((char_u *)"iconstring", 0);
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003857# endif
Bram Moolenaard3667a22006-03-16 21:35:52 +00003858 called_emsg = FALSE;
Bram Moolenaar84a93082018-06-16 22:58:15 +02003859 build_stl_str_hl(curwin, icon_str, sizeof(buf),
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003860 p_iconstring, use_sandbox,
Bram Moolenaard1f56e62006-02-22 21:25:37 +00003861 0, 0, NULL, NULL);
Bram Moolenaard3667a22006-03-16 21:35:52 +00003862 if (called_emsg)
3863 set_string_option_direct((char_u *)"iconstring", -1,
3864 (char_u *)"", OPT_FREE, SID_ERROR);
3865 called_emsg |= save_called_emsg;
3866 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003867 else
3868#endif
Bram Moolenaar84a93082018-06-16 22:58:15 +02003869 icon_str = p_iconstring;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003870 }
3871 else
3872 {
3873 if (buf_spname(curbuf) != NULL)
Bram Moolenaar84a93082018-06-16 22:58:15 +02003874 p = buf_spname(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003875 else /* use file name only in icon */
Bram Moolenaar84a93082018-06-16 22:58:15 +02003876 p = gettail(curbuf->b_ffname);
3877 *icon_str = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003878 /* Truncate name at 100 bytes. */
Bram Moolenaar84a93082018-06-16 22:58:15 +02003879 len = (int)STRLEN(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880 if (len > 100)
3881 {
3882 len -= 100;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003883 if (has_mbyte)
Bram Moolenaar84a93082018-06-16 22:58:15 +02003884 len += (*mb_tail_off)(p, p + len) + 1;
Bram Moolenaar84a93082018-06-16 22:58:15 +02003885 p += len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003886 }
Bram Moolenaar84a93082018-06-16 22:58:15 +02003887 STRCPY(icon_str, p);
3888 trans_characters(icon_str, IOSIZE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003889 }
3890 }
3891
Bram Moolenaar84a93082018-06-16 22:58:15 +02003892 mustset |= value_changed(icon_str, &lasticon);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003893
3894 if (mustset)
3895 resettitle();
3896}
3897
3898/*
3899 * Used for title and icon: Check if "str" differs from "*last". Set "*last"
3900 * from "str" if it does.
Bram Moolenaar84a93082018-06-16 22:58:15 +02003901 * Return TRUE if resettitle() is to be called.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003902 */
3903 static int
Bram Moolenaar84a93082018-06-16 22:58:15 +02003904value_changed(char_u *str, char_u **last)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003905{
3906 if ((str == NULL) != (*last == NULL)
3907 || (str != NULL && *last != NULL && STRCMP(str, *last) != 0))
3908 {
3909 vim_free(*last);
3910 if (str == NULL)
Bram Moolenaar84a93082018-06-16 22:58:15 +02003911 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003912 *last = NULL;
Bram Moolenaar40385db2018-08-07 22:31:44 +02003913 mch_restore_title(
3914 last == &lasttitle ? SAVE_RESTORE_TITLE : SAVE_RESTORE_ICON);
Bram Moolenaar84a93082018-06-16 22:58:15 +02003915 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003916 else
Bram Moolenaar84a93082018-06-16 22:58:15 +02003917 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00003918 *last = vim_strsave(str);
Bram Moolenaar84a93082018-06-16 22:58:15 +02003919 return TRUE;
3920 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003921 }
3922 return FALSE;
3923}
3924
3925/*
3926 * Put current window title back (used after calling a shell)
3927 */
3928 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003929resettitle(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003930{
3931 mch_settitle(lasttitle, lasticon);
3932}
Bram Moolenaarea408852005-06-25 22:49:46 +00003933
3934# if defined(EXITFREE) || defined(PROTO)
3935 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01003936free_titles(void)
Bram Moolenaarea408852005-06-25 22:49:46 +00003937{
3938 vim_free(lasttitle);
3939 vim_free(lasticon);
3940}
3941# endif
3942
Bram Moolenaar071d4272004-06-13 20:20:40 +00003943#endif /* FEAT_TITLE */
3944
Bram Moolenaarba6c0522006-02-25 21:45:02 +00003945#if defined(FEAT_STL_OPT) || defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003946/*
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003947 * Build a string from the status line items in "fmt".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003948 * Return length of string in screen cells.
3949 *
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00003950 * Normally works for window "wp", except when working for 'tabline' then it
3951 * is "curwin".
3952 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00003953 * Items are drawn interspersed with the text that surrounds it
3954 * Specials: %-<wid>(xxx%) => group, %= => middle marker, %< => truncation
3955 * Item: %-<minwid>.<maxwid><itemch> All but <itemch> are optional
3956 *
3957 * If maxwidth is not zero, the string will be filled at any middle marker
3958 * or truncated if too long, fillchar is used for all whitespace.
3959 */
3960 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01003961build_stl_str_hl(
3962 win_T *wp,
3963 char_u *out, /* buffer to write into != NameBuff */
3964 size_t outlen, /* length of out[] */
3965 char_u *fmt,
3966 int use_sandbox UNUSED, /* "fmt" was set insecurely, use sandbox */
3967 int fillchar,
3968 int maxwidth,
3969 struct stl_hlrec *hltab, /* return: HL attributes (can be NULL) */
3970 struct stl_hlrec *tabtab) /* return: tab page nrs (can be NULL) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003971{
Bram Moolenaar10772302019-01-20 18:25:54 +01003972 linenr_T lnum;
3973 size_t len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003974 char_u *p;
3975 char_u *s;
3976 char_u *t;
Bram Moolenaar567199b2013-04-24 16:52:36 +02003977 int byteval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003978#ifdef FEAT_EVAL
Bram Moolenaarba2929b2017-09-08 13:59:21 +02003979 win_T *save_curwin;
3980 buf_T *save_curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003981#endif
3982 int empty_line;
3983 colnr_T virtcol;
3984 long l;
3985 long n;
3986 int prevchar_isflag;
3987 int prevchar_isitem;
3988 int itemisflag;
3989 int fillable;
3990 char_u *str;
3991 long num;
3992 int width;
3993 int itemcnt;
3994 int curitem;
Bram Moolenaar6b89dbb2017-10-22 14:22:16 +02003995 int group_end_userhl;
3996 int group_start_userhl;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003997 int groupitem[STL_MAX_ITEM];
3998 int groupdepth;
3999 struct stl_item
4000 {
4001 char_u *start;
4002 int minwid;
4003 int maxwid;
4004 enum
4005 {
4006 Normal,
4007 Empty,
4008 Group,
4009 Middle,
4010 Highlight,
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004011 TabPage,
Bram Moolenaar071d4272004-06-13 20:20:40 +00004012 Trunc
4013 } type;
4014 } item[STL_MAX_ITEM];
4015 int minwid;
4016 int maxwid;
4017 int zeropad;
4018 char_u base;
4019 char_u opt;
4020#define TMPLEN 70
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004021 char_u buf_tmp[TMPLEN];
4022 char_u win_tmp[TMPLEN];
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004023 char_u *usefmt = fmt;
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004024 struct stl_hlrec *sp;
Bram Moolenaarba2929b2017-09-08 13:59:21 +02004025 int save_must_redraw = must_redraw;
4026 int save_redr_type = curwin->w_redr_type;
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004027
4028#ifdef FEAT_EVAL
4029 /*
4030 * When the format starts with "%!" then evaluate it as an expression and
4031 * use the result as the actual format string.
4032 */
4033 if (fmt[0] == '%' && fmt[1] == '!')
4034 {
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004035 typval_T tv;
4036
4037 tv.v_type = VAR_NUMBER;
4038 tv.vval.v_number = wp->w_id;
4039 set_var((char_u *)"g:statusline_winid", &tv, FALSE);
4040
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004041 usefmt = eval_to_string_safe(fmt + 2, NULL, use_sandbox);
4042 if (usefmt == NULL)
Bram Moolenaar4100af72006-08-29 14:48:14 +00004043 usefmt = fmt;
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004044
4045 do_unlet((char_u *)"g:statusline_winid", TRUE);
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004046 }
4047#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004048
4049 if (fillchar == 0)
4050 fillchar = ' ';
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004051 /* Can't handle a multi-byte fill character yet. */
4052 else if (mb_char2len(fillchar) > 1)
4053 fillchar = '-';
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004054
Bram Moolenaar10772302019-01-20 18:25:54 +01004055 // The cursor in windows other than the current one isn't always
4056 // up-to-date, esp. because of autocommands and timers.
4057 lnum = wp->w_cursor.lnum;
4058 if (lnum > wp->w_buffer->b_ml.ml_line_count)
4059 {
4060 lnum = wp->w_buffer->b_ml.ml_line_count;
4061 wp->w_cursor.lnum = lnum;
4062 }
4063
4064 // Get line & check if empty (cursorpos will show "0-1"). Note that
4065 // p will become invalid when getting another buffer line.
4066 p = ml_get_buf(wp->w_buffer, lnum, FALSE);
Bram Moolenaar567199b2013-04-24 16:52:36 +02004067 empty_line = (*p == NUL);
4068
Bram Moolenaar10772302019-01-20 18:25:54 +01004069 // Get the byte value now, in case we need it below. This is more efficient
4070 // than making a copy of the line.
4071 len = STRLEN(p);
4072 if (wp->w_cursor.col > (colnr_T)len)
4073 {
4074 // Line may have changed since checking the cursor column, or the lnum
4075 // was adjusted above.
4076 wp->w_cursor.col = (colnr_T)len;
Bram Moolenaar10772302019-01-20 18:25:54 +01004077 wp->w_cursor.coladd = 0;
Bram Moolenaar567199b2013-04-24 16:52:36 +02004078 byteval = 0;
Bram Moolenaar10772302019-01-20 18:25:54 +01004079 }
Bram Moolenaar567199b2013-04-24 16:52:36 +02004080 else
Bram Moolenaar567199b2013-04-24 16:52:36 +02004081 byteval = (*mb_ptr2char)(p + wp->w_cursor.col);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004082
4083 groupdepth = 0;
4084 p = out;
4085 curitem = 0;
4086 prevchar_isflag = TRUE;
4087 prevchar_isitem = FALSE;
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004088 for (s = usefmt; *s; )
Bram Moolenaar071d4272004-06-13 20:20:40 +00004089 {
Bram Moolenaarb75d09d2011-02-15 14:24:46 +01004090 if (curitem == STL_MAX_ITEM)
4091 {
4092 /* There are too many items. Add the error code to the statusline
4093 * to give the user a hint about what went wrong. */
4094 if (p + 6 < out + outlen)
4095 {
4096 mch_memmove(p, " E541", (size_t)5);
4097 p += 5;
4098 }
4099 break;
4100 }
4101
Bram Moolenaar071d4272004-06-13 20:20:40 +00004102 if (*s != NUL && *s != '%')
4103 prevchar_isflag = prevchar_isitem = FALSE;
4104
4105 /*
4106 * Handle up to the next '%' or the end.
4107 */
4108 while (*s != NUL && *s != '%' && p + 1 < out + outlen)
4109 *p++ = *s++;
4110 if (*s == NUL || p + 1 >= out + outlen)
4111 break;
4112
4113 /*
4114 * Handle one '%' item.
4115 */
4116 s++;
Bram Moolenaar1d87f512011-02-01 21:55:01 +01004117 if (*s == NUL) /* ignore trailing % */
4118 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004119 if (*s == '%')
4120 {
4121 if (p + 1 >= out + outlen)
4122 break;
4123 *p++ = *s++;
4124 prevchar_isflag = prevchar_isitem = FALSE;
4125 continue;
4126 }
4127 if (*s == STL_MIDDLEMARK)
4128 {
4129 s++;
4130 if (groupdepth > 0)
4131 continue;
4132 item[curitem].type = Middle;
4133 item[curitem++].start = p;
4134 continue;
4135 }
4136 if (*s == STL_TRUNCMARK)
4137 {
4138 s++;
4139 item[curitem].type = Trunc;
4140 item[curitem++].start = p;
4141 continue;
4142 }
4143 if (*s == ')')
4144 {
4145 s++;
4146 if (groupdepth < 1)
4147 continue;
4148 groupdepth--;
4149
4150 t = item[groupitem[groupdepth]].start;
4151 *p = NUL;
4152 l = vim_strsize(t);
4153 if (curitem > groupitem[groupdepth] + 1
4154 && item[groupitem[groupdepth]].minwid == 0)
4155 {
Bram Moolenaar6b89dbb2017-10-22 14:22:16 +02004156 /* remove group if all items are empty and highlight group
4157 * doesn't change */
4158 group_start_userhl = group_end_userhl = 0;
Bram Moolenaar235dddf2017-10-26 18:21:24 +02004159 for (n = groupitem[groupdepth] - 1; n >= 0; n--)
4160 {
Bram Moolenaar6b89dbb2017-10-22 14:22:16 +02004161 if (item[n].type == Highlight)
Bram Moolenaar235dddf2017-10-26 18:21:24 +02004162 {
4163 group_start_userhl = group_end_userhl = item[n].minwid;
4164 break;
4165 }
4166 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004167 for (n = groupitem[groupdepth] + 1; n < curitem; n++)
Bram Moolenaar6b89dbb2017-10-22 14:22:16 +02004168 {
4169 if (item[n].type == Normal)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004170 break;
Bram Moolenaar6b89dbb2017-10-22 14:22:16 +02004171 if (item[n].type == Highlight)
4172 group_end_userhl = item[n].minwid;
4173 }
4174 if (n == curitem && group_start_userhl == group_end_userhl)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004175 {
4176 p = t;
4177 l = 0;
4178 }
4179 }
4180 if (l > item[groupitem[groupdepth]].maxwid)
4181 {
4182 /* truncate, remove n bytes of text at the start */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004183 if (has_mbyte)
4184 {
4185 /* Find the first character that should be included. */
4186 n = 0;
4187 while (l >= item[groupitem[groupdepth]].maxwid)
4188 {
4189 l -= ptr2cells(t + n);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004190 n += (*mb_ptr2len)(t + n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004191 }
4192 }
4193 else
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004194 n = (long)(p - t) - item[groupitem[groupdepth]].maxwid + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004195
4196 *t = '<';
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004197 mch_memmove(t + 1, t + n, (size_t)(p - (t + n)));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004198 p = p - n + 1;
Bram Moolenaar13505972019-01-24 15:04:48 +01004199
4200 // Fill up space left over by half a double-wide char.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004201 while (++l < item[groupitem[groupdepth]].minwid)
4202 *p++ = fillchar;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004203
4204 /* correct the start of the items for the truncation */
4205 for (l = groupitem[groupdepth] + 1; l < curitem; l++)
4206 {
4207 item[l].start -= n;
4208 if (item[l].start < t)
4209 item[l].start = t;
4210 }
4211 }
4212 else if (abs(item[groupitem[groupdepth]].minwid) > l)
4213 {
4214 /* fill */
4215 n = item[groupitem[groupdepth]].minwid;
4216 if (n < 0)
4217 {
4218 /* fill by appending characters */
4219 n = 0 - n;
4220 while (l++ < n && p + 1 < out + outlen)
4221 *p++ = fillchar;
4222 }
4223 else
4224 {
4225 /* fill by inserting characters */
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004226 mch_memmove(t + n - l, t, (size_t)(p - t));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004227 l = n - l;
4228 if (p + l >= out + outlen)
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004229 l = (long)((out + outlen) - p - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004230 p += l;
4231 for (n = groupitem[groupdepth] + 1; n < curitem; n++)
4232 item[n].start += l;
4233 for ( ; l > 0; l--)
4234 *t++ = fillchar;
4235 }
4236 }
4237 continue;
4238 }
4239 minwid = 0;
4240 maxwid = 9999;
4241 zeropad = FALSE;
4242 l = 1;
4243 if (*s == '0')
4244 {
4245 s++;
4246 zeropad = TRUE;
4247 }
4248 if (*s == '-')
4249 {
4250 s++;
4251 l = -1;
4252 }
4253 if (VIM_ISDIGIT(*s))
4254 {
4255 minwid = (int)getdigits(&s);
4256 if (minwid < 0) /* overflow */
4257 minwid = 0;
4258 }
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004259 if (*s == STL_USER_HL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004260 {
4261 item[curitem].type = Highlight;
4262 item[curitem].start = p;
4263 item[curitem].minwid = minwid > 9 ? 1 : minwid;
4264 s++;
4265 curitem++;
4266 continue;
4267 }
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004268 if (*s == STL_TABPAGENR || *s == STL_TABCLOSENR)
4269 {
4270 if (*s == STL_TABCLOSENR)
4271 {
4272 if (minwid == 0)
4273 {
4274 /* %X ends the close label, go back to the previously
4275 * define tab label nr. */
4276 for (n = curitem - 1; n >= 0; --n)
4277 if (item[n].type == TabPage && item[n].minwid >= 0)
4278 {
4279 minwid = item[n].minwid;
4280 break;
4281 }
4282 }
4283 else
4284 /* close nrs are stored as negative values */
4285 minwid = - minwid;
4286 }
4287 item[curitem].type = TabPage;
4288 item[curitem].start = p;
4289 item[curitem].minwid = minwid;
4290 s++;
4291 curitem++;
4292 continue;
4293 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004294 if (*s == '.')
4295 {
4296 s++;
4297 if (VIM_ISDIGIT(*s))
4298 {
4299 maxwid = (int)getdigits(&s);
4300 if (maxwid <= 0) /* overflow */
4301 maxwid = 50;
4302 }
4303 }
4304 minwid = (minwid > 50 ? 50 : minwid) * l;
4305 if (*s == '(')
4306 {
4307 groupitem[groupdepth++] = curitem;
4308 item[curitem].type = Group;
4309 item[curitem].start = p;
4310 item[curitem].minwid = minwid;
4311 item[curitem].maxwid = maxwid;
4312 s++;
4313 curitem++;
4314 continue;
4315 }
4316 if (vim_strchr(STL_ALL, *s) == NULL)
4317 {
4318 s++;
4319 continue;
4320 }
4321 opt = *s++;
4322
4323 /* OK - now for the real work */
4324 base = 'D';
4325 itemisflag = FALSE;
4326 fillable = TRUE;
4327 num = -1;
4328 str = NULL;
4329 switch (opt)
4330 {
4331 case STL_FILEPATH:
4332 case STL_FULLPATH:
4333 case STL_FILENAME:
4334 fillable = FALSE; /* don't change ' ' to fillchar */
4335 if (buf_spname(wp->w_buffer) != NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02004336 vim_strncpy(NameBuff, buf_spname(wp->w_buffer), MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004337 else
4338 {
4339 t = (opt == STL_FULLPATH) ? wp->w_buffer->b_ffname
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00004340 : wp->w_buffer->b_fname;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004341 home_replace(wp->w_buffer, t, NameBuff, MAXPATHL, TRUE);
4342 }
4343 trans_characters(NameBuff, MAXPATHL);
4344 if (opt != STL_FILENAME)
4345 str = NameBuff;
4346 else
4347 str = gettail(NameBuff);
4348 break;
4349
4350 case STL_VIM_EXPR: /* '{' */
4351 itemisflag = TRUE;
4352 t = p;
4353 while (*s != '}' && *s != NUL && p + 1 < out + outlen)
4354 *p++ = *s++;
4355 if (*s != '}') /* missing '}' or out of space */
4356 break;
4357 s++;
4358 *p = 0;
4359 p = t;
4360
4361#ifdef FEAT_EVAL
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004362 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp),
4363 "%d", curbuf->b_fnum);
4364 set_internal_string_var((char_u *)"g:actual_curbuf", buf_tmp);
4365 vim_snprintf((char *)win_tmp, sizeof(win_tmp), "%d", curwin->w_id);
4366 set_internal_string_var((char_u *)"g:actual_curwin", win_tmp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004367
Bram Moolenaarba2929b2017-09-08 13:59:21 +02004368 save_curbuf = curbuf;
4369 save_curwin = curwin;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004370 curwin = wp;
4371 curbuf = wp->w_buffer;
4372
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00004373 str = eval_to_string_safe(p, &t, use_sandbox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004374
Bram Moolenaarba2929b2017-09-08 13:59:21 +02004375 curwin = save_curwin;
4376 curbuf = save_curbuf;
Bram Moolenaar01824652005-01-31 18:58:23 +00004377 do_unlet((char_u *)"g:actual_curbuf", TRUE);
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004378 do_unlet((char_u *)"g:actual_curwin", TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004379
4380 if (str != NULL && *str != 0)
4381 {
4382 if (*skipdigits(str) == NUL)
4383 {
4384 num = atoi((char *)str);
Bram Moolenaard23a8232018-02-10 18:45:26 +01004385 VIM_CLEAR(str);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004386 itemisflag = FALSE;
4387 }
4388 }
4389#endif
4390 break;
4391
4392 case STL_LINE:
4393 num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
4394 ? 0L : (long)(wp->w_cursor.lnum);
4395 break;
4396
4397 case STL_NUMLINES:
4398 num = wp->w_buffer->b_ml.ml_line_count;
4399 break;
4400
4401 case STL_COLUMN:
4402 num = !(State & INSERT) && empty_line
4403 ? 0 : (int)wp->w_cursor.col + 1;
4404 break;
4405
4406 case STL_VIRTCOL:
4407 case STL_VIRTCOL_ALT:
4408 /* In list mode virtcol needs to be recomputed */
4409 virtcol = wp->w_virtcol;
4410 if (wp->w_p_list && lcs_tab1 == NUL)
4411 {
4412 wp->w_p_list = FALSE;
4413 getvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL);
4414 wp->w_p_list = TRUE;
4415 }
4416 ++virtcol;
4417 /* Don't display %V if it's the same as %c. */
4418 if (opt == STL_VIRTCOL_ALT
4419 && (virtcol == (colnr_T)(!(State & INSERT) && empty_line
4420 ? 0 : (int)wp->w_cursor.col + 1)))
4421 break;
4422 num = (long)virtcol;
4423 break;
4424
4425 case STL_PERCENTAGE:
4426 num = (int)(((long)wp->w_cursor.lnum * 100L) /
4427 (long)wp->w_buffer->b_ml.ml_line_count);
4428 break;
4429
4430 case STL_ALTPERCENT:
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004431 str = buf_tmp;
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004432 get_rel_pos(wp, str, TMPLEN);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004433 break;
4434
4435 case STL_ARGLISTSTAT:
4436 fillable = FALSE;
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004437 buf_tmp[0] = 0;
4438 if (append_arg_number(wp, buf_tmp, (int)sizeof(buf_tmp), FALSE))
4439 str = buf_tmp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004440 break;
4441
4442 case STL_KEYMAP:
4443 fillable = FALSE;
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004444 if (get_keymap_str(wp, (char_u *)"<%s>", buf_tmp, TMPLEN))
4445 str = buf_tmp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004446 break;
4447 case STL_PAGENUM:
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00004448#if defined(FEAT_PRINTER) || defined(FEAT_GUI_TABLINE)
Bram Moolenaarba6c0522006-02-25 21:45:02 +00004449 num = printer_page_num;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004450#else
4451 num = 0;
4452#endif
4453 break;
4454
4455 case STL_BUFNO:
4456 num = wp->w_buffer->b_fnum;
4457 break;
4458
4459 case STL_OFFSET_X:
4460 base = 'X';
Bram Moolenaar2f40d122017-10-24 21:49:36 +02004461 /* FALLTHROUGH */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004462 case STL_OFFSET:
4463#ifdef FEAT_BYTEOFF
4464 l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL);
4465 num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ?
4466 0L : l + 1 + (!(State & INSERT) && empty_line ?
4467 0 : (int)wp->w_cursor.col);
4468#endif
4469 break;
4470
4471 case STL_BYTEVAL_X:
4472 base = 'X';
Bram Moolenaar2f40d122017-10-24 21:49:36 +02004473 /* FALLTHROUGH */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004474 case STL_BYTEVAL:
Bram Moolenaar567199b2013-04-24 16:52:36 +02004475 num = byteval;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004476 if (num == NL)
4477 num = 0;
4478 else if (num == CAR && get_fileformat(wp->w_buffer) == EOL_MAC)
4479 num = NL;
4480 break;
4481
4482 case STL_ROFLAG:
4483 case STL_ROFLAG_ALT:
4484 itemisflag = TRUE;
4485 if (wp->w_buffer->b_p_ro)
Bram Moolenaar23584032013-06-07 20:17:11 +02004486 str = (char_u *)((opt == STL_ROFLAG_ALT) ? ",RO" : _("[RO]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004487 break;
4488
4489 case STL_HELPFLAG:
4490 case STL_HELPFLAG_ALT:
4491 itemisflag = TRUE;
4492 if (wp->w_buffer->b_help)
4493 str = (char_u *)((opt == STL_HELPFLAG_ALT) ? ",HLP"
Bram Moolenaar899dddf2006-03-26 21:06:50 +00004494 : _("[Help]"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004495 break;
4496
Bram Moolenaar071d4272004-06-13 20:20:40 +00004497 case STL_FILETYPE:
4498 if (*wp->w_buffer->b_p_ft != NUL
4499 && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 3)
4500 {
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004501 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), "[%s]",
Bram Moolenaar9c13b352005-05-19 20:53:52 +00004502 wp->w_buffer->b_p_ft);
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004503 str = buf_tmp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004504 }
4505 break;
4506
4507 case STL_FILETYPE_ALT:
4508 itemisflag = TRUE;
4509 if (*wp->w_buffer->b_p_ft != NUL
4510 && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 2)
4511 {
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004512 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), ",%s",
Bram Moolenaar9c13b352005-05-19 20:53:52 +00004513 wp->w_buffer->b_p_ft);
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004514 for (t = buf_tmp; *t != 0; t++)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004515 *t = TOUPPER_LOC(*t);
Bram Moolenaar1c6fd1e2019-05-23 22:11:59 +02004516 str = buf_tmp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004517 }
4518 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004519
Bram Moolenaar4033c552017-09-16 20:54:51 +02004520#if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004521 case STL_PREVIEWFLAG:
4522 case STL_PREVIEWFLAG_ALT:
4523 itemisflag = TRUE;
4524 if (wp->w_p_pvw)
4525 str = (char_u *)((opt == STL_PREVIEWFLAG_ALT) ? ",PRV"
4526 : _("[Preview]"));
4527 break;
Bram Moolenaar7fd73202010-07-25 16:58:46 +02004528
4529 case STL_QUICKFIX:
4530 if (bt_quickfix(wp->w_buffer))
4531 str = (char_u *)(wp->w_llist_ref
4532 ? _(msg_loclist)
4533 : _(msg_qflist));
4534 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004535#endif
4536
4537 case STL_MODIFIED:
4538 case STL_MODIFIED_ALT:
4539 itemisflag = TRUE;
4540 switch ((opt == STL_MODIFIED_ALT)
4541 + bufIsChanged(wp->w_buffer) * 2
4542 + (!wp->w_buffer->b_p_ma) * 4)
4543 {
4544 case 2: str = (char_u *)"[+]"; break;
4545 case 3: str = (char_u *)",+"; break;
4546 case 4: str = (char_u *)"[-]"; break;
4547 case 5: str = (char_u *)",-"; break;
4548 case 6: str = (char_u *)"[+-]"; break;
4549 case 7: str = (char_u *)",+-"; break;
4550 }
4551 break;
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004552
4553 case STL_HIGHLIGHT:
4554 t = s;
4555 while (*s != '#' && *s != NUL)
4556 ++s;
4557 if (*s == '#')
4558 {
4559 item[curitem].type = Highlight;
4560 item[curitem].start = p;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00004561 item[curitem].minwid = -syn_namen2id(t, (int)(s - t));
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004562 curitem++;
4563 }
Bram Moolenaar11808222013-11-02 04:39:38 +01004564 if (*s != NUL)
4565 ++s;
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004566 continue;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004567 }
4568
4569 item[curitem].start = p;
4570 item[curitem].type = Normal;
4571 if (str != NULL && *str)
4572 {
4573 t = str;
4574 if (itemisflag)
4575 {
4576 if ((t[0] && t[1])
4577 && ((!prevchar_isitem && *t == ',')
4578 || (prevchar_isflag && *t == ' ')))
4579 t++;
4580 prevchar_isflag = TRUE;
4581 }
4582 l = vim_strsize(t);
4583 if (l > 0)
4584 prevchar_isitem = TRUE;
4585 if (l > maxwid)
4586 {
4587 while (l >= maxwid)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004588 if (has_mbyte)
4589 {
4590 l -= ptr2cells(t);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004591 t += (*mb_ptr2len)(t);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004592 }
4593 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004594 l -= byte2cells(*t++);
4595 if (p + 1 >= out + outlen)
4596 break;
4597 *p++ = '<';
4598 }
4599 if (minwid > 0)
4600 {
4601 for (; l < minwid && p + 1 < out + outlen; l++)
4602 {
4603 /* Don't put a "-" in front of a digit. */
4604 if (l + 1 == minwid && fillchar == '-' && VIM_ISDIGIT(*t))
4605 *p++ = ' ';
4606 else
4607 *p++ = fillchar;
4608 }
4609 minwid = 0;
4610 }
4611 else
4612 minwid *= -1;
4613 while (*t && p + 1 < out + outlen)
4614 {
4615 *p++ = *t++;
4616 /* Change a space by fillchar, unless fillchar is '-' and a
4617 * digit follows. */
4618 if (fillable && p[-1] == ' '
4619 && (!VIM_ISDIGIT(*t) || fillchar != '-'))
4620 p[-1] = fillchar;
4621 }
4622 for (; l < minwid && p + 1 < out + outlen; l++)
4623 *p++ = fillchar;
4624 }
4625 else if (num >= 0)
4626 {
4627 int nbase = (base == 'D' ? 10 : (base == 'O' ? 8 : 16));
4628 char_u nstr[20];
4629
4630 if (p + 20 >= out + outlen)
4631 break; /* not sufficient space */
4632 prevchar_isitem = TRUE;
4633 t = nstr;
4634 if (opt == STL_VIRTCOL_ALT)
4635 {
4636 *t++ = '-';
4637 minwid--;
4638 }
4639 *t++ = '%';
4640 if (zeropad)
4641 *t++ = '0';
4642 *t++ = '*';
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004643 *t++ = nbase == 16 ? base : (char_u)(nbase == 8 ? 'o' : 'd');
Bram Moolenaar071d4272004-06-13 20:20:40 +00004644 *t = 0;
4645
4646 for (n = num, l = 1; n >= nbase; n /= nbase)
4647 l++;
4648 if (opt == STL_VIRTCOL_ALT)
4649 l++;
4650 if (l > maxwid)
4651 {
4652 l += 2;
4653 n = l - maxwid;
4654 while (l-- > maxwid)
4655 num /= nbase;
4656 *t++ = '>';
4657 *t++ = '%';
4658 *t = t[-3];
4659 *++t = 0;
Bram Moolenaar9c13b352005-05-19 20:53:52 +00004660 vim_snprintf((char *)p, outlen - (p - out), (char *)nstr,
4661 0, num, n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004662 }
4663 else
Bram Moolenaar9c13b352005-05-19 20:53:52 +00004664 vim_snprintf((char *)p, outlen - (p - out), (char *)nstr,
4665 minwid, num);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004666 p += STRLEN(p);
4667 }
4668 else
4669 item[curitem].type = Empty;
4670
4671 if (opt == STL_VIM_EXPR)
4672 vim_free(str);
4673
4674 if (num >= 0 || (!itemisflag && str && *str))
4675 prevchar_isflag = FALSE; /* Item not NULL, but not a flag */
4676 curitem++;
4677 }
4678 *p = NUL;
4679 itemcnt = curitem;
4680
Bram Moolenaar030f0df2006-02-21 22:02:53 +00004681#ifdef FEAT_EVAL
4682 if (usefmt != fmt)
4683 vim_free(usefmt);
4684#endif
4685
Bram Moolenaar071d4272004-06-13 20:20:40 +00004686 width = vim_strsize(out);
4687 if (maxwidth > 0 && width > maxwidth)
4688 {
Bram Moolenaar9381ab72008-11-12 11:52:19 +00004689 /* Result is too long, must truncate somewhere. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004690 l = 0;
4691 if (itemcnt == 0)
4692 s = out;
4693 else
4694 {
4695 for ( ; l < itemcnt; l++)
4696 if (item[l].type == Trunc)
4697 {
4698 /* Truncate at %< item. */
4699 s = item[l].start;
4700 break;
4701 }
4702 if (l == itemcnt)
4703 {
4704 /* No %< item, truncate first item. */
4705 s = item[0].start;
4706 l = 0;
4707 }
4708 }
4709
4710 if (width - vim_strsize(s) >= maxwidth)
4711 {
4712 /* Truncation mark is beyond max length */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004713 if (has_mbyte)
4714 {
4715 s = out;
4716 width = 0;
4717 for (;;)
4718 {
4719 width += ptr2cells(s);
4720 if (width >= maxwidth)
4721 break;
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004722 s += (*mb_ptr2len)(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004723 }
4724 /* Fill up for half a double-wide character. */
4725 while (++width < maxwidth)
4726 *s++ = fillchar;
4727 }
4728 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004729 s = out + maxwidth - 1;
4730 for (l = 0; l < itemcnt; l++)
4731 if (item[l].start > s)
4732 break;
4733 itemcnt = l;
4734 *s++ = '>';
4735 *s = 0;
4736 }
4737 else
4738 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004739 if (has_mbyte)
4740 {
4741 n = 0;
4742 while (width >= maxwidth)
4743 {
4744 width -= ptr2cells(s + n);
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00004745 n += (*mb_ptr2len)(s + n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004746 }
4747 }
4748 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004749 n = width - maxwidth + 1;
4750 p = s + n;
Bram Moolenaarf2330482008-06-24 20:19:36 +00004751 STRMOVE(s + 1, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004752 *s = '<';
4753
4754 /* Fill up for half a double-wide character. */
4755 while (++width < maxwidth)
4756 {
4757 s = s + STRLEN(s);
4758 *s++ = fillchar;
4759 *s = NUL;
4760 }
4761
4762 --n; /* count the '<' */
4763 for (; l < itemcnt; l++)
4764 {
4765 if (item[l].start - n >= s)
4766 item[l].start -= n;
4767 else
4768 item[l].start = s;
4769 }
4770 }
4771 width = maxwidth;
4772 }
4773 else if (width < maxwidth && STRLEN(out) + maxwidth - width + 1 < outlen)
4774 {
4775 /* Apply STL_MIDDLE if any */
4776 for (l = 0; l < itemcnt; l++)
4777 if (item[l].type == Middle)
4778 break;
4779 if (l < itemcnt)
4780 {
4781 p = item[l].start + maxwidth - width;
Bram Moolenaarf2330482008-06-24 20:19:36 +00004782 STRMOVE(p, item[l].start);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004783 for (s = item[l].start; s < p; s++)
4784 *s = fillchar;
4785 for (l++; l < itemcnt; l++)
4786 item[l].start += maxwidth - width;
4787 width = maxwidth;
4788 }
4789 }
4790
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004791 /* Store the info about highlighting. */
4792 if (hltab != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004793 {
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004794 sp = hltab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004795 for (l = 0; l < itemcnt; l++)
4796 {
4797 if (item[l].type == Highlight)
4798 {
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004799 sp->start = item[l].start;
4800 sp->userhl = item[l].minwid;
4801 sp++;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004802 }
4803 }
Bram Moolenaard1f56e62006-02-22 21:25:37 +00004804 sp->start = NULL;
4805 sp->userhl = 0;
4806 }
4807
4808 /* Store the info about tab pages labels. */
4809 if (tabtab != NULL)
4810 {
4811 sp = tabtab;
4812 for (l = 0; l < itemcnt; l++)
4813 {
4814 if (item[l].type == TabPage)
4815 {
4816 sp->start = item[l].start;
4817 sp->userhl = item[l].minwid;
4818 sp++;
4819 }
4820 }
4821 sp->start = NULL;
4822 sp->userhl = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004823 }
4824
Bram Moolenaar65ed1362017-09-30 16:00:14 +02004825 /* When inside update_screen we do not want redrawing a stausline, ruler,
4826 * title, etc. to trigger another redraw, it may cause an endless loop. */
4827 if (updating_screen)
4828 {
4829 must_redraw = save_must_redraw;
4830 curwin->w_redr_type = save_redr_type;
4831 }
Bram Moolenaarba2929b2017-09-08 13:59:21 +02004832
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833 return width;
4834}
4835#endif /* FEAT_STL_OPT */
4836
Bram Moolenaarba6c0522006-02-25 21:45:02 +00004837#if defined(FEAT_STL_OPT) || defined(FEAT_CMDL_INFO) \
4838 || defined(FEAT_GUI_TABLINE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004839/*
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004840 * Get relative cursor position in window into "buf[buflen]", in the form 99%,
4841 * using "Top", "Bot" or "All" when appropriate.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004842 */
4843 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004844get_rel_pos(
4845 win_T *wp,
4846 char_u *buf,
4847 int buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004848{
4849 long above; /* number of lines above window */
4850 long below; /* number of lines below window */
4851
Bram Moolenaar0027c212015-01-07 13:31:52 +01004852 if (buflen < 3) /* need at least 3 chars for writing */
4853 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004854 above = wp->w_topline - 1;
4855#ifdef FEAT_DIFF
4856 above += diff_check_fill(wp, wp->w_topline) - wp->w_topfill;
Bram Moolenaar29bc9db2015-08-04 17:43:25 +02004857 if (wp->w_topline == 1 && wp->w_topfill >= 1)
4858 above = 0; /* All buffer lines are displayed and there is an
4859 * indication of filler lines, that can be considered
4860 * seeing all lines. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004861#endif
4862 below = wp->w_buffer->b_ml.ml_line_count - wp->w_botline + 1;
4863 if (below <= 0)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004864 vim_strncpy(buf, (char_u *)(above == 0 ? _("All") : _("Bot")),
4865 (size_t)(buflen - 1));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004866 else if (above <= 0)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004867 vim_strncpy(buf, (char_u *)_("Top"), (size_t)(buflen - 1));
Bram Moolenaar071d4272004-06-13 20:20:40 +00004868 else
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004869 vim_snprintf((char *)buf, (size_t)buflen, "%2d%%", above > 1000000L
Bram Moolenaar071d4272004-06-13 20:20:40 +00004870 ? (int)(above / ((above + below) / 100L))
4871 : (int)(above * 100L / (above + below)));
4872}
4873#endif
4874
4875/*
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004876 * Append (file 2 of 8) to "buf[buflen]", if editing more than one file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004877 * Return TRUE if it was appended.
4878 */
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004879 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01004880append_arg_number(
4881 win_T *wp,
4882 char_u *buf,
4883 int buflen,
4884 int add_file) /* Add "file" before the arg number */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004885{
4886 char_u *p;
4887
4888 if (ARGCOUNT <= 1) /* nothing to do */
4889 return FALSE;
4890
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004891 p = buf + STRLEN(buf); /* go to the end of the buffer */
4892 if (p - buf + 35 >= buflen) /* getting too long */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004893 return FALSE;
4894 *p++ = ' ';
4895 *p++ = '(';
4896 if (add_file)
4897 {
4898 STRCPY(p, "file ");
4899 p += 5;
4900 }
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00004901 vim_snprintf((char *)p, (size_t)(buflen - (p - buf)),
4902 wp->w_arg_idx_invalid ? "(%d) of %d)"
Bram Moolenaar071d4272004-06-13 20:20:40 +00004903 : "%d of %d)", wp->w_arg_idx + 1, ARGCOUNT);
4904 return TRUE;
4905}
4906
4907/*
4908 * If fname is not a full path, make it a full path.
4909 * Returns pointer to allocated memory (NULL for failure).
4910 */
4911 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01004912fix_fname(char_u *fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004913{
4914 /*
4915 * Force expanding the path always for Unix, because symbolic links may
4916 * mess up the full path name, even though it starts with a '/'.
4917 * Also expand when there is ".." in the file name, try to remove it,
4918 * because "c:/src/../README" is equal to "c:/README".
Bram Moolenaar9b942202007-10-03 12:31:33 +00004919 * Similarly "c:/src//file" is equal to "c:/src/file".
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920 * For MS-Windows also expand names like "longna~1" to "longname".
4921 */
Bram Moolenaar38323e42007-03-06 19:22:53 +00004922#ifdef UNIX
Bram Moolenaar071d4272004-06-13 20:20:40 +00004923 return FullName_save(fname, TRUE);
4924#else
Bram Moolenaar9b942202007-10-03 12:31:33 +00004925 if (!vim_isAbsName(fname)
4926 || strstr((char *)fname, "..") != NULL
4927 || strstr((char *)fname, "//") != NULL
4928# ifdef BACKSLASH_IN_FILENAME
4929 || strstr((char *)fname, "\\\\") != NULL
4930# endif
Bram Moolenaar48e330a2016-02-23 14:53:34 +01004931# if defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004932 || vim_strchr(fname, '~') != NULL
Bram Moolenaar9b942202007-10-03 12:31:33 +00004933# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004934 )
4935 return FullName_save(fname, FALSE);
4936
4937 fname = vim_strsave(fname);
4938
Bram Moolenaar9b942202007-10-03 12:31:33 +00004939# ifdef USE_FNAME_CASE
Bram Moolenaar00f148d2019-02-12 22:37:27 +01004940 if (fname != NULL)
4941 fname_case(fname, 0); /* set correct case for file name */
Bram Moolenaar9b942202007-10-03 12:31:33 +00004942# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004943
4944 return fname;
4945#endif
4946}
4947
4948/*
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02004949 * Make "*ffname" a full file name, set "*sfname" to "*ffname" if not NULL.
4950 * "*ffname" becomes a pointer to allocated memory (or NULL).
4951 * When resolving a link both "*sfname" and "*ffname" will point to the same
4952 * allocated memory.
4953 * The "*ffname" and "*sfname" pointer values on call will not be freed.
Bram Moolenaar32aa1022019-11-02 22:54:41 +01004954 * Note that the resulting "*ffname" pointer should be considered not allocated.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004955 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004956 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004957fname_expand(
4958 buf_T *buf UNUSED,
4959 char_u **ffname,
4960 char_u **sfname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004961{
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02004962 if (*ffname == NULL) // no file name given, nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00004963 return;
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02004964 if (*sfname == NULL) // no short file name given, use ffname
Bram Moolenaar071d4272004-06-13 20:20:40 +00004965 *sfname = *ffname;
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02004966 *ffname = fix_fname(*ffname); // expand to full path
Bram Moolenaar071d4272004-06-13 20:20:40 +00004967
4968#ifdef FEAT_SHORTCUT
4969 if (!buf->b_p_bin)
4970 {
Bram Moolenaarf193fff2006-04-27 00:02:13 +00004971 char_u *rfname;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004972
Bram Moolenaar3d6014f2018-10-11 19:27:47 +02004973 // If the file name is a shortcut file, use the file it links to.
Bram Moolenaardce1e892019-02-10 23:18:53 +01004974 rfname = mch_resolve_path(*ffname, FALSE);
Bram Moolenaarf193fff2006-04-27 00:02:13 +00004975 if (rfname != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004976 {
4977 vim_free(*ffname);
4978 *ffname = rfname;
4979 *sfname = rfname;
4980 }
4981 }
4982#endif
4983}
4984
4985/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004986 * Open a window for a number of buffers.
4987 */
4988 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01004989ex_buffer_all(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004990{
4991 buf_T *buf;
4992 win_T *wp, *wpnext;
4993 int split_ret = OK;
4994 int p_ea_save;
4995 int open_wins = 0;
4996 int r;
4997 int count; /* Maximum number of windows to open. */
4998 int all; /* When TRUE also load inactive buffers. */
Bram Moolenaare1438bb2006-03-01 22:01:55 +00004999 int had_tab = cmdmod.tab;
5000 tabpage_T *tpnext;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005001
5002 if (eap->addr_count == 0) /* make as many windows as possible */
5003 count = 9999;
5004 else
5005 count = eap->line2; /* make as many windows as specified */
5006 if (eap->cmdidx == CMD_unhide || eap->cmdidx == CMD_sunhide)
5007 all = FALSE;
5008 else
5009 all = TRUE;
5010
5011 setpcmark();
5012
5013#ifdef FEAT_GUI
5014 need_mouse_correct = TRUE;
5015#endif
5016
5017 /*
5018 * Close superfluous windows (two windows for the same buffer).
5019 * Also close windows that are not full-width.
5020 */
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005021 if (had_tab > 0)
Bram Moolenaar49e649f2013-05-06 04:50:35 +02005022 goto_tabpage_tp(first_tabpage, TRUE, TRUE);
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005023 for (;;)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005024 {
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005025 tpnext = curtab->tp_next;
5026 for (wp = firstwin; wp != NULL; wp = wpnext)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005027 {
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005028 wpnext = wp->w_next;
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00005029 if ((wp->w_buffer->b_nwindows > 1
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005030 || ((cmdmod.split & WSP_VERT)
5031 ? wp->w_height + wp->w_status_height < Rows - p_ch
Bram Moolenaarbfb2d402006-03-03 22:50:42 +00005032 - tabline_height()
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005033 : wp->w_width != Columns)
Bram Moolenaar4033c552017-09-16 20:54:51 +02005034 || (had_tab > 0 && wp != firstwin)) && !ONE_WINDOW
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005035 && !(wp->w_closing || wp->w_buffer->b_locked > 0))
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005036 {
5037 win_close(wp, FALSE);
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005038 wpnext = firstwin; /* just in case an autocommand does
5039 something strange with windows */
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005040 tpnext = first_tabpage; /* start all over... */
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005041 open_wins = 0;
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005042 }
5043 else
5044 ++open_wins;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005045 }
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005046
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005047 /* Without the ":tab" modifier only do the current tab page. */
5048 if (had_tab == 0 || tpnext == NULL)
5049 break;
Bram Moolenaar49e649f2013-05-06 04:50:35 +02005050 goto_tabpage_tp(tpnext, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005051 }
5052
5053 /*
5054 * Go through the buffer list. When a buffer doesn't have a window yet,
5055 * open one. Otherwise move the window to the right position.
5056 * Watch out for autocommands that delete buffers or windows!
5057 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005058 /* Don't execute Win/Buf Enter/Leave autocommands here. */
5059 ++autocmd_no_enter;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005060 win_enter(lastwin, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005061 ++autocmd_no_leave;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005062 for (buf = firstbuf; buf != NULL && open_wins < count; buf = buf->b_next)
5063 {
5064 /* Check if this buffer needs a window */
5065 if ((!all && buf->b_ml.ml_mfp == NULL) || !buf->b_p_bl)
5066 continue;
5067
Bram Moolenaarb475fb92006-03-02 22:40:52 +00005068 if (had_tab != 0)
5069 {
5070 /* With the ":tab" modifier don't move the window. */
5071 if (buf->b_nwindows > 0)
5072 wp = lastwin; /* buffer has a window, skip it */
5073 else
5074 wp = NULL;
5075 }
5076 else
Bram Moolenaarb475fb92006-03-02 22:40:52 +00005077 {
5078 /* Check if this buffer already has a window */
Bram Moolenaar29323592016-07-24 22:04:11 +02005079 FOR_ALL_WINDOWS(wp)
Bram Moolenaarb475fb92006-03-02 22:40:52 +00005080 if (wp->w_buffer == buf)
5081 break;
5082 /* If the buffer already has a window, move it */
5083 if (wp != NULL)
5084 win_move_after(wp, curwin);
5085 }
5086
5087 if (wp == NULL && split_ret == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005088 {
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02005089 bufref_T bufref;
5090
5091 set_bufref(&bufref, buf);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005092
Bram Moolenaar071d4272004-06-13 20:20:40 +00005093 /* Split the window and put the buffer in it */
5094 p_ea_save = p_ea;
5095 p_ea = TRUE; /* use space from all windows */
5096 split_ret = win_split(0, WSP_ROOM | WSP_BELOW);
5097 ++open_wins;
5098 p_ea = p_ea_save;
5099 if (split_ret == FAIL)
5100 continue;
5101
5102 /* Open the buffer in this window. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005103 swap_exists_action = SEA_DIALOG;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005104 set_curbuf(buf, DOBUF_GOTO);
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02005105 if (!bufref_valid(&bufref))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005106 {
Bram Moolenaarb25f9a92016-07-10 18:21:50 +02005107 /* autocommands deleted the buffer!!! */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005108 swap_exists_action = SEA_NONE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005109 break;
5110 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005111 if (swap_exists_action == SEA_QUIT)
5112 {
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02005113#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00005114 cleanup_T cs;
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005115
Bram Moolenaarc0197e22004-09-13 20:26:32 +00005116 /* Reset the error/interrupt/exception state here so that
5117 * aborting() returns FALSE when closing a window. */
5118 enter_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02005119#endif
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005120
Bram Moolenaarc0197e22004-09-13 20:26:32 +00005121 /* User selected Quit at ATTENTION prompt; close this window. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005122 win_close(curwin, TRUE);
5123 --open_wins;
5124 swap_exists_action = SEA_NONE;
Bram Moolenaar12033fb2005-12-16 21:49:31 +00005125 swap_exists_did_quit = TRUE;
Bram Moolenaarc0197e22004-09-13 20:26:32 +00005126
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02005127#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00005128 /* Restore the error/interrupt/exception state if not
5129 * discarded by a new aborting error, interrupt, or uncaught
5130 * exception. */
5131 leave_cleanup(&cs);
Bram Moolenaar67cf86b2019-04-28 22:25:38 +02005132#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005133 }
5134 else
5135 handle_swap_exists(NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005136 }
5137
5138 ui_breakcheck();
5139 if (got_int)
5140 {
5141 (void)vgetc(); /* only break the file loading, not the rest */
5142 break;
5143 }
Bram Moolenaar5eb86f92004-07-26 12:53:41 +00005144#ifdef FEAT_EVAL
5145 /* Autocommands deleted the buffer or aborted script processing!!! */
5146 if (aborting())
5147 break;
5148#endif
Bram Moolenaare1438bb2006-03-01 22:01:55 +00005149 /* When ":tab" was used open a new tab for a new window repeatedly. */
5150 if (had_tab > 0 && tabpage_index(NULL) <= p_tpm)
5151 cmdmod.tab = 9999;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005152 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005153 --autocmd_no_enter;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005154 win_enter(firstwin, FALSE); /* back to first window */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005155 --autocmd_no_leave;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005156
5157 /*
5158 * Close superfluous windows.
5159 */
5160 for (wp = lastwin; open_wins > count; )
5161 {
Bram Moolenaareb44a682017-08-03 22:44:55 +02005162 r = (buf_hide(wp->w_buffer) || !bufIsChanged(wp->w_buffer)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005163 || autowrite(wp->w_buffer, FALSE) == OK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005164 if (!win_valid(wp))
5165 {
5166 /* BufWrite Autocommands made the window invalid, start over */
5167 wp = lastwin;
5168 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005169 else if (r)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005170 {
Bram Moolenaareb44a682017-08-03 22:44:55 +02005171 win_close(wp, !buf_hide(wp->w_buffer));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005172 --open_wins;
5173 wp = lastwin;
5174 }
5175 else
5176 {
5177 wp = wp->w_prev;
5178 if (wp == NULL)
5179 break;
5180 }
5181 }
5182}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005183
Bram Moolenaar071d4272004-06-13 20:20:40 +00005184
Bram Moolenaarf28dbce2016-01-29 22:03:47 +01005185static int chk_modeline(linenr_T, int);
Bram Moolenaara3227e22006-03-08 21:32:40 +00005186
Bram Moolenaar071d4272004-06-13 20:20:40 +00005187/*
5188 * do_modelines() - process mode lines for the current file
5189 *
Bram Moolenaara3227e22006-03-08 21:32:40 +00005190 * "flags" can be:
5191 * OPT_WINONLY only set options local to window
5192 * OPT_NOWIN don't set options local to window
5193 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00005194 * Returns immediately if the "ml" option isn't set.
5195 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005196 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005197do_modelines(int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005198{
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00005199 linenr_T lnum;
5200 int nmlines;
5201 static int entered = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005202
5203 if (!curbuf->b_p_ml || (nmlines = (int)p_mls) == 0)
5204 return;
5205
5206 /* Disallow recursive entry here. Can happen when executing a modeline
5207 * triggers an autocommand, which reloads modelines with a ":do". */
5208 if (entered)
5209 return;
5210
5211 ++entered;
5212 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count && lnum <= nmlines;
5213 ++lnum)
Bram Moolenaara3227e22006-03-08 21:32:40 +00005214 if (chk_modeline(lnum, flags) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005215 nmlines = 0;
5216
5217 for (lnum = curbuf->b_ml.ml_line_count; lnum > 0 && lnum > nmlines
5218 && lnum > curbuf->b_ml.ml_line_count - nmlines; --lnum)
Bram Moolenaara3227e22006-03-08 21:32:40 +00005219 if (chk_modeline(lnum, flags) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005220 nmlines = 0;
5221 --entered;
5222}
5223
5224#include "version.h" /* for version number */
5225
5226/*
5227 * chk_modeline() - check a single line for a mode string
5228 * Return FAIL if an error encountered.
5229 */
5230 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005231chk_modeline(
5232 linenr_T lnum,
5233 int flags) /* Same as for do_modelines(). */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005234{
5235 char_u *s;
5236 char_u *e;
5237 char_u *linecopy; /* local copy of any modeline found */
5238 int prev;
5239 int vers;
5240 int end;
5241 int retval = OK;
5242 char_u *save_sourcing_name;
5243 linenr_T save_sourcing_lnum;
5244#ifdef FEAT_EVAL
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005245 sctx_T save_current_sctx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005246#endif
5247
5248 prev = -1;
5249 for (s = ml_get(lnum); *s != NUL; ++s)
5250 {
5251 if (prev == -1 || vim_isspace(prev))
5252 {
5253 if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0)
5254 || STRNCMP(s, "vi:", (size_t)3) == 0)
5255 break;
Bram Moolenaarc14621e2013-06-26 20:04:35 +02005256 /* Accept both "vim" and "Vim". */
5257 if ((s[0] == 'v' || s[0] == 'V') && s[1] == 'i' && s[2] == 'm')
Bram Moolenaar071d4272004-06-13 20:20:40 +00005258 {
5259 if (s[3] == '<' || s[3] == '=' || s[3] == '>')
5260 e = s + 4;
5261 else
5262 e = s + 3;
5263 vers = getdigits(&e);
5264 if (*e == ':'
Bram Moolenaar630a7302013-06-29 15:07:22 +02005265 && (s[0] != 'V'
5266 || STRNCMP(skipwhite(e + 1), "set", 3) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005267 && (s[3] == ':'
5268 || (VIM_VERSION_100 >= vers && isdigit(s[3]))
5269 || (VIM_VERSION_100 < vers && s[3] == '<')
5270 || (VIM_VERSION_100 > vers && s[3] == '>')
5271 || (VIM_VERSION_100 == vers && s[3] == '=')))
5272 break;
5273 }
5274 }
5275 prev = *s;
5276 }
5277
5278 if (*s)
5279 {
5280 do /* skip over "ex:", "vi:" or "vim:" */
5281 ++s;
5282 while (s[-1] != ':');
5283
5284 s = linecopy = vim_strsave(s); /* copy the line, it will change */
5285 if (linecopy == NULL)
5286 return FAIL;
5287
5288 save_sourcing_lnum = sourcing_lnum;
5289 save_sourcing_name = sourcing_name;
5290 sourcing_lnum = lnum; /* prepare for emsg() */
5291 sourcing_name = (char_u *)"modelines";
5292
5293 end = FALSE;
5294 while (end == FALSE)
5295 {
5296 s = skipwhite(s);
5297 if (*s == NUL)
5298 break;
5299
5300 /*
5301 * Find end of set command: ':' or end of line.
5302 * Skip over "\:", replacing it with ":".
5303 */
5304 for (e = s; *e != ':' && *e != NUL; ++e)
5305 if (e[0] == '\\' && e[1] == ':')
Bram Moolenaarf2330482008-06-24 20:19:36 +00005306 STRMOVE(e, e + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005307 if (*e == NUL)
5308 end = TRUE;
5309
5310 /*
5311 * If there is a "set" command, require a terminating ':' and
5312 * ignore the stuff after the ':'.
5313 * "vi:set opt opt opt: foo" -- foo not interpreted
5314 * "vi:opt opt opt: foo" -- foo interpreted
5315 * Accept "se" for compatibility with Elvis.
5316 */
5317 if (STRNCMP(s, "set ", (size_t)4) == 0
5318 || STRNCMP(s, "se ", (size_t)3) == 0)
5319 {
5320 if (*e != ':') /* no terminating ':'? */
5321 break;
5322 end = TRUE;
5323 s = vim_strchr(s, ' ') + 1;
5324 }
5325 *e = NUL; /* truncate the set command */
5326
5327 if (*s != NUL) /* skip over an empty "::" */
5328 {
Bram Moolenaar48f377a2018-12-21 13:03:28 +01005329 int secure_save = secure;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005330#ifdef FEAT_EVAL
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005331 save_current_sctx = current_sctx;
5332 current_sctx.sc_sid = SID_MODELINE;
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01005333 current_sctx.sc_seq = 0;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005334 current_sctx.sc_lnum = 0;
Bram Moolenaar558ca4a2019-04-04 18:15:38 +02005335 current_sctx.sc_version = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005336#endif
Bram Moolenaar5958f952018-11-20 04:25:21 +01005337 // Make sure no risky things are executed as a side effect.
Bram Moolenaar82b033e2019-03-24 14:02:04 +01005338 secure = 1;
Bram Moolenaar5958f952018-11-20 04:25:21 +01005339
Bram Moolenaara3227e22006-03-08 21:32:40 +00005340 retval = do_set(s, OPT_MODELINE | OPT_LOCAL | flags);
Bram Moolenaar5958f952018-11-20 04:25:21 +01005341
Bram Moolenaar48f377a2018-12-21 13:03:28 +01005342 secure = secure_save;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005343#ifdef FEAT_EVAL
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02005344 current_sctx = save_current_sctx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005345#endif
5346 if (retval == FAIL) /* stop if error found */
5347 break;
5348 }
5349 s = e + 1; /* advance to next part */
5350 }
5351
5352 sourcing_lnum = save_sourcing_lnum;
5353 sourcing_name = save_sourcing_name;
5354
5355 vim_free(linecopy);
5356 }
5357 return retval;
5358}
5359
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005360/*
Bram Moolenaar91335e52018-08-01 17:53:12 +02005361 * Return TRUE if "buf" is a normal buffer, 'buftype' is empty.
5362 */
5363 int
5364bt_normal(buf_T *buf)
5365{
5366 return buf != NULL && buf->b_p_bt[0] == NUL;
5367}
5368
Bram Moolenaar113e1072019-01-20 15:30:40 +01005369#if defined(FEAT_QUICKFIX) || defined(PROTO)
Bram Moolenaar91335e52018-08-01 17:53:12 +02005370/*
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005371 * Return TRUE if "buf" is the quickfix buffer.
5372 */
5373 int
5374bt_quickfix(buf_T *buf)
5375{
5376 return buf != NULL && buf->b_p_bt[0] == 'q';
5377}
Bram Moolenaar113e1072019-01-20 15:30:40 +01005378#endif
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005379
Bram Moolenaar113e1072019-01-20 15:30:40 +01005380#if defined(FEAT_TERMINAL) || defined(PROTO)
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005381/*
5382 * Return TRUE if "buf" is a terminal buffer.
5383 */
5384 int
5385bt_terminal(buf_T *buf)
5386{
5387 return buf != NULL && buf->b_p_bt[0] == 't';
5388}
Bram Moolenaar113e1072019-01-20 15:30:40 +01005389#endif
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005390
5391/*
Bram Moolenaard28cc3f2017-07-27 22:03:50 +02005392 * Return TRUE if "buf" is a help buffer.
5393 */
5394 int
5395bt_help(buf_T *buf)
5396{
5397 return buf != NULL && buf->b_help;
5398}
5399
5400/*
Bram Moolenaarf2732452018-06-03 14:47:35 +02005401 * Return TRUE if "buf" is a prompt buffer.
5402 */
5403 int
5404bt_prompt(buf_T *buf)
5405{
Bram Moolenaar4d784b22019-05-25 19:51:39 +02005406 return buf != NULL && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'r';
5407}
5408
5409/*
5410 * Return TRUE if "buf" is a buffer for a popup window.
5411 */
5412 int
5413bt_popup(buf_T *buf)
5414{
5415 return buf != NULL && buf->b_p_bt != NULL
5416 && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'o';
Bram Moolenaarf2732452018-06-03 14:47:35 +02005417}
5418
5419/*
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005420 * Return TRUE if "buf" is a "nofile", "acwrite", "terminal" or "prompt"
5421 * buffer. This means the buffer name is not a file name.
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005422 */
5423 int
Bram Moolenaar26910de2019-06-15 19:37:15 +02005424bt_nofilename(buf_T *buf)
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005425{
5426 return buf != NULL && ((buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f')
5427 || buf->b_p_bt[0] == 'a'
Bram Moolenaarf2732452018-06-03 14:47:35 +02005428 || buf->b_p_bt[0] == 't'
5429 || buf->b_p_bt[0] == 'p');
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005430}
5431
5432/*
Bram Moolenaar26910de2019-06-15 19:37:15 +02005433 * Return TRUE if "buf" has 'buftype' set to "nofile".
5434 */
5435 int
5436bt_nofile(buf_T *buf)
5437{
5438 return buf != NULL && buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f';
5439}
5440
5441/*
Bram Moolenaar04958cb2018-06-23 19:23:02 +02005442 * Return TRUE if "buf" is a "nowrite", "nofile", "terminal" or "prompt"
5443 * buffer.
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005444 */
5445 int
5446bt_dontwrite(buf_T *buf)
5447{
Bram Moolenaarf2732452018-06-03 14:47:35 +02005448 return buf != NULL && (buf->b_p_bt[0] == 'n'
5449 || buf->b_p_bt[0] == 't'
5450 || buf->b_p_bt[0] == 'p');
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005451}
5452
Bram Moolenaar113e1072019-01-20 15:30:40 +01005453#if defined(FEAT_QUICKFIX) || defined(PROTO)
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005454 int
5455bt_dontwrite_msg(buf_T *buf)
5456{
5457 if (bt_dontwrite(buf))
5458 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005459 emsg(_("E382: Cannot write, 'buftype' option is set"));
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005460 return TRUE;
5461 }
5462 return FALSE;
5463}
Bram Moolenaar113e1072019-01-20 15:30:40 +01005464#endif
Bram Moolenaarf0a521f2017-07-25 23:31:12 +02005465
5466/*
5467 * Return TRUE if the buffer should be hidden, according to 'hidden', ":hide"
5468 * and 'bufhidden'.
5469 */
5470 int
5471buf_hide(buf_T *buf)
5472{
5473 /* 'bufhidden' overrules 'hidden' and ":hide", check it first */
5474 switch (buf->b_p_bh[0])
5475 {
5476 case 'u': /* "unload" */
5477 case 'w': /* "wipe" */
5478 case 'd': return FALSE; /* "delete" */
5479 case 'h': return TRUE; /* "hide" */
5480 }
5481 return (p_hid || cmdmod.hide);
5482}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005483
5484/*
5485 * Return special buffer name.
5486 * Returns NULL when the buffer has a normal file name.
5487 */
Bram Moolenaare1704ba2012-10-03 18:25:00 +02005488 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01005489buf_spname(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005490{
Bram Moolenaar4033c552017-09-16 20:54:51 +02005491#if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005492 if (bt_quickfix(buf))
Bram Moolenaar28c258f2006-01-25 22:02:51 +00005493 {
Bram Moolenaar28c258f2006-01-25 22:02:51 +00005494 /*
Bram Moolenaaree8188f2019-02-05 21:23:04 +01005495 * Differentiate between the quickfix and location list buffers using
5496 * the buffer number stored in the global quickfix stack.
Bram Moolenaar28c258f2006-01-25 22:02:51 +00005497 */
Bram Moolenaaree8188f2019-02-05 21:23:04 +01005498 if (buf->b_fnum == qf_stack_get_bufnr())
Bram Moolenaare1704ba2012-10-03 18:25:00 +02005499 return (char_u *)_(msg_qflist);
Bram Moolenaaree8188f2019-02-05 21:23:04 +01005500 else
5501 return (char_u *)_(msg_loclist);
Bram Moolenaar28c258f2006-01-25 22:02:51 +00005502 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005503#endif
Bram Moolenaar21554412017-07-24 21:44:43 +02005504
Bram Moolenaar071d4272004-06-13 20:20:40 +00005505 /* There is no _file_ when 'buftype' is "nofile", b_sfname
Bram Moolenaar21554412017-07-24 21:44:43 +02005506 * contains the name as specified by the user. */
Bram Moolenaar26910de2019-06-15 19:37:15 +02005507 if (bt_nofilename(buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005508 {
Bram Moolenaar21554412017-07-24 21:44:43 +02005509#ifdef FEAT_TERMINAL
5510 if (buf->b_term != NULL)
5511 return term_get_status_text(buf->b_term);
5512#endif
Bram Moolenaare561a7e2017-08-29 22:44:59 +02005513 if (buf->b_fname != NULL)
5514 return buf->b_fname;
Bram Moolenaar891e1fd2018-06-06 18:02:39 +02005515#ifdef FEAT_JOB_CHANNEL
5516 if (bt_prompt(buf))
5517 return (char_u *)_("[Prompt]");
5518#endif
Bram Moolenaarc6896e22019-05-30 22:32:34 +02005519#ifdef FEAT_TEXT_PROP
5520 if (bt_popup(buf))
5521 return (char_u *)_("[Popup]");
5522#endif
Bram Moolenaare1704ba2012-10-03 18:25:00 +02005523 return (char_u *)_("[Scratch]");
Bram Moolenaar071d4272004-06-13 20:20:40 +00005524 }
Bram Moolenaar21554412017-07-24 21:44:43 +02005525
Bram Moolenaar071d4272004-06-13 20:20:40 +00005526 if (buf->b_fname == NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02005527 return (char_u *)_("[No Name]");
Bram Moolenaar071d4272004-06-13 20:20:40 +00005528 return NULL;
5529}
5530
Bram Moolenaar071d4272004-06-13 20:20:40 +00005531/*
5532 * Set 'buflisted' for curbuf to "on" and trigger autocommands if it changed.
5533 */
5534 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005535set_buflisted(int on)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005536{
5537 if (on != curbuf->b_p_bl)
5538 {
5539 curbuf->b_p_bl = on;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005540 if (on)
5541 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
5542 else
5543 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005544 }
5545}
5546
5547/*
5548 * Read the file for "buf" again and check if the contents changed.
5549 * Return TRUE if it changed or this could not be checked.
5550 */
5551 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01005552buf_contents_changed(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005553{
5554 buf_T *newbuf;
5555 int differ = TRUE;
5556 linenr_T lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005557 aco_save_T aco;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005558 exarg_T ea;
5559
5560 /* Allocate a buffer without putting it in the buffer list. */
5561 newbuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
5562 if (newbuf == NULL)
5563 return TRUE;
5564
5565 /* Force the 'fileencoding' and 'fileformat' to be equal. */
5566 if (prep_exarg(&ea, buf) == FAIL)
5567 {
5568 wipe_buffer(newbuf, FALSE);
5569 return TRUE;
5570 }
5571
Bram Moolenaar071d4272004-06-13 20:20:40 +00005572 /* set curwin/curbuf to buf and save a few things */
5573 aucmd_prepbuf(&aco, newbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005574
Bram Moolenaar4770d092006-01-12 23:22:24 +00005575 if (ml_open(curbuf) == OK
Bram Moolenaar071d4272004-06-13 20:20:40 +00005576 && readfile(buf->b_ffname, buf->b_fname,
5577 (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM,
5578 &ea, READ_NEW | READ_DUMMY) == OK)
5579 {
5580 /* compare the two files line by line */
5581 if (buf->b_ml.ml_line_count == curbuf->b_ml.ml_line_count)
5582 {
5583 differ = FALSE;
5584 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
5585 if (STRCMP(ml_get_buf(buf, lnum, FALSE), ml_get(lnum)) != 0)
5586 {
5587 differ = TRUE;
5588 break;
5589 }
5590 }
5591 }
5592 vim_free(ea.cmd);
5593
Bram Moolenaar071d4272004-06-13 20:20:40 +00005594 /* restore curwin/curbuf and a few other things */
5595 aucmd_restbuf(&aco);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005596
5597 if (curbuf != newbuf) /* safety check */
5598 wipe_buffer(newbuf, FALSE);
5599
5600 return differ;
5601}
5602
5603/*
5604 * Wipe out a buffer and decrement the last buffer number if it was used for
5605 * this buffer. Call this to wipe out a temp buffer that does not contain any
5606 * marks.
5607 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005608 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01005609wipe_buffer(
5610 buf_T *buf,
5611 int aucmd UNUSED) /* When TRUE trigger autocommands. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005612{
5613 if (buf->b_fnum == top_file_num - 1)
5614 --top_file_num;
5615
Bram Moolenaar071d4272004-06-13 20:20:40 +00005616 if (!aucmd) /* Don't trigger BufDelete autocommands here. */
Bram Moolenaar78ab3312007-09-29 12:16:41 +00005617 block_autocmds();
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005618
Bram Moolenaar42ec6562012-02-22 14:58:37 +01005619 close_buffer(NULL, buf, DOBUF_WIPE, FALSE);
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005620
Bram Moolenaar071d4272004-06-13 20:20:40 +00005621 if (!aucmd)
Bram Moolenaar78ab3312007-09-29 12:16:41 +00005622 unblock_autocmds();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005623}