Bram Moolenaar | edf3f97 | 2016-08-29 22:49:24 +0200 | [diff] [blame] | 1 | /* vi:set ts=8 sts=4 sw=4 noet: |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2 | * |
| 3 | * VIM - Vi IMproved by Bram Moolenaar |
| 4 | * |
| 5 | * Do ":help uganda" in Vim to read copying and usage conditions. |
| 6 | * Do ":help credits" in Vim to see a list of people who contributed. |
| 7 | * See README.txt for an overview of the Vim source code. |
| 8 | */ |
| 9 | |
| 10 | /* |
| 11 | * 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 Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 28 | #include "vim.h" |
| 29 | |
Bram Moolenaar | f28dbce | 2016-01-29 22:03:47 +0100 | [diff] [blame] | 30 | static char_u *buflist_match(regmatch_T *rmp, buf_T *buf, int ignore_case); |
Bram Moolenaar | f28dbce | 2016-01-29 22:03:47 +0100 | [diff] [blame] | 31 | static char_u *fname_match(regmatch_T *rmp, char_u *name, int ignore_case); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 32 | #ifdef UNIX |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 33 | static buf_T *buflist_findname_stat(char_u *ffname, stat_T *st); |
| 34 | static int otherfile_buf(buf_T *buf, char_u *ffname, stat_T *stp); |
| 35 | static int buf_same_ino(buf_T *buf, stat_T *stp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 36 | #else |
Bram Moolenaar | f28dbce | 2016-01-29 22:03:47 +0100 | [diff] [blame] | 37 | static int otherfile_buf(buf_T *buf, char_u *ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 38 | #endif |
| 39 | #ifdef FEAT_TITLE |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 40 | static int value_changed(char_u *str, char_u **last); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 41 | #endif |
Bram Moolenaar | f28dbce | 2016-01-29 22:03:47 +0100 | [diff] [blame] | 42 | static int append_arg_number(win_T *wp, char_u *buf, int buflen, int add_file); |
| 43 | static void free_buffer(buf_T *); |
| 44 | static void free_buffer_stuff(buf_T *buf, int free_options); |
| 45 | static void clear_wininfo(buf_T *buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 46 | |
| 47 | #ifdef UNIX |
| 48 | # define dev_T dev_t |
| 49 | #else |
| 50 | # define dev_T unsigned |
| 51 | #endif |
| 52 | |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 53 | #if defined(FEAT_QUICKFIX) |
Bram Moolenaar | 7fd7320 | 2010-07-25 16:58:46 +0200 | [diff] [blame] | 54 | static char *msg_loclist = N_("[Location List]"); |
| 55 | static char *msg_qflist = N_("[Quickfix List]"); |
| 56 | #endif |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 57 | static char *e_auabort = N_("E855: Autocommands caused command to abort"); |
Bram Moolenaar | 7fd7320 | 2010-07-25 16:58:46 +0200 | [diff] [blame] | 58 | |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 59 | /* Number of times free_buffer() was called. */ |
| 60 | static int buf_free_count = 0; |
| 61 | |
Bram Moolenaar | c024b46 | 2019-06-08 18:07:21 +0200 | [diff] [blame] | 62 | /* |
| 63 | * Read data from buffer for retrying. |
| 64 | */ |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 65 | static int |
| 66 | read_buffer( |
| 67 | int read_stdin, /* read file from stdin, otherwise fifo */ |
| 68 | exarg_T *eap, /* for forced 'ff' and 'fenc' or NULL */ |
| 69 | int flags) /* extra flags for readfile() */ |
| 70 | { |
| 71 | int retval = OK; |
| 72 | linenr_T line_count; |
| 73 | |
| 74 | /* |
| 75 | * Read from the buffer which the text is already filled in and append at |
| 76 | * the end. This makes it possible to retry when 'fileformat' or |
| 77 | * 'fileencoding' was guessed wrong. |
| 78 | */ |
| 79 | line_count = curbuf->b_ml.ml_line_count; |
| 80 | retval = readfile( |
| 81 | read_stdin ? NULL : curbuf->b_ffname, |
| 82 | read_stdin ? NULL : curbuf->b_fname, |
| 83 | (linenr_T)line_count, (linenr_T)0, (linenr_T)MAXLNUM, eap, |
| 84 | flags | READ_BUFFER); |
| 85 | if (retval == OK) |
| 86 | { |
| 87 | /* Delete the binary lines. */ |
| 88 | while (--line_count >= 0) |
| 89 | ml_delete((linenr_T)1, FALSE); |
| 90 | } |
| 91 | else |
| 92 | { |
| 93 | /* Delete the converted lines. */ |
| 94 | while (curbuf->b_ml.ml_line_count > line_count) |
| 95 | ml_delete(line_count, FALSE); |
| 96 | } |
| 97 | /* Put the cursor on the first line. */ |
| 98 | curwin->w_cursor.lnum = 1; |
| 99 | curwin->w_cursor.col = 0; |
| 100 | |
| 101 | if (read_stdin) |
| 102 | { |
| 103 | /* Set or reset 'modified' before executing autocommands, so that |
| 104 | * it can be changed there. */ |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 105 | if (!readonlymode && !BUFEMPTY()) |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 106 | changed(); |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 107 | else if (retval == OK) |
Bram Moolenaar | c024b46 | 2019-06-08 18:07:21 +0200 | [diff] [blame] | 108 | unchanged(curbuf, FALSE, TRUE); |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 109 | |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 110 | if (retval == OK) |
| 111 | { |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 112 | #ifdef FEAT_EVAL |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 113 | apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE, |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 114 | curbuf, &retval); |
| 115 | #else |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 116 | apply_autocmds(EVENT_STDINREADPOST, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 117 | #endif |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 118 | } |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 119 | } |
| 120 | return retval; |
| 121 | } |
| 122 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 123 | /* |
Bram Moolenaar | 5b8cfed | 2019-06-30 22:16:10 +0200 | [diff] [blame] | 124 | * Ensure buffer "buf" is loaded. Does not trigger the swap-exists action. |
| 125 | */ |
| 126 | void |
| 127 | buffer_ensure_loaded(buf_T *buf) |
| 128 | { |
| 129 | if (buf->b_ml.ml_mfp == NULL) |
| 130 | { |
| 131 | aco_save_T aco; |
| 132 | |
| 133 | aucmd_prepbuf(&aco, buf); |
| 134 | swap_exists_action = SEA_NONE; |
| 135 | open_buffer(FALSE, NULL, 0); |
| 136 | aucmd_restbuf(&aco); |
| 137 | } |
| 138 | } |
| 139 | |
| 140 | /* |
Bram Moolenaar | 55debbe | 2010-05-23 23:34:36 +0200 | [diff] [blame] | 141 | * Open current buffer, that is: open the memfile and read the file into |
| 142 | * memory. |
| 143 | * Return FAIL for failure, OK otherwise. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 144 | */ |
| 145 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 146 | open_buffer( |
| 147 | int read_stdin, /* read file from stdin */ |
| 148 | exarg_T *eap, /* for forced 'ff' and 'fenc' or NULL */ |
| 149 | int flags) /* extra flags for readfile() */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 150 | { |
| 151 | int retval = OK; |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 152 | bufref_T old_curbuf; |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 153 | #ifdef FEAT_SYN_HL |
| 154 | long old_tw = curbuf->b_p_tw; |
| 155 | #endif |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 156 | int read_fifo = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 157 | |
| 158 | /* |
| 159 | * The 'readonly' flag is only set when BF_NEVERLOADED is being reset. |
| 160 | * When re-entering the same buffer, it should not change, because the |
| 161 | * user may have reset the flag by hand. |
| 162 | */ |
| 163 | if (readonlymode && curbuf->b_ffname != NULL |
| 164 | && (curbuf->b_flags & BF_NEVERLOADED)) |
| 165 | curbuf->b_p_ro = TRUE; |
| 166 | |
Bram Moolenaar | 4770d09 | 2006-01-12 23:22:24 +0000 | [diff] [blame] | 167 | if (ml_open(curbuf) == FAIL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 168 | { |
| 169 | /* |
| 170 | * There MUST be a memfile, otherwise we can't do anything |
| 171 | * If we can't create one for the current buffer, take another buffer |
| 172 | */ |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 173 | close_buffer(NULL, curbuf, 0, FALSE); |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 174 | FOR_ALL_BUFFERS(curbuf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 175 | if (curbuf->b_ml.ml_mfp != NULL) |
| 176 | break; |
| 177 | /* |
| 178 | * if there is no memfile at all, exit |
Bram Moolenaar | e37d50a | 2008-08-06 17:06:04 +0000 | [diff] [blame] | 179 | * This is OK, since there are no changes to lose. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 180 | */ |
| 181 | if (curbuf == NULL) |
| 182 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 183 | emsg(_("E82: Cannot allocate any buffer, exiting...")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 184 | getout(2); |
| 185 | } |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 186 | emsg(_("E83: Cannot allocate buffer, using other one...")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 187 | enter_buffer(curbuf); |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 188 | #ifdef FEAT_SYN_HL |
| 189 | if (old_tw != curbuf->b_p_tw) |
| 190 | check_colorcolumn(curwin); |
| 191 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 192 | return FAIL; |
| 193 | } |
| 194 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 195 | /* The autocommands in readfile() may change the buffer, but only AFTER |
| 196 | * reading the file. */ |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 197 | set_bufref(&old_curbuf, curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 198 | modified_was_set = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 199 | |
| 200 | /* mark cursor position as being invalid */ |
Bram Moolenaar | 89c0ea4 | 2010-02-24 16:58:36 +0100 | [diff] [blame] | 201 | curwin->w_valid = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 202 | |
| 203 | if (curbuf->b_ffname != NULL |
| 204 | #ifdef FEAT_NETBEANS_INTG |
| 205 | && netbeansReadFile |
| 206 | #endif |
| 207 | ) |
| 208 | { |
Bram Moolenaar | 426dd02 | 2016-03-15 15:09:29 +0100 | [diff] [blame] | 209 | int old_msg_silent = msg_silent; |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 210 | #ifdef UNIX |
| 211 | int save_bin = curbuf->b_p_bin; |
| 212 | int perm; |
| 213 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 214 | #ifdef FEAT_NETBEANS_INTG |
| 215 | int oldFire = netbeansFireChanges; |
| 216 | |
| 217 | netbeansFireChanges = 0; |
| 218 | #endif |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 219 | #ifdef UNIX |
| 220 | perm = mch_getperm(curbuf->b_ffname); |
Bram Moolenaar | d569bb0 | 2018-08-11 13:57:20 +0200 | [diff] [blame] | 221 | if (perm >= 0 && (S_ISFIFO(perm) |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 222 | || S_ISSOCK(perm) |
Bram Moolenaar | f04507d | 2016-08-20 15:05:39 +0200 | [diff] [blame] | 223 | # ifdef OPEN_CHR_FILES |
| 224 | || (S_ISCHR(perm) && is_dev_fd_file(curbuf->b_ffname)) |
| 225 | # endif |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 226 | )) |
| 227 | read_fifo = TRUE; |
| 228 | if (read_fifo) |
| 229 | curbuf->b_p_bin = TRUE; |
| 230 | #endif |
Bram Moolenaar | 426dd02 | 2016-03-15 15:09:29 +0100 | [diff] [blame] | 231 | if (shortmess(SHM_FILEINFO)) |
| 232 | msg_silent = 1; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 233 | retval = readfile(curbuf->b_ffname, curbuf->b_fname, |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 234 | (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, eap, |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 235 | flags | READ_NEW | (read_fifo ? READ_FIFO : 0)); |
| 236 | #ifdef UNIX |
| 237 | if (read_fifo) |
| 238 | { |
| 239 | curbuf->b_p_bin = save_bin; |
| 240 | if (retval == OK) |
| 241 | retval = read_buffer(FALSE, eap, flags); |
| 242 | } |
| 243 | #endif |
Bram Moolenaar | 426dd02 | 2016-03-15 15:09:29 +0100 | [diff] [blame] | 244 | msg_silent = old_msg_silent; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 245 | #ifdef FEAT_NETBEANS_INTG |
| 246 | netbeansFireChanges = oldFire; |
| 247 | #endif |
| 248 | /* Help buffer is filtered. */ |
Bram Moolenaar | d28cc3f | 2017-07-27 22:03:50 +0200 | [diff] [blame] | 249 | if (bt_help(curbuf)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 250 | fix_help_buffer(); |
| 251 | } |
| 252 | else if (read_stdin) |
| 253 | { |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 254 | int save_bin = curbuf->b_p_bin; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 255 | |
| 256 | /* |
| 257 | * First read the text in binary mode into the buffer. |
| 258 | * Then read from that same buffer and append at the end. This makes |
| 259 | * it possible to retry when 'fileformat' or 'fileencoding' was |
| 260 | * guessed wrong. |
| 261 | */ |
| 262 | curbuf->b_p_bin = TRUE; |
| 263 | retval = readfile(NULL, NULL, (linenr_T)0, |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 264 | (linenr_T)0, (linenr_T)MAXLNUM, NULL, |
| 265 | flags | (READ_NEW + READ_STDIN)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 266 | curbuf->b_p_bin = save_bin; |
| 267 | if (retval == OK) |
Bram Moolenaar | f71d7b9 | 2016-08-09 22:14:05 +0200 | [diff] [blame] | 268 | retval = read_buffer(TRUE, eap, flags); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | /* if first time loading this buffer, init b_chartab[] */ |
| 272 | if (curbuf->b_flags & BF_NEVERLOADED) |
Bram Moolenaar | 6bcbcc5 | 2013-11-05 07:13:41 +0100 | [diff] [blame] | 273 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 274 | (void)buf_init_chartab(curbuf, FALSE); |
Bram Moolenaar | dce7c91 | 2013-11-05 17:40:52 +0100 | [diff] [blame] | 275 | #ifdef FEAT_CINDENT |
Bram Moolenaar | 6bcbcc5 | 2013-11-05 07:13:41 +0100 | [diff] [blame] | 276 | parse_cino(curbuf); |
Bram Moolenaar | dce7c91 | 2013-11-05 17:40:52 +0100 | [diff] [blame] | 277 | #endif |
Bram Moolenaar | 6bcbcc5 | 2013-11-05 07:13:41 +0100 | [diff] [blame] | 278 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 279 | |
| 280 | /* |
| 281 | * Set/reset the Changed flag first, autocmds may change the buffer. |
| 282 | * Apply the automatic commands, before processing the modelines. |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 283 | * So the modelines have priority over autocommands. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 284 | */ |
| 285 | /* When reading stdin, the buffer contents always needs writing, so set |
| 286 | * the changed flag. Unless in readonly mode: "ls | gview -". |
| 287 | * When interrupted and 'cpoptions' contains 'i' set changed flag. */ |
Bram Moolenaar | 512e6b8 | 2007-06-19 13:36:52 +0000 | [diff] [blame] | 288 | if ((got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 289 | || modified_was_set /* ":set modified" used in autocmd */ |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 290 | #ifdef FEAT_EVAL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 291 | || (aborting() && vim_strchr(p_cpo, CPO_INTMOD) != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 292 | #endif |
Bram Moolenaar | 512e6b8 | 2007-06-19 13:36:52 +0000 | [diff] [blame] | 293 | ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 294 | changed(); |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 295 | else if (retval == OK && !read_stdin && !read_fifo) |
Bram Moolenaar | c024b46 | 2019-06-08 18:07:21 +0200 | [diff] [blame] | 296 | unchanged(curbuf, FALSE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 297 | save_file_ff(curbuf); /* keep this fileformat */ |
| 298 | |
Bram Moolenaar | 8c64a36 | 2018-03-23 22:39:31 +0100 | [diff] [blame] | 299 | /* Set last_changedtick to avoid triggering a TextChanged autocommand right |
| 300 | * after it was added. */ |
| 301 | curbuf->b_last_changedtick = CHANGEDTICK(curbuf); |
| 302 | #ifdef FEAT_INS_EXPAND |
| 303 | curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf); |
| 304 | #endif |
| 305 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 306 | /* require "!" to overwrite the file, because it wasn't read completely */ |
| 307 | #ifdef FEAT_EVAL |
| 308 | if (aborting()) |
| 309 | #else |
| 310 | if (got_int) |
| 311 | #endif |
| 312 | curbuf->b_flags |= BF_READERR; |
| 313 | |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 314 | #ifdef FEAT_FOLDING |
| 315 | /* Need to update automatic folding. Do this before the autocommands, |
| 316 | * they may use the fold info. */ |
| 317 | foldUpdateAll(curwin); |
| 318 | #endif |
| 319 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 320 | /* need to set w_topline, unless some autocommand already did that. */ |
| 321 | if (!(curwin->w_valid & VALID_TOPLINE)) |
| 322 | { |
| 323 | curwin->w_topline = 1; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 324 | #ifdef FEAT_DIFF |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 325 | curwin->w_topfill = 0; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 326 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 327 | } |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 328 | #ifdef FEAT_EVAL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 329 | apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf, &retval); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 330 | #else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 331 | apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 332 | #endif |
| 333 | |
Bram Moolenaar | e13b9af | 2017-01-13 22:01:02 +0100 | [diff] [blame] | 334 | if (retval == OK) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 335 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 336 | /* |
| 337 | * The autocommands may have changed the current buffer. Apply the |
| 338 | * modelines to the correct buffer, if it still exists and is loaded. |
| 339 | */ |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 340 | if (bufref_valid(&old_curbuf) && old_curbuf.br_buf->b_ml.ml_mfp != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 341 | { |
| 342 | aco_save_T aco; |
| 343 | |
| 344 | /* Go to the buffer that was opened. */ |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 345 | aucmd_prepbuf(&aco, old_curbuf.br_buf); |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 346 | do_modelines(0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 347 | curbuf->b_flags &= ~(BF_CHECK_RO | BF_NEVERLOADED); |
| 348 | |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 349 | #ifdef FEAT_EVAL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 350 | apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf, |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 351 | &retval); |
| 352 | #else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 353 | apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 354 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 355 | |
| 356 | /* restore curwin/curbuf and a few other things */ |
| 357 | aucmd_restbuf(&aco); |
| 358 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 359 | } |
| 360 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 361 | return retval; |
| 362 | } |
| 363 | |
| 364 | /* |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 365 | * Store "buf" in "bufref" and set the free count. |
| 366 | */ |
| 367 | void |
| 368 | set_bufref(bufref_T *bufref, buf_T *buf) |
| 369 | { |
| 370 | bufref->br_buf = buf; |
Bram Moolenaar | fadacf0 | 2017-06-19 20:35:32 +0200 | [diff] [blame] | 371 | bufref->br_fnum = buf == NULL ? 0 : buf->b_fnum; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 372 | bufref->br_buf_free_count = buf_free_count; |
| 373 | } |
| 374 | |
| 375 | /* |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 376 | * Return TRUE if "bufref->br_buf" points to the same buffer as when |
| 377 | * set_bufref() was called and it is a valid buffer. |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 378 | * Only goes through the buffer list if buf_free_count changed. |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 379 | * Also checks if b_fnum is still the same, a :bwipe followed by :new might get |
| 380 | * the same allocated memory, but it's a different buffer. |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 381 | */ |
| 382 | int |
| 383 | bufref_valid(bufref_T *bufref) |
| 384 | { |
| 385 | return bufref->br_buf_free_count == buf_free_count |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 386 | ? TRUE : buf_valid(bufref->br_buf) |
| 387 | && bufref->br_fnum == bufref->br_buf->b_fnum; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 391 | * Return TRUE if "buf" points to a valid buffer (in the buffer list). |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 392 | * This can be slow if there are many buffers, prefer using bufref_valid(). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 393 | */ |
| 394 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 395 | buf_valid(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 396 | { |
| 397 | buf_T *bp; |
| 398 | |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 399 | /* Assume that we more often have a recent buffer, start with the last |
| 400 | * one. */ |
| 401 | for (bp = lastbuf; bp != NULL; bp = bp->b_prev) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 402 | if (bp == buf) |
| 403 | return TRUE; |
| 404 | return FALSE; |
| 405 | } |
| 406 | |
| 407 | /* |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 408 | * A hash table used to quickly lookup a buffer by its number. |
| 409 | */ |
| 410 | static hashtab_T buf_hashtab; |
| 411 | |
| 412 | static void |
| 413 | buf_hashtab_add(buf_T *buf) |
| 414 | { |
| 415 | sprintf((char *)buf->b_key, "%x", buf->b_fnum); |
| 416 | if (hash_add(&buf_hashtab, buf->b_key) == FAIL) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 417 | emsg(_("E931: Buffer cannot be registered")); |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 418 | } |
| 419 | |
| 420 | static void |
| 421 | buf_hashtab_remove(buf_T *buf) |
| 422 | { |
| 423 | hashitem_T *hi = hash_find(&buf_hashtab, buf->b_key); |
| 424 | |
| 425 | if (!HASHITEM_EMPTY(hi)) |
| 426 | hash_remove(&buf_hashtab, hi); |
| 427 | } |
| 428 | |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 429 | /* |
| 430 | * Return TRUE when buffer "buf" can be unloaded. |
| 431 | * Give an error message and return FALSE when the buffer is locked or the |
| 432 | * screen is being redrawn and the buffer is in a window. |
| 433 | */ |
| 434 | static int |
| 435 | can_unload_buffer(buf_T *buf) |
| 436 | { |
| 437 | int can_unload = !buf->b_locked; |
| 438 | |
| 439 | if (can_unload && updating_screen) |
| 440 | { |
| 441 | win_T *wp; |
| 442 | |
| 443 | FOR_ALL_WINDOWS(wp) |
| 444 | if (wp->w_buffer == buf) |
Bram Moolenaar | 9cea87c | 2018-09-21 16:59:45 +0200 | [diff] [blame] | 445 | { |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 446 | can_unload = FALSE; |
Bram Moolenaar | 9cea87c | 2018-09-21 16:59:45 +0200 | [diff] [blame] | 447 | break; |
| 448 | } |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 449 | } |
| 450 | if (!can_unload) |
Bram Moolenaar | defa067 | 2019-07-21 19:25:37 +0200 | [diff] [blame] | 451 | semsg(_("E937: Attempt to delete a buffer that is in use: %s"), |
| 452 | buf->b_fname); |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 453 | return can_unload; |
| 454 | } |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 455 | |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 456 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 457 | * Close the link to a buffer. |
| 458 | * "action" is used when there is no longer a window for the buffer. |
| 459 | * It can be: |
| 460 | * 0 buffer becomes hidden |
| 461 | * DOBUF_UNLOAD buffer is unloaded |
| 462 | * DOBUF_DELETE buffer is unloaded and removed from buffer list |
| 463 | * DOBUF_WIPE buffer is unloaded and really deleted |
| 464 | * When doing all but the first one on the current buffer, the caller should |
| 465 | * get a new buffer very soon! |
| 466 | * |
| 467 | * The 'bufhidden' option can force freeing and deleting. |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 468 | * |
| 469 | * When "abort_if_last" is TRUE then do not close the buffer if autocommands |
| 470 | * cause there to be only one window with this buffer. e.g. when ":quit" is |
| 471 | * supposed to close the window but autocommands close all other windows. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 472 | */ |
| 473 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 474 | close_buffer( |
| 475 | win_T *win, /* if not NULL, set b_last_cursor */ |
| 476 | buf_T *buf, |
| 477 | int action, |
Bram Moolenaar | 4d784b2 | 2019-05-25 19:51:39 +0200 | [diff] [blame] | 478 | int abort_if_last) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 479 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 480 | int is_curbuf; |
Bram Moolenaar | 2660c0e | 2010-01-19 14:59:56 +0100 | [diff] [blame] | 481 | int nwindows; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 482 | bufref_T bufref; |
Bram Moolenaar | 3a117e1 | 2016-10-30 21:57:52 +0100 | [diff] [blame] | 483 | int is_curwin = (curwin != NULL && curwin->w_buffer == buf); |
Bram Moolenaar | f9e687e | 2016-09-04 21:33:09 +0200 | [diff] [blame] | 484 | win_T *the_curwin = curwin; |
| 485 | tabpage_T *the_curtab = curtab; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 486 | int unload_buf = (action != 0); |
| 487 | int del_buf = (action == DOBUF_DEL || action == DOBUF_WIPE); |
| 488 | int wipe_buf = (action == DOBUF_WIPE); |
| 489 | |
Bram Moolenaar | 8adb0d0 | 2017-09-17 19:08:02 +0200 | [diff] [blame] | 490 | /* |
| 491 | * Force unloading or deleting when 'bufhidden' says so. |
| 492 | * The caller must take care of NOT deleting/freeing when 'bufhidden' is |
| 493 | * "hide" (otherwise we could never free or delete a buffer). |
| 494 | */ |
| 495 | if (buf->b_p_bh[0] == 'd') /* 'bufhidden' == "delete" */ |
| 496 | { |
| 497 | del_buf = TRUE; |
| 498 | unload_buf = TRUE; |
| 499 | } |
| 500 | else if (buf->b_p_bh[0] == 'w') /* 'bufhidden' == "wipe" */ |
| 501 | { |
| 502 | del_buf = TRUE; |
| 503 | unload_buf = TRUE; |
| 504 | wipe_buf = TRUE; |
| 505 | } |
| 506 | else if (buf->b_p_bh[0] == 'u') /* 'bufhidden' == "unload" */ |
| 507 | unload_buf = TRUE; |
| 508 | |
Bram Moolenaar | 94053a5 | 2017-08-01 21:44:33 +0200 | [diff] [blame] | 509 | #ifdef FEAT_TERMINAL |
Bram Moolenaar | 8adb0d0 | 2017-09-17 19:08:02 +0200 | [diff] [blame] | 510 | if (bt_terminal(buf) && (buf->b_nwindows == 1 || del_buf)) |
Bram Moolenaar | 94053a5 | 2017-08-01 21:44:33 +0200 | [diff] [blame] | 511 | { |
| 512 | if (term_job_running(buf->b_term)) |
| 513 | { |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 514 | if (wipe_buf || unload_buf) |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 515 | { |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 516 | if (!can_unload_buffer(buf)) |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 517 | return; |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 518 | |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 519 | /* Wiping out or unloading a terminal buffer kills the job. */ |
Bram Moolenaar | 94053a5 | 2017-08-01 21:44:33 +0200 | [diff] [blame] | 520 | free_terminal(buf); |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 521 | } |
Bram Moolenaar | 94053a5 | 2017-08-01 21:44:33 +0200 | [diff] [blame] | 522 | else |
| 523 | { |
| 524 | /* The job keeps running, hide the buffer. */ |
| 525 | del_buf = FALSE; |
| 526 | unload_buf = FALSE; |
| 527 | } |
| 528 | } |
| 529 | else |
| 530 | { |
| 531 | /* A terminal buffer is wiped out if the job has finished. */ |
| 532 | del_buf = TRUE; |
| 533 | unload_buf = TRUE; |
| 534 | wipe_buf = TRUE; |
| 535 | } |
| 536 | } |
Bram Moolenaar | 94053a5 | 2017-08-01 21:44:33 +0200 | [diff] [blame] | 537 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 538 | |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 539 | /* Disallow deleting the buffer when it is locked (already being closed or |
| 540 | * halfway a command that relies on it). Unloading is allowed. */ |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 541 | if ((del_buf || wipe_buf) && !can_unload_buffer(buf)) |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 542 | return; |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 543 | |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 544 | /* check no autocommands closed the window */ |
| 545 | if (win != NULL && win_valid_any_tab(win)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 546 | { |
| 547 | /* Set b_last_cursor when closing the last window for the buffer. |
| 548 | * Remember the last cursor position and window options of the buffer. |
| 549 | * This used to be only for the current window, but then options like |
| 550 | * 'foldmethod' may be lost with a ":only" command. */ |
| 551 | if (buf->b_nwindows == 1) |
| 552 | set_last_cursor(win); |
| 553 | buflist_setfpos(buf, win, |
| 554 | win->w_cursor.lnum == 1 ? 0 : win->w_cursor.lnum, |
| 555 | win->w_cursor.col, TRUE); |
| 556 | } |
| 557 | |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 558 | set_bufref(&bufref, buf); |
| 559 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 560 | /* When the buffer is no longer in a window, trigger BufWinLeave */ |
| 561 | if (buf->b_nwindows == 1) |
| 562 | { |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 563 | ++buf->b_locked; |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 564 | if (apply_autocmds(EVENT_BUFWINLEAVE, buf->b_fname, buf->b_fname, |
| 565 | FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 566 | && !bufref_valid(&bufref)) |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 567 | { |
Bram Moolenaar | 362ce48 | 2012-06-06 19:02:45 +0200 | [diff] [blame] | 568 | /* Autocommands deleted the buffer. */ |
| 569 | aucmd_abort: |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 570 | emsg(_(e_auabort)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 571 | return; |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 572 | } |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 573 | --buf->b_locked; |
Bram Moolenaar | 362ce48 | 2012-06-06 19:02:45 +0200 | [diff] [blame] | 574 | if (abort_if_last && one_window()) |
| 575 | /* Autocommands made this the only window. */ |
| 576 | goto aucmd_abort; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 577 | |
| 578 | /* When the buffer becomes hidden, but is not unloaded, trigger |
| 579 | * BufHidden */ |
| 580 | if (!unload_buf) |
| 581 | { |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 582 | ++buf->b_locked; |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 583 | if (apply_autocmds(EVENT_BUFHIDDEN, buf->b_fname, buf->b_fname, |
| 584 | FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 585 | && !bufref_valid(&bufref)) |
Bram Moolenaar | 362ce48 | 2012-06-06 19:02:45 +0200 | [diff] [blame] | 586 | /* Autocommands deleted the buffer. */ |
| 587 | goto aucmd_abort; |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 588 | --buf->b_locked; |
Bram Moolenaar | 362ce48 | 2012-06-06 19:02:45 +0200 | [diff] [blame] | 589 | if (abort_if_last && one_window()) |
| 590 | /* Autocommands made this the only window. */ |
| 591 | goto aucmd_abort; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 592 | } |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 593 | #ifdef FEAT_EVAL |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 594 | if (aborting()) /* autocmds may abort script processing */ |
| 595 | return; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 596 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 597 | } |
Bram Moolenaar | f9e687e | 2016-09-04 21:33:09 +0200 | [diff] [blame] | 598 | |
Bram Moolenaar | f9e687e | 2016-09-04 21:33:09 +0200 | [diff] [blame] | 599 | /* If the buffer was in curwin and the window has changed, go back to that |
| 600 | * window, if it still exists. This avoids that ":edit x" triggering a |
| 601 | * "tabnext" BufUnload autocmd leaves a window behind without a buffer. */ |
| 602 | if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin)) |
| 603 | { |
| 604 | block_autocmds(); |
| 605 | goto_tabpage_win(the_curtab, the_curwin); |
| 606 | unblock_autocmds(); |
| 607 | } |
Bram Moolenaar | f9e687e | 2016-09-04 21:33:09 +0200 | [diff] [blame] | 608 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 609 | nwindows = buf->b_nwindows; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 610 | |
| 611 | /* decrease the link count from windows (unless not in any window) */ |
| 612 | if (buf->b_nwindows > 0) |
| 613 | --buf->b_nwindows; |
| 614 | |
Bram Moolenaar | 97ce419 | 2017-12-01 20:35:58 +0100 | [diff] [blame] | 615 | #ifdef FEAT_DIFF |
| 616 | if (diffopt_hiddenoff() && !unload_buf && buf->b_nwindows == 0) |
Bram Moolenaar | b7407d3 | 2018-02-03 17:36:27 +0100 | [diff] [blame] | 617 | diff_buf_delete(buf); /* Clear 'diff' for hidden buffer. */ |
Bram Moolenaar | 97ce419 | 2017-12-01 20:35:58 +0100 | [diff] [blame] | 618 | #endif |
| 619 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 620 | /* Return when a window is displaying the buffer or when it's not |
| 621 | * unloaded. */ |
| 622 | if (buf->b_nwindows > 0 || !unload_buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 623 | return; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 624 | |
| 625 | /* Always remove the buffer when there is no file name. */ |
| 626 | if (buf->b_ffname == NULL) |
| 627 | del_buf = TRUE; |
| 628 | |
Bram Moolenaar | c4a908e | 2016-09-08 23:35:30 +0200 | [diff] [blame] | 629 | /* When closing the current buffer stop Visual mode before freeing |
| 630 | * anything. */ |
Bram Moolenaar | 4930a76 | 2016-09-11 14:39:53 +0200 | [diff] [blame] | 631 | if (buf == curbuf && VIsual_active |
Bram Moolenaar | 9a27c7f | 2016-09-09 12:57:09 +0200 | [diff] [blame] | 632 | #if defined(EXITFREE) |
| 633 | && !entered_free_all_mem |
| 634 | #endif |
| 635 | ) |
Bram Moolenaar | c4a908e | 2016-09-08 23:35:30 +0200 | [diff] [blame] | 636 | end_visual_mode(); |
| 637 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 638 | /* |
| 639 | * Free all things allocated for this buffer. |
| 640 | * Also calls the "BufDelete" autocommands when del_buf is TRUE. |
| 641 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 642 | /* Remember if we are closing the current buffer. Restore the number of |
| 643 | * windows, so that autocommands in buf_freeall() don't get confused. */ |
| 644 | is_curbuf = (buf == curbuf); |
| 645 | buf->b_nwindows = nwindows; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 646 | |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 647 | buf_freeall(buf, (del_buf ? BFA_DEL : 0) + (wipe_buf ? BFA_WIPE : 0)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 648 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 649 | /* Autocommands may have deleted the buffer. */ |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 650 | if (!bufref_valid(&bufref)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 651 | return; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 652 | #ifdef FEAT_EVAL |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 653 | if (aborting()) /* autocmds may abort script processing */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 654 | return; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 655 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 656 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 657 | /* |
| 658 | * It's possible that autocommands change curbuf to the one being deleted. |
| 659 | * This might cause the previous curbuf to be deleted unexpectedly. But |
| 660 | * in some cases it's OK to delete the curbuf, because a new one is |
| 661 | * obtained anyway. Therefore only return if curbuf changed to the |
| 662 | * deleted buffer. |
| 663 | */ |
| 664 | if (buf == curbuf && !is_curbuf) |
| 665 | return; |
Bram Moolenaar | 30445cb | 2016-07-09 15:21:02 +0200 | [diff] [blame] | 666 | |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 667 | if (win_valid_any_tab(win) && win->w_buffer == buf) |
Bram Moolenaar | 30445cb | 2016-07-09 15:21:02 +0200 | [diff] [blame] | 668 | win->w_buffer = NULL; /* make sure we don't use the buffer now */ |
| 669 | |
| 670 | /* Autocommands may have opened or closed windows for this buffer. |
| 671 | * Decrement the count for the close we do here. */ |
| 672 | if (buf->b_nwindows > 0) |
| 673 | --buf->b_nwindows; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 674 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 675 | /* |
| 676 | * Remove the buffer from the list. |
| 677 | */ |
| 678 | if (wipe_buf) |
| 679 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 680 | if (buf->b_sfname != buf->b_ffname) |
| 681 | VIM_CLEAR(buf->b_sfname); |
| 682 | else |
| 683 | buf->b_sfname = NULL; |
| 684 | VIM_CLEAR(buf->b_ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 685 | if (buf->b_prev == NULL) |
| 686 | firstbuf = buf->b_next; |
| 687 | else |
| 688 | buf->b_prev->b_next = buf->b_next; |
| 689 | if (buf->b_next == NULL) |
| 690 | lastbuf = buf->b_prev; |
| 691 | else |
| 692 | buf->b_next->b_prev = buf->b_prev; |
| 693 | free_buffer(buf); |
| 694 | } |
| 695 | else |
| 696 | { |
| 697 | if (del_buf) |
| 698 | { |
| 699 | /* Free all internal variables and reset option values, to make |
| 700 | * ":bdel" compatible with Vim 5.7. */ |
| 701 | free_buffer_stuff(buf, TRUE); |
| 702 | |
| 703 | /* Make it look like a new buffer. */ |
| 704 | buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED; |
| 705 | |
| 706 | /* Init the options when loaded again. */ |
| 707 | buf->b_p_initialized = FALSE; |
| 708 | } |
| 709 | buf_clear_file(buf); |
| 710 | if (del_buf) |
| 711 | buf->b_p_bl = FALSE; |
| 712 | } |
| 713 | } |
| 714 | |
| 715 | /* |
| 716 | * Make buffer not contain a file. |
| 717 | */ |
| 718 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 719 | buf_clear_file(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 720 | { |
| 721 | buf->b_ml.ml_line_count = 1; |
Bram Moolenaar | c024b46 | 2019-06-08 18:07:21 +0200 | [diff] [blame] | 722 | unchanged(buf, TRUE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 723 | buf->b_shortname = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 724 | buf->b_p_eol = TRUE; |
| 725 | buf->b_start_eol = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 726 | buf->b_p_bomb = FALSE; |
Bram Moolenaar | 83eb885 | 2007-08-12 13:51:26 +0000 | [diff] [blame] | 727 | buf->b_start_bomb = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 728 | buf->b_ml.ml_mfp = NULL; |
| 729 | buf->b_ml.ml_flags = ML_EMPTY; /* empty buffer */ |
| 730 | #ifdef FEAT_NETBEANS_INTG |
| 731 | netbeans_deleted_all_lines(buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 732 | #endif |
| 733 | } |
| 734 | |
| 735 | /* |
| 736 | * buf_freeall() - free all things allocated for a buffer that are related to |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 737 | * the file. Careful: get here with "curwin" NULL when exiting. |
| 738 | * flags: |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 739 | * BFA_DEL buffer is going to be deleted |
| 740 | * BFA_WIPE buffer is going to be wiped out |
| 741 | * BFA_KEEP_UNDO do not free undo information |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 742 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 743 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 744 | buf_freeall(buf_T *buf, int flags) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 745 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 746 | int is_curbuf = (buf == curbuf); |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 747 | bufref_T bufref; |
Bram Moolenaar | 030cddc | 2016-09-04 23:41:42 +0200 | [diff] [blame] | 748 | int is_curwin = (curwin != NULL && curwin->w_buffer == buf); |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 749 | win_T *the_curwin = curwin; |
| 750 | tabpage_T *the_curtab = curtab; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 751 | |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 752 | /* Make sure the buffer isn't closed by autocommands. */ |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 753 | ++buf->b_locked; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 754 | set_bufref(&bufref, buf); |
Bram Moolenaar | c67e892 | 2016-05-24 16:07:40 +0200 | [diff] [blame] | 755 | if (buf->b_ml.ml_mfp != NULL) |
| 756 | { |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 757 | if (apply_autocmds(EVENT_BUFUNLOAD, buf->b_fname, buf->b_fname, |
| 758 | FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 759 | && !bufref_valid(&bufref)) |
| 760 | /* autocommands deleted the buffer */ |
Bram Moolenaar | c67e892 | 2016-05-24 16:07:40 +0200 | [diff] [blame] | 761 | return; |
| 762 | } |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 763 | if ((flags & BFA_DEL) && buf->b_p_bl) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 764 | { |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 765 | if (apply_autocmds(EVENT_BUFDELETE, buf->b_fname, buf->b_fname, |
| 766 | FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 767 | && !bufref_valid(&bufref)) |
| 768 | /* autocommands deleted the buffer */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 769 | return; |
| 770 | } |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 771 | if (flags & BFA_WIPE) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 772 | { |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 773 | if (apply_autocmds(EVENT_BUFWIPEOUT, buf->b_fname, buf->b_fname, |
| 774 | FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 775 | && !bufref_valid(&bufref)) |
| 776 | /* autocommands deleted the buffer */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 777 | return; |
| 778 | } |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 779 | --buf->b_locked; |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 780 | |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 781 | /* If the buffer was in curwin and the window has changed, go back to that |
| 782 | * window, if it still exists. This avoids that ":edit x" triggering a |
| 783 | * "tabnext" BufUnload autocmd leaves a window behind without a buffer. */ |
| 784 | if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin)) |
| 785 | { |
| 786 | block_autocmds(); |
| 787 | goto_tabpage_win(the_curtab, the_curwin); |
| 788 | unblock_autocmds(); |
| 789 | } |
Bram Moolenaar | 5a49789 | 2016-09-03 16:29:04 +0200 | [diff] [blame] | 790 | |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 791 | #ifdef FEAT_EVAL |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 792 | if (aborting()) /* autocmds may abort script processing */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 793 | return; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 794 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 795 | |
| 796 | /* |
| 797 | * It's possible that autocommands change curbuf to the one being deleted. |
| 798 | * This might cause curbuf to be deleted unexpectedly. But in some cases |
| 799 | * it's OK to delete the curbuf, because a new one is obtained anyway. |
| 800 | * Therefore only return if curbuf changed to the deleted buffer. |
| 801 | */ |
| 802 | if (buf == curbuf && !is_curbuf) |
| 803 | return; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 804 | #ifdef FEAT_DIFF |
| 805 | diff_buf_delete(buf); /* Can't use 'diff' for unloaded buffer. */ |
| 806 | #endif |
Bram Moolenaar | a971b82 | 2011-09-14 14:43:25 +0200 | [diff] [blame] | 807 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 89c7122 | 2011-11-30 15:40:56 +0100 | [diff] [blame] | 808 | /* Remove any ownsyntax, unless exiting. */ |
Bram Moolenaar | 030cddc | 2016-09-04 23:41:42 +0200 | [diff] [blame] | 809 | if (curwin != NULL && curwin->w_buffer == buf) |
Bram Moolenaar | 89c7122 | 2011-11-30 15:40:56 +0100 | [diff] [blame] | 810 | reset_synblock(curwin); |
Bram Moolenaar | a971b82 | 2011-09-14 14:43:25 +0200 | [diff] [blame] | 811 | #endif |
Bram Moolenaar | b6799ac | 2007-05-10 16:44:05 +0000 | [diff] [blame] | 812 | |
| 813 | #ifdef FEAT_FOLDING |
| 814 | /* No folds in an empty buffer. */ |
Bram Moolenaar | b6799ac | 2007-05-10 16:44:05 +0000 | [diff] [blame] | 815 | { |
| 816 | win_T *win; |
| 817 | tabpage_T *tp; |
| 818 | |
| 819 | FOR_ALL_TAB_WINDOWS(tp, win) |
| 820 | if (win->w_buffer == buf) |
| 821 | clearFolding(win); |
| 822 | } |
Bram Moolenaar | b6799ac | 2007-05-10 16:44:05 +0000 | [diff] [blame] | 823 | #endif |
| 824 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 825 | #ifdef FEAT_TCL |
| 826 | tcl_buffer_free(buf); |
| 827 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 828 | ml_close(buf, TRUE); /* close and delete the memline/memfile */ |
| 829 | buf->b_ml.ml_line_count = 0; /* no lines in buffer */ |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 830 | if ((flags & BFA_KEEP_UNDO) == 0) |
| 831 | { |
| 832 | u_blockfree(buf); /* free the memory allocated for undo */ |
| 833 | u_clearall(buf); /* reset all undo information */ |
| 834 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 835 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 860cae1 | 2010-06-05 23:22:07 +0200 | [diff] [blame] | 836 | syntax_clear(&buf->b_s); /* reset syntax info */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 837 | #endif |
Bram Moolenaar | 98aefe7 | 2018-12-13 22:20:09 +0100 | [diff] [blame] | 838 | #ifdef FEAT_TEXT_PROP |
| 839 | clear_buf_prop_types(buf); |
| 840 | #endif |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 841 | buf->b_flags &= ~BF_READERR; /* a read error is no longer relevant */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 842 | } |
| 843 | |
| 844 | /* |
| 845 | * Free a buffer structure and the things it contains related to the buffer |
| 846 | * itself (not the file, that must have been done already). |
| 847 | */ |
| 848 | static void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 849 | free_buffer(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 850 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 851 | ++buf_free_count; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 852 | free_buffer_stuff(buf, TRUE); |
Bram Moolenaar | 429fa85 | 2013-04-15 12:27:36 +0200 | [diff] [blame] | 853 | #ifdef FEAT_EVAL |
Bram Moolenaar | b2c8750 | 2017-10-14 21:15:58 +0200 | [diff] [blame] | 854 | /* b:changedtick uses an item in buf_T, remove it now */ |
| 855 | dictitem_remove(buf->b_vars, (dictitem_T *)&buf->b_ct_di); |
Bram Moolenaar | 429fa85 | 2013-04-15 12:27:36 +0200 | [diff] [blame] | 856 | unref_var_dict(buf->b_vars); |
| 857 | #endif |
Bram Moolenaar | 0ba0429 | 2010-07-14 23:23:17 +0200 | [diff] [blame] | 858 | #ifdef FEAT_LUA |
| 859 | lua_buffer_free(buf); |
| 860 | #endif |
Bram Moolenaar | 325b7a2 | 2004-07-05 15:58:32 +0000 | [diff] [blame] | 861 | #ifdef FEAT_MZSCHEME |
| 862 | mzscheme_buffer_free(buf); |
| 863 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 864 | #ifdef FEAT_PERL |
| 865 | perl_buf_free(buf); |
| 866 | #endif |
| 867 | #ifdef FEAT_PYTHON |
| 868 | python_buffer_free(buf); |
| 869 | #endif |
Bram Moolenaar | bd5e15f | 2010-07-17 21:19:38 +0200 | [diff] [blame] | 870 | #ifdef FEAT_PYTHON3 |
| 871 | python3_buffer_free(buf); |
| 872 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 873 | #ifdef FEAT_RUBY |
| 874 | ruby_buffer_free(buf); |
| 875 | #endif |
Bram Moolenaar | e0f76d0 | 2016-05-09 20:38:53 +0200 | [diff] [blame] | 876 | #ifdef FEAT_JOB_CHANNEL |
| 877 | channel_buffer_free(buf); |
| 878 | #endif |
Bram Moolenaar | 96ca27a | 2017-07-17 23:20:24 +0200 | [diff] [blame] | 879 | #ifdef FEAT_TERMINAL |
Bram Moolenaar | d85f271 | 2017-07-28 21:51:57 +0200 | [diff] [blame] | 880 | free_terminal(buf); |
Bram Moolenaar | 96ca27a | 2017-07-17 23:20:24 +0200 | [diff] [blame] | 881 | #endif |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 882 | #ifdef FEAT_JOB_CHANNEL |
| 883 | vim_free(buf->b_prompt_text); |
Bram Moolenaar | 3a97bb3 | 2019-06-01 13:28:35 +0200 | [diff] [blame] | 884 | free_callback(&buf->b_prompt_callback); |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 885 | #endif |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 886 | |
| 887 | buf_hashtab_remove(buf); |
| 888 | |
Bram Moolenaar | 9280e3f | 2016-07-14 23:03:19 +0200 | [diff] [blame] | 889 | aubuflocal_remove(buf); |
| 890 | |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 891 | if (autocmd_busy) |
| 892 | { |
| 893 | /* Do not free the buffer structure while autocommands are executing, |
| 894 | * it's still needed. Free it when autocmd_busy is reset. */ |
| 895 | buf->b_next = au_pending_free_buf; |
| 896 | au_pending_free_buf = buf; |
| 897 | } |
| 898 | else |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 899 | vim_free(buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 900 | } |
| 901 | |
| 902 | /* |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 903 | * Initializes b:changedtick. |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 904 | */ |
| 905 | static void |
| 906 | init_changedtick(buf_T *buf) |
| 907 | { |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 908 | dictitem_T *di = (dictitem_T *)&buf->b_ct_di; |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 909 | |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 910 | di->di_flags = DI_FLAGS_FIX | DI_FLAGS_RO; |
| 911 | di->di_tv.v_type = VAR_NUMBER; |
| 912 | di->di_tv.v_lock = VAR_FIXED; |
| 913 | di->di_tv.vval.v_number = 0; |
| 914 | |
Bram Moolenaar | 92769c3 | 2017-02-25 15:41:37 +0100 | [diff] [blame] | 915 | #ifdef FEAT_EVAL |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 916 | STRCPY(buf->b_ct_di.di_key, "changedtick"); |
| 917 | (void)dict_add(buf->b_vars, di); |
Bram Moolenaar | 92769c3 | 2017-02-25 15:41:37 +0100 | [diff] [blame] | 918 | #endif |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 919 | } |
| 920 | |
| 921 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 922 | * Free stuff in the buffer for ":bdel" and when wiping out the buffer. |
| 923 | */ |
| 924 | static void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 925 | free_buffer_stuff( |
| 926 | buf_T *buf, |
| 927 | int free_options) /* free options as well */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 928 | { |
| 929 | if (free_options) |
| 930 | { |
| 931 | clear_wininfo(buf); /* including window-local options */ |
| 932 | free_buf_options(buf, TRUE); |
Bram Moolenaar | beca055 | 2010-10-27 16:18:00 +0200 | [diff] [blame] | 933 | #ifdef FEAT_SPELL |
| 934 | ga_clear(&buf->b_s.b_langp); |
| 935 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 936 | } |
| 937 | #ifdef FEAT_EVAL |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 938 | { |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 939 | varnumber_T tick = CHANGEDTICK(buf); |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 940 | |
| 941 | vars_clear(&buf->b_vars->dv_hashtab); /* free all buffer variables */ |
| 942 | hash_init(&buf->b_vars->dv_hashtab); |
| 943 | init_changedtick(buf); |
Bram Moolenaar | 95c526e | 2017-02-25 14:59:34 +0100 | [diff] [blame] | 944 | CHANGEDTICK(buf) = tick; |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 945 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 946 | #endif |
Bram Moolenaar | ac9fb18 | 2019-04-27 13:04:13 +0200 | [diff] [blame] | 947 | uc_clear(&buf->b_ucmds); // clear local user commands |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 948 | #ifdef FEAT_SIGNS |
Bram Moolenaar | ac9fb18 | 2019-04-27 13:04:13 +0200 | [diff] [blame] | 949 | buf_delete_signs(buf, (char_u *)"*"); // delete any signs |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 950 | #endif |
Bram Moolenaar | d7f8f5c | 2009-01-06 15:14:30 +0000 | [diff] [blame] | 951 | #ifdef FEAT_NETBEANS_INTG |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 952 | netbeans_file_killed(buf); |
Bram Moolenaar | d7f8f5c | 2009-01-06 15:14:30 +0000 | [diff] [blame] | 953 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 954 | map_clear_int(buf, MAP_ALL_MODES, TRUE, FALSE); /* clear local mappings */ |
| 955 | map_clear_int(buf, MAP_ALL_MODES, TRUE, TRUE); /* clear local abbrevs */ |
Bram Moolenaar | d23a823 | 2018-02-10 18:45:26 +0100 | [diff] [blame] | 956 | VIM_CLEAR(buf->b_start_fenc); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 957 | } |
| 958 | |
| 959 | /* |
| 960 | * Free the b_wininfo list for buffer "buf". |
| 961 | */ |
| 962 | static void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 963 | clear_wininfo(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 964 | { |
| 965 | wininfo_T *wip; |
| 966 | |
| 967 | while (buf->b_wininfo != NULL) |
| 968 | { |
| 969 | wip = buf->b_wininfo; |
| 970 | buf->b_wininfo = wip->wi_next; |
| 971 | if (wip->wi_optset) |
| 972 | { |
| 973 | clear_winopt(&wip->wi_opt); |
| 974 | #ifdef FEAT_FOLDING |
| 975 | deleteFoldRecurse(&wip->wi_folds); |
| 976 | #endif |
| 977 | } |
| 978 | vim_free(wip); |
| 979 | } |
| 980 | } |
| 981 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 982 | /* |
| 983 | * Go to another buffer. Handles the result of the ATTENTION dialog. |
| 984 | */ |
| 985 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 986 | goto_buffer( |
| 987 | exarg_T *eap, |
| 988 | int start, |
| 989 | int dir, |
| 990 | int count) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 991 | { |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 992 | bufref_T old_curbuf; |
| 993 | |
| 994 | set_bufref(&old_curbuf, curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 995 | |
| 996 | swap_exists_action = SEA_DIALOG; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 997 | (void)do_buffer(*eap->cmd == 's' ? DOBUF_SPLIT : DOBUF_GOTO, |
| 998 | start, dir, count, eap->forceit); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 999 | if (swap_exists_action == SEA_QUIT && *eap->cmd == 's') |
| 1000 | { |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1001 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1002 | cleanup_T cs; |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 1003 | |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1004 | /* Reset the error/interrupt/exception state here so that |
| 1005 | * aborting() returns FALSE when closing a window. */ |
| 1006 | enter_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1007 | #endif |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 1008 | |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1009 | /* Quitting means closing the split window, nothing else. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1010 | win_close(curwin, TRUE); |
| 1011 | swap_exists_action = SEA_NONE; |
Bram Moolenaar | 12033fb | 2005-12-16 21:49:31 +0000 | [diff] [blame] | 1012 | swap_exists_did_quit = TRUE; |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1013 | |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1014 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1015 | /* Restore the error/interrupt/exception state if not discarded by a |
| 1016 | * new aborting error, interrupt, or uncaught exception. */ |
| 1017 | leave_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1018 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1019 | } |
| 1020 | else |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 1021 | handle_swap_exists(&old_curbuf); |
Bram Moolenaar | 0c72fe4 | 2018-03-29 16:04:08 +0200 | [diff] [blame] | 1022 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1023 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1024 | /* |
| 1025 | * Handle the situation of swap_exists_action being set. |
| 1026 | * It is allowed for "old_curbuf" to be NULL or invalid. |
| 1027 | */ |
| 1028 | void |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 1029 | handle_swap_exists(bufref_T *old_curbuf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1030 | { |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1031 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1032 | cleanup_T cs; |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1033 | #endif |
| 1034 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1035 | long old_tw = curbuf->b_p_tw; |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1036 | #endif |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 1037 | buf_T *buf; |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 1038 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1039 | if (swap_exists_action == SEA_QUIT) |
| 1040 | { |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1041 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1042 | /* Reset the error/interrupt/exception state here so that |
| 1043 | * aborting() returns FALSE when closing a buffer. */ |
| 1044 | enter_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1045 | #endif |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1046 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1047 | /* User selected Quit at ATTENTION prompt. Go back to previous |
| 1048 | * buffer. If that buffer is gone or the same as the current one, |
| 1049 | * open a new, empty buffer. */ |
| 1050 | swap_exists_action = SEA_NONE; /* don't want it again */ |
Bram Moolenaar | 12033fb | 2005-12-16 21:49:31 +0000 | [diff] [blame] | 1051 | swap_exists_did_quit = TRUE; |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 1052 | close_buffer(curwin, curbuf, DOBUF_UNLOAD, FALSE); |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 1053 | if (old_curbuf == NULL || !bufref_valid(old_curbuf) |
| 1054 | || old_curbuf->br_buf == curbuf) |
| 1055 | buf = buflist_new(NULL, NULL, 1L, BLN_CURBUF | BLN_LISTED); |
| 1056 | else |
| 1057 | buf = old_curbuf->br_buf; |
| 1058 | if (buf != NULL) |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1059 | { |
Bram Moolenaar | 2f0f871 | 2018-08-21 18:50:18 +0200 | [diff] [blame] | 1060 | int old_msg_silent = msg_silent; |
| 1061 | |
| 1062 | if (shortmess(SHM_FILEINFO)) |
| 1063 | msg_silent = 1; // prevent fileinfo message |
Bram Moolenaar | 7c0a2f3 | 2016-07-10 22:11:16 +0200 | [diff] [blame] | 1064 | enter_buffer(buf); |
Bram Moolenaar | 2f0f871 | 2018-08-21 18:50:18 +0200 | [diff] [blame] | 1065 | // restore msg_silent, so that the command line will be shown |
| 1066 | msg_silent = old_msg_silent; |
| 1067 | |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1068 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1069 | if (old_tw != curbuf->b_p_tw) |
| 1070 | check_colorcolumn(curwin); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1071 | #endif |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1072 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1073 | /* If "old_curbuf" is NULL we are in big trouble here... */ |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1074 | |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1075 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1076 | /* Restore the error/interrupt/exception state if not discarded by a |
| 1077 | * new aborting error, interrupt, or uncaught exception. */ |
| 1078 | leave_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1079 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1080 | } |
| 1081 | else if (swap_exists_action == SEA_RECOVER) |
| 1082 | { |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1083 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1084 | /* Reset the error/interrupt/exception state here so that |
| 1085 | * aborting() returns FALSE when closing a buffer. */ |
| 1086 | enter_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1087 | #endif |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1088 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1089 | /* User selected Recover at ATTENTION prompt. */ |
| 1090 | msg_scroll = TRUE; |
Bram Moolenaar | 99499b1 | 2019-05-23 21:35:48 +0200 | [diff] [blame] | 1091 | ml_recover(FALSE); |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 1092 | msg_puts("\n"); /* don't overwrite the last message */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1093 | cmdline_row = msg_row; |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 1094 | do_modelines(0); |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1095 | |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1096 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 1097 | /* Restore the error/interrupt/exception state if not discarded by a |
| 1098 | * new aborting error, interrupt, or uncaught exception. */ |
| 1099 | leave_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 1100 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1101 | } |
| 1102 | swap_exists_action = SEA_NONE; |
| 1103 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1104 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1105 | /* |
| 1106 | * do_bufdel() - delete or unload buffer(s) |
| 1107 | * |
| 1108 | * addr_count == 0: ":bdel" - delete current buffer |
| 1109 | * addr_count == 1: ":N bdel" or ":bdel N [N ..]" - first delete |
| 1110 | * buffer "end_bnr", then any other arguments. |
| 1111 | * addr_count == 2: ":N,N bdel" - delete buffers in range |
| 1112 | * |
| 1113 | * command can be DOBUF_UNLOAD (":bunload"), DOBUF_WIPE (":bwipeout") or |
| 1114 | * DOBUF_DEL (":bdel") |
| 1115 | * |
| 1116 | * Returns error message or NULL |
| 1117 | */ |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1118 | char * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1119 | do_bufdel( |
| 1120 | int command, |
| 1121 | char_u *arg, /* pointer to extra arguments */ |
| 1122 | int addr_count, |
| 1123 | int start_bnr, /* first buffer number in a range */ |
| 1124 | int end_bnr, /* buffer nr or last buffer nr in a range */ |
| 1125 | int forceit) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1126 | { |
| 1127 | int do_current = 0; /* delete current buffer? */ |
| 1128 | int deleted = 0; /* number of buffers deleted */ |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1129 | char *errormsg = NULL; /* return value */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1130 | int bnr; /* buffer number */ |
| 1131 | char_u *p; |
| 1132 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1133 | if (addr_count == 0) |
| 1134 | { |
| 1135 | (void)do_buffer(command, DOBUF_CURRENT, FORWARD, 0, forceit); |
| 1136 | } |
| 1137 | else |
| 1138 | { |
| 1139 | if (addr_count == 2) |
| 1140 | { |
| 1141 | if (*arg) /* both range and argument is not allowed */ |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1142 | return _(e_trailing); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1143 | bnr = start_bnr; |
| 1144 | } |
| 1145 | else /* addr_count == 1 */ |
| 1146 | bnr = end_bnr; |
| 1147 | |
| 1148 | for ( ;!got_int; ui_breakcheck()) |
| 1149 | { |
| 1150 | /* |
| 1151 | * delete the current buffer last, otherwise when the |
| 1152 | * current buffer is deleted, the next buffer becomes |
| 1153 | * the current one and will be loaded, which may then |
| 1154 | * also be deleted, etc. |
| 1155 | */ |
| 1156 | if (bnr == curbuf->b_fnum) |
| 1157 | do_current = bnr; |
| 1158 | else if (do_buffer(command, DOBUF_FIRST, FORWARD, (int)bnr, |
| 1159 | forceit) == OK) |
| 1160 | ++deleted; |
| 1161 | |
| 1162 | /* |
| 1163 | * find next buffer number to delete/unload |
| 1164 | */ |
| 1165 | if (addr_count == 2) |
| 1166 | { |
| 1167 | if (++bnr > end_bnr) |
| 1168 | break; |
| 1169 | } |
| 1170 | else /* addr_count == 1 */ |
| 1171 | { |
| 1172 | arg = skipwhite(arg); |
| 1173 | if (*arg == NUL) |
| 1174 | break; |
| 1175 | if (!VIM_ISDIGIT(*arg)) |
| 1176 | { |
| 1177 | p = skiptowhite_esc(arg); |
Bram Moolenaar | 0c279bb | 2013-03-19 14:25:54 +0100 | [diff] [blame] | 1178 | bnr = buflist_findpat(arg, p, command == DOBUF_WIPE, |
| 1179 | FALSE, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1180 | if (bnr < 0) /* failed */ |
| 1181 | break; |
| 1182 | arg = p; |
| 1183 | } |
| 1184 | else |
| 1185 | bnr = getdigits(&arg); |
| 1186 | } |
| 1187 | } |
| 1188 | if (!got_int && do_current && do_buffer(command, DOBUF_FIRST, |
| 1189 | FORWARD, do_current, forceit) == OK) |
| 1190 | ++deleted; |
| 1191 | |
| 1192 | if (deleted == 0) |
| 1193 | { |
| 1194 | if (command == DOBUF_UNLOAD) |
Bram Moolenaar | 51485f0 | 2005-06-04 21:55:20 +0000 | [diff] [blame] | 1195 | STRCPY(IObuff, _("E515: No buffers were unloaded")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1196 | else if (command == DOBUF_DEL) |
Bram Moolenaar | 51485f0 | 2005-06-04 21:55:20 +0000 | [diff] [blame] | 1197 | STRCPY(IObuff, _("E516: No buffers were deleted")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1198 | else |
Bram Moolenaar | 51485f0 | 2005-06-04 21:55:20 +0000 | [diff] [blame] | 1199 | STRCPY(IObuff, _("E517: No buffers were wiped out")); |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1200 | errormsg = (char *)IObuff; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1201 | } |
| 1202 | else if (deleted >= p_report) |
| 1203 | { |
| 1204 | if (command == DOBUF_UNLOAD) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1205 | smsg(NGETTEXT("%d buffer unloaded", |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 1206 | "%d buffers unloaded", deleted), deleted); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1207 | else if (command == DOBUF_DEL) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1208 | smsg(NGETTEXT("%d buffer deleted", |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 1209 | "%d buffers deleted", deleted), deleted); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1210 | else |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1211 | smsg(NGETTEXT("%d buffer wiped out", |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 1212 | "%d buffers wiped out", deleted), deleted); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1213 | } |
| 1214 | } |
| 1215 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1216 | |
| 1217 | return errormsg; |
| 1218 | } |
| 1219 | |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1220 | /* |
| 1221 | * Make the current buffer empty. |
| 1222 | * Used when it is wiped out and it's the last buffer. |
| 1223 | */ |
| 1224 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1225 | empty_curbuf( |
| 1226 | int close_others, |
| 1227 | int forceit, |
| 1228 | int action) |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1229 | { |
| 1230 | int retval; |
| 1231 | buf_T *buf = curbuf; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1232 | bufref_T bufref; |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1233 | |
| 1234 | if (action == DOBUF_UNLOAD) |
| 1235 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1236 | emsg(_("E90: Cannot unload last buffer")); |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1237 | return FAIL; |
| 1238 | } |
| 1239 | |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1240 | set_bufref(&bufref, buf); |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1241 | if (close_others) |
| 1242 | /* Close any other windows on this buffer, then make it empty. */ |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1243 | close_windows(buf, TRUE); |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1244 | |
| 1245 | setpcmark(); |
| 1246 | retval = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, |
| 1247 | forceit ? ECMD_FORCEIT : 0, curwin); |
| 1248 | |
| 1249 | /* |
| 1250 | * do_ecmd() may create a new buffer, then we have to delete |
| 1251 | * the old one. But do_ecmd() may have done that already, check |
| 1252 | * if the buffer still exists. |
| 1253 | */ |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1254 | if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows == 0) |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1255 | close_buffer(NULL, buf, action, FALSE); |
| 1256 | if (!close_others) |
| 1257 | need_fileinfo = FALSE; |
| 1258 | return retval; |
| 1259 | } |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 1260 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1261 | /* |
| 1262 | * Implementation of the commands for the buffer list. |
| 1263 | * |
| 1264 | * action == DOBUF_GOTO go to specified buffer |
| 1265 | * action == DOBUF_SPLIT split window and go to specified buffer |
| 1266 | * action == DOBUF_UNLOAD unload specified buffer(s) |
| 1267 | * action == DOBUF_DEL delete specified buffer(s) from buffer list |
| 1268 | * action == DOBUF_WIPE delete specified buffer(s) really |
| 1269 | * |
| 1270 | * start == DOBUF_CURRENT go to "count" buffer from current buffer |
| 1271 | * start == DOBUF_FIRST go to "count" buffer from first buffer |
| 1272 | * start == DOBUF_LAST go to "count" buffer from last buffer |
| 1273 | * start == DOBUF_MOD go to "count" modified buffer from current buffer |
| 1274 | * |
| 1275 | * Return FAIL or OK. |
| 1276 | */ |
| 1277 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1278 | do_buffer( |
| 1279 | int action, |
| 1280 | int start, |
| 1281 | int dir, /* FORWARD or BACKWARD */ |
| 1282 | int count, /* buffer number or number of buffers */ |
| 1283 | int forceit) /* TRUE for :...! */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1284 | { |
| 1285 | buf_T *buf; |
| 1286 | buf_T *bp; |
| 1287 | int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL |
| 1288 | || action == DOBUF_WIPE); |
| 1289 | |
| 1290 | switch (start) |
| 1291 | { |
| 1292 | case DOBUF_FIRST: buf = firstbuf; break; |
| 1293 | case DOBUF_LAST: buf = lastbuf; break; |
| 1294 | default: buf = curbuf; break; |
| 1295 | } |
| 1296 | if (start == DOBUF_MOD) /* find next modified buffer */ |
| 1297 | { |
| 1298 | while (count-- > 0) |
| 1299 | { |
| 1300 | do |
| 1301 | { |
| 1302 | buf = buf->b_next; |
| 1303 | if (buf == NULL) |
| 1304 | buf = firstbuf; |
| 1305 | } |
| 1306 | while (buf != curbuf && !bufIsChanged(buf)); |
| 1307 | } |
| 1308 | if (!bufIsChanged(buf)) |
| 1309 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1310 | emsg(_("E84: No modified buffer found")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1311 | return FAIL; |
| 1312 | } |
| 1313 | } |
| 1314 | else if (start == DOBUF_FIRST && count) /* find specified buffer number */ |
| 1315 | { |
| 1316 | while (buf != NULL && buf->b_fnum != count) |
| 1317 | buf = buf->b_next; |
| 1318 | } |
| 1319 | else |
| 1320 | { |
| 1321 | bp = NULL; |
| 1322 | while (count > 0 || (!unload && !buf->b_p_bl && bp != buf)) |
| 1323 | { |
| 1324 | /* remember the buffer where we start, we come back there when all |
| 1325 | * buffers are unlisted. */ |
| 1326 | if (bp == NULL) |
| 1327 | bp = buf; |
| 1328 | if (dir == FORWARD) |
| 1329 | { |
| 1330 | buf = buf->b_next; |
| 1331 | if (buf == NULL) |
| 1332 | buf = firstbuf; |
| 1333 | } |
| 1334 | else |
| 1335 | { |
| 1336 | buf = buf->b_prev; |
| 1337 | if (buf == NULL) |
| 1338 | buf = lastbuf; |
| 1339 | } |
| 1340 | /* don't count unlisted buffers */ |
| 1341 | if (unload || buf->b_p_bl) |
| 1342 | { |
| 1343 | --count; |
| 1344 | bp = NULL; /* use this buffer as new starting point */ |
| 1345 | } |
| 1346 | if (bp == buf) |
| 1347 | { |
| 1348 | /* back where we started, didn't find anything. */ |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1349 | emsg(_("E85: There is no listed buffer")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1350 | return FAIL; |
| 1351 | } |
| 1352 | } |
| 1353 | } |
| 1354 | |
| 1355 | if (buf == NULL) /* could not find it */ |
| 1356 | { |
| 1357 | if (start == DOBUF_FIRST) |
| 1358 | { |
| 1359 | /* don't warn when deleting */ |
| 1360 | if (!unload) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1361 | semsg(_(e_nobufnr), count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1362 | } |
| 1363 | else if (dir == FORWARD) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1364 | emsg(_("E87: Cannot go beyond last buffer")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1365 | else |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1366 | emsg(_("E88: Cannot go before first buffer")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1367 | return FAIL; |
| 1368 | } |
| 1369 | |
| 1370 | #ifdef FEAT_GUI |
| 1371 | need_mouse_correct = TRUE; |
| 1372 | #endif |
| 1373 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1374 | /* |
| 1375 | * delete buffer buf from memory and/or the list |
| 1376 | */ |
| 1377 | if (unload) |
| 1378 | { |
| 1379 | int forward; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1380 | bufref_T bufref; |
| 1381 | |
Bram Moolenaar | 94f0195 | 2018-09-01 15:30:03 +0200 | [diff] [blame] | 1382 | if (!can_unload_buffer(buf)) |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 1383 | return FAIL; |
Bram Moolenaar | a997b45 | 2018-04-17 23:24:06 +0200 | [diff] [blame] | 1384 | |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1385 | set_bufref(&bufref, buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1386 | |
| 1387 | /* When unloading or deleting a buffer that's already unloaded and |
| 1388 | * unlisted: fail silently. */ |
| 1389 | if (action != DOBUF_WIPE && buf->b_ml.ml_mfp == NULL && !buf->b_p_bl) |
| 1390 | return FAIL; |
| 1391 | |
| 1392 | if (!forceit && bufIsChanged(buf)) |
| 1393 | { |
Bram Moolenaar | 0c72fe4 | 2018-03-29 16:04:08 +0200 | [diff] [blame] | 1394 | #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1395 | if ((p_confirm || cmdmod.confirm) && p_write) |
| 1396 | { |
| 1397 | dialog_changed(buf, FALSE); |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1398 | if (!bufref_valid(&bufref)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1399 | /* Autocommand deleted buffer, oops! It's not changed |
| 1400 | * now. */ |
| 1401 | return FAIL; |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 1402 | /* If it's still changed fail silently, the dialog already |
| 1403 | * mentioned why it fails. */ |
| 1404 | if (bufIsChanged(buf)) |
| 1405 | return FAIL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1406 | } |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 1407 | else |
Bram Moolenaar | 0c72fe4 | 2018-03-29 16:04:08 +0200 | [diff] [blame] | 1408 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1409 | { |
Bram Moolenaar | b5443cc | 2019-01-15 20:19:40 +0100 | [diff] [blame] | 1410 | semsg(_("E89: No write since last change for buffer %d (add ! to override)"), |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1411 | buf->b_fnum); |
| 1412 | return FAIL; |
| 1413 | } |
| 1414 | } |
| 1415 | |
Bram Moolenaar | c4a908e | 2016-09-08 23:35:30 +0200 | [diff] [blame] | 1416 | /* When closing the current buffer stop Visual mode. */ |
Bram Moolenaar | 4930a76 | 2016-09-11 14:39:53 +0200 | [diff] [blame] | 1417 | if (buf == curbuf && VIsual_active) |
Bram Moolenaar | c4a908e | 2016-09-08 23:35:30 +0200 | [diff] [blame] | 1418 | end_visual_mode(); |
| 1419 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1420 | /* |
| 1421 | * If deleting the last (listed) buffer, make it empty. |
| 1422 | * The last (listed) buffer cannot be unloaded. |
| 1423 | */ |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 1424 | FOR_ALL_BUFFERS(bp) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1425 | if (bp->b_p_bl && bp != buf) |
| 1426 | break; |
| 1427 | if (bp == NULL && buf == curbuf) |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1428 | return empty_curbuf(TRUE, forceit, action); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1429 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1430 | /* |
| 1431 | * If the deleted buffer is the current one, close the current window |
Bram Moolenaar | f740b29 | 2006-02-16 22:11:02 +0000 | [diff] [blame] | 1432 | * (unless it's the only window). Repeat this so long as we end up in |
| 1433 | * a window with this buffer. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1434 | */ |
Bram Moolenaar | f740b29 | 2006-02-16 22:11:02 +0000 | [diff] [blame] | 1435 | while (buf == curbuf |
Bram Moolenaar | e0ab94e | 2016-09-04 19:50:54 +0200 | [diff] [blame] | 1436 | && !(curwin->w_closing || curwin->w_buffer->b_locked > 0) |
Bram Moolenaar | 459ca56 | 2016-11-10 18:16:33 +0100 | [diff] [blame] | 1437 | && (!ONE_WINDOW || first_tabpage->tp_next != NULL)) |
Bram Moolenaar | c93df6b | 2013-08-14 17:11:20 +0200 | [diff] [blame] | 1438 | { |
| 1439 | if (win_close(curwin, FALSE) == FAIL) |
| 1440 | break; |
| 1441 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1442 | |
| 1443 | /* |
| 1444 | * If the buffer to be deleted is not the current one, delete it here. |
| 1445 | */ |
| 1446 | if (buf != curbuf) |
| 1447 | { |
Bram Moolenaar | f740b29 | 2006-02-16 22:11:02 +0000 | [diff] [blame] | 1448 | close_windows(buf, FALSE); |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 1449 | if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows <= 0) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1450 | close_buffer(NULL, buf, action, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1451 | return OK; |
| 1452 | } |
| 1453 | |
| 1454 | /* |
| 1455 | * Deleting the current buffer: Need to find another buffer to go to. |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1456 | * There should be another, otherwise it would have been handled |
| 1457 | * above. However, autocommands may have deleted all buffers. |
Bram Moolenaar | 19ff9bf | 2016-07-10 19:03:57 +0200 | [diff] [blame] | 1458 | * First use au_new_curbuf.br_buf, if it is valid. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1459 | * Then prefer the buffer we most recently visited. |
| 1460 | * Else try to find one that is loaded, after the current buffer, |
| 1461 | * then before the current buffer. |
| 1462 | * Finally use any buffer. |
| 1463 | */ |
| 1464 | buf = NULL; /* selected buffer */ |
| 1465 | bp = NULL; /* used when no loaded buffer found */ |
Bram Moolenaar | 19ff9bf | 2016-07-10 19:03:57 +0200 | [diff] [blame] | 1466 | if (au_new_curbuf.br_buf != NULL && bufref_valid(&au_new_curbuf)) |
| 1467 | buf = au_new_curbuf.br_buf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1468 | #ifdef FEAT_JUMPLIST |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1469 | else if (curwin->w_jumplistlen > 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1470 | { |
| 1471 | int jumpidx; |
| 1472 | |
| 1473 | jumpidx = curwin->w_jumplistidx - 1; |
| 1474 | if (jumpidx < 0) |
| 1475 | jumpidx = curwin->w_jumplistlen - 1; |
| 1476 | |
| 1477 | forward = jumpidx; |
| 1478 | while (jumpidx != curwin->w_jumplistidx) |
| 1479 | { |
| 1480 | buf = buflist_findnr(curwin->w_jumplist[jumpidx].fmark.fnum); |
| 1481 | if (buf != NULL) |
| 1482 | { |
| 1483 | if (buf == curbuf || !buf->b_p_bl) |
| 1484 | buf = NULL; /* skip current and unlisted bufs */ |
| 1485 | else if (buf->b_ml.ml_mfp == NULL) |
| 1486 | { |
| 1487 | /* skip unloaded buf, but may keep it for later */ |
| 1488 | if (bp == NULL) |
| 1489 | bp = buf; |
| 1490 | buf = NULL; |
| 1491 | } |
| 1492 | } |
| 1493 | if (buf != NULL) /* found a valid buffer: stop searching */ |
| 1494 | break; |
| 1495 | /* advance to older entry in jump list */ |
| 1496 | if (!jumpidx && curwin->w_jumplistidx == curwin->w_jumplistlen) |
| 1497 | break; |
| 1498 | if (--jumpidx < 0) |
| 1499 | jumpidx = curwin->w_jumplistlen - 1; |
| 1500 | if (jumpidx == forward) /* List exhausted for sure */ |
| 1501 | break; |
| 1502 | } |
| 1503 | } |
| 1504 | #endif |
| 1505 | |
| 1506 | if (buf == NULL) /* No previous buffer, Try 2'nd approach */ |
| 1507 | { |
| 1508 | forward = TRUE; |
| 1509 | buf = curbuf->b_next; |
| 1510 | for (;;) |
| 1511 | { |
| 1512 | if (buf == NULL) |
| 1513 | { |
| 1514 | if (!forward) /* tried both directions */ |
| 1515 | break; |
| 1516 | buf = curbuf->b_prev; |
| 1517 | forward = FALSE; |
| 1518 | continue; |
| 1519 | } |
| 1520 | /* in non-help buffer, try to skip help buffers, and vv */ |
| 1521 | if (buf->b_help == curbuf->b_help && buf->b_p_bl) |
| 1522 | { |
| 1523 | if (buf->b_ml.ml_mfp != NULL) /* found loaded buffer */ |
| 1524 | break; |
| 1525 | if (bp == NULL) /* remember unloaded buf for later */ |
| 1526 | bp = buf; |
| 1527 | } |
| 1528 | if (forward) |
| 1529 | buf = buf->b_next; |
| 1530 | else |
| 1531 | buf = buf->b_prev; |
| 1532 | } |
| 1533 | } |
| 1534 | if (buf == NULL) /* No loaded buffer, use unloaded one */ |
| 1535 | buf = bp; |
| 1536 | if (buf == NULL) /* No loaded buffer, find listed one */ |
| 1537 | { |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 1538 | FOR_ALL_BUFFERS(buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1539 | if (buf->b_p_bl && buf != curbuf) |
| 1540 | break; |
| 1541 | } |
| 1542 | if (buf == NULL) /* Still no buffer, just take one */ |
| 1543 | { |
| 1544 | if (curbuf->b_next != NULL) |
| 1545 | buf = curbuf->b_next; |
| 1546 | else |
| 1547 | buf = curbuf->b_prev; |
| 1548 | } |
| 1549 | } |
| 1550 | |
Bram Moolenaar | a02471e | 2014-01-10 16:43:14 +0100 | [diff] [blame] | 1551 | if (buf == NULL) |
| 1552 | { |
| 1553 | /* Autocommands must have wiped out all other buffers. Only option |
| 1554 | * now is to make the current buffer empty. */ |
| 1555 | return empty_curbuf(FALSE, forceit, action); |
| 1556 | } |
| 1557 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1558 | /* |
| 1559 | * make buf current buffer |
| 1560 | */ |
| 1561 | if (action == DOBUF_SPLIT) /* split window first */ |
| 1562 | { |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 1563 | /* If 'switchbuf' contains "useopen": jump to first window containing |
| 1564 | * "buf" if one exists */ |
| 1565 | if ((swb_flags & SWB_USEOPEN) && buf_jump_open_win(buf)) |
Bram Moolenaar | 779b74b | 2006-04-10 14:55:34 +0000 | [diff] [blame] | 1566 | return OK; |
Bram Moolenaar | 9381ab7 | 2008-11-12 11:52:19 +0000 | [diff] [blame] | 1567 | /* If 'switchbuf' contains "usetab": jump to first window in any tab |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 1568 | * page containing "buf" if one exists */ |
| 1569 | if ((swb_flags & SWB_USETAB) && buf_jump_open_tab(buf)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1570 | return OK; |
| 1571 | if (win_split(0, 0) == FAIL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1572 | return FAIL; |
| 1573 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1574 | |
| 1575 | /* go to current buffer - nothing to do */ |
| 1576 | if (buf == curbuf) |
| 1577 | return OK; |
| 1578 | |
| 1579 | /* |
| 1580 | * Check if the current buffer may be abandoned. |
| 1581 | */ |
| 1582 | if (action == DOBUF_GOTO && !can_abandon(curbuf, forceit)) |
| 1583 | { |
| 1584 | #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) |
| 1585 | if ((p_confirm || cmdmod.confirm) && p_write) |
| 1586 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1587 | bufref_T bufref; |
| 1588 | |
| 1589 | set_bufref(&bufref, buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1590 | dialog_changed(curbuf, FALSE); |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1591 | if (!bufref_valid(&bufref)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1592 | /* Autocommand deleted buffer, oops! */ |
| 1593 | return FAIL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1594 | } |
| 1595 | if (bufIsChanged(curbuf)) |
| 1596 | #endif |
| 1597 | { |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1598 | no_write_message(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1599 | return FAIL; |
| 1600 | } |
| 1601 | } |
| 1602 | |
| 1603 | /* Go to the other buffer. */ |
| 1604 | set_curbuf(buf, action); |
| 1605 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1606 | if (action == DOBUF_SPLIT) |
Bram Moolenaar | 3368ea2 | 2010-09-21 16:56:35 +0200 | [diff] [blame] | 1607 | RESET_BINDING(curwin); /* reset 'scrollbind' and 'cursorbind' */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1608 | |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1609 | #if defined(FEAT_EVAL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1610 | if (aborting()) /* autocmds may abort script processing */ |
| 1611 | return FAIL; |
| 1612 | #endif |
| 1613 | |
| 1614 | return OK; |
| 1615 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1616 | |
| 1617 | /* |
| 1618 | * Set current buffer to "buf". Executes autocommands and closes current |
| 1619 | * buffer. "action" tells how to close the current buffer: |
| 1620 | * DOBUF_GOTO free or hide it |
| 1621 | * DOBUF_SPLIT nothing |
| 1622 | * DOBUF_UNLOAD unload it |
| 1623 | * DOBUF_DEL delete it |
| 1624 | * DOBUF_WIPE wipe it out |
| 1625 | */ |
| 1626 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1627 | set_curbuf(buf_T *buf, int action) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1628 | { |
| 1629 | buf_T *prevbuf; |
| 1630 | int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL |
| 1631 | || action == DOBUF_WIPE); |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1632 | #ifdef FEAT_SYN_HL |
| 1633 | long old_tw = curbuf->b_p_tw; |
| 1634 | #endif |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1635 | bufref_T newbufref; |
| 1636 | bufref_T prevbufref; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1637 | |
| 1638 | setpcmark(); |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1639 | if (!cmdmod.keepalt) |
| 1640 | curwin->w_alt_fnum = curbuf->b_fnum; /* remember alternate file */ |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 1641 | buflist_altfpos(curwin); /* remember curpos */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1642 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1643 | /* Don't restart Select mode after switching to another buffer. */ |
| 1644 | VIsual_reselect = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1645 | |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1646 | /* close_windows() or apply_autocmds() may change curbuf and wipe out "buf" |
| 1647 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1648 | prevbuf = curbuf; |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1649 | set_bufref(&prevbufref, prevbuf); |
| 1650 | set_bufref(&newbufref, buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1651 | |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1652 | /* Autocommands may delete the curren buffer and/or the buffer we wan to go |
| 1653 | * to. In those cases don't close the buffer. */ |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 1654 | if (!apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf) |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1655 | || (bufref_valid(&prevbufref) |
| 1656 | && bufref_valid(&newbufref) |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1657 | #ifdef FEAT_EVAL |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1658 | && !aborting() |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1659 | #endif |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1660 | )) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1661 | { |
Bram Moolenaar | a971b82 | 2011-09-14 14:43:25 +0200 | [diff] [blame] | 1662 | #ifdef FEAT_SYN_HL |
| 1663 | if (prevbuf == curwin->w_buffer) |
| 1664 | reset_synblock(curwin); |
| 1665 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1666 | if (unload) |
Bram Moolenaar | f740b29 | 2006-02-16 22:11:02 +0000 | [diff] [blame] | 1667 | close_windows(prevbuf, FALSE); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1668 | #if defined(FEAT_EVAL) |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1669 | if (bufref_valid(&prevbufref) && !aborting()) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1670 | #else |
Bram Moolenaar | 9bca805 | 2017-12-18 12:37:55 +0100 | [diff] [blame] | 1671 | if (bufref_valid(&prevbufref)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1672 | #endif |
Bram Moolenaar | 607a95ed | 2006-03-28 20:57:42 +0000 | [diff] [blame] | 1673 | { |
Bram Moolenaar | e25865a | 2012-07-06 16:22:02 +0200 | [diff] [blame] | 1674 | win_T *previouswin = curwin; |
Bram Moolenaar | 607a95ed | 2006-03-28 20:57:42 +0000 | [diff] [blame] | 1675 | if (prevbuf == curbuf) |
Bram Moolenaar | 779b74b | 2006-04-10 14:55:34 +0000 | [diff] [blame] | 1676 | u_sync(FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1677 | close_buffer(prevbuf == curwin->w_buffer ? curwin : NULL, prevbuf, |
| 1678 | unload ? action : (action == DOBUF_GOTO |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 1679 | && !buf_hide(prevbuf) |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 1680 | && !bufIsChanged(prevbuf)) ? DOBUF_UNLOAD : 0, FALSE); |
Bram Moolenaar | e25865a | 2012-07-06 16:22:02 +0200 | [diff] [blame] | 1681 | if (curwin != previouswin && win_valid(previouswin)) |
Bram Moolenaar | 9e93122 | 2012-06-20 11:55:01 +0200 | [diff] [blame] | 1682 | /* autocommands changed curwin, Grr! */ |
Bram Moolenaar | e25865a | 2012-07-06 16:22:02 +0200 | [diff] [blame] | 1683 | curwin = previouswin; |
Bram Moolenaar | 607a95ed | 2006-03-28 20:57:42 +0000 | [diff] [blame] | 1684 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1685 | } |
Bram Moolenaar | 5bd266c | 2008-09-01 15:33:17 +0000 | [diff] [blame] | 1686 | /* An autocommand may have deleted "buf", already entered it (e.g., when |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1687 | * it did ":bunload") or aborted the script processing. |
Bram Moolenaar | 9e93122 | 2012-06-20 11:55:01 +0200 | [diff] [blame] | 1688 | * If curwin->w_buffer is null, enter_buffer() will make it valid again */ |
| 1689 | if ((buf_valid(buf) && buf != curbuf |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1690 | #ifdef FEAT_EVAL |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 1691 | && !aborting() |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1692 | #endif |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1693 | ) || curwin->w_buffer == NULL) |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1694 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1695 | enter_buffer(buf); |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1696 | #ifdef FEAT_SYN_HL |
| 1697 | if (old_tw != curbuf->b_p_tw) |
| 1698 | check_colorcolumn(curwin); |
| 1699 | #endif |
| 1700 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1701 | } |
| 1702 | |
| 1703 | /* |
| 1704 | * Enter a new current buffer. |
Bram Moolenaar | 6d47df7 | 2013-02-17 15:45:37 +0100 | [diff] [blame] | 1705 | * Old curbuf must have been abandoned already! This also means "curbuf" may |
| 1706 | * be pointing to freed memory. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1707 | */ |
| 1708 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1709 | enter_buffer(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1710 | { |
| 1711 | /* Copy buffer and window local option values. Not for a help buffer. */ |
| 1712 | buf_copy_options(buf, BCO_ENTER | BCO_NOHELP); |
| 1713 | if (!buf->b_help) |
| 1714 | get_winopts(buf); |
| 1715 | #ifdef FEAT_FOLDING |
| 1716 | else |
| 1717 | /* Remove all folds in the window. */ |
| 1718 | clearFolding(curwin); |
| 1719 | foldUpdateAll(curwin); /* update folds (later). */ |
| 1720 | #endif |
| 1721 | |
| 1722 | /* Get the buffer in the current window. */ |
| 1723 | curwin->w_buffer = buf; |
| 1724 | curbuf = buf; |
| 1725 | ++curbuf->b_nwindows; |
| 1726 | |
| 1727 | #ifdef FEAT_DIFF |
Bram Moolenaar | 49d7bf1 | 2006-02-17 21:45:41 +0000 | [diff] [blame] | 1728 | if (curwin->w_p_diff) |
| 1729 | diff_buf_add(curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1730 | #endif |
| 1731 | |
Bram Moolenaar | a971b82 | 2011-09-14 14:43:25 +0200 | [diff] [blame] | 1732 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 96ca27a | 2017-07-17 23:20:24 +0200 | [diff] [blame] | 1733 | curwin->w_s = &(curbuf->b_s); |
Bram Moolenaar | a971b82 | 2011-09-14 14:43:25 +0200 | [diff] [blame] | 1734 | #endif |
| 1735 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1736 | /* Cursor on first line by default. */ |
| 1737 | curwin->w_cursor.lnum = 1; |
| 1738 | curwin->w_cursor.col = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1739 | curwin->w_cursor.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1740 | curwin->w_set_curswant = TRUE; |
Bram Moolenaar | d4153d4 | 2008-11-15 15:06:17 +0000 | [diff] [blame] | 1741 | curwin->w_topline_was_set = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1742 | |
Bram Moolenaar | 89c0ea4 | 2010-02-24 16:58:36 +0100 | [diff] [blame] | 1743 | /* mark cursor position as being invalid */ |
| 1744 | curwin->w_valid = 0; |
| 1745 | |
Bram Moolenaar | 9cea87c | 2018-09-21 16:59:45 +0200 | [diff] [blame] | 1746 | buflist_setfpos(curbuf, curwin, curbuf->b_last_cursor.lnum, |
| 1747 | curbuf->b_last_cursor.col, TRUE); |
| 1748 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1749 | /* Make sure the buffer is loaded. */ |
| 1750 | if (curbuf->b_ml.ml_mfp == NULL) /* need to load the file */ |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1751 | { |
| 1752 | /* If there is no filetype, allow for detecting one. Esp. useful for |
| 1753 | * ":ball" used in a autocommand. If there already is a filetype we |
| 1754 | * might prefer to keep it. */ |
| 1755 | if (*curbuf->b_p_ft == NUL) |
| 1756 | did_filetype = FALSE; |
| 1757 | |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 1758 | open_buffer(FALSE, NULL, 0); |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 1759 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1760 | else |
| 1761 | { |
Bram Moolenaar | eda6522 | 2019-05-16 20:29:44 +0200 | [diff] [blame] | 1762 | if (!msg_silent && !shortmess(SHM_FILEINFO)) |
| 1763 | need_fileinfo = TRUE; // display file info after redraw |
| 1764 | |
| 1765 | // check if file changed |
| 1766 | (void)buf_check_timestamp(curbuf, FALSE); |
| 1767 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1768 | curwin->w_topline = 1; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1769 | #ifdef FEAT_DIFF |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1770 | curwin->w_topfill = 0; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1771 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1772 | apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf); |
| 1773 | apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1774 | } |
| 1775 | |
| 1776 | /* If autocommands did not change the cursor position, restore cursor lnum |
| 1777 | * and possibly cursor col. */ |
| 1778 | if (curwin->w_cursor.lnum == 1 && inindent(0)) |
| 1779 | buflist_getfpos(); |
| 1780 | |
| 1781 | check_arg_idx(curwin); /* check for valid arg_idx */ |
| 1782 | #ifdef FEAT_TITLE |
| 1783 | maketitle(); |
| 1784 | #endif |
Bram Moolenaar | d4153d4 | 2008-11-15 15:06:17 +0000 | [diff] [blame] | 1785 | /* when autocmds didn't change it */ |
| 1786 | if (curwin->w_topline == 1 && !curwin->w_topline_was_set) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1787 | scroll_cursor_halfway(FALSE); /* redisplay at correct position */ |
| 1788 | |
Bram Moolenaar | 009b259 | 2004-10-24 19:18:58 +0000 | [diff] [blame] | 1789 | #ifdef FEAT_NETBEANS_INTG |
| 1790 | /* Send fileOpened event because we've changed buffers. */ |
Bram Moolenaar | b26e632 | 2010-05-22 21:34:09 +0200 | [diff] [blame] | 1791 | netbeans_file_activated(curbuf); |
Bram Moolenaar | 009b259 | 2004-10-24 19:18:58 +0000 | [diff] [blame] | 1792 | #endif |
| 1793 | |
Bram Moolenaar | 498efdb | 2006-09-05 14:31:54 +0000 | [diff] [blame] | 1794 | /* Change directories when the 'acd' option is set. */ |
Bram Moolenaar | 6f47002 | 2018-04-10 18:47:20 +0200 | [diff] [blame] | 1795 | DO_AUTOCHDIR; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1796 | |
| 1797 | #ifdef FEAT_KEYMAP |
| 1798 | if (curbuf->b_kmap_state & KEYMAP_INIT) |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 1799 | (void)keymap_init(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1800 | #endif |
Bram Moolenaar | 706cdeb | 2007-05-06 21:55:31 +0000 | [diff] [blame] | 1801 | #ifdef FEAT_SPELL |
| 1802 | /* May need to set the spell language. Can only do this after the buffer |
| 1803 | * has been properly setup. */ |
Bram Moolenaar | 860cae1 | 2010-06-05 23:22:07 +0200 | [diff] [blame] | 1804 | if (!curbuf->b_help && curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL) |
| 1805 | (void)did_set_spelllang(curwin); |
Bram Moolenaar | 706cdeb | 2007-05-06 21:55:31 +0000 | [diff] [blame] | 1806 | #endif |
Bram Moolenaar | ab9c89b | 2016-07-03 17:47:26 +0200 | [diff] [blame] | 1807 | #ifdef FEAT_VIMINFO |
| 1808 | curbuf->b_last_used = vim_time(); |
| 1809 | #endif |
Bram Moolenaar | 706cdeb | 2007-05-06 21:55:31 +0000 | [diff] [blame] | 1810 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1811 | redraw_later(NOT_VALID); |
| 1812 | } |
| 1813 | |
Bram Moolenaar | 498efdb | 2006-09-05 14:31:54 +0000 | [diff] [blame] | 1814 | #if defined(FEAT_AUTOCHDIR) || defined(PROTO) |
| 1815 | /* |
| 1816 | * Change to the directory of the current buffer. |
Bram Moolenaar | 6bd364e | 2016-02-23 16:19:07 +0100 | [diff] [blame] | 1817 | * Don't do this while still starting up. |
Bram Moolenaar | 498efdb | 2006-09-05 14:31:54 +0000 | [diff] [blame] | 1818 | */ |
| 1819 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1820 | do_autochdir(void) |
Bram Moolenaar | 498efdb | 2006-09-05 14:31:54 +0000 | [diff] [blame] | 1821 | { |
Bram Moolenaar | 5c71994 | 2016-07-09 23:40:45 +0200 | [diff] [blame] | 1822 | if ((starting == 0 || test_autochdir) |
Bram Moolenaar | 6bd364e | 2016-02-23 16:19:07 +0100 | [diff] [blame] | 1823 | && curbuf->b_ffname != NULL |
Bram Moolenaar | b7407d3 | 2018-02-03 17:36:27 +0100 | [diff] [blame] | 1824 | && vim_chdirfile(curbuf->b_ffname, "auto") == OK) |
Bram Moolenaar | 498efdb | 2006-09-05 14:31:54 +0000 | [diff] [blame] | 1825 | shorten_fnames(TRUE); |
| 1826 | } |
| 1827 | #endif |
| 1828 | |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1829 | void |
| 1830 | no_write_message(void) |
| 1831 | { |
| 1832 | #ifdef FEAT_TERMINAL |
| 1833 | if (term_job_running(curbuf->b_term)) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1834 | emsg(_("E948: Job still running (add ! to end the job)")); |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1835 | else |
| 1836 | #endif |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1837 | emsg(_("E37: No write since last change (add ! to override)")); |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1838 | } |
| 1839 | |
| 1840 | void |
Bram Moolenaar | 7a76092 | 2018-02-19 23:10:02 +0100 | [diff] [blame] | 1841 | no_write_message_nobang(buf_T *buf UNUSED) |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1842 | { |
| 1843 | #ifdef FEAT_TERMINAL |
Bram Moolenaar | 7a76092 | 2018-02-19 23:10:02 +0100 | [diff] [blame] | 1844 | if (term_job_running(buf->b_term)) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1845 | emsg(_("E948: Job still running")); |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1846 | else |
| 1847 | #endif |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 1848 | emsg(_("E37: No write since last change")); |
Bram Moolenaar | f5be7cd | 2017-08-17 16:55:13 +0200 | [diff] [blame] | 1849 | } |
| 1850 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1851 | /* |
| 1852 | * functions for dealing with the buffer list |
| 1853 | */ |
| 1854 | |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 1855 | static int top_file_num = 1; /* highest file number */ |
| 1856 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1857 | /* |
Bram Moolenaar | 46a53df | 2018-04-24 21:58:51 +0200 | [diff] [blame] | 1858 | * Return TRUE if the current buffer is empty, unnamed, unmodified and used in |
| 1859 | * only one window. That means it can be re-used. |
| 1860 | */ |
| 1861 | int |
| 1862 | curbuf_reusable(void) |
| 1863 | { |
| 1864 | return (curbuf != NULL |
| 1865 | && curbuf->b_ffname == NULL |
| 1866 | && curbuf->b_nwindows <= 1 |
| 1867 | && (curbuf->b_ml.ml_mfp == NULL || BUFEMPTY()) |
Bram Moolenaar | d85c396 | 2019-04-07 14:19:14 +0200 | [diff] [blame] | 1868 | #if defined(FEAT_QUICKFIX) |
Bram Moolenaar | 39803d8 | 2019-04-07 12:04:51 +0200 | [diff] [blame] | 1869 | && !bt_quickfix(curbuf) |
Bram Moolenaar | d85c396 | 2019-04-07 14:19:14 +0200 | [diff] [blame] | 1870 | #endif |
Bram Moolenaar | 46a53df | 2018-04-24 21:58:51 +0200 | [diff] [blame] | 1871 | && !curbufIsChanged()); |
| 1872 | } |
| 1873 | |
| 1874 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1875 | * Add a file name to the buffer list. Return a pointer to the buffer. |
| 1876 | * If the same file name already exists return a pointer to that buffer. |
| 1877 | * If it does not exist, or if fname == NULL, a new entry is created. |
| 1878 | * If (flags & BLN_CURBUF) is TRUE, may use current buffer. |
| 1879 | * If (flags & BLN_LISTED) is TRUE, add new buffer to buffer list. |
| 1880 | * If (flags & BLN_DUMMY) is TRUE, don't count it as a real buffer. |
Bram Moolenaar | b127cfd | 2016-05-29 16:24:50 +0200 | [diff] [blame] | 1881 | * If (flags & BLN_NEW) is TRUE, don't use an existing buffer. |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 1882 | * If (flags & BLN_NOOPT) is TRUE, don't copy options from the current buffer |
| 1883 | * if the buffer already exists. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1884 | * This is the ONLY way to create a new buffer. |
| 1885 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1886 | buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 1887 | buflist_new( |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 1888 | char_u *ffname_arg, // full path of fname or relative |
| 1889 | char_u *sfname_arg, // short fname or NULL |
| 1890 | linenr_T lnum, // preferred cursor line |
| 1891 | int flags) // BLN_ defines |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1892 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 1893 | char_u *ffname = ffname_arg; |
| 1894 | char_u *sfname = sfname_arg; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1895 | buf_T *buf; |
| 1896 | #ifdef UNIX |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 1897 | stat_T st; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1898 | #endif |
| 1899 | |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 1900 | if (top_file_num == 1) |
| 1901 | hash_init(&buf_hashtab); |
| 1902 | |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 1903 | fname_expand(curbuf, &ffname, &sfname); // will allocate ffname |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1904 | |
| 1905 | /* |
| 1906 | * If file name already exists in the list, update the entry. |
| 1907 | */ |
| 1908 | #ifdef UNIX |
| 1909 | /* On Unix we can use inode numbers when the file exists. Works better |
| 1910 | * for hard links. */ |
| 1911 | if (sfname == NULL || mch_stat((char *)sfname, &st) < 0) |
| 1912 | st.st_dev = (dev_T)-1; |
| 1913 | #endif |
Bram Moolenaar | b127cfd | 2016-05-29 16:24:50 +0200 | [diff] [blame] | 1914 | if (ffname != NULL && !(flags & (BLN_DUMMY | BLN_NEW)) && (buf = |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1915 | #ifdef UNIX |
| 1916 | buflist_findname_stat(ffname, &st) |
| 1917 | #else |
| 1918 | buflist_findname(ffname) |
| 1919 | #endif |
| 1920 | ) != NULL) |
| 1921 | { |
| 1922 | vim_free(ffname); |
| 1923 | if (lnum != 0) |
| 1924 | buflist_setfpos(buf, curwin, lnum, (colnr_T)0, FALSE); |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 1925 | |
| 1926 | if ((flags & BLN_NOOPT) == 0) |
| 1927 | /* copy the options now, if 'cpo' doesn't have 's' and not done |
| 1928 | * already */ |
| 1929 | buf_copy_options(buf, 0); |
| 1930 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1931 | if ((flags & BLN_LISTED) && !buf->b_p_bl) |
| 1932 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1933 | bufref_T bufref; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1934 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1935 | buf->b_p_bl = TRUE; |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1936 | set_bufref(&bufref, buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1937 | if (!(flags & BLN_DUMMY)) |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 1938 | { |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 1939 | if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 1940 | && !bufref_valid(&bufref)) |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 1941 | return NULL; |
| 1942 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1943 | } |
| 1944 | return buf; |
| 1945 | } |
| 1946 | |
| 1947 | /* |
| 1948 | * If the current buffer has no name and no contents, use the current |
| 1949 | * buffer. Otherwise: Need to allocate a new buffer structure. |
| 1950 | * |
| 1951 | * This is the ONLY place where a new buffer structure is allocated! |
Bram Moolenaar | 4770d09 | 2006-01-12 23:22:24 +0000 | [diff] [blame] | 1952 | * (A spell file buffer is allocated in spell.c, but that's not a normal |
| 1953 | * buffer.) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1954 | */ |
| 1955 | buf = NULL; |
Bram Moolenaar | 46a53df | 2018-04-24 21:58:51 +0200 | [diff] [blame] | 1956 | if ((flags & BLN_CURBUF) && curbuf_reusable()) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1957 | { |
| 1958 | buf = curbuf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1959 | /* It's like this buffer is deleted. Watch out for autocommands that |
| 1960 | * change curbuf! If that happens, allocate a new buffer anyway. */ |
| 1961 | if (curbuf->b_p_bl) |
| 1962 | apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf); |
| 1963 | if (buf == curbuf) |
| 1964 | apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 1965 | #ifdef FEAT_EVAL |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 1966 | if (aborting()) /* autocmds may abort script processing */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1967 | return NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1968 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1969 | if (buf == curbuf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1970 | { |
| 1971 | /* Make sure 'bufhidden' and 'buftype' are empty */ |
| 1972 | clear_string_option(&buf->b_p_bh); |
| 1973 | clear_string_option(&buf->b_p_bt); |
| 1974 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1975 | } |
| 1976 | if (buf != curbuf || curbuf == NULL) |
| 1977 | { |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 1978 | buf = ALLOC_CLEAR_ONE(buf_T); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1979 | if (buf == NULL) |
| 1980 | { |
| 1981 | vim_free(ffname); |
| 1982 | return NULL; |
| 1983 | } |
Bram Moolenaar | 429fa85 | 2013-04-15 12:27:36 +0200 | [diff] [blame] | 1984 | #ifdef FEAT_EVAL |
| 1985 | /* init b: variables */ |
| 1986 | buf->b_vars = dict_alloc(); |
| 1987 | if (buf->b_vars == NULL) |
| 1988 | { |
| 1989 | vim_free(ffname); |
| 1990 | vim_free(buf); |
| 1991 | return NULL; |
| 1992 | } |
| 1993 | init_var_dict(buf->b_vars, &buf->b_bufvar, VAR_SCOPE); |
| 1994 | #endif |
Bram Moolenaar | 79518e2 | 2017-02-17 16:31:35 +0100 | [diff] [blame] | 1995 | init_changedtick(buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 1996 | } |
| 1997 | |
| 1998 | if (ffname != NULL) |
| 1999 | { |
| 2000 | buf->b_ffname = ffname; |
| 2001 | buf->b_sfname = vim_strsave(sfname); |
| 2002 | } |
| 2003 | |
| 2004 | clear_wininfo(buf); |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 2005 | buf->b_wininfo = ALLOC_CLEAR_ONE(wininfo_T); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2006 | |
| 2007 | if ((ffname != NULL && (buf->b_ffname == NULL || buf->b_sfname == NULL)) |
| 2008 | || buf->b_wininfo == NULL) |
| 2009 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 2010 | if (buf->b_sfname != buf->b_ffname) |
| 2011 | VIM_CLEAR(buf->b_sfname); |
| 2012 | else |
| 2013 | buf->b_sfname = NULL; |
Bram Moolenaar | d23a823 | 2018-02-10 18:45:26 +0100 | [diff] [blame] | 2014 | VIM_CLEAR(buf->b_ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2015 | if (buf != curbuf) |
| 2016 | free_buffer(buf); |
| 2017 | return NULL; |
| 2018 | } |
| 2019 | |
| 2020 | if (buf == curbuf) |
| 2021 | { |
| 2022 | /* free all things allocated for this buffer */ |
Bram Moolenaar | 59f931e | 2010-07-24 20:27:03 +0200 | [diff] [blame] | 2023 | buf_freeall(buf, 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2024 | if (buf != curbuf) /* autocommands deleted the buffer! */ |
| 2025 | return NULL; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 2026 | #if defined(FEAT_EVAL) |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 2027 | if (aborting()) /* autocmds may abort script processing */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2028 | return NULL; |
| 2029 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2030 | free_buffer_stuff(buf, FALSE); /* delete local variables et al. */ |
Bram Moolenaar | 0ac24e1 | 2012-11-20 12:16:58 +0100 | [diff] [blame] | 2031 | |
| 2032 | /* Init the options. */ |
| 2033 | buf->b_p_initialized = FALSE; |
| 2034 | buf_copy_options(buf, BCO_ENTER); |
| 2035 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2036 | #ifdef FEAT_KEYMAP |
| 2037 | /* need to reload lmaps and set b:keymap_name */ |
| 2038 | curbuf->b_kmap_state |= KEYMAP_INIT; |
| 2039 | #endif |
| 2040 | } |
| 2041 | else |
| 2042 | { |
| 2043 | /* |
| 2044 | * put new buffer at the end of the buffer list |
| 2045 | */ |
| 2046 | buf->b_next = NULL; |
| 2047 | if (firstbuf == NULL) /* buffer list is empty */ |
| 2048 | { |
| 2049 | buf->b_prev = NULL; |
| 2050 | firstbuf = buf; |
| 2051 | } |
| 2052 | else /* append new buffer at end of list */ |
| 2053 | { |
| 2054 | lastbuf->b_next = buf; |
| 2055 | buf->b_prev = lastbuf; |
| 2056 | } |
| 2057 | lastbuf = buf; |
| 2058 | |
| 2059 | buf->b_fnum = top_file_num++; |
| 2060 | if (top_file_num < 0) /* wrap around (may cause duplicates) */ |
| 2061 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2062 | emsg(_("W14: Warning: List of file names overflow")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2063 | if (emsg_silent == 0) |
| 2064 | { |
| 2065 | out_flush(); |
| 2066 | ui_delay(3000L, TRUE); /* make sure it is noticed */ |
| 2067 | } |
| 2068 | top_file_num = 1; |
| 2069 | } |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 2070 | buf_hashtab_add(buf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2071 | |
| 2072 | /* |
| 2073 | * Always copy the options from the current buffer. |
| 2074 | */ |
| 2075 | buf_copy_options(buf, BCO_ALWAYS); |
| 2076 | } |
| 2077 | |
| 2078 | buf->b_wininfo->wi_fpos.lnum = lnum; |
| 2079 | buf->b_wininfo->wi_win = curwin; |
| 2080 | |
Bram Moolenaar | 1fad5d4 | 2005-01-25 21:44:33 +0000 | [diff] [blame] | 2081 | #ifdef FEAT_SYN_HL |
Bram Moolenaar | 860cae1 | 2010-06-05 23:22:07 +0200 | [diff] [blame] | 2082 | hash_init(&buf->b_s.b_keywtab); |
| 2083 | hash_init(&buf->b_s.b_keywtab_ic); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2084 | #endif |
| 2085 | |
| 2086 | buf->b_fname = buf->b_sfname; |
| 2087 | #ifdef UNIX |
| 2088 | if (st.st_dev == (dev_T)-1) |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 2089 | buf->b_dev_valid = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2090 | else |
| 2091 | { |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 2092 | buf->b_dev_valid = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2093 | buf->b_dev = st.st_dev; |
| 2094 | buf->b_ino = st.st_ino; |
| 2095 | } |
| 2096 | #endif |
| 2097 | buf->b_u_synced = TRUE; |
| 2098 | buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED; |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2099 | if (flags & BLN_DUMMY) |
| 2100 | buf->b_flags |= BF_DUMMY; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2101 | buf_clear_file(buf); |
| 2102 | clrallmarks(buf); /* clear marks */ |
| 2103 | fmarks_check_names(buf); /* check file marks for this file */ |
| 2104 | buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE; /* init 'buflisted' */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2105 | if (!(flags & BLN_DUMMY)) |
| 2106 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 2107 | bufref_T bufref; |
| 2108 | |
Bram Moolenaar | 8da9bbf | 2015-02-27 19:34:56 +0100 | [diff] [blame] | 2109 | /* Tricky: these autocommands may change the buffer list. They could |
| 2110 | * also split the window with re-using the one empty buffer. This may |
| 2111 | * result in unexpectedly losing the empty buffer. */ |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 2112 | set_bufref(&bufref, buf); |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 2113 | if (apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 2114 | && !bufref_valid(&bufref)) |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 2115 | return NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2116 | if (flags & BLN_LISTED) |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 2117 | { |
Bram Moolenaar | 8240433 | 2016-07-10 17:00:38 +0200 | [diff] [blame] | 2118 | if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf) |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 2119 | && !bufref_valid(&bufref)) |
Bram Moolenaar | 4c7ab1b | 2014-04-06 20:45:43 +0200 | [diff] [blame] | 2120 | return NULL; |
| 2121 | } |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 2122 | #ifdef FEAT_EVAL |
Bram Moolenaar | 293ee4d | 2004-12-09 21:34:53 +0000 | [diff] [blame] | 2123 | if (aborting()) /* autocmds may abort script processing */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2124 | return NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2125 | #endif |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 2126 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2127 | |
| 2128 | return buf; |
| 2129 | } |
| 2130 | |
| 2131 | /* |
| 2132 | * Free the memory for the options of a buffer. |
| 2133 | * If "free_p_ff" is TRUE also free 'fileformat', 'buftype' and |
| 2134 | * 'fileencoding'. |
| 2135 | */ |
| 2136 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2137 | free_buf_options( |
| 2138 | buf_T *buf, |
| 2139 | int free_p_ff) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2140 | { |
| 2141 | if (free_p_ff) |
| 2142 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2143 | clear_string_option(&buf->b_p_fenc); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2144 | clear_string_option(&buf->b_p_ff); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2145 | clear_string_option(&buf->b_p_bh); |
| 2146 | clear_string_option(&buf->b_p_bt); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2147 | } |
| 2148 | #ifdef FEAT_FIND_ID |
| 2149 | clear_string_option(&buf->b_p_def); |
| 2150 | clear_string_option(&buf->b_p_inc); |
| 2151 | # ifdef FEAT_EVAL |
| 2152 | clear_string_option(&buf->b_p_inex); |
| 2153 | # endif |
| 2154 | #endif |
| 2155 | #if defined(FEAT_CINDENT) && defined(FEAT_EVAL) |
| 2156 | clear_string_option(&buf->b_p_inde); |
| 2157 | clear_string_option(&buf->b_p_indk); |
| 2158 | #endif |
Bram Moolenaar | 371d540 | 2006-03-20 21:47:49 +0000 | [diff] [blame] | 2159 | #if defined(FEAT_BEVAL) && defined(FEAT_EVAL) |
| 2160 | clear_string_option(&buf->b_p_bexpr); |
| 2161 | #endif |
Bram Moolenaar | 49771f4 | 2010-07-20 17:32:38 +0200 | [diff] [blame] | 2162 | #if defined(FEAT_CRYPT) |
| 2163 | clear_string_option(&buf->b_p_cm); |
| 2164 | #endif |
Bram Moolenaar | 24a2d41 | 2017-01-24 17:48:36 +0100 | [diff] [blame] | 2165 | clear_string_option(&buf->b_p_fp); |
Bram Moolenaar | 1d2ba7f | 2006-02-14 22:29:30 +0000 | [diff] [blame] | 2166 | #if defined(FEAT_EVAL) |
| 2167 | clear_string_option(&buf->b_p_fex); |
| 2168 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2169 | #ifdef FEAT_CRYPT |
| 2170 | clear_string_option(&buf->b_p_key); |
| 2171 | #endif |
| 2172 | clear_string_option(&buf->b_p_kp); |
| 2173 | clear_string_option(&buf->b_p_mps); |
| 2174 | clear_string_option(&buf->b_p_fo); |
Bram Moolenaar | 86b6835 | 2004-12-27 21:59:20 +0000 | [diff] [blame] | 2175 | clear_string_option(&buf->b_p_flp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2176 | clear_string_option(&buf->b_p_isk); |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 2177 | #ifdef FEAT_VARTABS |
| 2178 | clear_string_option(&buf->b_p_vsts); |
Bram Moolenaar | bdace83 | 2019-03-02 10:13:42 +0100 | [diff] [blame] | 2179 | vim_free(buf->b_p_vsts_nopaste); |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 2180 | buf->b_p_vsts_nopaste = NULL; |
Bram Moolenaar | bdace83 | 2019-03-02 10:13:42 +0100 | [diff] [blame] | 2181 | vim_free(buf->b_p_vsts_array); |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 2182 | buf->b_p_vsts_array = NULL; |
| 2183 | clear_string_option(&buf->b_p_vts); |
Bram Moolenaar | 55c77cf | 2019-02-16 19:05:11 +0100 | [diff] [blame] | 2184 | VIM_CLEAR(buf->b_p_vts_array); |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 2185 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2186 | #ifdef FEAT_KEYMAP |
| 2187 | clear_string_option(&buf->b_p_keymap); |
Bram Moolenaar | 5013832 | 2018-01-28 17:05:16 +0100 | [diff] [blame] | 2188 | keymap_clear(&buf->b_kmap_ga); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2189 | ga_clear(&buf->b_kmap_ga); |
| 2190 | #endif |
| 2191 | #ifdef FEAT_COMMENTS |
| 2192 | clear_string_option(&buf->b_p_com); |
| 2193 | #endif |
| 2194 | #ifdef FEAT_FOLDING |
| 2195 | clear_string_option(&buf->b_p_cms); |
| 2196 | #endif |
| 2197 | clear_string_option(&buf->b_p_nf); |
| 2198 | #ifdef FEAT_SYN_HL |
| 2199 | clear_string_option(&buf->b_p_syn); |
Bram Moolenaar | b8060fe | 2016-01-19 22:29:28 +0100 | [diff] [blame] | 2200 | clear_string_option(&buf->b_s.b_syn_isk); |
Bram Moolenaar | f71a3db | 2006-03-12 21:50:18 +0000 | [diff] [blame] | 2201 | #endif |
| 2202 | #ifdef FEAT_SPELL |
Bram Moolenaar | 860cae1 | 2010-06-05 23:22:07 +0200 | [diff] [blame] | 2203 | clear_string_option(&buf->b_s.b_p_spc); |
| 2204 | clear_string_option(&buf->b_s.b_p_spf); |
Bram Moolenaar | 473de61 | 2013-06-08 18:19:48 +0200 | [diff] [blame] | 2205 | vim_regfree(buf->b_s.b_cap_prog); |
Bram Moolenaar | 860cae1 | 2010-06-05 23:22:07 +0200 | [diff] [blame] | 2206 | buf->b_s.b_cap_prog = NULL; |
| 2207 | clear_string_option(&buf->b_s.b_p_spl); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2208 | #endif |
| 2209 | #ifdef FEAT_SEARCHPATH |
| 2210 | clear_string_option(&buf->b_p_sua); |
| 2211 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2212 | clear_string_option(&buf->b_p_ft); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2213 | #ifdef FEAT_CINDENT |
| 2214 | clear_string_option(&buf->b_p_cink); |
| 2215 | clear_string_option(&buf->b_p_cino); |
| 2216 | #endif |
| 2217 | #if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT) |
| 2218 | clear_string_option(&buf->b_p_cinw); |
| 2219 | #endif |
| 2220 | #ifdef FEAT_INS_EXPAND |
| 2221 | clear_string_option(&buf->b_p_cpt); |
| 2222 | #endif |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 2223 | #ifdef FEAT_COMPL_FUNC |
| 2224 | clear_string_option(&buf->b_p_cfu); |
Bram Moolenaar | e344bea | 2005-09-01 20:46:49 +0000 | [diff] [blame] | 2225 | clear_string_option(&buf->b_p_ofu); |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 2226 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2227 | #ifdef FEAT_QUICKFIX |
| 2228 | clear_string_option(&buf->b_p_gp); |
| 2229 | clear_string_option(&buf->b_p_mp); |
| 2230 | clear_string_option(&buf->b_p_efm); |
| 2231 | #endif |
| 2232 | clear_string_option(&buf->b_p_ep); |
| 2233 | clear_string_option(&buf->b_p_path); |
| 2234 | clear_string_option(&buf->b_p_tags); |
Bram Moolenaar | 0f6562e | 2015-11-24 18:48:14 +0100 | [diff] [blame] | 2235 | clear_string_option(&buf->b_p_tc); |
Bram Moolenaar | 45e18cb | 2019-04-28 18:05:35 +0200 | [diff] [blame] | 2236 | #ifdef FEAT_EVAL |
| 2237 | clear_string_option(&buf->b_p_tfu); |
| 2238 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2239 | #ifdef FEAT_INS_EXPAND |
| 2240 | clear_string_option(&buf->b_p_dict); |
| 2241 | clear_string_option(&buf->b_p_tsr); |
| 2242 | #endif |
Bram Moolenaar | cfbc5ee | 2004-07-02 15:38:35 +0000 | [diff] [blame] | 2243 | #ifdef FEAT_TEXTOBJ |
| 2244 | clear_string_option(&buf->b_p_qe); |
| 2245 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2246 | buf->b_p_ar = -1; |
Bram Moolenaar | f5a2fd8 | 2013-11-06 05:26:15 +0100 | [diff] [blame] | 2247 | buf->b_p_ul = NO_LOCAL_UNDOLEVEL; |
Bram Moolenaar | af6c131 | 2014-03-12 18:55:58 +0100 | [diff] [blame] | 2248 | #ifdef FEAT_LISP |
| 2249 | clear_string_option(&buf->b_p_lw); |
| 2250 | #endif |
Bram Moolenaar | b8ee25a | 2014-09-23 15:45:08 +0200 | [diff] [blame] | 2251 | clear_string_option(&buf->b_p_bkc); |
Bram Moolenaar | 2c7292d | 2017-03-05 17:43:31 +0100 | [diff] [blame] | 2252 | clear_string_option(&buf->b_p_menc); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2253 | } |
| 2254 | |
| 2255 | /* |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 2256 | * Get alternate file "n". |
| 2257 | * Set linenr to "lnum" or altfpos.lnum if "lnum" == 0. |
| 2258 | * Also set cursor column to altfpos.col if 'startofline' is not set. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2259 | * if (options & GETF_SETMARK) call setpcmark() |
| 2260 | * if (options & GETF_ALT) we are jumping to an alternate file. |
| 2261 | * if (options & GETF_SWITCH) respect 'switchbuf' settings when jumping |
| 2262 | * |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 2263 | * Return FAIL for failure, OK for success. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2264 | */ |
| 2265 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2266 | buflist_getfile( |
| 2267 | int n, |
| 2268 | linenr_T lnum, |
| 2269 | int options, |
| 2270 | int forceit) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2271 | { |
| 2272 | buf_T *buf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2273 | win_T *wp = NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2274 | pos_T *fpos; |
| 2275 | colnr_T col; |
| 2276 | |
| 2277 | buf = buflist_findnr(n); |
| 2278 | if (buf == NULL) |
| 2279 | { |
| 2280 | if ((options & GETF_ALT) && n == 0) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2281 | emsg(_(e_noalt)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2282 | else |
Bram Moolenaar | b5443cc | 2019-01-15 20:19:40 +0100 | [diff] [blame] | 2283 | semsg(_("E92: Buffer %d not found"), n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2284 | return FAIL; |
| 2285 | } |
| 2286 | |
| 2287 | /* if alternate file is the current buffer, nothing to do */ |
| 2288 | if (buf == curbuf) |
| 2289 | return OK; |
| 2290 | |
Bram Moolenaar | 2d3f489 | 2006-01-20 23:02:51 +0000 | [diff] [blame] | 2291 | if (text_locked()) |
Bram Moolenaar | 05a7bb3 | 2006-01-19 22:09:32 +0000 | [diff] [blame] | 2292 | { |
Bram Moolenaar | 2d3f489 | 2006-01-20 23:02:51 +0000 | [diff] [blame] | 2293 | text_locked_msg(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2294 | return FAIL; |
Bram Moolenaar | 05a7bb3 | 2006-01-19 22:09:32 +0000 | [diff] [blame] | 2295 | } |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 2296 | if (curbuf_locked()) |
| 2297 | return FAIL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2298 | |
| 2299 | /* altfpos may be changed by getfile(), get it now */ |
| 2300 | if (lnum == 0) |
| 2301 | { |
| 2302 | fpos = buflist_findfpos(buf); |
| 2303 | lnum = fpos->lnum; |
| 2304 | col = fpos->col; |
| 2305 | } |
| 2306 | else |
| 2307 | col = 0; |
| 2308 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2309 | if (options & GETF_SWITCH) |
| 2310 | { |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 2311 | /* If 'switchbuf' contains "useopen": jump to first window containing |
| 2312 | * "buf" if one exists */ |
| 2313 | if (swb_flags & SWB_USEOPEN) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2314 | wp = buf_jump_open_win(buf); |
Bram Moolenaar | a594d77 | 2015-06-19 14:41:49 +0200 | [diff] [blame] | 2315 | |
Bram Moolenaar | 84a05ac | 2013-05-06 04:24:17 +0200 | [diff] [blame] | 2316 | /* If 'switchbuf' contains "usetab": jump to first window in any tab |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 2317 | * page containing "buf" if one exists */ |
| 2318 | if (wp == NULL && (swb_flags & SWB_USETAB)) |
Bram Moolenaar | 779b74b | 2006-04-10 14:55:34 +0000 | [diff] [blame] | 2319 | wp = buf_jump_open_tab(buf); |
Bram Moolenaar | a594d77 | 2015-06-19 14:41:49 +0200 | [diff] [blame] | 2320 | |
| 2321 | /* If 'switchbuf' contains "split", "vsplit" or "newtab" and the |
| 2322 | * current buffer isn't empty: open new tab or window */ |
| 2323 | if (wp == NULL && (swb_flags & (SWB_VSPLIT | SWB_SPLIT | SWB_NEWTAB)) |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 2324 | && !BUFEMPTY()) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2325 | { |
Bram Moolenaar | a594d77 | 2015-06-19 14:41:49 +0200 | [diff] [blame] | 2326 | if (swb_flags & SWB_NEWTAB) |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 2327 | tabpage_new(); |
Bram Moolenaar | a594d77 | 2015-06-19 14:41:49 +0200 | [diff] [blame] | 2328 | else if (win_split(0, (swb_flags & SWB_VSPLIT) ? WSP_VERT : 0) |
| 2329 | == FAIL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2330 | return FAIL; |
Bram Moolenaar | 3368ea2 | 2010-09-21 16:56:35 +0200 | [diff] [blame] | 2331 | RESET_BINDING(curwin); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2332 | } |
| 2333 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2334 | |
| 2335 | ++RedrawingDisabled; |
Bram Moolenaar | 8ad80de | 2017-06-05 16:01:59 +0200 | [diff] [blame] | 2336 | if (GETFILE_SUCCESS(getfile(buf->b_fnum, NULL, NULL, |
| 2337 | (options & GETF_SETMARK), lnum, forceit))) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2338 | { |
| 2339 | --RedrawingDisabled; |
| 2340 | |
| 2341 | /* cursor is at to BOL and w_cursor.lnum is checked due to getfile() */ |
| 2342 | if (!p_sol && col != 0) |
| 2343 | { |
| 2344 | curwin->w_cursor.col = col; |
| 2345 | check_cursor_col(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2346 | curwin->w_cursor.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2347 | curwin->w_set_curswant = TRUE; |
| 2348 | } |
| 2349 | return OK; |
| 2350 | } |
| 2351 | --RedrawingDisabled; |
| 2352 | return FAIL; |
| 2353 | } |
| 2354 | |
| 2355 | /* |
| 2356 | * go to the last know line number for the current buffer |
| 2357 | */ |
| 2358 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2359 | buflist_getfpos(void) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2360 | { |
| 2361 | pos_T *fpos; |
| 2362 | |
| 2363 | fpos = buflist_findfpos(curbuf); |
| 2364 | |
| 2365 | curwin->w_cursor.lnum = fpos->lnum; |
| 2366 | check_cursor_lnum(); |
| 2367 | |
| 2368 | if (p_sol) |
| 2369 | curwin->w_cursor.col = 0; |
| 2370 | else |
| 2371 | { |
| 2372 | curwin->w_cursor.col = fpos->col; |
| 2373 | check_cursor_col(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2374 | curwin->w_cursor.coladd = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2375 | curwin->w_set_curswant = TRUE; |
| 2376 | } |
| 2377 | } |
| 2378 | |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2379 | #if defined(FEAT_QUICKFIX) || defined(FEAT_EVAL) || defined(PROTO) |
| 2380 | /* |
| 2381 | * Find file in buffer list by name (it has to be for the current window). |
| 2382 | * Returns NULL if not found. |
| 2383 | */ |
| 2384 | buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2385 | buflist_findname_exp(char_u *fname) |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2386 | { |
| 2387 | char_u *ffname; |
| 2388 | buf_T *buf = NULL; |
| 2389 | |
| 2390 | /* First make the name into a full path name */ |
| 2391 | ffname = FullName_save(fname, |
| 2392 | #ifdef UNIX |
| 2393 | TRUE /* force expansion, get rid of symbolic links */ |
| 2394 | #else |
| 2395 | FALSE |
| 2396 | #endif |
| 2397 | ); |
| 2398 | if (ffname != NULL) |
| 2399 | { |
| 2400 | buf = buflist_findname(ffname); |
| 2401 | vim_free(ffname); |
| 2402 | } |
| 2403 | return buf; |
| 2404 | } |
| 2405 | #endif |
| 2406 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2407 | /* |
| 2408 | * Find file in buffer list by name (it has to be for the current window). |
| 2409 | * "ffname" must have a full path. |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2410 | * Skips dummy buffers. |
| 2411 | * Returns NULL if not found. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2412 | */ |
| 2413 | buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2414 | buflist_findname(char_u *ffname) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2415 | { |
| 2416 | #ifdef UNIX |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 2417 | stat_T st; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2418 | |
| 2419 | if (mch_stat((char *)ffname, &st) < 0) |
| 2420 | st.st_dev = (dev_T)-1; |
| 2421 | return buflist_findname_stat(ffname, &st); |
| 2422 | } |
| 2423 | |
| 2424 | /* |
| 2425 | * Same as buflist_findname(), but pass the stat structure to avoid getting it |
| 2426 | * twice for the same file. |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2427 | * Returns NULL if not found. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2428 | */ |
| 2429 | static buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2430 | buflist_findname_stat( |
| 2431 | char_u *ffname, |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 2432 | stat_T *stp) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2433 | { |
| 2434 | #endif |
| 2435 | buf_T *buf; |
| 2436 | |
Bram Moolenaar | ea3f2e7 | 2016-07-10 20:27:32 +0200 | [diff] [blame] | 2437 | /* Start at the last buffer, expect to find a match sooner. */ |
| 2438 | for (buf = lastbuf; buf != NULL; buf = buf->b_prev) |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 2439 | if ((buf->b_flags & BF_DUMMY) == 0 && !otherfile_buf(buf, ffname |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2440 | #ifdef UNIX |
| 2441 | , stp |
| 2442 | #endif |
| 2443 | )) |
| 2444 | return buf; |
| 2445 | return NULL; |
| 2446 | } |
| 2447 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2448 | /* |
| 2449 | * Find file in buffer list by a regexp pattern. |
| 2450 | * Return fnum of the found buffer. |
| 2451 | * Return < 0 for error. |
| 2452 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2453 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2454 | buflist_findpat( |
| 2455 | char_u *pattern, |
| 2456 | char_u *pattern_end, /* pointer to first char after pattern */ |
| 2457 | int unlisted, /* find unlisted buffers */ |
| 2458 | int diffmode UNUSED, /* find diff-mode buffers only */ |
| 2459 | int curtab_only) /* find buffers in current tab only */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2460 | { |
| 2461 | buf_T *buf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2462 | int match = -1; |
| 2463 | int find_listed; |
| 2464 | char_u *pat; |
| 2465 | char_u *patend; |
| 2466 | int attempt; |
| 2467 | char_u *p; |
| 2468 | int toggledollar; |
| 2469 | |
| 2470 | if (pattern_end == pattern + 1 && (*pattern == '%' || *pattern == '#')) |
| 2471 | { |
| 2472 | if (*pattern == '%') |
| 2473 | match = curbuf->b_fnum; |
| 2474 | else |
| 2475 | match = curwin->w_alt_fnum; |
| 2476 | #ifdef FEAT_DIFF |
| 2477 | if (diffmode && !diff_mode_buf(buflist_findnr(match))) |
| 2478 | match = -1; |
| 2479 | #endif |
| 2480 | } |
| 2481 | |
| 2482 | /* |
| 2483 | * Try four ways of matching a listed buffer: |
| 2484 | * attempt == 0: without '^' or '$' (at any position) |
Bram Moolenaar | b6799ac | 2007-05-10 16:44:05 +0000 | [diff] [blame] | 2485 | * attempt == 1: with '^' at start (only at position 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2486 | * attempt == 2: with '$' at end (only match at end) |
| 2487 | * attempt == 3: with '^' at start and '$' at end (only full match) |
| 2488 | * Repeat this for finding an unlisted buffer if there was no matching |
| 2489 | * listed buffer. |
| 2490 | */ |
| 2491 | else |
| 2492 | { |
| 2493 | pat = file_pat_to_reg_pat(pattern, pattern_end, NULL, FALSE); |
| 2494 | if (pat == NULL) |
| 2495 | return -1; |
| 2496 | patend = pat + STRLEN(pat) - 1; |
| 2497 | toggledollar = (patend > pat && *patend == '$'); |
| 2498 | |
| 2499 | /* First try finding a listed buffer. If not found and "unlisted" |
| 2500 | * is TRUE, try finding an unlisted buffer. */ |
| 2501 | find_listed = TRUE; |
| 2502 | for (;;) |
| 2503 | { |
| 2504 | for (attempt = 0; attempt <= 3; ++attempt) |
| 2505 | { |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2506 | regmatch_T regmatch; |
| 2507 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2508 | /* may add '^' and '$' */ |
| 2509 | if (toggledollar) |
| 2510 | *patend = (attempt < 2) ? NUL : '$'; /* add/remove '$' */ |
| 2511 | p = pat; |
| 2512 | if (*p == '^' && !(attempt & 1)) /* add/remove '^' */ |
| 2513 | ++p; |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2514 | regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0); |
| 2515 | if (regmatch.regprog == NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2516 | { |
| 2517 | vim_free(pat); |
| 2518 | return -1; |
| 2519 | } |
| 2520 | |
Bram Moolenaar | ea3f2e7 | 2016-07-10 20:27:32 +0200 | [diff] [blame] | 2521 | for (buf = lastbuf; buf != NULL; buf = buf->b_prev) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2522 | if (buf->b_p_bl == find_listed |
| 2523 | #ifdef FEAT_DIFF |
| 2524 | && (!diffmode || diff_mode_buf(buf)) |
| 2525 | #endif |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2526 | && buflist_match(®match, buf, FALSE) != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2527 | { |
Bram Moolenaar | 0c279bb | 2013-03-19 14:25:54 +0100 | [diff] [blame] | 2528 | if (curtab_only) |
| 2529 | { |
| 2530 | /* Ignore the match if the buffer is not open in |
| 2531 | * the current tab. */ |
Bram Moolenaar | 0c279bb | 2013-03-19 14:25:54 +0100 | [diff] [blame] | 2532 | win_T *wp; |
| 2533 | |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 2534 | FOR_ALL_WINDOWS(wp) |
Bram Moolenaar | 0c279bb | 2013-03-19 14:25:54 +0100 | [diff] [blame] | 2535 | if (wp->w_buffer == buf) |
| 2536 | break; |
| 2537 | if (wp == NULL) |
| 2538 | continue; |
Bram Moolenaar | 0c279bb | 2013-03-19 14:25:54 +0100 | [diff] [blame] | 2539 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2540 | if (match >= 0) /* already found a match */ |
| 2541 | { |
| 2542 | match = -2; |
| 2543 | break; |
| 2544 | } |
| 2545 | match = buf->b_fnum; /* remember first match */ |
| 2546 | } |
| 2547 | |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2548 | vim_regfree(regmatch.regprog); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2549 | if (match >= 0) /* found one match */ |
| 2550 | break; |
| 2551 | } |
| 2552 | |
| 2553 | /* Only search for unlisted buffers if there was no match with |
| 2554 | * a listed buffer. */ |
| 2555 | if (!unlisted || !find_listed || match != -1) |
| 2556 | break; |
| 2557 | find_listed = FALSE; |
| 2558 | } |
| 2559 | |
| 2560 | vim_free(pat); |
| 2561 | } |
| 2562 | |
| 2563 | if (match == -2) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2564 | semsg(_("E93: More than one match for %s"), pattern); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2565 | else if (match < 0) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 2566 | semsg(_("E94: No matching buffer for %s"), pattern); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2567 | return match; |
| 2568 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2569 | |
| 2570 | #if defined(FEAT_CMDL_COMPL) || defined(PROTO) |
| 2571 | |
| 2572 | /* |
| 2573 | * Find all buffer names that match. |
| 2574 | * For command line expansion of ":buf" and ":sbuf". |
| 2575 | * Return OK if matches found, FAIL otherwise. |
| 2576 | */ |
| 2577 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2578 | ExpandBufnames( |
| 2579 | char_u *pat, |
| 2580 | int *num_file, |
| 2581 | char_u ***file, |
| 2582 | int options) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2583 | { |
| 2584 | int count = 0; |
| 2585 | buf_T *buf; |
| 2586 | int round; |
| 2587 | char_u *p; |
| 2588 | int attempt; |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2589 | char_u *patc; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2590 | |
| 2591 | *num_file = 0; /* return values in case of FAIL */ |
| 2592 | *file = NULL; |
| 2593 | |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2594 | /* Make a copy of "pat" and change "^" to "\(^\|[\/]\)". */ |
| 2595 | if (*pat == '^') |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2596 | { |
Bram Moolenaar | 964b374 | 2019-05-24 18:54:09 +0200 | [diff] [blame] | 2597 | patc = alloc(STRLEN(pat) + 11); |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2598 | if (patc == NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2599 | return FAIL; |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2600 | STRCPY(patc, "\\(^\\|[\\/]\\)"); |
| 2601 | STRCPY(patc + 11, pat + 1); |
| 2602 | } |
| 2603 | else |
| 2604 | patc = pat; |
| 2605 | |
| 2606 | /* |
| 2607 | * attempt == 0: try match with '\<', match at start of word |
Bram Moolenaar | d8a4e56 | 2005-05-18 22:06:55 +0000 | [diff] [blame] | 2608 | * attempt == 1: try match without '\<', match anywhere |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2609 | */ |
Bram Moolenaar | d8a4e56 | 2005-05-18 22:06:55 +0000 | [diff] [blame] | 2610 | for (attempt = 0; attempt <= 1; ++attempt) |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2611 | { |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2612 | regmatch_T regmatch; |
| 2613 | |
Bram Moolenaar | d8a4e56 | 2005-05-18 22:06:55 +0000 | [diff] [blame] | 2614 | if (attempt > 0 && patc == pat) |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2615 | break; /* there was no anchor, no need to try again */ |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2616 | regmatch.regprog = vim_regcomp(patc + attempt * 11, RE_MAGIC); |
| 2617 | if (regmatch.regprog == NULL) |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2618 | { |
| 2619 | if (patc != pat) |
| 2620 | vim_free(patc); |
| 2621 | return FAIL; |
| 2622 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2623 | |
| 2624 | /* |
| 2625 | * round == 1: Count the matches. |
| 2626 | * round == 2: Build the array to keep the matches. |
| 2627 | */ |
| 2628 | for (round = 1; round <= 2; ++round) |
| 2629 | { |
| 2630 | count = 0; |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 2631 | FOR_ALL_BUFFERS(buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2632 | { |
| 2633 | if (!buf->b_p_bl) /* skip unlisted buffers */ |
| 2634 | continue; |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2635 | p = buflist_match(®match, buf, p_wic); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2636 | if (p != NULL) |
| 2637 | { |
| 2638 | if (round == 1) |
| 2639 | ++count; |
| 2640 | else |
| 2641 | { |
| 2642 | if (options & WILD_HOME_REPLACE) |
| 2643 | p = home_replace_save(buf, p); |
| 2644 | else |
| 2645 | p = vim_strsave(p); |
| 2646 | (*file)[count++] = p; |
| 2647 | } |
| 2648 | } |
| 2649 | } |
| 2650 | if (count == 0) /* no match found, break here */ |
| 2651 | break; |
| 2652 | if (round == 1) |
| 2653 | { |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 2654 | *file = ALLOC_MULT(char_u *, count); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2655 | if (*file == NULL) |
| 2656 | { |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2657 | vim_regfree(regmatch.regprog); |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2658 | if (patc != pat) |
| 2659 | vim_free(patc); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2660 | return FAIL; |
| 2661 | } |
| 2662 | } |
| 2663 | } |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2664 | vim_regfree(regmatch.regprog); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2665 | if (count) /* match(es) found, break here */ |
| 2666 | break; |
| 2667 | } |
| 2668 | |
Bram Moolenaar | 05159a0 | 2005-02-26 23:04:13 +0000 | [diff] [blame] | 2669 | if (patc != pat) |
| 2670 | vim_free(patc); |
| 2671 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2672 | *num_file = count; |
| 2673 | return (count == 0 ? FAIL : OK); |
| 2674 | } |
| 2675 | |
| 2676 | #endif /* FEAT_CMDL_COMPL */ |
| 2677 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2678 | /* |
| 2679 | * Check for a match on the file name for buffer "buf" with regprog "prog". |
| 2680 | */ |
| 2681 | static char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2682 | buflist_match( |
| 2683 | regmatch_T *rmp, |
| 2684 | buf_T *buf, |
| 2685 | int ignore_case) /* when TRUE ignore case, when FALSE use 'fic' */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2686 | { |
| 2687 | char_u *match; |
| 2688 | |
| 2689 | /* First try the short file name, then the long file name. */ |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2690 | match = fname_match(rmp, buf->b_sfname, ignore_case); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2691 | if (match == NULL) |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2692 | match = fname_match(rmp, buf->b_ffname, ignore_case); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2693 | |
| 2694 | return match; |
| 2695 | } |
| 2696 | |
| 2697 | /* |
| 2698 | * Try matching the regexp in "prog" with file name "name". |
| 2699 | * Return "name" when there is a match, NULL when not. |
| 2700 | */ |
| 2701 | static char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2702 | fname_match( |
| 2703 | regmatch_T *rmp, |
| 2704 | char_u *name, |
| 2705 | int ignore_case) /* when TRUE ignore case, when FALSE use 'fic' */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2706 | { |
| 2707 | char_u *match = NULL; |
| 2708 | char_u *p; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2709 | |
| 2710 | if (name != NULL) |
| 2711 | { |
Bram Moolenaar | 4b9d637 | 2014-09-23 14:24:40 +0200 | [diff] [blame] | 2712 | /* Ignore case when 'fileignorecase' or the argument is set. */ |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2713 | rmp->rm_ic = p_fic || ignore_case; |
| 2714 | if (vim_regexec(rmp, name, (colnr_T)0)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2715 | match = name; |
| 2716 | else |
| 2717 | { |
| 2718 | /* Replace $(HOME) with '~' and try matching again. */ |
| 2719 | p = home_replace_save(NULL, name); |
Bram Moolenaar | dffa5b8 | 2014-11-19 16:38:07 +0100 | [diff] [blame] | 2720 | if (p != NULL && vim_regexec(rmp, p, (colnr_T)0)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2721 | match = name; |
| 2722 | vim_free(p); |
| 2723 | } |
| 2724 | } |
| 2725 | |
| 2726 | return match; |
| 2727 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2728 | |
| 2729 | /* |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 2730 | * Find a file in the buffer list by buffer number. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2731 | */ |
| 2732 | buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2733 | buflist_findnr(int nr) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2734 | { |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 2735 | char_u key[VIM_SIZEOF_INT * 2 + 1]; |
| 2736 | hashitem_T *hi; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2737 | |
| 2738 | if (nr == 0) |
| 2739 | nr = curwin->w_alt_fnum; |
Bram Moolenaar | 480778b | 2016-07-14 22:09:39 +0200 | [diff] [blame] | 2740 | sprintf((char *)key, "%x", nr); |
| 2741 | hi = hash_find(&buf_hashtab, key); |
| 2742 | |
| 2743 | if (!HASHITEM_EMPTY(hi)) |
| 2744 | return (buf_T *)(hi->hi_key |
| 2745 | - ((unsigned)(curbuf->b_key - (char_u *)curbuf))); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2746 | return NULL; |
| 2747 | } |
| 2748 | |
| 2749 | /* |
| 2750 | * Get name of file 'n' in the buffer list. |
| 2751 | * When the file has no name an empty string is returned. |
| 2752 | * home_replace() is used to shorten the file name (used for marks). |
| 2753 | * Returns a pointer to allocated memory, of NULL when failed. |
| 2754 | */ |
| 2755 | char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2756 | buflist_nr2name( |
| 2757 | int n, |
| 2758 | int fullname, |
| 2759 | int helptail) /* for help buffers return tail only */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2760 | { |
| 2761 | buf_T *buf; |
| 2762 | |
| 2763 | buf = buflist_findnr(n); |
| 2764 | if (buf == NULL) |
| 2765 | return NULL; |
| 2766 | return home_replace_save(helptail ? buf : NULL, |
| 2767 | fullname ? buf->b_ffname : buf->b_fname); |
| 2768 | } |
| 2769 | |
| 2770 | /* |
| 2771 | * Set the "lnum" and "col" for the buffer "buf" and the current window. |
| 2772 | * When "copy_options" is TRUE save the local window option values. |
| 2773 | * When "lnum" is 0 only do the options. |
| 2774 | */ |
Bram Moolenaar | defa067 | 2019-07-21 19:25:37 +0200 | [diff] [blame] | 2775 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2776 | buflist_setfpos( |
| 2777 | buf_T *buf, |
| 2778 | win_T *win, |
| 2779 | linenr_T lnum, |
| 2780 | colnr_T col, |
| 2781 | int copy_options) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2782 | { |
| 2783 | wininfo_T *wip; |
| 2784 | |
| 2785 | for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next) |
| 2786 | if (wip->wi_win == win) |
| 2787 | break; |
| 2788 | if (wip == NULL) |
| 2789 | { |
| 2790 | /* allocate a new entry */ |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 2791 | wip = ALLOC_CLEAR_ONE(wininfo_T); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2792 | if (wip == NULL) |
| 2793 | return; |
| 2794 | wip->wi_win = win; |
| 2795 | if (lnum == 0) /* set lnum even when it's 0 */ |
| 2796 | lnum = 1; |
| 2797 | } |
| 2798 | else |
| 2799 | { |
| 2800 | /* remove the entry from the list */ |
| 2801 | if (wip->wi_prev) |
| 2802 | wip->wi_prev->wi_next = wip->wi_next; |
| 2803 | else |
| 2804 | buf->b_wininfo = wip->wi_next; |
| 2805 | if (wip->wi_next) |
| 2806 | wip->wi_next->wi_prev = wip->wi_prev; |
| 2807 | if (copy_options && wip->wi_optset) |
| 2808 | { |
| 2809 | clear_winopt(&wip->wi_opt); |
| 2810 | #ifdef FEAT_FOLDING |
| 2811 | deleteFoldRecurse(&wip->wi_folds); |
| 2812 | #endif |
| 2813 | } |
| 2814 | } |
| 2815 | if (lnum != 0) |
| 2816 | { |
| 2817 | wip->wi_fpos.lnum = lnum; |
| 2818 | wip->wi_fpos.col = col; |
| 2819 | } |
| 2820 | if (copy_options) |
| 2821 | { |
| 2822 | /* Save the window-specific option values. */ |
| 2823 | copy_winopt(&win->w_onebuf_opt, &wip->wi_opt); |
| 2824 | #ifdef FEAT_FOLDING |
| 2825 | wip->wi_fold_manual = win->w_fold_manual; |
| 2826 | cloneFoldGrowArray(&win->w_folds, &wip->wi_folds); |
| 2827 | #endif |
| 2828 | wip->wi_optset = TRUE; |
| 2829 | } |
| 2830 | |
| 2831 | /* insert the entry in front of the list */ |
| 2832 | wip->wi_next = buf->b_wininfo; |
| 2833 | buf->b_wininfo = wip; |
| 2834 | wip->wi_prev = NULL; |
| 2835 | if (wip->wi_next) |
| 2836 | wip->wi_next->wi_prev = wip; |
| 2837 | |
| 2838 | return; |
| 2839 | } |
| 2840 | |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2841 | #ifdef FEAT_DIFF |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2842 | /* |
| 2843 | * Return TRUE when "wip" has 'diff' set and the diff is only for another tab |
| 2844 | * page. That's because a diff is local to a tab page. |
| 2845 | */ |
| 2846 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2847 | wininfo_other_tab_diff(wininfo_T *wip) |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2848 | { |
| 2849 | win_T *wp; |
| 2850 | |
| 2851 | if (wip->wi_opt.wo_diff) |
| 2852 | { |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 2853 | FOR_ALL_WINDOWS(wp) |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2854 | /* return FALSE when it's a window in the current tab page, thus |
| 2855 | * the buffer was in diff mode here */ |
| 2856 | if (wip->wi_win == wp) |
| 2857 | return FALSE; |
| 2858 | return TRUE; |
| 2859 | } |
| 2860 | return FALSE; |
| 2861 | } |
| 2862 | #endif |
| 2863 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2864 | /* |
| 2865 | * Find info for the current window in buffer "buf". |
| 2866 | * If not found, return the info for the most recently used window. |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2867 | * When "skip_diff_buffer" is TRUE avoid windows with 'diff' set that is in |
| 2868 | * another tab page. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2869 | * Returns NULL when there isn't any info. |
| 2870 | */ |
| 2871 | static wininfo_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2872 | find_wininfo( |
| 2873 | buf_T *buf, |
| 2874 | int skip_diff_buffer UNUSED) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2875 | { |
| 2876 | wininfo_T *wip; |
| 2877 | |
| 2878 | for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next) |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2879 | if (wip->wi_win == curwin |
| 2880 | #ifdef FEAT_DIFF |
| 2881 | && (!skip_diff_buffer || !wininfo_other_tab_diff(wip)) |
| 2882 | #endif |
| 2883 | ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2884 | break; |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2885 | |
| 2886 | /* If no wininfo for curwin, use the first in the list (that doesn't have |
| 2887 | * 'diff' set and is in another tab page). */ |
| 2888 | if (wip == NULL) |
| 2889 | { |
| 2890 | #ifdef FEAT_DIFF |
| 2891 | if (skip_diff_buffer) |
| 2892 | { |
| 2893 | for (wip = buf->b_wininfo; wip != NULL; wip = wip->wi_next) |
| 2894 | if (!wininfo_other_tab_diff(wip)) |
| 2895 | break; |
| 2896 | } |
| 2897 | else |
| 2898 | #endif |
| 2899 | wip = buf->b_wininfo; |
| 2900 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2901 | return wip; |
| 2902 | } |
| 2903 | |
| 2904 | /* |
| 2905 | * Reset the local window options to the values last used in this window. |
| 2906 | * If the buffer wasn't used in this window before, use the values from |
| 2907 | * the most recently used window. If the values were never set, use the |
| 2908 | * global values for the window. |
| 2909 | */ |
| 2910 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2911 | get_winopts(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2912 | { |
| 2913 | wininfo_T *wip; |
| 2914 | |
| 2915 | clear_winopt(&curwin->w_onebuf_opt); |
| 2916 | #ifdef FEAT_FOLDING |
| 2917 | clearFolding(curwin); |
| 2918 | #endif |
| 2919 | |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2920 | wip = find_wininfo(buf, TRUE); |
Bram Moolenaar | 25782a7 | 2018-05-13 18:05:33 +0200 | [diff] [blame] | 2921 | if (wip != NULL && wip->wi_win != NULL |
| 2922 | && wip->wi_win != curwin && wip->wi_win->w_buffer == buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2923 | { |
Bram Moolenaar | 25782a7 | 2018-05-13 18:05:33 +0200 | [diff] [blame] | 2924 | /* The buffer is currently displayed in the window: use the actual |
| 2925 | * option values instead of the saved (possibly outdated) values. */ |
| 2926 | win_T *wp = wip->wi_win; |
| 2927 | |
| 2928 | copy_winopt(&wp->w_onebuf_opt, &curwin->w_onebuf_opt); |
| 2929 | #ifdef FEAT_FOLDING |
| 2930 | curwin->w_fold_manual = wp->w_fold_manual; |
| 2931 | curwin->w_foldinvalid = TRUE; |
| 2932 | cloneFoldGrowArray(&wp->w_folds, &curwin->w_folds); |
| 2933 | #endif |
| 2934 | } |
| 2935 | else if (wip != NULL && wip->wi_optset) |
| 2936 | { |
| 2937 | /* the buffer was displayed in the current window earlier */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2938 | copy_winopt(&wip->wi_opt, &curwin->w_onebuf_opt); |
| 2939 | #ifdef FEAT_FOLDING |
| 2940 | curwin->w_fold_manual = wip->wi_fold_manual; |
| 2941 | curwin->w_foldinvalid = TRUE; |
| 2942 | cloneFoldGrowArray(&wip->wi_folds, &curwin->w_folds); |
| 2943 | #endif |
| 2944 | } |
| 2945 | else |
| 2946 | copy_winopt(&curwin->w_allbuf_opt, &curwin->w_onebuf_opt); |
| 2947 | |
| 2948 | #ifdef FEAT_FOLDING |
| 2949 | /* Set 'foldlevel' to 'foldlevelstart' if it's not negative. */ |
| 2950 | if (p_fdls >= 0) |
| 2951 | curwin->w_p_fdl = p_fdls; |
| 2952 | #endif |
Bram Moolenaar | 1701e40 | 2011-05-05 17:32:44 +0200 | [diff] [blame] | 2953 | #ifdef FEAT_SYN_HL |
| 2954 | check_colorcolumn(curwin); |
| 2955 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2956 | } |
| 2957 | |
| 2958 | /* |
| 2959 | * Find the position (lnum and col) for the buffer 'buf' for the current |
| 2960 | * window. |
| 2961 | * Returns a pointer to no_position if no position is found. |
| 2962 | */ |
| 2963 | pos_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2964 | buflist_findfpos(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2965 | { |
| 2966 | wininfo_T *wip; |
Bram Moolenaar | 29ddebe | 2019-01-26 17:28:26 +0100 | [diff] [blame] | 2967 | static pos_T no_position = {1, 0, 0}; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2968 | |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 2969 | wip = find_wininfo(buf, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2970 | if (wip != NULL) |
| 2971 | return &(wip->wi_fpos); |
| 2972 | else |
| 2973 | return &no_position; |
| 2974 | } |
| 2975 | |
| 2976 | /* |
| 2977 | * Find the lnum for the buffer 'buf' for the current window. |
| 2978 | */ |
| 2979 | linenr_T |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2980 | buflist_findlnum(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2981 | { |
| 2982 | return buflist_findfpos(buf)->lnum; |
| 2983 | } |
| 2984 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2985 | /* |
Bram Moolenaar | 45e5fd1 | 2017-06-04 14:58:02 +0200 | [diff] [blame] | 2986 | * List all known file names (for :files and :buffers command). |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2987 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2988 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 2989 | buflist_list(exarg_T *eap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 2990 | { |
| 2991 | buf_T *buf; |
| 2992 | int len; |
| 2993 | int i; |
Bram Moolenaar | 304b64c | 2017-08-13 20:43:48 +0200 | [diff] [blame] | 2994 | int ro_char; |
| 2995 | int changed_char; |
Bram Moolenaar | 0751f51 | 2018-03-29 16:37:16 +0200 | [diff] [blame] | 2996 | #ifdef FEAT_TERMINAL |
| 2997 | int job_running; |
| 2998 | int job_none_open; |
| 2999 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3000 | |
| 3001 | for (buf = firstbuf; buf != NULL && !got_int; buf = buf->b_next) |
| 3002 | { |
Bram Moolenaar | 0751f51 | 2018-03-29 16:37:16 +0200 | [diff] [blame] | 3003 | #ifdef FEAT_TERMINAL |
| 3004 | job_running = term_job_running(buf->b_term); |
| 3005 | job_none_open = job_running && term_none_open(buf->b_term); |
| 3006 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3007 | /* skip unlisted buffers, unless ! was used */ |
Bram Moolenaar | d51cb70 | 2015-07-21 15:03:06 +0200 | [diff] [blame] | 3008 | if ((!buf->b_p_bl && !eap->forceit && !vim_strchr(eap->arg, 'u')) |
| 3009 | || (vim_strchr(eap->arg, 'u') && buf->b_p_bl) |
| 3010 | || (vim_strchr(eap->arg, '+') |
| 3011 | && ((buf->b_flags & BF_READERR) || !bufIsChanged(buf))) |
| 3012 | || (vim_strchr(eap->arg, 'a') |
Bram Moolenaar | 0751f51 | 2018-03-29 16:37:16 +0200 | [diff] [blame] | 3013 | && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows == 0)) |
Bram Moolenaar | d51cb70 | 2015-07-21 15:03:06 +0200 | [diff] [blame] | 3014 | || (vim_strchr(eap->arg, 'h') |
Bram Moolenaar | 0751f51 | 2018-03-29 16:37:16 +0200 | [diff] [blame] | 3015 | && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows != 0)) |
| 3016 | #ifdef FEAT_TERMINAL |
| 3017 | || (vim_strchr(eap->arg, 'R') |
| 3018 | && (!job_running || (job_running && job_none_open))) |
| 3019 | || (vim_strchr(eap->arg, '?') |
| 3020 | && (!job_running || (job_running && !job_none_open))) |
| 3021 | || (vim_strchr(eap->arg, 'F') |
| 3022 | && (job_running || buf->b_term == NULL)) |
| 3023 | #endif |
Bram Moolenaar | d51cb70 | 2015-07-21 15:03:06 +0200 | [diff] [blame] | 3024 | || (vim_strchr(eap->arg, '-') && buf->b_p_ma) |
| 3025 | || (vim_strchr(eap->arg, '=') && !buf->b_p_ro) |
| 3026 | || (vim_strchr(eap->arg, 'x') && !(buf->b_flags & BF_READERR)) |
| 3027 | || (vim_strchr(eap->arg, '%') && buf != curbuf) |
| 3028 | || (vim_strchr(eap->arg, '#') |
| 3029 | && (buf == curbuf || curwin->w_alt_fnum != buf->b_fnum))) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3030 | continue; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3031 | if (buf_spname(buf) != NULL) |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 3032 | vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3033 | else |
| 3034 | home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE); |
Bram Moolenaar | 77401ad | 2016-08-24 00:12:12 +0200 | [diff] [blame] | 3035 | if (message_filtered(NameBuff)) |
| 3036 | continue; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3037 | |
Bram Moolenaar | 304b64c | 2017-08-13 20:43:48 +0200 | [diff] [blame] | 3038 | changed_char = (buf->b_flags & BF_READERR) ? 'x' |
| 3039 | : (bufIsChanged(buf) ? '+' : ' '); |
| 3040 | #ifdef FEAT_TERMINAL |
| 3041 | if (term_job_running(buf->b_term)) |
| 3042 | { |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 3043 | if (term_none_open(buf->b_term)) |
| 3044 | ro_char = '?'; |
| 3045 | else |
| 3046 | ro_char = 'R'; |
Bram Moolenaar | 304b64c | 2017-08-13 20:43:48 +0200 | [diff] [blame] | 3047 | changed_char = ' '; /* bufIsChanged() returns TRUE to avoid |
| 3048 | * closing, but it's not actually changed. */ |
| 3049 | } |
| 3050 | else if (buf->b_term != NULL) |
| 3051 | ro_char = 'F'; |
| 3052 | else |
| 3053 | #endif |
| 3054 | ro_char = !buf->b_p_ma ? '-' : (buf->b_p_ro ? '=' : ' '); |
| 3055 | |
Bram Moolenaar | 77401ad | 2016-08-24 00:12:12 +0200 | [diff] [blame] | 3056 | msg_putchar('\n'); |
Bram Moolenaar | 50cde82 | 2005-06-05 21:54:54 +0000 | [diff] [blame] | 3057 | len = vim_snprintf((char *)IObuff, IOSIZE - 20, "%3d%c%c%c%c%c \"%s\"", |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3058 | buf->b_fnum, |
| 3059 | buf->b_p_bl ? ' ' : 'u', |
| 3060 | buf == curbuf ? '%' : |
| 3061 | (curwin->w_alt_fnum == buf->b_fnum ? '#' : ' '), |
| 3062 | buf->b_ml.ml_mfp == NULL ? ' ' : |
| 3063 | (buf->b_nwindows == 0 ? 'h' : 'a'), |
Bram Moolenaar | 304b64c | 2017-08-13 20:43:48 +0200 | [diff] [blame] | 3064 | ro_char, |
| 3065 | changed_char, |
Bram Moolenaar | 51485f0 | 2005-06-04 21:55:20 +0000 | [diff] [blame] | 3066 | NameBuff); |
Bram Moolenaar | 507edf6 | 2016-01-10 20:54:17 +0100 | [diff] [blame] | 3067 | if (len > IOSIZE - 20) |
| 3068 | len = IOSIZE - 20; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3069 | |
| 3070 | /* put "line 999" in column 40 or after the file name */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3071 | i = 40 - vim_strsize(IObuff); |
| 3072 | do |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3073 | IObuff[len++] = ' '; |
Bram Moolenaar | abab0b0 | 2019-03-30 18:47:01 +0100 | [diff] [blame] | 3074 | while (--i > 0 && len < IOSIZE - 18); |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 3075 | vim_snprintf((char *)IObuff + len, (size_t)(IOSIZE - len), |
| 3076 | _("line %ld"), buf == curbuf ? curwin->w_cursor.lnum |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 3077 | : (long)buflist_findlnum(buf)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3078 | msg_outtrans(IObuff); |
| 3079 | out_flush(); /* output one line at a time */ |
| 3080 | ui_breakcheck(); |
| 3081 | } |
| 3082 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3083 | |
| 3084 | /* |
| 3085 | * Get file name and line number for file 'fnum'. |
| 3086 | * Used by DoOneCmd() for translating '%' and '#'. |
| 3087 | * Used by insert_reg() and cmdline_paste() for '#' register. |
| 3088 | * Return FAIL if not found, OK for success. |
| 3089 | */ |
| 3090 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3091 | buflist_name_nr( |
| 3092 | int fnum, |
| 3093 | char_u **fname, |
| 3094 | linenr_T *lnum) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3095 | { |
| 3096 | buf_T *buf; |
| 3097 | |
| 3098 | buf = buflist_findnr(fnum); |
| 3099 | if (buf == NULL || buf->b_fname == NULL) |
| 3100 | return FAIL; |
| 3101 | |
| 3102 | *fname = buf->b_fname; |
| 3103 | *lnum = buflist_findlnum(buf); |
| 3104 | |
| 3105 | return OK; |
| 3106 | } |
| 3107 | |
| 3108 | /* |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3109 | * Set the file name for "buf"' to "ffname_arg", short file name to |
| 3110 | * "sfname_arg". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3111 | * The file name with the full path is also remembered, for when :cd is used. |
| 3112 | * Returns FAIL for failure (file name already in use by other buffer) |
| 3113 | * OK otherwise. |
| 3114 | */ |
| 3115 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3116 | setfname( |
| 3117 | buf_T *buf, |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3118 | char_u *ffname_arg, |
| 3119 | char_u *sfname_arg, |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3120 | int message) /* give message when buffer already exists */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3121 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3122 | char_u *ffname = ffname_arg; |
| 3123 | char_u *sfname = sfname_arg; |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3124 | buf_T *obuf = NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3125 | #ifdef UNIX |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3126 | stat_T st; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3127 | #endif |
| 3128 | |
| 3129 | if (ffname == NULL || *ffname == NUL) |
| 3130 | { |
| 3131 | /* Removing the name. */ |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3132 | if (buf->b_sfname != buf->b_ffname) |
| 3133 | VIM_CLEAR(buf->b_sfname); |
| 3134 | else |
| 3135 | buf->b_sfname = NULL; |
Bram Moolenaar | d23a823 | 2018-02-10 18:45:26 +0100 | [diff] [blame] | 3136 | VIM_CLEAR(buf->b_ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3137 | #ifdef UNIX |
| 3138 | st.st_dev = (dev_T)-1; |
| 3139 | #endif |
| 3140 | } |
| 3141 | else |
| 3142 | { |
| 3143 | fname_expand(buf, &ffname, &sfname); /* will allocate ffname */ |
| 3144 | if (ffname == NULL) /* out of memory */ |
| 3145 | return FAIL; |
| 3146 | |
| 3147 | /* |
| 3148 | * if the file name is already used in another buffer: |
| 3149 | * - if the buffer is loaded, fail |
| 3150 | * - if the buffer is not loaded, delete it from the list |
| 3151 | */ |
| 3152 | #ifdef UNIX |
| 3153 | if (mch_stat((char *)ffname, &st) < 0) |
| 3154 | st.st_dev = (dev_T)-1; |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3155 | #endif |
| 3156 | if (!(buf->b_flags & BF_DUMMY)) |
| 3157 | #ifdef UNIX |
| 3158 | obuf = buflist_findname_stat(ffname, &st); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3159 | #else |
Bram Moolenaar | 8169525 | 2004-12-29 20:58:21 +0000 | [diff] [blame] | 3160 | obuf = buflist_findname(ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3161 | #endif |
| 3162 | if (obuf != NULL && obuf != buf) |
| 3163 | { |
| 3164 | if (obuf->b_ml.ml_mfp != NULL) /* it's loaded, fail */ |
| 3165 | { |
| 3166 | if (message) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3167 | emsg(_("E95: Buffer with this name already exists")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3168 | vim_free(ffname); |
| 3169 | return FAIL; |
| 3170 | } |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 3171 | /* delete from the list */ |
| 3172 | close_buffer(NULL, obuf, DOBUF_WIPE, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3173 | } |
| 3174 | sfname = vim_strsave(sfname); |
| 3175 | if (ffname == NULL || sfname == NULL) |
| 3176 | { |
| 3177 | vim_free(sfname); |
| 3178 | vim_free(ffname); |
| 3179 | return FAIL; |
| 3180 | } |
| 3181 | #ifdef USE_FNAME_CASE |
Bram Moolenaar | 00f148d | 2019-02-12 22:37:27 +0100 | [diff] [blame] | 3182 | fname_case(sfname, 0); /* set correct case for short file name */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3183 | #endif |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3184 | if (buf->b_sfname != buf->b_ffname) |
| 3185 | vim_free(buf->b_sfname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3186 | vim_free(buf->b_ffname); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3187 | buf->b_ffname = ffname; |
| 3188 | buf->b_sfname = sfname; |
| 3189 | } |
| 3190 | buf->b_fname = buf->b_sfname; |
| 3191 | #ifdef UNIX |
| 3192 | if (st.st_dev == (dev_T)-1) |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3193 | buf->b_dev_valid = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3194 | else |
| 3195 | { |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3196 | buf->b_dev_valid = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3197 | buf->b_dev = st.st_dev; |
| 3198 | buf->b_ino = st.st_ino; |
| 3199 | } |
| 3200 | #endif |
| 3201 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3202 | buf->b_shortname = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3203 | |
| 3204 | buf_name_changed(buf); |
| 3205 | return OK; |
| 3206 | } |
| 3207 | |
| 3208 | /* |
Bram Moolenaar | 86b6835 | 2004-12-27 21:59:20 +0000 | [diff] [blame] | 3209 | * Crude way of changing the name of a buffer. Use with care! |
| 3210 | * The name should be relative to the current directory. |
| 3211 | */ |
| 3212 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3213 | buf_set_name(int fnum, char_u *name) |
Bram Moolenaar | 86b6835 | 2004-12-27 21:59:20 +0000 | [diff] [blame] | 3214 | { |
| 3215 | buf_T *buf; |
| 3216 | |
| 3217 | buf = buflist_findnr(fnum); |
| 3218 | if (buf != NULL) |
| 3219 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 3220 | if (buf->b_sfname != buf->b_ffname) |
| 3221 | vim_free(buf->b_sfname); |
Bram Moolenaar | 86b6835 | 2004-12-27 21:59:20 +0000 | [diff] [blame] | 3222 | vim_free(buf->b_ffname); |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 3223 | buf->b_ffname = vim_strsave(name); |
| 3224 | buf->b_sfname = NULL; |
| 3225 | /* Allocate ffname and expand into full path. Also resolves .lnk |
| 3226 | * files on Win32. */ |
| 3227 | fname_expand(buf, &buf->b_ffname, &buf->b_sfname); |
Bram Moolenaar | 86b6835 | 2004-12-27 21:59:20 +0000 | [diff] [blame] | 3228 | buf->b_fname = buf->b_sfname; |
| 3229 | } |
| 3230 | } |
| 3231 | |
| 3232 | /* |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3233 | * Take care of what needs to be done when the name of buffer "buf" has |
| 3234 | * changed. |
| 3235 | */ |
| 3236 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3237 | buf_name_changed(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3238 | { |
| 3239 | /* |
| 3240 | * If the file name changed, also change the name of the swapfile |
| 3241 | */ |
| 3242 | if (buf->b_ml.ml_mfp != NULL) |
| 3243 | ml_setname(buf); |
| 3244 | |
| 3245 | if (curwin->w_buffer == buf) |
| 3246 | check_arg_idx(curwin); /* check file name for arg list */ |
| 3247 | #ifdef FEAT_TITLE |
| 3248 | maketitle(); /* set window title */ |
| 3249 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3250 | status_redraw_all(); /* status lines need to be redrawn */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3251 | fmarks_check_names(buf); /* check named file marks */ |
| 3252 | ml_timestamp(buf); /* reset timestamp */ |
| 3253 | } |
| 3254 | |
| 3255 | /* |
| 3256 | * set alternate file name for current window |
| 3257 | * |
| 3258 | * Used by do_one_cmd(), do_write() and do_ecmd(). |
| 3259 | * Return the buffer. |
| 3260 | */ |
| 3261 | buf_T * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3262 | setaltfname( |
| 3263 | char_u *ffname, |
| 3264 | char_u *sfname, |
| 3265 | linenr_T lnum) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3266 | { |
| 3267 | buf_T *buf; |
| 3268 | |
| 3269 | /* Create a buffer. 'buflisted' is not set if it's a new buffer */ |
| 3270 | buf = buflist_new(ffname, sfname, lnum, 0); |
Bram Moolenaar | d4755bb | 2004-09-02 19:12:26 +0000 | [diff] [blame] | 3271 | if (buf != NULL && !cmdmod.keepalt) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3272 | curwin->w_alt_fnum = buf->b_fnum; |
| 3273 | return buf; |
| 3274 | } |
| 3275 | |
| 3276 | /* |
| 3277 | * Get alternate file name for current window. |
| 3278 | * Return NULL if there isn't any, and give error message if requested. |
| 3279 | */ |
| 3280 | char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3281 | getaltfname( |
| 3282 | int errmsg) /* give error message */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3283 | { |
| 3284 | char_u *fname; |
| 3285 | linenr_T dummy; |
| 3286 | |
| 3287 | if (buflist_name_nr(0, &fname, &dummy) == FAIL) |
| 3288 | { |
| 3289 | if (errmsg) |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 3290 | emsg(_(e_noalt)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3291 | return NULL; |
| 3292 | } |
| 3293 | return fname; |
| 3294 | } |
| 3295 | |
| 3296 | /* |
| 3297 | * Add a file name to the buflist and return its number. |
| 3298 | * Uses same flags as buflist_new(), except BLN_DUMMY. |
| 3299 | * |
| 3300 | * used by qf_init(), main() and doarglist() |
| 3301 | */ |
| 3302 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3303 | buflist_add(char_u *fname, int flags) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3304 | { |
| 3305 | buf_T *buf; |
| 3306 | |
| 3307 | buf = buflist_new(fname, NULL, (linenr_T)0, flags); |
| 3308 | if (buf != NULL) |
| 3309 | return buf->b_fnum; |
| 3310 | return 0; |
| 3311 | } |
| 3312 | |
| 3313 | #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO) |
| 3314 | /* |
| 3315 | * Adjust slashes in file names. Called after 'shellslash' was set. |
| 3316 | */ |
| 3317 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3318 | buflist_slash_adjust(void) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3319 | { |
| 3320 | buf_T *bp; |
| 3321 | |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 3322 | FOR_ALL_BUFFERS(bp) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3323 | { |
| 3324 | if (bp->b_ffname != NULL) |
| 3325 | slash_adjust(bp->b_ffname); |
| 3326 | if (bp->b_sfname != NULL) |
| 3327 | slash_adjust(bp->b_sfname); |
| 3328 | } |
| 3329 | } |
| 3330 | #endif |
| 3331 | |
| 3332 | /* |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 3333 | * Set alternate cursor position for the current buffer and window "win". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3334 | * Also save the local window option values. |
| 3335 | */ |
| 3336 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3337 | buflist_altfpos(win_T *win) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3338 | { |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 3339 | buflist_setfpos(curbuf, win, win->w_cursor.lnum, win->w_cursor.col, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3340 | } |
| 3341 | |
| 3342 | /* |
| 3343 | * Return TRUE if 'ffname' is not the same file as current file. |
| 3344 | * Fname must have a full path (expanded by mch_FullName()). |
| 3345 | */ |
| 3346 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3347 | otherfile(char_u *ffname) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3348 | { |
| 3349 | return otherfile_buf(curbuf, ffname |
| 3350 | #ifdef UNIX |
| 3351 | , NULL |
| 3352 | #endif |
| 3353 | ); |
| 3354 | } |
| 3355 | |
| 3356 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3357 | otherfile_buf( |
| 3358 | buf_T *buf, |
| 3359 | char_u *ffname |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3360 | #ifdef UNIX |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3361 | , stat_T *stp |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3362 | #endif |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3363 | ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3364 | { |
| 3365 | /* no name is different */ |
| 3366 | if (ffname == NULL || *ffname == NUL || buf->b_ffname == NULL) |
| 3367 | return TRUE; |
| 3368 | if (fnamecmp(ffname, buf->b_ffname) == 0) |
| 3369 | return FALSE; |
| 3370 | #ifdef UNIX |
| 3371 | { |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3372 | stat_T st; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3373 | |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3374 | /* If no stat_T given, get it now */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3375 | if (stp == NULL) |
| 3376 | { |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3377 | if (!buf->b_dev_valid || mch_stat((char *)ffname, &st) < 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3378 | st.st_dev = (dev_T)-1; |
| 3379 | stp = &st; |
| 3380 | } |
| 3381 | /* Use dev/ino to check if the files are the same, even when the names |
| 3382 | * are different (possible with links). Still need to compare the |
| 3383 | * name above, for when the file doesn't exist yet. |
| 3384 | * Problem: The dev/ino changes when a file is deleted (and created |
| 3385 | * again) and remains the same when renamed/moved. We don't want to |
| 3386 | * mch_stat() each buffer each time, that would be too slow. Get the |
| 3387 | * dev/ino again when they appear to match, but not when they appear |
| 3388 | * to be different: Could skip a buffer when it's actually the same |
| 3389 | * file. */ |
| 3390 | if (buf_same_ino(buf, stp)) |
| 3391 | { |
| 3392 | buf_setino(buf); |
| 3393 | if (buf_same_ino(buf, stp)) |
| 3394 | return FALSE; |
| 3395 | } |
| 3396 | } |
| 3397 | #endif |
| 3398 | return TRUE; |
| 3399 | } |
| 3400 | |
| 3401 | #if defined(UNIX) || defined(PROTO) |
| 3402 | /* |
| 3403 | * Set inode and device number for a buffer. |
| 3404 | * Must always be called when b_fname is changed!. |
| 3405 | */ |
| 3406 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3407 | buf_setino(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3408 | { |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3409 | stat_T st; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3410 | |
| 3411 | if (buf->b_fname != NULL && mch_stat((char *)buf->b_fname, &st) >= 0) |
| 3412 | { |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3413 | buf->b_dev_valid = TRUE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3414 | buf->b_dev = st.st_dev; |
| 3415 | buf->b_ino = st.st_ino; |
| 3416 | } |
| 3417 | else |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3418 | buf->b_dev_valid = FALSE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3419 | } |
| 3420 | |
| 3421 | /* |
| 3422 | * Return TRUE if dev/ino in buffer "buf" matches with "stp". |
| 3423 | */ |
| 3424 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3425 | buf_same_ino( |
| 3426 | buf_T *buf, |
Bram Moolenaar | 8767f52 | 2016-07-01 17:17:39 +0200 | [diff] [blame] | 3427 | stat_T *stp) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3428 | { |
Bram Moolenaar | f1726cc | 2009-05-13 18:48:16 +0000 | [diff] [blame] | 3429 | return (buf->b_dev_valid |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3430 | && stp->st_dev == buf->b_dev |
| 3431 | && stp->st_ino == buf->b_ino); |
| 3432 | } |
| 3433 | #endif |
| 3434 | |
Bram Moolenaar | 1d2ba7f | 2006-02-14 22:29:30 +0000 | [diff] [blame] | 3435 | /* |
| 3436 | * Print info about the current buffer. |
| 3437 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3438 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3439 | fileinfo( |
| 3440 | int fullname, /* when non-zero print full path */ |
| 3441 | int shorthelp, |
| 3442 | int dont_truncate) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3443 | { |
| 3444 | char_u *name; |
| 3445 | int n; |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3446 | char *p; |
| 3447 | char *buffer; |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 3448 | size_t len; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3449 | |
Bram Moolenaar | c799fe2 | 2019-05-28 23:08:19 +0200 | [diff] [blame] | 3450 | buffer = alloc(IOSIZE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3451 | if (buffer == NULL) |
| 3452 | return; |
| 3453 | |
| 3454 | if (fullname > 1) /* 2 CTRL-G: include buffer number */ |
| 3455 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3456 | vim_snprintf(buffer, IOSIZE, "buf %d: ", curbuf->b_fnum); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3457 | p = buffer + STRLEN(buffer); |
| 3458 | } |
| 3459 | else |
| 3460 | p = buffer; |
| 3461 | |
| 3462 | *p++ = '"'; |
| 3463 | if (buf_spname(curbuf) != NULL) |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3464 | vim_strncpy((char_u *)p, buf_spname(curbuf), IOSIZE - (p - buffer) - 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3465 | else |
| 3466 | { |
| 3467 | if (!fullname && curbuf->b_fname != NULL) |
| 3468 | name = curbuf->b_fname; |
| 3469 | else |
| 3470 | name = curbuf->b_ffname; |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3471 | home_replace(shorthelp ? curbuf : NULL, name, (char_u *)p, |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3472 | (int)(IOSIZE - (p - buffer)), TRUE); |
| 3473 | } |
| 3474 | |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3475 | vim_snprintf_add(buffer, IOSIZE, "\"%s%s%s%s%s%s", |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3476 | curbufIsChanged() ? (shortmess(SHM_MOD) |
| 3477 | ? " [+]" : _(" [Modified]")) : " ", |
| 3478 | (curbuf->b_flags & BF_NOTEDITED) |
| 3479 | #ifdef FEAT_QUICKFIX |
| 3480 | && !bt_dontwrite(curbuf) |
| 3481 | #endif |
| 3482 | ? _("[Not edited]") : "", |
| 3483 | (curbuf->b_flags & BF_NEW) |
| 3484 | #ifdef FEAT_QUICKFIX |
| 3485 | && !bt_dontwrite(curbuf) |
| 3486 | #endif |
| 3487 | ? _("[New file]") : "", |
| 3488 | (curbuf->b_flags & BF_READERR) ? _("[Read errors]") : "", |
Bram Moolenaar | 2358403 | 2013-06-07 20:17:11 +0200 | [diff] [blame] | 3489 | curbuf->b_p_ro ? (shortmess(SHM_RO) ? _("[RO]") |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3490 | : _("[readonly]")) : "", |
| 3491 | (curbufIsChanged() || (curbuf->b_flags & BF_WRITE_MASK) |
| 3492 | || curbuf->b_p_ro) ? |
| 3493 | " " : ""); |
| 3494 | /* With 32 bit longs and more than 21,474,836 lines multiplying by 100 |
| 3495 | * causes an overflow, thus for large numbers divide instead. */ |
| 3496 | if (curwin->w_cursor.lnum > 1000000L) |
| 3497 | n = (int)(((long)curwin->w_cursor.lnum) / |
| 3498 | ((long)curbuf->b_ml.ml_line_count / 100L)); |
| 3499 | else |
| 3500 | n = (int)(((long)curwin->w_cursor.lnum * 100L) / |
| 3501 | (long)curbuf->b_ml.ml_line_count); |
| 3502 | if (curbuf->b_ml.ml_flags & ML_EMPTY) |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3503 | vim_snprintf_add(buffer, IOSIZE, "%s", _(no_lines_msg)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3504 | #ifdef FEAT_CMDL_INFO |
| 3505 | else if (p_ru) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3506 | /* Current line and column are already on the screen -- webb */ |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3507 | vim_snprintf_add(buffer, IOSIZE, |
Bram Moolenaar | da6e891 | 2018-08-21 15:12:14 +0200 | [diff] [blame] | 3508 | NGETTEXT("%ld line --%d%%--", "%ld lines --%d%%--", |
| 3509 | curbuf->b_ml.ml_line_count), |
| 3510 | (long)curbuf->b_ml.ml_line_count, n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3511 | #endif |
| 3512 | else |
| 3513 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3514 | vim_snprintf_add(buffer, IOSIZE, |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3515 | _("line %ld of %ld --%d%%-- col "), |
| 3516 | (long)curwin->w_cursor.lnum, |
| 3517 | (long)curbuf->b_ml.ml_line_count, |
| 3518 | n); |
| 3519 | validate_virtcol(); |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 3520 | len = STRLEN(buffer); |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3521 | col_print((char_u *)buffer + len, IOSIZE - len, |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3522 | (int)curwin->w_cursor.col + 1, (int)curwin->w_virtcol + 1); |
| 3523 | } |
| 3524 | |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3525 | (void)append_arg_number(curwin, (char_u *)buffer, IOSIZE, |
| 3526 | !shortmess(SHM_FILE)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3527 | |
| 3528 | if (dont_truncate) |
| 3529 | { |
| 3530 | /* Temporarily set msg_scroll to avoid the message being truncated. |
| 3531 | * First call msg_start() to get the message in the right place. */ |
| 3532 | msg_start(); |
| 3533 | n = msg_scroll; |
| 3534 | msg_scroll = TRUE; |
| 3535 | msg(buffer); |
| 3536 | msg_scroll = n; |
| 3537 | } |
| 3538 | else |
| 3539 | { |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3540 | p = (char *)msg_trunc_attr(buffer, FALSE, 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3541 | if (restart_edit != 0 || (msg_scrolled && !need_wait_return)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3542 | /* Need to repeat the message after redrawing when: |
| 3543 | * - When restart_edit is set (otherwise there will be a delay |
| 3544 | * before redrawing). |
| 3545 | * - When the screen was scrolled but there is no wait-return |
| 3546 | * prompt. */ |
Bram Moolenaar | 32526b3 | 2019-01-19 17:43:09 +0100 | [diff] [blame] | 3547 | set_keep_msg((char_u *)p, 0); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3548 | } |
| 3549 | |
| 3550 | vim_free(buffer); |
| 3551 | } |
| 3552 | |
| 3553 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3554 | col_print( |
| 3555 | char_u *buf, |
| 3556 | size_t buflen, |
| 3557 | int col, |
| 3558 | int vcol) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3559 | { |
| 3560 | if (col == vcol) |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 3561 | vim_snprintf((char *)buf, buflen, "%d", col); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3562 | else |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 3563 | vim_snprintf((char *)buf, buflen, "%d-%d", col, vcol); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3564 | } |
| 3565 | |
| 3566 | #if defined(FEAT_TITLE) || defined(PROTO) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3567 | static char_u *lasttitle = NULL; |
| 3568 | static char_u *lasticon = NULL; |
| 3569 | |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3570 | /* |
| 3571 | * Put the file name in the title bar and icon of the window. |
| 3572 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3573 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3574 | maketitle(void) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3575 | { |
| 3576 | char_u *p; |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3577 | char_u *title_str = NULL; |
| 3578 | char_u *icon_str = NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3579 | int maxlen = 0; |
| 3580 | int len; |
| 3581 | int mustset; |
| 3582 | char_u buf[IOSIZE]; |
| 3583 | int off; |
| 3584 | |
| 3585 | if (!redrawing()) |
| 3586 | { |
| 3587 | /* Postpone updating the title when 'lazyredraw' is set. */ |
| 3588 | need_maketitle = TRUE; |
| 3589 | return; |
| 3590 | } |
| 3591 | |
| 3592 | need_maketitle = FALSE; |
Bram Moolenaar | bed7bec | 2010-07-25 13:42:29 +0200 | [diff] [blame] | 3593 | if (!p_title && !p_icon && lasttitle == NULL && lasticon == NULL) |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3594 | return; // nothing to do |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3595 | |
| 3596 | if (p_title) |
| 3597 | { |
| 3598 | if (p_titlelen > 0) |
| 3599 | { |
| 3600 | maxlen = p_titlelen * Columns / 100; |
| 3601 | if (maxlen < 10) |
| 3602 | maxlen = 10; |
| 3603 | } |
| 3604 | |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3605 | title_str = buf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3606 | if (*p_titlestring != NUL) |
| 3607 | { |
| 3608 | #ifdef FEAT_STL_OPT |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3609 | if (stl_syntax & STL_IN_TITLE) |
| 3610 | { |
| 3611 | int use_sandbox = FALSE; |
| 3612 | int save_called_emsg = called_emsg; |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3613 | |
| 3614 | # ifdef FEAT_EVAL |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3615 | use_sandbox = was_set_insecurely((char_u *)"titlestring", 0); |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3616 | # endif |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3617 | called_emsg = FALSE; |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3618 | build_stl_str_hl(curwin, title_str, sizeof(buf), |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3619 | p_titlestring, use_sandbox, |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 3620 | 0, maxlen, NULL, NULL); |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3621 | if (called_emsg) |
| 3622 | set_string_option_direct((char_u *)"titlestring", -1, |
| 3623 | (char_u *)"", OPT_FREE, SID_ERROR); |
| 3624 | called_emsg |= save_called_emsg; |
| 3625 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3626 | else |
| 3627 | #endif |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3628 | title_str = p_titlestring; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3629 | } |
| 3630 | else |
| 3631 | { |
| 3632 | /* format: "fname + (path) (1 of 2) - VIM" */ |
| 3633 | |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3634 | #define SPACE_FOR_FNAME (IOSIZE - 100) |
| 3635 | #define SPACE_FOR_DIR (IOSIZE - 20) |
| 3636 | #define SPACE_FOR_ARGNR (IOSIZE - 10) /* at least room for " - VIM" */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3637 | if (curbuf->b_fname == NULL) |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3638 | vim_strncpy(buf, (char_u *)_("[No Name]"), SPACE_FOR_FNAME); |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 3639 | #ifdef FEAT_TERMINAL |
| 3640 | else if (curbuf->b_term != NULL) |
| 3641 | { |
| 3642 | vim_strncpy(buf, term_get_status_text(curbuf->b_term), |
| 3643 | SPACE_FOR_FNAME); |
| 3644 | } |
| 3645 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3646 | else |
| 3647 | { |
| 3648 | p = transstr(gettail(curbuf->b_fname)); |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3649 | vim_strncpy(buf, p, SPACE_FOR_FNAME); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3650 | vim_free(p); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3651 | } |
| 3652 | |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 3653 | #ifdef FEAT_TERMINAL |
| 3654 | if (curbuf->b_term == NULL) |
| 3655 | #endif |
| 3656 | switch (bufIsChanged(curbuf) |
| 3657 | + (curbuf->b_p_ro * 2) |
| 3658 | + (!curbuf->b_p_ma * 4)) |
| 3659 | { |
| 3660 | case 1: STRCAT(buf, " +"); break; |
| 3661 | case 2: STRCAT(buf, " ="); break; |
| 3662 | case 3: STRCAT(buf, " =+"); break; |
| 3663 | case 4: |
| 3664 | case 6: STRCAT(buf, " -"); break; |
| 3665 | case 5: |
| 3666 | case 7: STRCAT(buf, " -+"); break; |
| 3667 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3668 | |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 3669 | if (curbuf->b_fname != NULL |
| 3670 | #ifdef FEAT_TERMINAL |
| 3671 | && curbuf->b_term == NULL |
| 3672 | #endif |
| 3673 | ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3674 | { |
| 3675 | /* Get path of file, replace home dir with ~ */ |
| 3676 | off = (int)STRLEN(buf); |
| 3677 | buf[off++] = ' '; |
| 3678 | buf[off++] = '('; |
| 3679 | home_replace(curbuf, curbuf->b_ffname, |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3680 | buf + off, SPACE_FOR_DIR - off, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3681 | #ifdef BACKSLASH_IN_FILENAME |
| 3682 | /* avoid "c:/name" to be reduced to "c" */ |
| 3683 | if (isalpha(buf[off]) && buf[off + 1] == ':') |
| 3684 | off += 2; |
| 3685 | #endif |
| 3686 | /* remove the file name */ |
Bram Moolenaar | 1cd871b | 2004-12-19 22:46:22 +0000 | [diff] [blame] | 3687 | p = gettail_sep(buf + off); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3688 | if (p == buf + off) |
Bram Moolenaar | 1f2903c | 2017-07-23 19:51:01 +0200 | [diff] [blame] | 3689 | { |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 3690 | /* must be a help buffer */ |
| 3691 | vim_strncpy(buf + off, (char_u *)_("help"), |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3692 | (size_t)(SPACE_FOR_DIR - off - 1)); |
Bram Moolenaar | 1f2903c | 2017-07-23 19:51:01 +0200 | [diff] [blame] | 3693 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3694 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3695 | *p = NUL; |
Bram Moolenaar | 1cd871b | 2004-12-19 22:46:22 +0000 | [diff] [blame] | 3696 | |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3697 | /* Translate unprintable chars and concatenate. Keep some |
| 3698 | * room for the server name. When there is no room (very long |
| 3699 | * file name) use (...). */ |
| 3700 | if (off < SPACE_FOR_DIR) |
| 3701 | { |
| 3702 | p = transstr(buf + off); |
| 3703 | vim_strncpy(buf + off, p, (size_t)(SPACE_FOR_DIR - off)); |
| 3704 | vim_free(p); |
| 3705 | } |
| 3706 | else |
| 3707 | { |
| 3708 | vim_strncpy(buf + off, (char_u *)"...", |
| 3709 | (size_t)(SPACE_FOR_ARGNR - off)); |
| 3710 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3711 | STRCAT(buf, ")"); |
| 3712 | } |
| 3713 | |
Bram Moolenaar | 2c66669 | 2012-09-05 13:30:40 +0200 | [diff] [blame] | 3714 | append_arg_number(curwin, buf, SPACE_FOR_ARGNR, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3715 | |
| 3716 | #if defined(FEAT_CLIENTSERVER) |
| 3717 | if (serverName != NULL) |
| 3718 | { |
| 3719 | STRCAT(buf, " - "); |
Bram Moolenaar | ef9d6aa | 2011-04-11 16:56:35 +0200 | [diff] [blame] | 3720 | vim_strcat(buf, serverName, IOSIZE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3721 | } |
| 3722 | else |
| 3723 | #endif |
| 3724 | STRCAT(buf, " - VIM"); |
| 3725 | |
| 3726 | if (maxlen > 0) |
| 3727 | { |
| 3728 | /* make it shorter by removing a bit in the middle */ |
Bram Moolenaar | f31b764 | 2012-01-20 20:44:43 +0100 | [diff] [blame] | 3729 | if (vim_strsize(buf) > maxlen) |
| 3730 | trunc_string(buf, buf, maxlen, IOSIZE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3731 | } |
| 3732 | } |
| 3733 | } |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3734 | mustset = value_changed(title_str, &lasttitle); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3735 | |
| 3736 | if (p_icon) |
| 3737 | { |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3738 | icon_str = buf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3739 | if (*p_iconstring != NUL) |
| 3740 | { |
| 3741 | #ifdef FEAT_STL_OPT |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3742 | if (stl_syntax & STL_IN_ICON) |
| 3743 | { |
| 3744 | int use_sandbox = FALSE; |
| 3745 | int save_called_emsg = called_emsg; |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3746 | |
| 3747 | # ifdef FEAT_EVAL |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3748 | use_sandbox = was_set_insecurely((char_u *)"iconstring", 0); |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3749 | # endif |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3750 | called_emsg = FALSE; |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3751 | build_stl_str_hl(curwin, icon_str, sizeof(buf), |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3752 | p_iconstring, use_sandbox, |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 3753 | 0, 0, NULL, NULL); |
Bram Moolenaar | d3667a2 | 2006-03-16 21:35:52 +0000 | [diff] [blame] | 3754 | if (called_emsg) |
| 3755 | set_string_option_direct((char_u *)"iconstring", -1, |
| 3756 | (char_u *)"", OPT_FREE, SID_ERROR); |
| 3757 | called_emsg |= save_called_emsg; |
| 3758 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3759 | else |
| 3760 | #endif |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3761 | icon_str = p_iconstring; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3762 | } |
| 3763 | else |
| 3764 | { |
| 3765 | if (buf_spname(curbuf) != NULL) |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3766 | p = buf_spname(curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3767 | else /* use file name only in icon */ |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3768 | p = gettail(curbuf->b_ffname); |
| 3769 | *icon_str = NUL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3770 | /* Truncate name at 100 bytes. */ |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3771 | len = (int)STRLEN(p); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3772 | if (len > 100) |
| 3773 | { |
| 3774 | len -= 100; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3775 | if (has_mbyte) |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3776 | len += (*mb_tail_off)(p, p + len) + 1; |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3777 | p += len; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3778 | } |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3779 | STRCPY(icon_str, p); |
| 3780 | trans_characters(icon_str, IOSIZE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3781 | } |
| 3782 | } |
| 3783 | |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3784 | mustset |= value_changed(icon_str, &lasticon); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3785 | |
| 3786 | if (mustset) |
| 3787 | resettitle(); |
| 3788 | } |
| 3789 | |
| 3790 | /* |
| 3791 | * Used for title and icon: Check if "str" differs from "*last". Set "*last" |
| 3792 | * from "str" if it does. |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3793 | * Return TRUE if resettitle() is to be called. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3794 | */ |
| 3795 | static int |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3796 | value_changed(char_u *str, char_u **last) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3797 | { |
| 3798 | if ((str == NULL) != (*last == NULL) |
| 3799 | || (str != NULL && *last != NULL && STRCMP(str, *last) != 0)) |
| 3800 | { |
| 3801 | vim_free(*last); |
| 3802 | if (str == NULL) |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3803 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3804 | *last = NULL; |
Bram Moolenaar | 40385db | 2018-08-07 22:31:44 +0200 | [diff] [blame] | 3805 | mch_restore_title( |
| 3806 | last == &lasttitle ? SAVE_RESTORE_TITLE : SAVE_RESTORE_ICON); |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3807 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3808 | else |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3809 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3810 | *last = vim_strsave(str); |
Bram Moolenaar | 84a9308 | 2018-06-16 22:58:15 +0200 | [diff] [blame] | 3811 | return TRUE; |
| 3812 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3813 | } |
| 3814 | return FALSE; |
| 3815 | } |
| 3816 | |
| 3817 | /* |
| 3818 | * Put current window title back (used after calling a shell) |
| 3819 | */ |
| 3820 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3821 | resettitle(void) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3822 | { |
| 3823 | mch_settitle(lasttitle, lasticon); |
| 3824 | } |
Bram Moolenaar | ea40885 | 2005-06-25 22:49:46 +0000 | [diff] [blame] | 3825 | |
| 3826 | # if defined(EXITFREE) || defined(PROTO) |
| 3827 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3828 | free_titles(void) |
Bram Moolenaar | ea40885 | 2005-06-25 22:49:46 +0000 | [diff] [blame] | 3829 | { |
| 3830 | vim_free(lasttitle); |
| 3831 | vim_free(lasticon); |
| 3832 | } |
| 3833 | # endif |
| 3834 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3835 | #endif /* FEAT_TITLE */ |
| 3836 | |
Bram Moolenaar | ba6c052 | 2006-02-25 21:45:02 +0000 | [diff] [blame] | 3837 | #if defined(FEAT_STL_OPT) || defined(FEAT_GUI_TABLINE) || defined(PROTO) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3838 | /* |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3839 | * Build a string from the status line items in "fmt". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3840 | * Return length of string in screen cells. |
| 3841 | * |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 3842 | * Normally works for window "wp", except when working for 'tabline' then it |
| 3843 | * is "curwin". |
| 3844 | * |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3845 | * Items are drawn interspersed with the text that surrounds it |
| 3846 | * Specials: %-<wid>(xxx%) => group, %= => middle marker, %< => truncation |
| 3847 | * Item: %-<minwid>.<maxwid><itemch> All but <itemch> are optional |
| 3848 | * |
| 3849 | * If maxwidth is not zero, the string will be filled at any middle marker |
| 3850 | * or truncated if too long, fillchar is used for all whitespace. |
| 3851 | */ |
| 3852 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 3853 | build_stl_str_hl( |
| 3854 | win_T *wp, |
| 3855 | char_u *out, /* buffer to write into != NameBuff */ |
| 3856 | size_t outlen, /* length of out[] */ |
| 3857 | char_u *fmt, |
| 3858 | int use_sandbox UNUSED, /* "fmt" was set insecurely, use sandbox */ |
| 3859 | int fillchar, |
| 3860 | int maxwidth, |
| 3861 | struct stl_hlrec *hltab, /* return: HL attributes (can be NULL) */ |
| 3862 | struct stl_hlrec *tabtab) /* return: tab page nrs (can be NULL) */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3863 | { |
Bram Moolenaar | 1077230 | 2019-01-20 18:25:54 +0100 | [diff] [blame] | 3864 | linenr_T lnum; |
| 3865 | size_t len; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3866 | char_u *p; |
| 3867 | char_u *s; |
| 3868 | char_u *t; |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 3869 | int byteval; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3870 | #ifdef FEAT_EVAL |
Bram Moolenaar | ba2929b | 2017-09-08 13:59:21 +0200 | [diff] [blame] | 3871 | win_T *save_curwin; |
| 3872 | buf_T *save_curbuf; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3873 | #endif |
| 3874 | int empty_line; |
| 3875 | colnr_T virtcol; |
| 3876 | long l; |
| 3877 | long n; |
| 3878 | int prevchar_isflag; |
| 3879 | int prevchar_isitem; |
| 3880 | int itemisflag; |
| 3881 | int fillable; |
| 3882 | char_u *str; |
| 3883 | long num; |
| 3884 | int width; |
| 3885 | int itemcnt; |
| 3886 | int curitem; |
Bram Moolenaar | 6b89dbb | 2017-10-22 14:22:16 +0200 | [diff] [blame] | 3887 | int group_end_userhl; |
| 3888 | int group_start_userhl; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3889 | int groupitem[STL_MAX_ITEM]; |
| 3890 | int groupdepth; |
| 3891 | struct stl_item |
| 3892 | { |
| 3893 | char_u *start; |
| 3894 | int minwid; |
| 3895 | int maxwid; |
| 3896 | enum |
| 3897 | { |
| 3898 | Normal, |
| 3899 | Empty, |
| 3900 | Group, |
| 3901 | Middle, |
| 3902 | Highlight, |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 3903 | TabPage, |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3904 | Trunc |
| 3905 | } type; |
| 3906 | } item[STL_MAX_ITEM]; |
| 3907 | int minwid; |
| 3908 | int maxwid; |
| 3909 | int zeropad; |
| 3910 | char_u base; |
| 3911 | char_u opt; |
| 3912 | #define TMPLEN 70 |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 3913 | char_u buf_tmp[TMPLEN]; |
| 3914 | char_u win_tmp[TMPLEN]; |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 3915 | char_u *usefmt = fmt; |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 3916 | struct stl_hlrec *sp; |
Bram Moolenaar | ba2929b | 2017-09-08 13:59:21 +0200 | [diff] [blame] | 3917 | int save_must_redraw = must_redraw; |
| 3918 | int save_redr_type = curwin->w_redr_type; |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 3919 | |
| 3920 | #ifdef FEAT_EVAL |
| 3921 | /* |
| 3922 | * When the format starts with "%!" then evaluate it as an expression and |
| 3923 | * use the result as the actual format string. |
| 3924 | */ |
| 3925 | if (fmt[0] == '%' && fmt[1] == '!') |
| 3926 | { |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 3927 | typval_T tv; |
| 3928 | |
| 3929 | tv.v_type = VAR_NUMBER; |
| 3930 | tv.vval.v_number = wp->w_id; |
| 3931 | set_var((char_u *)"g:statusline_winid", &tv, FALSE); |
| 3932 | |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 3933 | usefmt = eval_to_string_safe(fmt + 2, NULL, use_sandbox); |
| 3934 | if (usefmt == NULL) |
Bram Moolenaar | 4100af7 | 2006-08-29 14:48:14 +0000 | [diff] [blame] | 3935 | usefmt = fmt; |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 3936 | |
| 3937 | do_unlet((char_u *)"g:statusline_winid", TRUE); |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 3938 | } |
| 3939 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3940 | |
| 3941 | if (fillchar == 0) |
| 3942 | fillchar = ' '; |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 3943 | /* Can't handle a multi-byte fill character yet. */ |
| 3944 | else if (mb_char2len(fillchar) > 1) |
| 3945 | fillchar = '-'; |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 3946 | |
Bram Moolenaar | 1077230 | 2019-01-20 18:25:54 +0100 | [diff] [blame] | 3947 | // The cursor in windows other than the current one isn't always |
| 3948 | // up-to-date, esp. because of autocommands and timers. |
| 3949 | lnum = wp->w_cursor.lnum; |
| 3950 | if (lnum > wp->w_buffer->b_ml.ml_line_count) |
| 3951 | { |
| 3952 | lnum = wp->w_buffer->b_ml.ml_line_count; |
| 3953 | wp->w_cursor.lnum = lnum; |
| 3954 | } |
| 3955 | |
| 3956 | // Get line & check if empty (cursorpos will show "0-1"). Note that |
| 3957 | // p will become invalid when getting another buffer line. |
| 3958 | p = ml_get_buf(wp->w_buffer, lnum, FALSE); |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 3959 | empty_line = (*p == NUL); |
| 3960 | |
Bram Moolenaar | 1077230 | 2019-01-20 18:25:54 +0100 | [diff] [blame] | 3961 | // Get the byte value now, in case we need it below. This is more efficient |
| 3962 | // than making a copy of the line. |
| 3963 | len = STRLEN(p); |
| 3964 | if (wp->w_cursor.col > (colnr_T)len) |
| 3965 | { |
| 3966 | // Line may have changed since checking the cursor column, or the lnum |
| 3967 | // was adjusted above. |
| 3968 | wp->w_cursor.col = (colnr_T)len; |
Bram Moolenaar | 1077230 | 2019-01-20 18:25:54 +0100 | [diff] [blame] | 3969 | wp->w_cursor.coladd = 0; |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 3970 | byteval = 0; |
Bram Moolenaar | 1077230 | 2019-01-20 18:25:54 +0100 | [diff] [blame] | 3971 | } |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 3972 | else |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 3973 | byteval = (*mb_ptr2char)(p + wp->w_cursor.col); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3974 | |
| 3975 | groupdepth = 0; |
| 3976 | p = out; |
| 3977 | curitem = 0; |
| 3978 | prevchar_isflag = TRUE; |
| 3979 | prevchar_isitem = FALSE; |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 3980 | for (s = usefmt; *s; ) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3981 | { |
Bram Moolenaar | b75d09d | 2011-02-15 14:24:46 +0100 | [diff] [blame] | 3982 | if (curitem == STL_MAX_ITEM) |
| 3983 | { |
| 3984 | /* There are too many items. Add the error code to the statusline |
| 3985 | * to give the user a hint about what went wrong. */ |
| 3986 | if (p + 6 < out + outlen) |
| 3987 | { |
| 3988 | mch_memmove(p, " E541", (size_t)5); |
| 3989 | p += 5; |
| 3990 | } |
| 3991 | break; |
| 3992 | } |
| 3993 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 3994 | if (*s != NUL && *s != '%') |
| 3995 | prevchar_isflag = prevchar_isitem = FALSE; |
| 3996 | |
| 3997 | /* |
| 3998 | * Handle up to the next '%' or the end. |
| 3999 | */ |
| 4000 | while (*s != NUL && *s != '%' && p + 1 < out + outlen) |
| 4001 | *p++ = *s++; |
| 4002 | if (*s == NUL || p + 1 >= out + outlen) |
| 4003 | break; |
| 4004 | |
| 4005 | /* |
| 4006 | * Handle one '%' item. |
| 4007 | */ |
| 4008 | s++; |
Bram Moolenaar | 1d87f51 | 2011-02-01 21:55:01 +0100 | [diff] [blame] | 4009 | if (*s == NUL) /* ignore trailing % */ |
| 4010 | break; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4011 | if (*s == '%') |
| 4012 | { |
| 4013 | if (p + 1 >= out + outlen) |
| 4014 | break; |
| 4015 | *p++ = *s++; |
| 4016 | prevchar_isflag = prevchar_isitem = FALSE; |
| 4017 | continue; |
| 4018 | } |
| 4019 | if (*s == STL_MIDDLEMARK) |
| 4020 | { |
| 4021 | s++; |
| 4022 | if (groupdepth > 0) |
| 4023 | continue; |
| 4024 | item[curitem].type = Middle; |
| 4025 | item[curitem++].start = p; |
| 4026 | continue; |
| 4027 | } |
| 4028 | if (*s == STL_TRUNCMARK) |
| 4029 | { |
| 4030 | s++; |
| 4031 | item[curitem].type = Trunc; |
| 4032 | item[curitem++].start = p; |
| 4033 | continue; |
| 4034 | } |
| 4035 | if (*s == ')') |
| 4036 | { |
| 4037 | s++; |
| 4038 | if (groupdepth < 1) |
| 4039 | continue; |
| 4040 | groupdepth--; |
| 4041 | |
| 4042 | t = item[groupitem[groupdepth]].start; |
| 4043 | *p = NUL; |
| 4044 | l = vim_strsize(t); |
| 4045 | if (curitem > groupitem[groupdepth] + 1 |
| 4046 | && item[groupitem[groupdepth]].minwid == 0) |
| 4047 | { |
Bram Moolenaar | 6b89dbb | 2017-10-22 14:22:16 +0200 | [diff] [blame] | 4048 | /* remove group if all items are empty and highlight group |
| 4049 | * doesn't change */ |
| 4050 | group_start_userhl = group_end_userhl = 0; |
Bram Moolenaar | 235dddf | 2017-10-26 18:21:24 +0200 | [diff] [blame] | 4051 | for (n = groupitem[groupdepth] - 1; n >= 0; n--) |
| 4052 | { |
Bram Moolenaar | 6b89dbb | 2017-10-22 14:22:16 +0200 | [diff] [blame] | 4053 | if (item[n].type == Highlight) |
Bram Moolenaar | 235dddf | 2017-10-26 18:21:24 +0200 | [diff] [blame] | 4054 | { |
| 4055 | group_start_userhl = group_end_userhl = item[n].minwid; |
| 4056 | break; |
| 4057 | } |
| 4058 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4059 | for (n = groupitem[groupdepth] + 1; n < curitem; n++) |
Bram Moolenaar | 6b89dbb | 2017-10-22 14:22:16 +0200 | [diff] [blame] | 4060 | { |
| 4061 | if (item[n].type == Normal) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4062 | break; |
Bram Moolenaar | 6b89dbb | 2017-10-22 14:22:16 +0200 | [diff] [blame] | 4063 | if (item[n].type == Highlight) |
| 4064 | group_end_userhl = item[n].minwid; |
| 4065 | } |
| 4066 | if (n == curitem && group_start_userhl == group_end_userhl) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4067 | { |
| 4068 | p = t; |
| 4069 | l = 0; |
| 4070 | } |
| 4071 | } |
| 4072 | if (l > item[groupitem[groupdepth]].maxwid) |
| 4073 | { |
| 4074 | /* truncate, remove n bytes of text at the start */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4075 | if (has_mbyte) |
| 4076 | { |
| 4077 | /* Find the first character that should be included. */ |
| 4078 | n = 0; |
| 4079 | while (l >= item[groupitem[groupdepth]].maxwid) |
| 4080 | { |
| 4081 | l -= ptr2cells(t + n); |
Bram Moolenaar | 0fa313a | 2005-08-10 21:07:57 +0000 | [diff] [blame] | 4082 | n += (*mb_ptr2len)(t + n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4083 | } |
| 4084 | } |
| 4085 | else |
Bram Moolenaar | a93fa7e | 2006-04-17 22:14:47 +0000 | [diff] [blame] | 4086 | n = (long)(p - t) - item[groupitem[groupdepth]].maxwid + 1; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4087 | |
| 4088 | *t = '<'; |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4089 | mch_memmove(t + 1, t + n, (size_t)(p - (t + n))); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4090 | p = p - n + 1; |
Bram Moolenaar | 1350597 | 2019-01-24 15:04:48 +0100 | [diff] [blame] | 4091 | |
| 4092 | // Fill up space left over by half a double-wide char. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4093 | while (++l < item[groupitem[groupdepth]].minwid) |
| 4094 | *p++ = fillchar; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4095 | |
| 4096 | /* correct the start of the items for the truncation */ |
| 4097 | for (l = groupitem[groupdepth] + 1; l < curitem; l++) |
| 4098 | { |
| 4099 | item[l].start -= n; |
| 4100 | if (item[l].start < t) |
| 4101 | item[l].start = t; |
| 4102 | } |
| 4103 | } |
| 4104 | else if (abs(item[groupitem[groupdepth]].minwid) > l) |
| 4105 | { |
| 4106 | /* fill */ |
| 4107 | n = item[groupitem[groupdepth]].minwid; |
| 4108 | if (n < 0) |
| 4109 | { |
| 4110 | /* fill by appending characters */ |
| 4111 | n = 0 - n; |
| 4112 | while (l++ < n && p + 1 < out + outlen) |
| 4113 | *p++ = fillchar; |
| 4114 | } |
| 4115 | else |
| 4116 | { |
| 4117 | /* fill by inserting characters */ |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4118 | mch_memmove(t + n - l, t, (size_t)(p - t)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4119 | l = n - l; |
| 4120 | if (p + l >= out + outlen) |
Bram Moolenaar | a93fa7e | 2006-04-17 22:14:47 +0000 | [diff] [blame] | 4121 | l = (long)((out + outlen) - p - 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4122 | p += l; |
| 4123 | for (n = groupitem[groupdepth] + 1; n < curitem; n++) |
| 4124 | item[n].start += l; |
| 4125 | for ( ; l > 0; l--) |
| 4126 | *t++ = fillchar; |
| 4127 | } |
| 4128 | } |
| 4129 | continue; |
| 4130 | } |
| 4131 | minwid = 0; |
| 4132 | maxwid = 9999; |
| 4133 | zeropad = FALSE; |
| 4134 | l = 1; |
| 4135 | if (*s == '0') |
| 4136 | { |
| 4137 | s++; |
| 4138 | zeropad = TRUE; |
| 4139 | } |
| 4140 | if (*s == '-') |
| 4141 | { |
| 4142 | s++; |
| 4143 | l = -1; |
| 4144 | } |
| 4145 | if (VIM_ISDIGIT(*s)) |
| 4146 | { |
| 4147 | minwid = (int)getdigits(&s); |
| 4148 | if (minwid < 0) /* overflow */ |
| 4149 | minwid = 0; |
| 4150 | } |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 4151 | if (*s == STL_USER_HL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4152 | { |
| 4153 | item[curitem].type = Highlight; |
| 4154 | item[curitem].start = p; |
| 4155 | item[curitem].minwid = minwid > 9 ? 1 : minwid; |
| 4156 | s++; |
| 4157 | curitem++; |
| 4158 | continue; |
| 4159 | } |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 4160 | if (*s == STL_TABPAGENR || *s == STL_TABCLOSENR) |
| 4161 | { |
| 4162 | if (*s == STL_TABCLOSENR) |
| 4163 | { |
| 4164 | if (minwid == 0) |
| 4165 | { |
| 4166 | /* %X ends the close label, go back to the previously |
| 4167 | * define tab label nr. */ |
| 4168 | for (n = curitem - 1; n >= 0; --n) |
| 4169 | if (item[n].type == TabPage && item[n].minwid >= 0) |
| 4170 | { |
| 4171 | minwid = item[n].minwid; |
| 4172 | break; |
| 4173 | } |
| 4174 | } |
| 4175 | else |
| 4176 | /* close nrs are stored as negative values */ |
| 4177 | minwid = - minwid; |
| 4178 | } |
| 4179 | item[curitem].type = TabPage; |
| 4180 | item[curitem].start = p; |
| 4181 | item[curitem].minwid = minwid; |
| 4182 | s++; |
| 4183 | curitem++; |
| 4184 | continue; |
| 4185 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4186 | if (*s == '.') |
| 4187 | { |
| 4188 | s++; |
| 4189 | if (VIM_ISDIGIT(*s)) |
| 4190 | { |
| 4191 | maxwid = (int)getdigits(&s); |
| 4192 | if (maxwid <= 0) /* overflow */ |
| 4193 | maxwid = 50; |
| 4194 | } |
| 4195 | } |
| 4196 | minwid = (minwid > 50 ? 50 : minwid) * l; |
| 4197 | if (*s == '(') |
| 4198 | { |
| 4199 | groupitem[groupdepth++] = curitem; |
| 4200 | item[curitem].type = Group; |
| 4201 | item[curitem].start = p; |
| 4202 | item[curitem].minwid = minwid; |
| 4203 | item[curitem].maxwid = maxwid; |
| 4204 | s++; |
| 4205 | curitem++; |
| 4206 | continue; |
| 4207 | } |
| 4208 | if (vim_strchr(STL_ALL, *s) == NULL) |
| 4209 | { |
| 4210 | s++; |
| 4211 | continue; |
| 4212 | } |
| 4213 | opt = *s++; |
| 4214 | |
| 4215 | /* OK - now for the real work */ |
| 4216 | base = 'D'; |
| 4217 | itemisflag = FALSE; |
| 4218 | fillable = TRUE; |
| 4219 | num = -1; |
| 4220 | str = NULL; |
| 4221 | switch (opt) |
| 4222 | { |
| 4223 | case STL_FILEPATH: |
| 4224 | case STL_FULLPATH: |
| 4225 | case STL_FILENAME: |
| 4226 | fillable = FALSE; /* don't change ' ' to fillchar */ |
| 4227 | if (buf_spname(wp->w_buffer) != NULL) |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 4228 | vim_strncpy(NameBuff, buf_spname(wp->w_buffer), MAXPATHL - 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4229 | else |
| 4230 | { |
| 4231 | t = (opt == STL_FULLPATH) ? wp->w_buffer->b_ffname |
Bram Moolenaar | 1d2ba7f | 2006-02-14 22:29:30 +0000 | [diff] [blame] | 4232 | : wp->w_buffer->b_fname; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4233 | home_replace(wp->w_buffer, t, NameBuff, MAXPATHL, TRUE); |
| 4234 | } |
| 4235 | trans_characters(NameBuff, MAXPATHL); |
| 4236 | if (opt != STL_FILENAME) |
| 4237 | str = NameBuff; |
| 4238 | else |
| 4239 | str = gettail(NameBuff); |
| 4240 | break; |
| 4241 | |
| 4242 | case STL_VIM_EXPR: /* '{' */ |
| 4243 | itemisflag = TRUE; |
| 4244 | t = p; |
| 4245 | while (*s != '}' && *s != NUL && p + 1 < out + outlen) |
| 4246 | *p++ = *s++; |
| 4247 | if (*s != '}') /* missing '}' or out of space */ |
| 4248 | break; |
| 4249 | s++; |
| 4250 | *p = 0; |
| 4251 | p = t; |
| 4252 | |
| 4253 | #ifdef FEAT_EVAL |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4254 | vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), |
| 4255 | "%d", curbuf->b_fnum); |
| 4256 | set_internal_string_var((char_u *)"g:actual_curbuf", buf_tmp); |
| 4257 | vim_snprintf((char *)win_tmp, sizeof(win_tmp), "%d", curwin->w_id); |
| 4258 | set_internal_string_var((char_u *)"g:actual_curwin", win_tmp); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4259 | |
Bram Moolenaar | ba2929b | 2017-09-08 13:59:21 +0200 | [diff] [blame] | 4260 | save_curbuf = curbuf; |
| 4261 | save_curwin = curwin; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4262 | curwin = wp; |
| 4263 | curbuf = wp->w_buffer; |
| 4264 | |
Bram Moolenaar | 2a0449d | 2006-02-20 21:27:21 +0000 | [diff] [blame] | 4265 | str = eval_to_string_safe(p, &t, use_sandbox); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4266 | |
Bram Moolenaar | ba2929b | 2017-09-08 13:59:21 +0200 | [diff] [blame] | 4267 | curwin = save_curwin; |
| 4268 | curbuf = save_curbuf; |
Bram Moolenaar | 0182465 | 2005-01-31 18:58:23 +0000 | [diff] [blame] | 4269 | do_unlet((char_u *)"g:actual_curbuf", TRUE); |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4270 | do_unlet((char_u *)"g:actual_curwin", TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4271 | |
| 4272 | if (str != NULL && *str != 0) |
| 4273 | { |
| 4274 | if (*skipdigits(str) == NUL) |
| 4275 | { |
| 4276 | num = atoi((char *)str); |
Bram Moolenaar | d23a823 | 2018-02-10 18:45:26 +0100 | [diff] [blame] | 4277 | VIM_CLEAR(str); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4278 | itemisflag = FALSE; |
| 4279 | } |
| 4280 | } |
| 4281 | #endif |
| 4282 | break; |
| 4283 | |
| 4284 | case STL_LINE: |
| 4285 | num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) |
| 4286 | ? 0L : (long)(wp->w_cursor.lnum); |
| 4287 | break; |
| 4288 | |
| 4289 | case STL_NUMLINES: |
| 4290 | num = wp->w_buffer->b_ml.ml_line_count; |
| 4291 | break; |
| 4292 | |
| 4293 | case STL_COLUMN: |
| 4294 | num = !(State & INSERT) && empty_line |
| 4295 | ? 0 : (int)wp->w_cursor.col + 1; |
| 4296 | break; |
| 4297 | |
| 4298 | case STL_VIRTCOL: |
| 4299 | case STL_VIRTCOL_ALT: |
| 4300 | /* In list mode virtcol needs to be recomputed */ |
| 4301 | virtcol = wp->w_virtcol; |
| 4302 | if (wp->w_p_list && lcs_tab1 == NUL) |
| 4303 | { |
| 4304 | wp->w_p_list = FALSE; |
| 4305 | getvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL); |
| 4306 | wp->w_p_list = TRUE; |
| 4307 | } |
| 4308 | ++virtcol; |
| 4309 | /* Don't display %V if it's the same as %c. */ |
| 4310 | if (opt == STL_VIRTCOL_ALT |
| 4311 | && (virtcol == (colnr_T)(!(State & INSERT) && empty_line |
| 4312 | ? 0 : (int)wp->w_cursor.col + 1))) |
| 4313 | break; |
| 4314 | num = (long)virtcol; |
| 4315 | break; |
| 4316 | |
| 4317 | case STL_PERCENTAGE: |
| 4318 | num = (int)(((long)wp->w_cursor.lnum * 100L) / |
| 4319 | (long)wp->w_buffer->b_ml.ml_line_count); |
| 4320 | break; |
| 4321 | |
| 4322 | case STL_ALTPERCENT: |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4323 | str = buf_tmp; |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4324 | get_rel_pos(wp, str, TMPLEN); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4325 | break; |
| 4326 | |
| 4327 | case STL_ARGLISTSTAT: |
| 4328 | fillable = FALSE; |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4329 | buf_tmp[0] = 0; |
| 4330 | if (append_arg_number(wp, buf_tmp, (int)sizeof(buf_tmp), FALSE)) |
| 4331 | str = buf_tmp; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4332 | break; |
| 4333 | |
| 4334 | case STL_KEYMAP: |
| 4335 | fillable = FALSE; |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4336 | if (get_keymap_str(wp, (char_u *)"<%s>", buf_tmp, TMPLEN)) |
| 4337 | str = buf_tmp; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4338 | break; |
| 4339 | case STL_PAGENUM: |
Bram Moolenaar | bfb2d40 | 2006-03-03 22:50:42 +0000 | [diff] [blame] | 4340 | #if defined(FEAT_PRINTER) || defined(FEAT_GUI_TABLINE) |
Bram Moolenaar | ba6c052 | 2006-02-25 21:45:02 +0000 | [diff] [blame] | 4341 | num = printer_page_num; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4342 | #else |
| 4343 | num = 0; |
| 4344 | #endif |
| 4345 | break; |
| 4346 | |
| 4347 | case STL_BUFNO: |
| 4348 | num = wp->w_buffer->b_fnum; |
| 4349 | break; |
| 4350 | |
| 4351 | case STL_OFFSET_X: |
| 4352 | base = 'X'; |
Bram Moolenaar | 2f40d12 | 2017-10-24 21:49:36 +0200 | [diff] [blame] | 4353 | /* FALLTHROUGH */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4354 | case STL_OFFSET: |
| 4355 | #ifdef FEAT_BYTEOFF |
| 4356 | l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL); |
| 4357 | num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ? |
| 4358 | 0L : l + 1 + (!(State & INSERT) && empty_line ? |
| 4359 | 0 : (int)wp->w_cursor.col); |
| 4360 | #endif |
| 4361 | break; |
| 4362 | |
| 4363 | case STL_BYTEVAL_X: |
| 4364 | base = 'X'; |
Bram Moolenaar | 2f40d12 | 2017-10-24 21:49:36 +0200 | [diff] [blame] | 4365 | /* FALLTHROUGH */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4366 | case STL_BYTEVAL: |
Bram Moolenaar | 567199b | 2013-04-24 16:52:36 +0200 | [diff] [blame] | 4367 | num = byteval; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4368 | if (num == NL) |
| 4369 | num = 0; |
| 4370 | else if (num == CAR && get_fileformat(wp->w_buffer) == EOL_MAC) |
| 4371 | num = NL; |
| 4372 | break; |
| 4373 | |
| 4374 | case STL_ROFLAG: |
| 4375 | case STL_ROFLAG_ALT: |
| 4376 | itemisflag = TRUE; |
| 4377 | if (wp->w_buffer->b_p_ro) |
Bram Moolenaar | 2358403 | 2013-06-07 20:17:11 +0200 | [diff] [blame] | 4378 | str = (char_u *)((opt == STL_ROFLAG_ALT) ? ",RO" : _("[RO]")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4379 | break; |
| 4380 | |
| 4381 | case STL_HELPFLAG: |
| 4382 | case STL_HELPFLAG_ALT: |
| 4383 | itemisflag = TRUE; |
| 4384 | if (wp->w_buffer->b_help) |
| 4385 | str = (char_u *)((opt == STL_HELPFLAG_ALT) ? ",HLP" |
Bram Moolenaar | 899dddf | 2006-03-26 21:06:50 +0000 | [diff] [blame] | 4386 | : _("[Help]")); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4387 | break; |
| 4388 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4389 | case STL_FILETYPE: |
| 4390 | if (*wp->w_buffer->b_p_ft != NUL |
| 4391 | && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 3) |
| 4392 | { |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4393 | vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), "[%s]", |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 4394 | wp->w_buffer->b_p_ft); |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4395 | str = buf_tmp; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4396 | } |
| 4397 | break; |
| 4398 | |
| 4399 | case STL_FILETYPE_ALT: |
| 4400 | itemisflag = TRUE; |
| 4401 | if (*wp->w_buffer->b_p_ft != NUL |
| 4402 | && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 2) |
| 4403 | { |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4404 | vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), ",%s", |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 4405 | wp->w_buffer->b_p_ft); |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4406 | for (t = buf_tmp; *t != 0; t++) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4407 | *t = TOUPPER_LOC(*t); |
Bram Moolenaar | 1c6fd1e | 2019-05-23 22:11:59 +0200 | [diff] [blame] | 4408 | str = buf_tmp; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4409 | } |
| 4410 | break; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4411 | |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 4412 | #if defined(FEAT_QUICKFIX) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4413 | case STL_PREVIEWFLAG: |
| 4414 | case STL_PREVIEWFLAG_ALT: |
| 4415 | itemisflag = TRUE; |
| 4416 | if (wp->w_p_pvw) |
| 4417 | str = (char_u *)((opt == STL_PREVIEWFLAG_ALT) ? ",PRV" |
| 4418 | : _("[Preview]")); |
| 4419 | break; |
Bram Moolenaar | 7fd7320 | 2010-07-25 16:58:46 +0200 | [diff] [blame] | 4420 | |
| 4421 | case STL_QUICKFIX: |
| 4422 | if (bt_quickfix(wp->w_buffer)) |
| 4423 | str = (char_u *)(wp->w_llist_ref |
| 4424 | ? _(msg_loclist) |
| 4425 | : _(msg_qflist)); |
| 4426 | break; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4427 | #endif |
| 4428 | |
| 4429 | case STL_MODIFIED: |
| 4430 | case STL_MODIFIED_ALT: |
| 4431 | itemisflag = TRUE; |
| 4432 | switch ((opt == STL_MODIFIED_ALT) |
| 4433 | + bufIsChanged(wp->w_buffer) * 2 |
| 4434 | + (!wp->w_buffer->b_p_ma) * 4) |
| 4435 | { |
| 4436 | case 2: str = (char_u *)"[+]"; break; |
| 4437 | case 3: str = (char_u *)",+"; break; |
| 4438 | case 4: str = (char_u *)"[-]"; break; |
| 4439 | case 5: str = (char_u *)",-"; break; |
| 4440 | case 6: str = (char_u *)"[+-]"; break; |
| 4441 | case 7: str = (char_u *)",+-"; break; |
| 4442 | } |
| 4443 | break; |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 4444 | |
| 4445 | case STL_HIGHLIGHT: |
| 4446 | t = s; |
| 4447 | while (*s != '#' && *s != NUL) |
| 4448 | ++s; |
| 4449 | if (*s == '#') |
| 4450 | { |
| 4451 | item[curitem].type = Highlight; |
| 4452 | item[curitem].start = p; |
Bram Moolenaar | a93fa7e | 2006-04-17 22:14:47 +0000 | [diff] [blame] | 4453 | item[curitem].minwid = -syn_namen2id(t, (int)(s - t)); |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 4454 | curitem++; |
| 4455 | } |
Bram Moolenaar | 1180822 | 2013-11-02 04:39:38 +0100 | [diff] [blame] | 4456 | if (*s != NUL) |
| 4457 | ++s; |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 4458 | continue; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4459 | } |
| 4460 | |
| 4461 | item[curitem].start = p; |
| 4462 | item[curitem].type = Normal; |
| 4463 | if (str != NULL && *str) |
| 4464 | { |
| 4465 | t = str; |
| 4466 | if (itemisflag) |
| 4467 | { |
| 4468 | if ((t[0] && t[1]) |
| 4469 | && ((!prevchar_isitem && *t == ',') |
| 4470 | || (prevchar_isflag && *t == ' '))) |
| 4471 | t++; |
| 4472 | prevchar_isflag = TRUE; |
| 4473 | } |
| 4474 | l = vim_strsize(t); |
| 4475 | if (l > 0) |
| 4476 | prevchar_isitem = TRUE; |
| 4477 | if (l > maxwid) |
| 4478 | { |
| 4479 | while (l >= maxwid) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4480 | if (has_mbyte) |
| 4481 | { |
| 4482 | l -= ptr2cells(t); |
Bram Moolenaar | 0fa313a | 2005-08-10 21:07:57 +0000 | [diff] [blame] | 4483 | t += (*mb_ptr2len)(t); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4484 | } |
| 4485 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4486 | l -= byte2cells(*t++); |
| 4487 | if (p + 1 >= out + outlen) |
| 4488 | break; |
| 4489 | *p++ = '<'; |
| 4490 | } |
| 4491 | if (minwid > 0) |
| 4492 | { |
| 4493 | for (; l < minwid && p + 1 < out + outlen; l++) |
| 4494 | { |
| 4495 | /* Don't put a "-" in front of a digit. */ |
| 4496 | if (l + 1 == minwid && fillchar == '-' && VIM_ISDIGIT(*t)) |
| 4497 | *p++ = ' '; |
| 4498 | else |
| 4499 | *p++ = fillchar; |
| 4500 | } |
| 4501 | minwid = 0; |
| 4502 | } |
| 4503 | else |
| 4504 | minwid *= -1; |
| 4505 | while (*t && p + 1 < out + outlen) |
| 4506 | { |
| 4507 | *p++ = *t++; |
| 4508 | /* Change a space by fillchar, unless fillchar is '-' and a |
| 4509 | * digit follows. */ |
| 4510 | if (fillable && p[-1] == ' ' |
| 4511 | && (!VIM_ISDIGIT(*t) || fillchar != '-')) |
| 4512 | p[-1] = fillchar; |
| 4513 | } |
| 4514 | for (; l < minwid && p + 1 < out + outlen; l++) |
| 4515 | *p++ = fillchar; |
| 4516 | } |
| 4517 | else if (num >= 0) |
| 4518 | { |
| 4519 | int nbase = (base == 'D' ? 10 : (base == 'O' ? 8 : 16)); |
| 4520 | char_u nstr[20]; |
| 4521 | |
| 4522 | if (p + 20 >= out + outlen) |
| 4523 | break; /* not sufficient space */ |
| 4524 | prevchar_isitem = TRUE; |
| 4525 | t = nstr; |
| 4526 | if (opt == STL_VIRTCOL_ALT) |
| 4527 | { |
| 4528 | *t++ = '-'; |
| 4529 | minwid--; |
| 4530 | } |
| 4531 | *t++ = '%'; |
| 4532 | if (zeropad) |
| 4533 | *t++ = '0'; |
| 4534 | *t++ = '*'; |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4535 | *t++ = nbase == 16 ? base : (char_u)(nbase == 8 ? 'o' : 'd'); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4536 | *t = 0; |
| 4537 | |
| 4538 | for (n = num, l = 1; n >= nbase; n /= nbase) |
| 4539 | l++; |
| 4540 | if (opt == STL_VIRTCOL_ALT) |
| 4541 | l++; |
| 4542 | if (l > maxwid) |
| 4543 | { |
| 4544 | l += 2; |
| 4545 | n = l - maxwid; |
| 4546 | while (l-- > maxwid) |
| 4547 | num /= nbase; |
| 4548 | *t++ = '>'; |
| 4549 | *t++ = '%'; |
| 4550 | *t = t[-3]; |
| 4551 | *++t = 0; |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 4552 | vim_snprintf((char *)p, outlen - (p - out), (char *)nstr, |
| 4553 | 0, num, n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4554 | } |
| 4555 | else |
Bram Moolenaar | 9c13b35 | 2005-05-19 20:53:52 +0000 | [diff] [blame] | 4556 | vim_snprintf((char *)p, outlen - (p - out), (char *)nstr, |
| 4557 | minwid, num); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4558 | p += STRLEN(p); |
| 4559 | } |
| 4560 | else |
| 4561 | item[curitem].type = Empty; |
| 4562 | |
| 4563 | if (opt == STL_VIM_EXPR) |
| 4564 | vim_free(str); |
| 4565 | |
| 4566 | if (num >= 0 || (!itemisflag && str && *str)) |
| 4567 | prevchar_isflag = FALSE; /* Item not NULL, but not a flag */ |
| 4568 | curitem++; |
| 4569 | } |
| 4570 | *p = NUL; |
| 4571 | itemcnt = curitem; |
| 4572 | |
Bram Moolenaar | 030f0df | 2006-02-21 22:02:53 +0000 | [diff] [blame] | 4573 | #ifdef FEAT_EVAL |
| 4574 | if (usefmt != fmt) |
| 4575 | vim_free(usefmt); |
| 4576 | #endif |
| 4577 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4578 | width = vim_strsize(out); |
| 4579 | if (maxwidth > 0 && width > maxwidth) |
| 4580 | { |
Bram Moolenaar | 9381ab7 | 2008-11-12 11:52:19 +0000 | [diff] [blame] | 4581 | /* Result is too long, must truncate somewhere. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4582 | l = 0; |
| 4583 | if (itemcnt == 0) |
| 4584 | s = out; |
| 4585 | else |
| 4586 | { |
| 4587 | for ( ; l < itemcnt; l++) |
| 4588 | if (item[l].type == Trunc) |
| 4589 | { |
| 4590 | /* Truncate at %< item. */ |
| 4591 | s = item[l].start; |
| 4592 | break; |
| 4593 | } |
| 4594 | if (l == itemcnt) |
| 4595 | { |
| 4596 | /* No %< item, truncate first item. */ |
| 4597 | s = item[0].start; |
| 4598 | l = 0; |
| 4599 | } |
| 4600 | } |
| 4601 | |
| 4602 | if (width - vim_strsize(s) >= maxwidth) |
| 4603 | { |
| 4604 | /* Truncation mark is beyond max length */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4605 | if (has_mbyte) |
| 4606 | { |
| 4607 | s = out; |
| 4608 | width = 0; |
| 4609 | for (;;) |
| 4610 | { |
| 4611 | width += ptr2cells(s); |
| 4612 | if (width >= maxwidth) |
| 4613 | break; |
Bram Moolenaar | 0fa313a | 2005-08-10 21:07:57 +0000 | [diff] [blame] | 4614 | s += (*mb_ptr2len)(s); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4615 | } |
| 4616 | /* Fill up for half a double-wide character. */ |
| 4617 | while (++width < maxwidth) |
| 4618 | *s++ = fillchar; |
| 4619 | } |
| 4620 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4621 | s = out + maxwidth - 1; |
| 4622 | for (l = 0; l < itemcnt; l++) |
| 4623 | if (item[l].start > s) |
| 4624 | break; |
| 4625 | itemcnt = l; |
| 4626 | *s++ = '>'; |
| 4627 | *s = 0; |
| 4628 | } |
| 4629 | else |
| 4630 | { |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4631 | if (has_mbyte) |
| 4632 | { |
| 4633 | n = 0; |
| 4634 | while (width >= maxwidth) |
| 4635 | { |
| 4636 | width -= ptr2cells(s + n); |
Bram Moolenaar | 0fa313a | 2005-08-10 21:07:57 +0000 | [diff] [blame] | 4637 | n += (*mb_ptr2len)(s + n); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4638 | } |
| 4639 | } |
| 4640 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4641 | n = width - maxwidth + 1; |
| 4642 | p = s + n; |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 4643 | STRMOVE(s + 1, p); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4644 | *s = '<'; |
| 4645 | |
| 4646 | /* Fill up for half a double-wide character. */ |
| 4647 | while (++width < maxwidth) |
| 4648 | { |
| 4649 | s = s + STRLEN(s); |
| 4650 | *s++ = fillchar; |
| 4651 | *s = NUL; |
| 4652 | } |
| 4653 | |
| 4654 | --n; /* count the '<' */ |
| 4655 | for (; l < itemcnt; l++) |
| 4656 | { |
| 4657 | if (item[l].start - n >= s) |
| 4658 | item[l].start -= n; |
| 4659 | else |
| 4660 | item[l].start = s; |
| 4661 | } |
| 4662 | } |
| 4663 | width = maxwidth; |
| 4664 | } |
| 4665 | else if (width < maxwidth && STRLEN(out) + maxwidth - width + 1 < outlen) |
| 4666 | { |
| 4667 | /* Apply STL_MIDDLE if any */ |
| 4668 | for (l = 0; l < itemcnt; l++) |
| 4669 | if (item[l].type == Middle) |
| 4670 | break; |
| 4671 | if (l < itemcnt) |
| 4672 | { |
| 4673 | p = item[l].start + maxwidth - width; |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 4674 | STRMOVE(p, item[l].start); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4675 | for (s = item[l].start; s < p; s++) |
| 4676 | *s = fillchar; |
| 4677 | for (l++; l < itemcnt; l++) |
| 4678 | item[l].start += maxwidth - width; |
| 4679 | width = maxwidth; |
| 4680 | } |
| 4681 | } |
| 4682 | |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 4683 | /* Store the info about highlighting. */ |
| 4684 | if (hltab != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4685 | { |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 4686 | sp = hltab; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4687 | for (l = 0; l < itemcnt; l++) |
| 4688 | { |
| 4689 | if (item[l].type == Highlight) |
| 4690 | { |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 4691 | sp->start = item[l].start; |
| 4692 | sp->userhl = item[l].minwid; |
| 4693 | sp++; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4694 | } |
| 4695 | } |
Bram Moolenaar | d1f56e6 | 2006-02-22 21:25:37 +0000 | [diff] [blame] | 4696 | sp->start = NULL; |
| 4697 | sp->userhl = 0; |
| 4698 | } |
| 4699 | |
| 4700 | /* Store the info about tab pages labels. */ |
| 4701 | if (tabtab != NULL) |
| 4702 | { |
| 4703 | sp = tabtab; |
| 4704 | for (l = 0; l < itemcnt; l++) |
| 4705 | { |
| 4706 | if (item[l].type == TabPage) |
| 4707 | { |
| 4708 | sp->start = item[l].start; |
| 4709 | sp->userhl = item[l].minwid; |
| 4710 | sp++; |
| 4711 | } |
| 4712 | } |
| 4713 | sp->start = NULL; |
| 4714 | sp->userhl = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4715 | } |
| 4716 | |
Bram Moolenaar | 65ed136 | 2017-09-30 16:00:14 +0200 | [diff] [blame] | 4717 | /* When inside update_screen we do not want redrawing a stausline, ruler, |
| 4718 | * title, etc. to trigger another redraw, it may cause an endless loop. */ |
| 4719 | if (updating_screen) |
| 4720 | { |
| 4721 | must_redraw = save_must_redraw; |
| 4722 | curwin->w_redr_type = save_redr_type; |
| 4723 | } |
Bram Moolenaar | ba2929b | 2017-09-08 13:59:21 +0200 | [diff] [blame] | 4724 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4725 | return width; |
| 4726 | } |
| 4727 | #endif /* FEAT_STL_OPT */ |
| 4728 | |
Bram Moolenaar | ba6c052 | 2006-02-25 21:45:02 +0000 | [diff] [blame] | 4729 | #if defined(FEAT_STL_OPT) || defined(FEAT_CMDL_INFO) \ |
| 4730 | || defined(FEAT_GUI_TABLINE) || defined(PROTO) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4731 | /* |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4732 | * Get relative cursor position in window into "buf[buflen]", in the form 99%, |
| 4733 | * using "Top", "Bot" or "All" when appropriate. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4734 | */ |
| 4735 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4736 | get_rel_pos( |
| 4737 | win_T *wp, |
| 4738 | char_u *buf, |
| 4739 | int buflen) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4740 | { |
| 4741 | long above; /* number of lines above window */ |
| 4742 | long below; /* number of lines below window */ |
| 4743 | |
Bram Moolenaar | 0027c21 | 2015-01-07 13:31:52 +0100 | [diff] [blame] | 4744 | if (buflen < 3) /* need at least 3 chars for writing */ |
| 4745 | return; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4746 | above = wp->w_topline - 1; |
| 4747 | #ifdef FEAT_DIFF |
| 4748 | above += diff_check_fill(wp, wp->w_topline) - wp->w_topfill; |
Bram Moolenaar | 29bc9db | 2015-08-04 17:43:25 +0200 | [diff] [blame] | 4749 | if (wp->w_topline == 1 && wp->w_topfill >= 1) |
| 4750 | above = 0; /* All buffer lines are displayed and there is an |
| 4751 | * indication of filler lines, that can be considered |
| 4752 | * seeing all lines. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4753 | #endif |
| 4754 | below = wp->w_buffer->b_ml.ml_line_count - wp->w_botline + 1; |
| 4755 | if (below <= 0) |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4756 | vim_strncpy(buf, (char_u *)(above == 0 ? _("All") : _("Bot")), |
| 4757 | (size_t)(buflen - 1)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4758 | else if (above <= 0) |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4759 | vim_strncpy(buf, (char_u *)_("Top"), (size_t)(buflen - 1)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4760 | else |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4761 | vim_snprintf((char *)buf, (size_t)buflen, "%2d%%", above > 1000000L |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4762 | ? (int)(above / ((above + below) / 100L)) |
| 4763 | : (int)(above * 100L / (above + below))); |
| 4764 | } |
| 4765 | #endif |
| 4766 | |
| 4767 | /* |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4768 | * Append (file 2 of 8) to "buf[buflen]", if editing more than one file. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4769 | * Return TRUE if it was appended. |
| 4770 | */ |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4771 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4772 | append_arg_number( |
| 4773 | win_T *wp, |
| 4774 | char_u *buf, |
| 4775 | int buflen, |
| 4776 | int add_file) /* Add "file" before the arg number */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4777 | { |
| 4778 | char_u *p; |
| 4779 | |
| 4780 | if (ARGCOUNT <= 1) /* nothing to do */ |
| 4781 | return FALSE; |
| 4782 | |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4783 | p = buf + STRLEN(buf); /* go to the end of the buffer */ |
| 4784 | if (p - buf + 35 >= buflen) /* getting too long */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4785 | return FALSE; |
| 4786 | *p++ = ' '; |
| 4787 | *p++ = '('; |
| 4788 | if (add_file) |
| 4789 | { |
| 4790 | STRCPY(p, "file "); |
| 4791 | p += 5; |
| 4792 | } |
Bram Moolenaar | 0ab2a88 | 2009-05-13 10:51:08 +0000 | [diff] [blame] | 4793 | vim_snprintf((char *)p, (size_t)(buflen - (p - buf)), |
| 4794 | wp->w_arg_idx_invalid ? "(%d) of %d)" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4795 | : "%d of %d)", wp->w_arg_idx + 1, ARGCOUNT); |
| 4796 | return TRUE; |
| 4797 | } |
| 4798 | |
| 4799 | /* |
| 4800 | * If fname is not a full path, make it a full path. |
| 4801 | * Returns pointer to allocated memory (NULL for failure). |
| 4802 | */ |
| 4803 | char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4804 | fix_fname(char_u *fname) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4805 | { |
| 4806 | /* |
| 4807 | * Force expanding the path always for Unix, because symbolic links may |
| 4808 | * mess up the full path name, even though it starts with a '/'. |
| 4809 | * Also expand when there is ".." in the file name, try to remove it, |
| 4810 | * because "c:/src/../README" is equal to "c:/README". |
Bram Moolenaar | 9b94220 | 2007-10-03 12:31:33 +0000 | [diff] [blame] | 4811 | * Similarly "c:/src//file" is equal to "c:/src/file". |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4812 | * For MS-Windows also expand names like "longna~1" to "longname". |
| 4813 | */ |
Bram Moolenaar | 38323e4 | 2007-03-06 19:22:53 +0000 | [diff] [blame] | 4814 | #ifdef UNIX |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4815 | return FullName_save(fname, TRUE); |
| 4816 | #else |
Bram Moolenaar | 9b94220 | 2007-10-03 12:31:33 +0000 | [diff] [blame] | 4817 | if (!vim_isAbsName(fname) |
| 4818 | || strstr((char *)fname, "..") != NULL |
| 4819 | || strstr((char *)fname, "//") != NULL |
| 4820 | # ifdef BACKSLASH_IN_FILENAME |
| 4821 | || strstr((char *)fname, "\\\\") != NULL |
| 4822 | # endif |
Bram Moolenaar | 48e330a | 2016-02-23 14:53:34 +0100 | [diff] [blame] | 4823 | # if defined(MSWIN) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4824 | || vim_strchr(fname, '~') != NULL |
Bram Moolenaar | 9b94220 | 2007-10-03 12:31:33 +0000 | [diff] [blame] | 4825 | # endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4826 | ) |
| 4827 | return FullName_save(fname, FALSE); |
| 4828 | |
| 4829 | fname = vim_strsave(fname); |
| 4830 | |
Bram Moolenaar | 9b94220 | 2007-10-03 12:31:33 +0000 | [diff] [blame] | 4831 | # ifdef USE_FNAME_CASE |
Bram Moolenaar | 00f148d | 2019-02-12 22:37:27 +0100 | [diff] [blame] | 4832 | if (fname != NULL) |
| 4833 | fname_case(fname, 0); /* set correct case for file name */ |
Bram Moolenaar | 9b94220 | 2007-10-03 12:31:33 +0000 | [diff] [blame] | 4834 | # endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4835 | |
| 4836 | return fname; |
| 4837 | #endif |
| 4838 | } |
| 4839 | |
| 4840 | /* |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 4841 | * Make "*ffname" a full file name, set "*sfname" to "*ffname" if not NULL. |
| 4842 | * "*ffname" becomes a pointer to allocated memory (or NULL). |
| 4843 | * When resolving a link both "*sfname" and "*ffname" will point to the same |
| 4844 | * allocated memory. |
| 4845 | * The "*ffname" and "*sfname" pointer values on call will not be freed. |
| 4846 | * Note that the resulting "*ffname" pointer should be considered not allocaed. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4847 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4848 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4849 | fname_expand( |
| 4850 | buf_T *buf UNUSED, |
| 4851 | char_u **ffname, |
| 4852 | char_u **sfname) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4853 | { |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 4854 | if (*ffname == NULL) // no file name given, nothing to do |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4855 | return; |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 4856 | if (*sfname == NULL) // no short file name given, use ffname |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4857 | *sfname = *ffname; |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 4858 | *ffname = fix_fname(*ffname); // expand to full path |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4859 | |
| 4860 | #ifdef FEAT_SHORTCUT |
| 4861 | if (!buf->b_p_bin) |
| 4862 | { |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 4863 | char_u *rfname; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4864 | |
Bram Moolenaar | 3d6014f | 2018-10-11 19:27:47 +0200 | [diff] [blame] | 4865 | // If the file name is a shortcut file, use the file it links to. |
Bram Moolenaar | dce1e89 | 2019-02-10 23:18:53 +0100 | [diff] [blame] | 4866 | rfname = mch_resolve_path(*ffname, FALSE); |
Bram Moolenaar | f193fff | 2006-04-27 00:02:13 +0000 | [diff] [blame] | 4867 | if (rfname != NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4868 | { |
| 4869 | vim_free(*ffname); |
| 4870 | *ffname = rfname; |
| 4871 | *sfname = rfname; |
| 4872 | } |
| 4873 | } |
| 4874 | #endif |
| 4875 | } |
| 4876 | |
| 4877 | /* |
| 4878 | * Get the file name for an argument list entry. |
| 4879 | */ |
| 4880 | char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4881 | alist_name(aentry_T *aep) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4882 | { |
| 4883 | buf_T *bp; |
| 4884 | |
| 4885 | /* Use the name from the associated buffer if it exists. */ |
| 4886 | bp = buflist_findnr(aep->ae_fnum); |
Bram Moolenaar | 8421282 | 2006-11-07 21:59:47 +0000 | [diff] [blame] | 4887 | if (bp == NULL || bp->b_fname == NULL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4888 | return aep->ae_fname; |
| 4889 | return bp->b_fname; |
| 4890 | } |
| 4891 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4892 | /* |
| 4893 | * do_arg_all(): Open up to 'count' windows, one for each argument. |
| 4894 | */ |
| 4895 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 4896 | do_arg_all( |
| 4897 | int count, |
| 4898 | int forceit, /* hide buffers in current windows */ |
| 4899 | int keep_tabs) /* keep current tabs, for ":tab drop file" */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4900 | { |
| 4901 | int i; |
| 4902 | win_T *wp, *wpnext; |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4903 | char_u *opened; /* Array of weight for which args are open: |
| 4904 | * 0: not opened |
| 4905 | * 1: opened in other tab |
| 4906 | * 2: opened in curtab |
| 4907 | * 3: opened in curtab and curwin |
| 4908 | */ |
Bram Moolenaar | d089d9b | 2007-09-30 12:02:55 +0000 | [diff] [blame] | 4909 | int opened_len; /* length of opened[] */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4910 | int use_firstwin = FALSE; /* use first window for arglist */ |
| 4911 | int split_ret = OK; |
| 4912 | int p_ea_save; |
| 4913 | alist_T *alist; /* argument list to be used */ |
| 4914 | buf_T *buf; |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4915 | tabpage_T *tpnext; |
| 4916 | int had_tab = cmdmod.tab; |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4917 | win_T *old_curwin, *last_curwin; |
| 4918 | tabpage_T *old_curtab, *last_curtab; |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 4919 | win_T *new_curwin = NULL; |
| 4920 | tabpage_T *new_curtab = NULL; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4921 | |
| 4922 | if (ARGCOUNT <= 0) |
| 4923 | { |
| 4924 | /* Don't give an error message. We don't want it when the ":all" |
| 4925 | * command is in the .vimrc. */ |
| 4926 | return; |
| 4927 | } |
| 4928 | setpcmark(); |
| 4929 | |
| 4930 | opened_len = ARGCOUNT; |
Bram Moolenaar | 18a4ba2 | 2019-05-24 19:39:03 +0200 | [diff] [blame] | 4931 | opened = alloc_clear(opened_len); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4932 | if (opened == NULL) |
| 4933 | return; |
| 4934 | |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4935 | /* Autocommands may do anything to the argument list. Make sure it's not |
| 4936 | * freed while we are working here by "locking" it. We still have to |
| 4937 | * watch out for its size to be changed. */ |
| 4938 | alist = curwin->w_alist; |
| 4939 | ++alist->al_refcount; |
| 4940 | |
| 4941 | old_curwin = curwin; |
| 4942 | old_curtab = curtab; |
| 4943 | |
Bram Moolenaar | 44a2f92 | 2016-03-19 22:11:51 +0100 | [diff] [blame] | 4944 | # ifdef FEAT_GUI |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4945 | need_mouse_correct = TRUE; |
Bram Moolenaar | 44a2f92 | 2016-03-19 22:11:51 +0100 | [diff] [blame] | 4946 | # endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4947 | |
| 4948 | /* |
| 4949 | * Try closing all windows that are not in the argument list. |
| 4950 | * Also close windows that are not full width; |
| 4951 | * When 'hidden' or "forceit" set the buffer becomes hidden. |
| 4952 | * Windows that have a changed buffer and can't be hidden won't be closed. |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4953 | * When the ":tab" modifier was used do this for all tab pages. |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4954 | */ |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4955 | if (had_tab > 0) |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 4956 | goto_tabpage_tp(first_tabpage, TRUE, TRUE); |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4957 | for (;;) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4958 | { |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4959 | tpnext = curtab->tp_next; |
| 4960 | for (wp = firstwin; wp != NULL; wp = wpnext) |
| 4961 | { |
| 4962 | wpnext = wp->w_next; |
| 4963 | buf = wp->w_buffer; |
| 4964 | if (buf->b_ffname == NULL |
Bram Moolenaar | 5a030a5 | 2016-12-01 17:48:29 +0100 | [diff] [blame] | 4965 | || (!keep_tabs && (buf->b_nwindows > 1 |
| 4966 | || wp->w_width != Columns))) |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4967 | i = opened_len; |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4968 | else |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4969 | { |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 4970 | /* check if the buffer in this window is in the arglist */ |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4971 | for (i = 0; i < opened_len; ++i) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4972 | { |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4973 | if (i < alist->al_ga.ga_len |
| 4974 | && (AARGLIST(alist)[i].ae_fnum == buf->b_fnum |
| 4975 | || fullpathcmp(alist_name(&AARGLIST(alist)[i]), |
Bram Moolenaar | 99499b1 | 2019-05-23 21:35:48 +0200 | [diff] [blame] | 4976 | buf->b_ffname, TRUE, TRUE) & FPC_SAME)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 4977 | { |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4978 | int weight = 1; |
| 4979 | |
| 4980 | if (old_curtab == curtab) |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 4981 | { |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4982 | ++weight; |
| 4983 | if (old_curwin == wp) |
| 4984 | ++weight; |
| 4985 | } |
| 4986 | |
| 4987 | if (weight > (int)opened[i]) |
| 4988 | { |
| 4989 | opened[i] = (char_u)weight; |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 4990 | if (i == 0) |
| 4991 | { |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4992 | if (new_curwin != NULL) |
| 4993 | new_curwin->w_arg_idx = opened_len; |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 4994 | new_curwin = wp; |
| 4995 | new_curtab = curtab; |
| 4996 | } |
| 4997 | } |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 4998 | else if (keep_tabs) |
| 4999 | i = opened_len; |
| 5000 | |
| 5001 | if (wp->w_alist != alist) |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5002 | { |
| 5003 | /* Use the current argument list for all windows |
| 5004 | * containing a file from it. */ |
| 5005 | alist_unlink(wp->w_alist); |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5006 | wp->w_alist = alist; |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5007 | ++wp->w_alist->al_refcount; |
| 5008 | } |
| 5009 | break; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5010 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5011 | } |
| 5012 | } |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5013 | wp->w_arg_idx = i; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5014 | |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5015 | if (i == opened_len && !keep_tabs)/* close this window */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5016 | { |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5017 | if (buf_hide(buf) || forceit || buf->b_nwindows > 1 |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5018 | || !bufIsChanged(buf)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5019 | { |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5020 | /* If the buffer was changed, and we would like to hide it, |
| 5021 | * try autowriting. */ |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5022 | if (!buf_hide(buf) && buf->b_nwindows <= 1 |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5023 | && bufIsChanged(buf)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5024 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 5025 | bufref_T bufref; |
| 5026 | |
| 5027 | set_bufref(&bufref, buf); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5028 | |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5029 | (void)autowrite(buf, FALSE); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5030 | |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5031 | /* check if autocommands removed the window */ |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 5032 | if (!win_valid(wp) || !bufref_valid(&bufref)) |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5033 | { |
| 5034 | wpnext = firstwin; /* start all over... */ |
| 5035 | continue; |
| 5036 | } |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5037 | } |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5038 | /* don't close last window */ |
Bram Moolenaar | a1f4cb9 | 2016-11-06 15:25:42 +0100 | [diff] [blame] | 5039 | if (ONE_WINDOW |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5040 | && (first_tabpage->tp_next == NULL || !had_tab)) |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5041 | use_firstwin = TRUE; |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5042 | else |
| 5043 | { |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5044 | win_close(wp, !buf_hide(buf) && !bufIsChanged(buf)); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5045 | |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5046 | /* check if autocommands removed the next window */ |
| 5047 | if (!win_valid(wpnext)) |
| 5048 | wpnext = firstwin; /* start all over... */ |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 5049 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5050 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5051 | } |
| 5052 | } |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5053 | |
| 5054 | /* Without the ":tab" modifier only do the current tab page. */ |
| 5055 | if (had_tab == 0 || tpnext == NULL) |
| 5056 | break; |
| 5057 | |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5058 | /* check if autocommands removed the next tab page */ |
| 5059 | if (!valid_tabpage(tpnext)) |
| 5060 | tpnext = first_tabpage; /* start all over...*/ |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5061 | |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 5062 | goto_tabpage_tp(tpnext, TRUE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5063 | } |
| 5064 | |
| 5065 | /* |
| 5066 | * Open a window for files in the argument list that don't have one. |
| 5067 | * ARGCOUNT may change while doing this, because of autocommands. |
| 5068 | */ |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5069 | if (count > opened_len || count <= 0) |
| 5070 | count = opened_len; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5071 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5072 | /* Don't execute Win/Buf Enter/Leave autocommands here. */ |
| 5073 | ++autocmd_no_enter; |
| 5074 | ++autocmd_no_leave; |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5075 | last_curwin = curwin; |
| 5076 | last_curtab = curtab; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5077 | win_enter(lastwin, FALSE); |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 5078 | /* ":drop all" should re-use an empty window to avoid "--remote-tab" |
| 5079 | * leaving an empty tab page when executed locally. */ |
Bram Moolenaar | b5aedf3 | 2017-03-12 18:23:53 +0100 | [diff] [blame] | 5080 | if (keep_tabs && BUFEMPTY() && curbuf->b_nwindows == 1 |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 5081 | && curbuf->b_ffname == NULL && !curbuf->b_changed) |
| 5082 | use_firstwin = TRUE; |
Bram Moolenaar | 910f66f | 2006-04-05 20:41:53 +0000 | [diff] [blame] | 5083 | |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5084 | for (i = 0; i < count && i < opened_len && !got_int; ++i) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5085 | { |
| 5086 | if (alist == &global_alist && i == global_alist.al_ga.ga_len - 1) |
| 5087 | arg_had_last = TRUE; |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5088 | if (opened[i] > 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5089 | { |
| 5090 | /* Move the already present window to below the current window */ |
| 5091 | if (curwin->w_arg_idx != i) |
| 5092 | { |
| 5093 | for (wpnext = firstwin; wpnext != NULL; wpnext = wpnext->w_next) |
| 5094 | { |
| 5095 | if (wpnext->w_arg_idx == i) |
| 5096 | { |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5097 | if (keep_tabs) |
| 5098 | { |
| 5099 | new_curwin = wpnext; |
| 5100 | new_curtab = curtab; |
| 5101 | } |
Bram Moolenaar | 1417c76 | 2019-07-27 17:31:36 +0200 | [diff] [blame] | 5102 | else if (wpnext->w_frame->fr_parent |
| 5103 | != curwin->w_frame->fr_parent) |
| 5104 | { |
| 5105 | emsg(_("E249: window layout changed unexpectedly")); |
| 5106 | i = count; |
| 5107 | break; |
| 5108 | } |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5109 | else |
| 5110 | win_move_after(wpnext, curwin); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5111 | break; |
| 5112 | } |
| 5113 | } |
| 5114 | } |
| 5115 | } |
| 5116 | else if (split_ret == OK) |
| 5117 | { |
| 5118 | if (!use_firstwin) /* split current window */ |
| 5119 | { |
| 5120 | p_ea_save = p_ea; |
| 5121 | p_ea = TRUE; /* use space from all windows */ |
| 5122 | split_ret = win_split(0, WSP_ROOM | WSP_BELOW); |
| 5123 | p_ea = p_ea_save; |
| 5124 | if (split_ret == FAIL) |
| 5125 | continue; |
| 5126 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5127 | else /* first window: do autocmd for leaving this buffer */ |
| 5128 | --autocmd_no_leave; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5129 | |
| 5130 | /* |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5131 | * edit file "i" |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5132 | */ |
| 5133 | curwin->w_arg_idx = i; |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5134 | if (i == 0) |
| 5135 | { |
| 5136 | new_curwin = curwin; |
| 5137 | new_curtab = curtab; |
| 5138 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5139 | (void)do_ecmd(0, alist_name(&AARGLIST(alist)[i]), NULL, NULL, |
| 5140 | ECMD_ONE, |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5141 | ((buf_hide(curwin->w_buffer) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5142 | || bufIsChanged(curwin->w_buffer)) ? ECMD_HIDE : 0) |
Bram Moolenaar | 701f7af | 2008-11-15 13:12:07 +0000 | [diff] [blame] | 5143 | + ECMD_OLDBUF, curwin); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5144 | if (use_firstwin) |
| 5145 | ++autocmd_no_leave; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5146 | use_firstwin = FALSE; |
| 5147 | } |
| 5148 | ui_breakcheck(); |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5149 | |
| 5150 | /* When ":tab" was used open a new tab for a new window repeatedly. */ |
| 5151 | if (had_tab > 0 && tabpage_index(NULL) <= p_tpm) |
| 5152 | cmdmod.tab = 9999; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5153 | } |
| 5154 | |
| 5155 | /* Remove the "lock" on the argument list. */ |
| 5156 | alist_unlink(alist); |
| 5157 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5158 | --autocmd_no_enter; |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5159 | |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5160 | /* restore last referenced tabpage's curwin */ |
| 5161 | if (last_curtab != new_curtab) |
| 5162 | { |
| 5163 | if (valid_tabpage(last_curtab)) |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 5164 | goto_tabpage_tp(last_curtab, TRUE, TRUE); |
Bram Moolenaar | 52379ea | 2012-02-22 19:13:08 +0100 | [diff] [blame] | 5165 | if (win_valid(last_curwin)) |
| 5166 | win_enter(last_curwin, FALSE); |
| 5167 | } |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5168 | /* to window with first arg */ |
| 5169 | if (valid_tabpage(new_curtab)) |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 5170 | goto_tabpage_tp(new_curtab, TRUE, TRUE); |
Bram Moolenaar | 8ee8926 | 2006-03-11 21:16:47 +0000 | [diff] [blame] | 5171 | if (win_valid(new_curwin)) |
| 5172 | win_enter(new_curwin, FALSE); |
| 5173 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5174 | --autocmd_no_leave; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5175 | vim_free(opened); |
| 5176 | } |
| 5177 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5178 | /* |
| 5179 | * Open a window for a number of buffers. |
| 5180 | */ |
| 5181 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5182 | ex_buffer_all(exarg_T *eap) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5183 | { |
| 5184 | buf_T *buf; |
| 5185 | win_T *wp, *wpnext; |
| 5186 | int split_ret = OK; |
| 5187 | int p_ea_save; |
| 5188 | int open_wins = 0; |
| 5189 | int r; |
| 5190 | int count; /* Maximum number of windows to open. */ |
| 5191 | int all; /* When TRUE also load inactive buffers. */ |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5192 | int had_tab = cmdmod.tab; |
| 5193 | tabpage_T *tpnext; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5194 | |
| 5195 | if (eap->addr_count == 0) /* make as many windows as possible */ |
| 5196 | count = 9999; |
| 5197 | else |
| 5198 | count = eap->line2; /* make as many windows as specified */ |
| 5199 | if (eap->cmdidx == CMD_unhide || eap->cmdidx == CMD_sunhide) |
| 5200 | all = FALSE; |
| 5201 | else |
| 5202 | all = TRUE; |
| 5203 | |
| 5204 | setpcmark(); |
| 5205 | |
| 5206 | #ifdef FEAT_GUI |
| 5207 | need_mouse_correct = TRUE; |
| 5208 | #endif |
| 5209 | |
| 5210 | /* |
| 5211 | * Close superfluous windows (two windows for the same buffer). |
| 5212 | * Also close windows that are not full-width. |
| 5213 | */ |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5214 | if (had_tab > 0) |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 5215 | goto_tabpage_tp(first_tabpage, TRUE, TRUE); |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5216 | for (;;) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5217 | { |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5218 | tpnext = curtab->tp_next; |
| 5219 | for (wp = firstwin; wp != NULL; wp = wpnext) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5220 | { |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5221 | wpnext = wp->w_next; |
Bram Moolenaar | bfb2d40 | 2006-03-03 22:50:42 +0000 | [diff] [blame] | 5222 | if ((wp->w_buffer->b_nwindows > 1 |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5223 | || ((cmdmod.split & WSP_VERT) |
| 5224 | ? wp->w_height + wp->w_status_height < Rows - p_ch |
Bram Moolenaar | bfb2d40 | 2006-03-03 22:50:42 +0000 | [diff] [blame] | 5225 | - tabline_height() |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5226 | : wp->w_width != Columns) |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 5227 | || (had_tab > 0 && wp != firstwin)) && !ONE_WINDOW |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5228 | && !(wp->w_closing || wp->w_buffer->b_locked > 0)) |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5229 | { |
| 5230 | win_close(wp, FALSE); |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5231 | wpnext = firstwin; /* just in case an autocommand does |
| 5232 | something strange with windows */ |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 5233 | tpnext = first_tabpage; /* start all over... */ |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5234 | open_wins = 0; |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5235 | } |
| 5236 | else |
| 5237 | ++open_wins; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5238 | } |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5239 | |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5240 | /* Without the ":tab" modifier only do the current tab page. */ |
| 5241 | if (had_tab == 0 || tpnext == NULL) |
| 5242 | break; |
Bram Moolenaar | 49e649f | 2013-05-06 04:50:35 +0200 | [diff] [blame] | 5243 | goto_tabpage_tp(tpnext, TRUE, TRUE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5244 | } |
| 5245 | |
| 5246 | /* |
| 5247 | * Go through the buffer list. When a buffer doesn't have a window yet, |
| 5248 | * open one. Otherwise move the window to the right position. |
| 5249 | * Watch out for autocommands that delete buffers or windows! |
| 5250 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5251 | /* Don't execute Win/Buf Enter/Leave autocommands here. */ |
| 5252 | ++autocmd_no_enter; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5253 | win_enter(lastwin, FALSE); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5254 | ++autocmd_no_leave; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5255 | for (buf = firstbuf; buf != NULL && open_wins < count; buf = buf->b_next) |
| 5256 | { |
| 5257 | /* Check if this buffer needs a window */ |
| 5258 | if ((!all && buf->b_ml.ml_mfp == NULL) || !buf->b_p_bl) |
| 5259 | continue; |
| 5260 | |
Bram Moolenaar | b475fb9 | 2006-03-02 22:40:52 +0000 | [diff] [blame] | 5261 | if (had_tab != 0) |
| 5262 | { |
| 5263 | /* With the ":tab" modifier don't move the window. */ |
| 5264 | if (buf->b_nwindows > 0) |
| 5265 | wp = lastwin; /* buffer has a window, skip it */ |
| 5266 | else |
| 5267 | wp = NULL; |
| 5268 | } |
| 5269 | else |
Bram Moolenaar | b475fb9 | 2006-03-02 22:40:52 +0000 | [diff] [blame] | 5270 | { |
| 5271 | /* Check if this buffer already has a window */ |
Bram Moolenaar | 2932359 | 2016-07-24 22:04:11 +0200 | [diff] [blame] | 5272 | FOR_ALL_WINDOWS(wp) |
Bram Moolenaar | b475fb9 | 2006-03-02 22:40:52 +0000 | [diff] [blame] | 5273 | if (wp->w_buffer == buf) |
| 5274 | break; |
| 5275 | /* If the buffer already has a window, move it */ |
| 5276 | if (wp != NULL) |
| 5277 | win_move_after(wp, curwin); |
| 5278 | } |
| 5279 | |
| 5280 | if (wp == NULL && split_ret == OK) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5281 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 5282 | bufref_T bufref; |
| 5283 | |
| 5284 | set_bufref(&bufref, buf); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5285 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5286 | /* Split the window and put the buffer in it */ |
| 5287 | p_ea_save = p_ea; |
| 5288 | p_ea = TRUE; /* use space from all windows */ |
| 5289 | split_ret = win_split(0, WSP_ROOM | WSP_BELOW); |
| 5290 | ++open_wins; |
| 5291 | p_ea = p_ea_save; |
| 5292 | if (split_ret == FAIL) |
| 5293 | continue; |
| 5294 | |
| 5295 | /* Open the buffer in this window. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5296 | swap_exists_action = SEA_DIALOG; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5297 | set_curbuf(buf, DOBUF_GOTO); |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 5298 | if (!bufref_valid(&bufref)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5299 | { |
Bram Moolenaar | b25f9a9 | 2016-07-10 18:21:50 +0200 | [diff] [blame] | 5300 | /* autocommands deleted the buffer!!! */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5301 | swap_exists_action = SEA_NONE; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5302 | break; |
| 5303 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5304 | if (swap_exists_action == SEA_QUIT) |
| 5305 | { |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 5306 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 5307 | cleanup_T cs; |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 5308 | |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 5309 | /* Reset the error/interrupt/exception state here so that |
| 5310 | * aborting() returns FALSE when closing a window. */ |
| 5311 | enter_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 5312 | #endif |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 5313 | |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 5314 | /* User selected Quit at ATTENTION prompt; close this window. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5315 | win_close(curwin, TRUE); |
| 5316 | --open_wins; |
| 5317 | swap_exists_action = SEA_NONE; |
Bram Moolenaar | 12033fb | 2005-12-16 21:49:31 +0000 | [diff] [blame] | 5318 | swap_exists_did_quit = TRUE; |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 5319 | |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 5320 | #if defined(FEAT_EVAL) |
Bram Moolenaar | c0197e2 | 2004-09-13 20:26:32 +0000 | [diff] [blame] | 5321 | /* Restore the error/interrupt/exception state if not |
| 5322 | * discarded by a new aborting error, interrupt, or uncaught |
| 5323 | * exception. */ |
| 5324 | leave_cleanup(&cs); |
Bram Moolenaar | 67cf86b | 2019-04-28 22:25:38 +0200 | [diff] [blame] | 5325 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5326 | } |
| 5327 | else |
| 5328 | handle_swap_exists(NULL); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5329 | } |
| 5330 | |
| 5331 | ui_breakcheck(); |
| 5332 | if (got_int) |
| 5333 | { |
| 5334 | (void)vgetc(); /* only break the file loading, not the rest */ |
| 5335 | break; |
| 5336 | } |
Bram Moolenaar | 5eb86f9 | 2004-07-26 12:53:41 +0000 | [diff] [blame] | 5337 | #ifdef FEAT_EVAL |
| 5338 | /* Autocommands deleted the buffer or aborted script processing!!! */ |
| 5339 | if (aborting()) |
| 5340 | break; |
| 5341 | #endif |
Bram Moolenaar | e1438bb | 2006-03-01 22:01:55 +0000 | [diff] [blame] | 5342 | /* When ":tab" was used open a new tab for a new window repeatedly. */ |
| 5343 | if (had_tab > 0 && tabpage_index(NULL) <= p_tpm) |
| 5344 | cmdmod.tab = 9999; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5345 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5346 | --autocmd_no_enter; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5347 | win_enter(firstwin, FALSE); /* back to first window */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5348 | --autocmd_no_leave; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5349 | |
| 5350 | /* |
| 5351 | * Close superfluous windows. |
| 5352 | */ |
| 5353 | for (wp = lastwin; open_wins > count; ) |
| 5354 | { |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5355 | r = (buf_hide(wp->w_buffer) || !bufIsChanged(wp->w_buffer) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5356 | || autowrite(wp->w_buffer, FALSE) == OK); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5357 | if (!win_valid(wp)) |
| 5358 | { |
| 5359 | /* BufWrite Autocommands made the window invalid, start over */ |
| 5360 | wp = lastwin; |
| 5361 | } |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5362 | else if (r) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5363 | { |
Bram Moolenaar | eb44a68 | 2017-08-03 22:44:55 +0200 | [diff] [blame] | 5364 | win_close(wp, !buf_hide(wp->w_buffer)); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5365 | --open_wins; |
| 5366 | wp = lastwin; |
| 5367 | } |
| 5368 | else |
| 5369 | { |
| 5370 | wp = wp->w_prev; |
| 5371 | if (wp == NULL) |
| 5372 | break; |
| 5373 | } |
| 5374 | } |
| 5375 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5376 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5377 | |
Bram Moolenaar | f28dbce | 2016-01-29 22:03:47 +0100 | [diff] [blame] | 5378 | static int chk_modeline(linenr_T, int); |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 5379 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5380 | /* |
| 5381 | * do_modelines() - process mode lines for the current file |
| 5382 | * |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 5383 | * "flags" can be: |
| 5384 | * OPT_WINONLY only set options local to window |
| 5385 | * OPT_NOWIN don't set options local to window |
| 5386 | * |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5387 | * Returns immediately if the "ml" option isn't set. |
| 5388 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5389 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5390 | do_modelines(int flags) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5391 | { |
Bram Moolenaar | 15d0a8c | 2004-09-06 17:44:46 +0000 | [diff] [blame] | 5392 | linenr_T lnum; |
| 5393 | int nmlines; |
| 5394 | static int entered = 0; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5395 | |
| 5396 | if (!curbuf->b_p_ml || (nmlines = (int)p_mls) == 0) |
| 5397 | return; |
| 5398 | |
| 5399 | /* Disallow recursive entry here. Can happen when executing a modeline |
| 5400 | * triggers an autocommand, which reloads modelines with a ":do". */ |
| 5401 | if (entered) |
| 5402 | return; |
| 5403 | |
| 5404 | ++entered; |
| 5405 | for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count && lnum <= nmlines; |
| 5406 | ++lnum) |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 5407 | if (chk_modeline(lnum, flags) == FAIL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5408 | nmlines = 0; |
| 5409 | |
| 5410 | for (lnum = curbuf->b_ml.ml_line_count; lnum > 0 && lnum > nmlines |
| 5411 | && lnum > curbuf->b_ml.ml_line_count - nmlines; --lnum) |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 5412 | if (chk_modeline(lnum, flags) == FAIL) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5413 | nmlines = 0; |
| 5414 | --entered; |
| 5415 | } |
| 5416 | |
| 5417 | #include "version.h" /* for version number */ |
| 5418 | |
| 5419 | /* |
| 5420 | * chk_modeline() - check a single line for a mode string |
| 5421 | * Return FAIL if an error encountered. |
| 5422 | */ |
| 5423 | static int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5424 | chk_modeline( |
| 5425 | linenr_T lnum, |
| 5426 | int flags) /* Same as for do_modelines(). */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5427 | { |
| 5428 | char_u *s; |
| 5429 | char_u *e; |
| 5430 | char_u *linecopy; /* local copy of any modeline found */ |
| 5431 | int prev; |
| 5432 | int vers; |
| 5433 | int end; |
| 5434 | int retval = OK; |
| 5435 | char_u *save_sourcing_name; |
| 5436 | linenr_T save_sourcing_lnum; |
| 5437 | #ifdef FEAT_EVAL |
Bram Moolenaar | f29c1c6 | 2018-09-10 21:05:02 +0200 | [diff] [blame] | 5438 | sctx_T save_current_sctx; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5439 | #endif |
| 5440 | |
| 5441 | prev = -1; |
| 5442 | for (s = ml_get(lnum); *s != NUL; ++s) |
| 5443 | { |
| 5444 | if (prev == -1 || vim_isspace(prev)) |
| 5445 | { |
| 5446 | if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0) |
| 5447 | || STRNCMP(s, "vi:", (size_t)3) == 0) |
| 5448 | break; |
Bram Moolenaar | c14621e | 2013-06-26 20:04:35 +0200 | [diff] [blame] | 5449 | /* Accept both "vim" and "Vim". */ |
| 5450 | if ((s[0] == 'v' || s[0] == 'V') && s[1] == 'i' && s[2] == 'm') |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5451 | { |
| 5452 | if (s[3] == '<' || s[3] == '=' || s[3] == '>') |
| 5453 | e = s + 4; |
| 5454 | else |
| 5455 | e = s + 3; |
| 5456 | vers = getdigits(&e); |
| 5457 | if (*e == ':' |
Bram Moolenaar | 630a730 | 2013-06-29 15:07:22 +0200 | [diff] [blame] | 5458 | && (s[0] != 'V' |
| 5459 | || STRNCMP(skipwhite(e + 1), "set", 3) == 0) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5460 | && (s[3] == ':' |
| 5461 | || (VIM_VERSION_100 >= vers && isdigit(s[3])) |
| 5462 | || (VIM_VERSION_100 < vers && s[3] == '<') |
| 5463 | || (VIM_VERSION_100 > vers && s[3] == '>') |
| 5464 | || (VIM_VERSION_100 == vers && s[3] == '='))) |
| 5465 | break; |
| 5466 | } |
| 5467 | } |
| 5468 | prev = *s; |
| 5469 | } |
| 5470 | |
| 5471 | if (*s) |
| 5472 | { |
| 5473 | do /* skip over "ex:", "vi:" or "vim:" */ |
| 5474 | ++s; |
| 5475 | while (s[-1] != ':'); |
| 5476 | |
| 5477 | s = linecopy = vim_strsave(s); /* copy the line, it will change */ |
| 5478 | if (linecopy == NULL) |
| 5479 | return FAIL; |
| 5480 | |
| 5481 | save_sourcing_lnum = sourcing_lnum; |
| 5482 | save_sourcing_name = sourcing_name; |
| 5483 | sourcing_lnum = lnum; /* prepare for emsg() */ |
| 5484 | sourcing_name = (char_u *)"modelines"; |
| 5485 | |
| 5486 | end = FALSE; |
| 5487 | while (end == FALSE) |
| 5488 | { |
| 5489 | s = skipwhite(s); |
| 5490 | if (*s == NUL) |
| 5491 | break; |
| 5492 | |
| 5493 | /* |
| 5494 | * Find end of set command: ':' or end of line. |
| 5495 | * Skip over "\:", replacing it with ":". |
| 5496 | */ |
| 5497 | for (e = s; *e != ':' && *e != NUL; ++e) |
| 5498 | if (e[0] == '\\' && e[1] == ':') |
Bram Moolenaar | f233048 | 2008-06-24 20:19:36 +0000 | [diff] [blame] | 5499 | STRMOVE(e, e + 1); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5500 | if (*e == NUL) |
| 5501 | end = TRUE; |
| 5502 | |
| 5503 | /* |
| 5504 | * If there is a "set" command, require a terminating ':' and |
| 5505 | * ignore the stuff after the ':'. |
| 5506 | * "vi:set opt opt opt: foo" -- foo not interpreted |
| 5507 | * "vi:opt opt opt: foo" -- foo interpreted |
| 5508 | * Accept "se" for compatibility with Elvis. |
| 5509 | */ |
| 5510 | if (STRNCMP(s, "set ", (size_t)4) == 0 |
| 5511 | || STRNCMP(s, "se ", (size_t)3) == 0) |
| 5512 | { |
| 5513 | if (*e != ':') /* no terminating ':'? */ |
| 5514 | break; |
| 5515 | end = TRUE; |
| 5516 | s = vim_strchr(s, ' ') + 1; |
| 5517 | } |
| 5518 | *e = NUL; /* truncate the set command */ |
| 5519 | |
| 5520 | if (*s != NUL) /* skip over an empty "::" */ |
| 5521 | { |
Bram Moolenaar | 48f377a | 2018-12-21 13:03:28 +0100 | [diff] [blame] | 5522 | int secure_save = secure; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5523 | #ifdef FEAT_EVAL |
Bram Moolenaar | f29c1c6 | 2018-09-10 21:05:02 +0200 | [diff] [blame] | 5524 | save_current_sctx = current_sctx; |
| 5525 | current_sctx.sc_sid = SID_MODELINE; |
Bram Moolenaar | ded5f1b | 2018-11-10 17:33:29 +0100 | [diff] [blame] | 5526 | current_sctx.sc_seq = 0; |
Bram Moolenaar | f29c1c6 | 2018-09-10 21:05:02 +0200 | [diff] [blame] | 5527 | current_sctx.sc_lnum = 0; |
Bram Moolenaar | 558ca4a | 2019-04-04 18:15:38 +0200 | [diff] [blame] | 5528 | current_sctx.sc_version = 1; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5529 | #endif |
Bram Moolenaar | 5958f95 | 2018-11-20 04:25:21 +0100 | [diff] [blame] | 5530 | // Make sure no risky things are executed as a side effect. |
Bram Moolenaar | 82b033e | 2019-03-24 14:02:04 +0100 | [diff] [blame] | 5531 | secure = 1; |
Bram Moolenaar | 5958f95 | 2018-11-20 04:25:21 +0100 | [diff] [blame] | 5532 | |
Bram Moolenaar | a3227e2 | 2006-03-08 21:32:40 +0000 | [diff] [blame] | 5533 | retval = do_set(s, OPT_MODELINE | OPT_LOCAL | flags); |
Bram Moolenaar | 5958f95 | 2018-11-20 04:25:21 +0100 | [diff] [blame] | 5534 | |
Bram Moolenaar | 48f377a | 2018-12-21 13:03:28 +0100 | [diff] [blame] | 5535 | secure = secure_save; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5536 | #ifdef FEAT_EVAL |
Bram Moolenaar | f29c1c6 | 2018-09-10 21:05:02 +0200 | [diff] [blame] | 5537 | current_sctx = save_current_sctx; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5538 | #endif |
| 5539 | if (retval == FAIL) /* stop if error found */ |
| 5540 | break; |
| 5541 | } |
| 5542 | s = e + 1; /* advance to next part */ |
| 5543 | } |
| 5544 | |
| 5545 | sourcing_lnum = save_sourcing_lnum; |
| 5546 | sourcing_name = save_sourcing_name; |
| 5547 | |
| 5548 | vim_free(linecopy); |
| 5549 | } |
| 5550 | return retval; |
| 5551 | } |
| 5552 | |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5553 | /* |
Bram Moolenaar | 91335e5 | 2018-08-01 17:53:12 +0200 | [diff] [blame] | 5554 | * Return TRUE if "buf" is a normal buffer, 'buftype' is empty. |
| 5555 | */ |
| 5556 | int |
| 5557 | bt_normal(buf_T *buf) |
| 5558 | { |
| 5559 | return buf != NULL && buf->b_p_bt[0] == NUL; |
| 5560 | } |
| 5561 | |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5562 | #if defined(FEAT_QUICKFIX) || defined(PROTO) |
Bram Moolenaar | 91335e5 | 2018-08-01 17:53:12 +0200 | [diff] [blame] | 5563 | /* |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5564 | * Return TRUE if "buf" is the quickfix buffer. |
| 5565 | */ |
| 5566 | int |
| 5567 | bt_quickfix(buf_T *buf) |
| 5568 | { |
| 5569 | return buf != NULL && buf->b_p_bt[0] == 'q'; |
| 5570 | } |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5571 | #endif |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5572 | |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5573 | #if defined(FEAT_TERMINAL) || defined(PROTO) |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5574 | /* |
| 5575 | * Return TRUE if "buf" is a terminal buffer. |
| 5576 | */ |
| 5577 | int |
| 5578 | bt_terminal(buf_T *buf) |
| 5579 | { |
| 5580 | return buf != NULL && buf->b_p_bt[0] == 't'; |
| 5581 | } |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5582 | #endif |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5583 | |
| 5584 | /* |
Bram Moolenaar | d28cc3f | 2017-07-27 22:03:50 +0200 | [diff] [blame] | 5585 | * Return TRUE if "buf" is a help buffer. |
| 5586 | */ |
| 5587 | int |
| 5588 | bt_help(buf_T *buf) |
| 5589 | { |
| 5590 | return buf != NULL && buf->b_help; |
| 5591 | } |
| 5592 | |
| 5593 | /* |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 5594 | * Return TRUE if "buf" is a prompt buffer. |
| 5595 | */ |
| 5596 | int |
| 5597 | bt_prompt(buf_T *buf) |
| 5598 | { |
Bram Moolenaar | 4d784b2 | 2019-05-25 19:51:39 +0200 | [diff] [blame] | 5599 | return buf != NULL && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'r'; |
| 5600 | } |
| 5601 | |
| 5602 | /* |
| 5603 | * Return TRUE if "buf" is a buffer for a popup window. |
| 5604 | */ |
| 5605 | int |
| 5606 | bt_popup(buf_T *buf) |
| 5607 | { |
| 5608 | return buf != NULL && buf->b_p_bt != NULL |
| 5609 | && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'o'; |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 5610 | } |
| 5611 | |
| 5612 | /* |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 5613 | * Return TRUE if "buf" is a "nofile", "acwrite", "terminal" or "prompt" |
| 5614 | * buffer. This means the buffer name is not a file name. |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5615 | */ |
| 5616 | int |
Bram Moolenaar | 26910de | 2019-06-15 19:37:15 +0200 | [diff] [blame] | 5617 | bt_nofilename(buf_T *buf) |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5618 | { |
| 5619 | return buf != NULL && ((buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f') |
| 5620 | || buf->b_p_bt[0] == 'a' |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 5621 | || buf->b_p_bt[0] == 't' |
| 5622 | || buf->b_p_bt[0] == 'p'); |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5623 | } |
| 5624 | |
| 5625 | /* |
Bram Moolenaar | 26910de | 2019-06-15 19:37:15 +0200 | [diff] [blame] | 5626 | * Return TRUE if "buf" has 'buftype' set to "nofile". |
| 5627 | */ |
| 5628 | int |
| 5629 | bt_nofile(buf_T *buf) |
| 5630 | { |
| 5631 | return buf != NULL && buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f'; |
| 5632 | } |
| 5633 | |
| 5634 | /* |
Bram Moolenaar | 04958cb | 2018-06-23 19:23:02 +0200 | [diff] [blame] | 5635 | * Return TRUE if "buf" is a "nowrite", "nofile", "terminal" or "prompt" |
| 5636 | * buffer. |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5637 | */ |
| 5638 | int |
| 5639 | bt_dontwrite(buf_T *buf) |
| 5640 | { |
Bram Moolenaar | f273245 | 2018-06-03 14:47:35 +0200 | [diff] [blame] | 5641 | return buf != NULL && (buf->b_p_bt[0] == 'n' |
| 5642 | || buf->b_p_bt[0] == 't' |
| 5643 | || buf->b_p_bt[0] == 'p'); |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5644 | } |
| 5645 | |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5646 | #if defined(FEAT_QUICKFIX) || defined(PROTO) |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5647 | int |
| 5648 | bt_dontwrite_msg(buf_T *buf) |
| 5649 | { |
| 5650 | if (bt_dontwrite(buf)) |
| 5651 | { |
Bram Moolenaar | f9e3e09 | 2019-01-13 23:38:42 +0100 | [diff] [blame] | 5652 | emsg(_("E382: Cannot write, 'buftype' option is set")); |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5653 | return TRUE; |
| 5654 | } |
| 5655 | return FALSE; |
| 5656 | } |
Bram Moolenaar | 113e107 | 2019-01-20 15:30:40 +0100 | [diff] [blame] | 5657 | #endif |
Bram Moolenaar | f0a521f | 2017-07-25 23:31:12 +0200 | [diff] [blame] | 5658 | |
| 5659 | /* |
| 5660 | * Return TRUE if the buffer should be hidden, according to 'hidden', ":hide" |
| 5661 | * and 'bufhidden'. |
| 5662 | */ |
| 5663 | int |
| 5664 | buf_hide(buf_T *buf) |
| 5665 | { |
| 5666 | /* 'bufhidden' overrules 'hidden' and ":hide", check it first */ |
| 5667 | switch (buf->b_p_bh[0]) |
| 5668 | { |
| 5669 | case 'u': /* "unload" */ |
| 5670 | case 'w': /* "wipe" */ |
| 5671 | case 'd': return FALSE; /* "delete" */ |
| 5672 | case 'h': return TRUE; /* "hide" */ |
| 5673 | } |
| 5674 | return (p_hid || cmdmod.hide); |
| 5675 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5676 | |
| 5677 | /* |
| 5678 | * Return special buffer name. |
| 5679 | * Returns NULL when the buffer has a normal file name. |
| 5680 | */ |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 5681 | char_u * |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5682 | buf_spname(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5683 | { |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 5684 | #if defined(FEAT_QUICKFIX) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5685 | if (bt_quickfix(buf)) |
Bram Moolenaar | 28c258f | 2006-01-25 22:02:51 +0000 | [diff] [blame] | 5686 | { |
Bram Moolenaar | 28c258f | 2006-01-25 22:02:51 +0000 | [diff] [blame] | 5687 | /* |
Bram Moolenaar | ee8188f | 2019-02-05 21:23:04 +0100 | [diff] [blame] | 5688 | * Differentiate between the quickfix and location list buffers using |
| 5689 | * the buffer number stored in the global quickfix stack. |
Bram Moolenaar | 28c258f | 2006-01-25 22:02:51 +0000 | [diff] [blame] | 5690 | */ |
Bram Moolenaar | ee8188f | 2019-02-05 21:23:04 +0100 | [diff] [blame] | 5691 | if (buf->b_fnum == qf_stack_get_bufnr()) |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 5692 | return (char_u *)_(msg_qflist); |
Bram Moolenaar | ee8188f | 2019-02-05 21:23:04 +0100 | [diff] [blame] | 5693 | else |
| 5694 | return (char_u *)_(msg_loclist); |
Bram Moolenaar | 28c258f | 2006-01-25 22:02:51 +0000 | [diff] [blame] | 5695 | } |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5696 | #endif |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 5697 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5698 | /* There is no _file_ when 'buftype' is "nofile", b_sfname |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 5699 | * contains the name as specified by the user. */ |
Bram Moolenaar | 26910de | 2019-06-15 19:37:15 +0200 | [diff] [blame] | 5700 | if (bt_nofilename(buf)) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5701 | { |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 5702 | #ifdef FEAT_TERMINAL |
| 5703 | if (buf->b_term != NULL) |
| 5704 | return term_get_status_text(buf->b_term); |
| 5705 | #endif |
Bram Moolenaar | e561a7e | 2017-08-29 22:44:59 +0200 | [diff] [blame] | 5706 | if (buf->b_fname != NULL) |
| 5707 | return buf->b_fname; |
Bram Moolenaar | 891e1fd | 2018-06-06 18:02:39 +0200 | [diff] [blame] | 5708 | #ifdef FEAT_JOB_CHANNEL |
| 5709 | if (bt_prompt(buf)) |
| 5710 | return (char_u *)_("[Prompt]"); |
| 5711 | #endif |
Bram Moolenaar | c6896e2 | 2019-05-30 22:32:34 +0200 | [diff] [blame] | 5712 | #ifdef FEAT_TEXT_PROP |
| 5713 | if (bt_popup(buf)) |
| 5714 | return (char_u *)_("[Popup]"); |
| 5715 | #endif |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 5716 | return (char_u *)_("[Scratch]"); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5717 | } |
Bram Moolenaar | 2155441 | 2017-07-24 21:44:43 +0200 | [diff] [blame] | 5718 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5719 | if (buf->b_fname == NULL) |
Bram Moolenaar | e1704ba | 2012-10-03 18:25:00 +0200 | [diff] [blame] | 5720 | return (char_u *)_("[No Name]"); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5721 | return NULL; |
| 5722 | } |
| 5723 | |
Bram Moolenaar | 6b7355a | 2017-08-04 21:37:54 +0200 | [diff] [blame] | 5724 | #if defined(FEAT_JOB_CHANNEL) \ |
Bram Moolenaar | 4a3aef7 | 2013-07-17 19:12:57 +0200 | [diff] [blame] | 5725 | || defined(FEAT_PYTHON) || defined(FEAT_PYTHON3) \ |
| 5726 | || defined(PROTO) |
Bram Moolenaar | 6b7355a | 2017-08-04 21:37:54 +0200 | [diff] [blame] | 5727 | # define SWITCH_TO_WIN |
| 5728 | |
| 5729 | /* |
| 5730 | * Find a window that contains "buf" and switch to it. |
| 5731 | * If there is no such window, use the current window and change "curbuf". |
| 5732 | * Caller must initialize save_curbuf to NULL. |
| 5733 | * restore_win_for_buf() MUST be called later! |
| 5734 | */ |
| 5735 | void |
| 5736 | switch_to_win_for_buf( |
| 5737 | buf_T *buf, |
| 5738 | win_T **save_curwinp, |
| 5739 | tabpage_T **save_curtabp, |
| 5740 | bufref_T *save_curbuf) |
| 5741 | { |
| 5742 | win_T *wp; |
| 5743 | tabpage_T *tp; |
| 5744 | |
| 5745 | if (find_win_for_buf(buf, &wp, &tp) == FAIL) |
| 5746 | switch_buffer(save_curbuf, buf); |
| 5747 | else if (switch_win(save_curwinp, save_curtabp, wp, tp, TRUE) == FAIL) |
| 5748 | { |
| 5749 | restore_win(*save_curwinp, *save_curtabp, TRUE); |
| 5750 | switch_buffer(save_curbuf, buf); |
| 5751 | } |
| 5752 | } |
| 5753 | |
| 5754 | void |
| 5755 | restore_win_for_buf( |
| 5756 | win_T *save_curwin, |
| 5757 | tabpage_T *save_curtab, |
| 5758 | bufref_T *save_curbuf) |
| 5759 | { |
| 5760 | if (save_curbuf->br_buf == NULL) |
| 5761 | restore_win(save_curwin, save_curtab, TRUE); |
| 5762 | else |
| 5763 | restore_buffer(save_curbuf); |
| 5764 | } |
| 5765 | #endif |
| 5766 | |
Bram Moolenaar | 4033c55 | 2017-09-16 20:54:51 +0200 | [diff] [blame] | 5767 | #if defined(FEAT_QUICKFIX) || defined(SWITCH_TO_WIN) || defined(PROTO) |
Bram Moolenaar | 4a3aef7 | 2013-07-17 19:12:57 +0200 | [diff] [blame] | 5768 | /* |
| 5769 | * Find a window for buffer "buf". |
| 5770 | * If found OK is returned and "wp" and "tp" are set to the window and tabpage. |
| 5771 | * If not found FAIL is returned. |
| 5772 | */ |
| 5773 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5774 | find_win_for_buf( |
| 5775 | buf_T *buf, |
| 5776 | win_T **wp, |
| 5777 | tabpage_T **tp) |
Bram Moolenaar | 4a3aef7 | 2013-07-17 19:12:57 +0200 | [diff] [blame] | 5778 | { |
| 5779 | FOR_ALL_TAB_WINDOWS(*tp, *wp) |
| 5780 | if ((*wp)->w_buffer == buf) |
| 5781 | goto win_found; |
| 5782 | return FAIL; |
| 5783 | win_found: |
| 5784 | return OK; |
| 5785 | } |
| 5786 | #endif |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5787 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5788 | /* |
| 5789 | * Set 'buflisted' for curbuf to "on" and trigger autocommands if it changed. |
| 5790 | */ |
| 5791 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5792 | set_buflisted(int on) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5793 | { |
| 5794 | if (on != curbuf->b_p_bl) |
| 5795 | { |
| 5796 | curbuf->b_p_bl = on; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5797 | if (on) |
| 5798 | apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf); |
| 5799 | else |
| 5800 | apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5801 | } |
| 5802 | } |
| 5803 | |
| 5804 | /* |
| 5805 | * Read the file for "buf" again and check if the contents changed. |
| 5806 | * Return TRUE if it changed or this could not be checked. |
| 5807 | */ |
| 5808 | int |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5809 | buf_contents_changed(buf_T *buf) |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5810 | { |
| 5811 | buf_T *newbuf; |
| 5812 | int differ = TRUE; |
| 5813 | linenr_T lnum; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5814 | aco_save_T aco; |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5815 | exarg_T ea; |
| 5816 | |
| 5817 | /* Allocate a buffer without putting it in the buffer list. */ |
| 5818 | newbuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY); |
| 5819 | if (newbuf == NULL) |
| 5820 | return TRUE; |
| 5821 | |
| 5822 | /* Force the 'fileencoding' and 'fileformat' to be equal. */ |
| 5823 | if (prep_exarg(&ea, buf) == FAIL) |
| 5824 | { |
| 5825 | wipe_buffer(newbuf, FALSE); |
| 5826 | return TRUE; |
| 5827 | } |
| 5828 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5829 | /* set curwin/curbuf to buf and save a few things */ |
| 5830 | aucmd_prepbuf(&aco, newbuf); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5831 | |
Bram Moolenaar | 4770d09 | 2006-01-12 23:22:24 +0000 | [diff] [blame] | 5832 | if (ml_open(curbuf) == OK |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5833 | && readfile(buf->b_ffname, buf->b_fname, |
| 5834 | (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, |
| 5835 | &ea, READ_NEW | READ_DUMMY) == OK) |
| 5836 | { |
| 5837 | /* compare the two files line by line */ |
| 5838 | if (buf->b_ml.ml_line_count == curbuf->b_ml.ml_line_count) |
| 5839 | { |
| 5840 | differ = FALSE; |
| 5841 | for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) |
| 5842 | if (STRCMP(ml_get_buf(buf, lnum, FALSE), ml_get(lnum)) != 0) |
| 5843 | { |
| 5844 | differ = TRUE; |
| 5845 | break; |
| 5846 | } |
| 5847 | } |
| 5848 | } |
| 5849 | vim_free(ea.cmd); |
| 5850 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5851 | /* restore curwin/curbuf and a few other things */ |
| 5852 | aucmd_restbuf(&aco); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5853 | |
| 5854 | if (curbuf != newbuf) /* safety check */ |
| 5855 | wipe_buffer(newbuf, FALSE); |
| 5856 | |
| 5857 | return differ; |
| 5858 | } |
| 5859 | |
| 5860 | /* |
| 5861 | * Wipe out a buffer and decrement the last buffer number if it was used for |
| 5862 | * this buffer. Call this to wipe out a temp buffer that does not contain any |
| 5863 | * marks. |
| 5864 | */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5865 | void |
Bram Moolenaar | 7454a06 | 2016-01-30 15:14:10 +0100 | [diff] [blame] | 5866 | wipe_buffer( |
| 5867 | buf_T *buf, |
| 5868 | int aucmd UNUSED) /* When TRUE trigger autocommands. */ |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5869 | { |
| 5870 | if (buf->b_fnum == top_file_num - 1) |
| 5871 | --top_file_num; |
| 5872 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5873 | if (!aucmd) /* Don't trigger BufDelete autocommands here. */ |
Bram Moolenaar | 78ab331 | 2007-09-29 12:16:41 +0000 | [diff] [blame] | 5874 | block_autocmds(); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5875 | |
Bram Moolenaar | 42ec656 | 2012-02-22 14:58:37 +0100 | [diff] [blame] | 5876 | close_buffer(NULL, buf, DOBUF_WIPE, FALSE); |
Bram Moolenaar | f2bd8ef | 2018-03-04 18:08:14 +0100 | [diff] [blame] | 5877 | |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5878 | if (!aucmd) |
Bram Moolenaar | 78ab331 | 2007-09-29 12:16:41 +0000 | [diff] [blame] | 5879 | unblock_autocmds(); |
Bram Moolenaar | 071d427 | 2004-06-13 20:20:40 +0000 | [diff] [blame] | 5880 | } |
Bram Moolenaar | 75a1a94 | 2019-06-20 03:45:36 +0200 | [diff] [blame] | 5881 | |
| 5882 | #if defined(FEAT_EVAL) || defined(PROTO) |
| 5883 | /* |
| 5884 | * Mark references in functions of buffers. |
| 5885 | */ |
| 5886 | int |
| 5887 | set_ref_in_buffers(int copyID) |
| 5888 | { |
| 5889 | int abort = FALSE; |
| 5890 | buf_T *bp; |
| 5891 | |
| 5892 | FOR_ALL_BUFFERS(bp) |
| 5893 | { |
| 5894 | listener_T *lnr; |
| 5895 | typval_T tv; |
| 5896 | |
| 5897 | for (lnr = bp->b_listener; !abort && lnr != NULL; lnr = lnr->lr_next) |
| 5898 | { |
| 5899 | if (lnr->lr_callback.cb_partial != NULL) |
| 5900 | { |
| 5901 | tv.v_type = VAR_PARTIAL; |
| 5902 | tv.vval.v_partial = lnr->lr_callback.cb_partial; |
| 5903 | abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL); |
| 5904 | } |
| 5905 | } |
| 5906 | # ifdef FEAT_JOB_CHANNEL |
| 5907 | if (!abort && bp->b_prompt_callback.cb_partial != NULL) |
| 5908 | { |
| 5909 | tv.v_type = VAR_PARTIAL; |
| 5910 | tv.vval.v_partial = bp->b_prompt_callback.cb_partial; |
| 5911 | abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL); |
| 5912 | } |
| 5913 | if (!abort && bp->b_prompt_interrupt.cb_partial != NULL) |
| 5914 | { |
| 5915 | tv.v_type = VAR_PARTIAL; |
| 5916 | tv.vval.v_partial = bp->b_prompt_interrupt.cb_partial; |
| 5917 | abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL); |
| 5918 | } |
| 5919 | # endif |
| 5920 | if (abort) |
| 5921 | break; |
| 5922 | } |
| 5923 | return abort; |
| 5924 | } |
| 5925 | #endif |