1 /* vi:set ts=8 sts=4 sw=4 noet: 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 28 #include "vim.h" 29 30 31 #ifdef FEAT_EVAL 32 // Determines how deeply nested %{} blocks will be evaluated in statusline. 33 # define MAX_STL_EVAL_DEPTH 100 34 #endif 35 36 static void enter_buffer(buf_T *buf); 37 static void buflist_getfpos(void); 38 static char_u *buflist_match(regmatch_T *rmp, buf_T *buf, int ignore_case); 39 static char_u *fname_match(regmatch_T *rmp, char_u *name, int ignore_case); 40 #ifdef UNIX 41 static buf_T *buflist_findname_stat(char_u *ffname, stat_T *st); 42 static int otherfile_buf(buf_T *buf, char_u *ffname, stat_T *stp); 43 static int buf_same_ino(buf_T *buf, stat_T *stp); 44 #else 45 static int otherfile_buf(buf_T *buf, char_u *ffname); 46 #endif 47 #ifdef FEAT_TITLE 48 static int value_changed(char_u *str, char_u **last); 49 #endif 50 static int append_arg_number(win_T *wp, char_u *buf, int buflen, int add_file); 51 static void free_buffer(buf_T *); 52 static void free_buffer_stuff(buf_T *buf, int free_options); 53 static void clear_wininfo(buf_T *buf); 54 55 #ifdef UNIX 56 # define dev_T dev_t 57 #else 58 # define dev_T unsigned 59 #endif 60 61 #define FOR_ALL_BUFS_FROM_LAST(buf) \ 62 for ((buf) = lastbuf; (buf) != NULL; (buf) = (buf)->b_prev) 63 64 #if defined(FEAT_QUICKFIX) 65 static char *msg_loclist = N_("[Location List]"); 66 static char *msg_qflist = N_("[Quickfix List]"); 67 #endif 68 static char *e_auabort = N_("E855: Autocommands caused command to abort"); 69 70 // Number of times free_buffer() was called. 71 static int buf_free_count = 0; 72 73 static int top_file_num = 1; // highest file number 74 static garray_T buf_reuse = GA_EMPTY; // file numbers to recycle 75 76 /* 77 * Return the highest possible buffer number. 78 */ 79 int 80 get_highest_fnum(void) 81 { 82 return top_file_num - 1; 83 } 84 85 /* 86 * Read data from buffer for retrying. 87 */ 88 static int 89 read_buffer( 90 int read_stdin, // read file from stdin, otherwise fifo 91 exarg_T *eap, // for forced 'ff' and 'fenc' or NULL 92 int flags) // extra flags for readfile() 93 { 94 int retval = OK; 95 linenr_T line_count; 96 97 /* 98 * Read from the buffer which the text is already filled in and append at 99 * the end. This makes it possible to retry when 'fileformat' or 100 * 'fileencoding' was guessed wrong. 101 */ 102 line_count = curbuf->b_ml.ml_line_count; 103 retval = readfile( 104 read_stdin ? NULL : curbuf->b_ffname, 105 read_stdin ? NULL : curbuf->b_fname, 106 line_count, (linenr_T)0, (linenr_T)MAXLNUM, eap, 107 flags | READ_BUFFER); 108 if (retval == OK) 109 { 110 // Delete the binary lines. 111 while (--line_count >= 0) 112 ml_delete((linenr_T)1); 113 } 114 else 115 { 116 // Delete the converted lines. 117 while (curbuf->b_ml.ml_line_count > line_count) 118 ml_delete(line_count); 119 } 120 // Put the cursor on the first line. 121 curwin->w_cursor.lnum = 1; 122 curwin->w_cursor.col = 0; 123 124 if (read_stdin) 125 { 126 // Set or reset 'modified' before executing autocommands, so that 127 // it can be changed there. 128 if (!readonlymode && !BUFEMPTY()) 129 changed(); 130 else if (retval == OK) 131 unchanged(curbuf, FALSE, TRUE); 132 133 if (retval == OK) 134 { 135 #ifdef FEAT_EVAL 136 apply_autocmds_retval(EVENT_STDINREADPOST, NULL, NULL, FALSE, 137 curbuf, &retval); 138 #else 139 apply_autocmds(EVENT_STDINREADPOST, NULL, NULL, FALSE, curbuf); 140 #endif 141 } 142 } 143 return retval; 144 } 145 146 /* 147 * Ensure buffer "buf" is loaded. Does not trigger the swap-exists action. 148 */ 149 void 150 buffer_ensure_loaded(buf_T *buf) 151 { 152 if (buf->b_ml.ml_mfp == NULL) 153 { 154 aco_save_T aco; 155 156 aucmd_prepbuf(&aco, buf); 157 swap_exists_action = SEA_NONE; 158 open_buffer(FALSE, NULL, 0); 159 aucmd_restbuf(&aco); 160 } 161 } 162 163 /* 164 * Open current buffer, that is: open the memfile and read the file into 165 * memory. 166 * Return FAIL for failure, OK otherwise. 167 */ 168 int 169 open_buffer( 170 int read_stdin, // read file from stdin 171 exarg_T *eap, // for forced 'ff' and 'fenc' or NULL 172 int flags) // extra flags for readfile() 173 { 174 int retval = OK; 175 bufref_T old_curbuf; 176 #ifdef FEAT_SYN_HL 177 long old_tw = curbuf->b_p_tw; 178 #endif 179 int read_fifo = FALSE; 180 181 /* 182 * The 'readonly' flag is only set when BF_NEVERLOADED is being reset. 183 * When re-entering the same buffer, it should not change, because the 184 * user may have reset the flag by hand. 185 */ 186 if (readonlymode && curbuf->b_ffname != NULL 187 && (curbuf->b_flags & BF_NEVERLOADED)) 188 curbuf->b_p_ro = TRUE; 189 190 if (ml_open(curbuf) == FAIL) 191 { 192 /* 193 * There MUST be a memfile, otherwise we can't do anything 194 * If we can't create one for the current buffer, take another buffer 195 */ 196 close_buffer(NULL, curbuf, 0, FALSE, FALSE); 197 FOR_ALL_BUFFERS(curbuf) 198 if (curbuf->b_ml.ml_mfp != NULL) 199 break; 200 /* 201 * If there is no memfile at all, exit. 202 * This is OK, since there are no changes to lose. 203 */ 204 if (curbuf == NULL) 205 { 206 emsg(_("E82: Cannot allocate any buffer, exiting...")); 207 208 // Don't try to do any saving, with "curbuf" NULL almost nothing 209 // will work. 210 v_dying = 2; 211 getout(2); 212 } 213 214 emsg(_("E83: Cannot allocate buffer, using other one...")); 215 enter_buffer(curbuf); 216 #ifdef FEAT_SYN_HL 217 if (old_tw != curbuf->b_p_tw) 218 check_colorcolumn(curwin); 219 #endif 220 return FAIL; 221 } 222 223 // The autocommands in readfile() may change the buffer, but only AFTER 224 // reading the file. 225 set_bufref(&old_curbuf, curbuf); 226 modified_was_set = FALSE; 227 228 // mark cursor position as being invalid 229 curwin->w_valid = 0; 230 231 if (curbuf->b_ffname != NULL 232 #ifdef FEAT_NETBEANS_INTG 233 && netbeansReadFile 234 #endif 235 ) 236 { 237 int old_msg_silent = msg_silent; 238 #ifdef UNIX 239 int save_bin = curbuf->b_p_bin; 240 int perm; 241 #endif 242 #ifdef FEAT_NETBEANS_INTG 243 int oldFire = netbeansFireChanges; 244 245 netbeansFireChanges = 0; 246 #endif 247 #ifdef UNIX 248 perm = mch_getperm(curbuf->b_ffname); 249 if (perm >= 0 && (S_ISFIFO(perm) 250 || S_ISSOCK(perm) 251 # ifdef OPEN_CHR_FILES 252 || (S_ISCHR(perm) && is_dev_fd_file(curbuf->b_ffname)) 253 # endif 254 )) 255 read_fifo = TRUE; 256 if (read_fifo) 257 curbuf->b_p_bin = TRUE; 258 #endif 259 if (shortmess(SHM_FILEINFO)) 260 msg_silent = 1; 261 retval = readfile(curbuf->b_ffname, curbuf->b_fname, 262 (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, eap, 263 flags | READ_NEW | (read_fifo ? READ_FIFO : 0)); 264 #ifdef UNIX 265 if (read_fifo) 266 { 267 curbuf->b_p_bin = save_bin; 268 if (retval == OK) 269 retval = read_buffer(FALSE, eap, flags); 270 } 271 #endif 272 msg_silent = old_msg_silent; 273 #ifdef FEAT_NETBEANS_INTG 274 netbeansFireChanges = oldFire; 275 #endif 276 // Help buffer is filtered. 277 if (bt_help(curbuf)) 278 fix_help_buffer(); 279 } 280 else if (read_stdin) 281 { 282 int save_bin = curbuf->b_p_bin; 283 284 /* 285 * First read the text in binary mode into the buffer. 286 * Then read from that same buffer and append at the end. This makes 287 * it possible to retry when 'fileformat' or 'fileencoding' was 288 * guessed wrong. 289 */ 290 curbuf->b_p_bin = TRUE; 291 retval = readfile(NULL, NULL, (linenr_T)0, 292 (linenr_T)0, (linenr_T)MAXLNUM, NULL, 293 flags | (READ_NEW + READ_STDIN)); 294 curbuf->b_p_bin = save_bin; 295 if (retval == OK) 296 retval = read_buffer(TRUE, eap, flags); 297 } 298 299 // if first time loading this buffer, init b_chartab[] 300 if (curbuf->b_flags & BF_NEVERLOADED) 301 { 302 (void)buf_init_chartab(curbuf, FALSE); 303 #ifdef FEAT_CINDENT 304 parse_cino(curbuf); 305 #endif 306 } 307 308 /* 309 * Set/reset the Changed flag first, autocmds may change the buffer. 310 * Apply the automatic commands, before processing the modelines. 311 * So the modelines have priority over autocommands. 312 */ 313 // When reading stdin, the buffer contents always needs writing, so set 314 // the changed flag. Unless in readonly mode: "ls | gview -". 315 // When interrupted and 'cpoptions' contains 'i' set changed flag. 316 if ((got_int && vim_strchr(p_cpo, CPO_INTMOD) != NULL) 317 || modified_was_set // ":set modified" used in autocmd 318 #ifdef FEAT_EVAL 319 || (aborting() && vim_strchr(p_cpo, CPO_INTMOD) != NULL) 320 #endif 321 ) 322 changed(); 323 else if (retval == OK && !read_stdin && !read_fifo) 324 unchanged(curbuf, FALSE, TRUE); 325 save_file_ff(curbuf); // keep this fileformat 326 327 // Set last_changedtick to avoid triggering a TextChanged autocommand right 328 // after it was added. 329 curbuf->b_last_changedtick = CHANGEDTICK(curbuf); 330 curbuf->b_last_changedtick_i = CHANGEDTICK(curbuf); 331 curbuf->b_last_changedtick_pum = CHANGEDTICK(curbuf); 332 333 // require "!" to overwrite the file, because it wasn't read completely 334 #ifdef FEAT_EVAL 335 if (aborting()) 336 #else 337 if (got_int) 338 #endif 339 curbuf->b_flags |= BF_READERR; 340 341 #ifdef FEAT_FOLDING 342 // Need to update automatic folding. Do this before the autocommands, 343 // they may use the fold info. 344 foldUpdateAll(curwin); 345 #endif 346 347 // need to set w_topline, unless some autocommand already did that. 348 if (!(curwin->w_valid & VALID_TOPLINE)) 349 { 350 curwin->w_topline = 1; 351 #ifdef FEAT_DIFF 352 curwin->w_topfill = 0; 353 #endif 354 } 355 #ifdef FEAT_EVAL 356 apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf, &retval); 357 #else 358 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf); 359 #endif 360 361 if (retval == OK) 362 { 363 /* 364 * The autocommands may have changed the current buffer. Apply the 365 * modelines to the correct buffer, if it still exists and is loaded. 366 */ 367 if (bufref_valid(&old_curbuf) && old_curbuf.br_buf->b_ml.ml_mfp != NULL) 368 { 369 aco_save_T aco; 370 371 // Go to the buffer that was opened. 372 aucmd_prepbuf(&aco, old_curbuf.br_buf); 373 do_modelines(0); 374 curbuf->b_flags &= ~(BF_CHECK_RO | BF_NEVERLOADED); 375 376 #ifdef FEAT_EVAL 377 apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf, 378 &retval); 379 #else 380 apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf); 381 #endif 382 383 // restore curwin/curbuf and a few other things 384 aucmd_restbuf(&aco); 385 } 386 } 387 388 return retval; 389 } 390 391 /* 392 * Store "buf" in "bufref" and set the free count. 393 */ 394 void 395 set_bufref(bufref_T *bufref, buf_T *buf) 396 { 397 bufref->br_buf = buf; 398 bufref->br_fnum = buf == NULL ? 0 : buf->b_fnum; 399 bufref->br_buf_free_count = buf_free_count; 400 } 401 402 /* 403 * Return TRUE if "bufref->br_buf" points to the same buffer as when 404 * set_bufref() was called and it is a valid buffer. 405 * Only goes through the buffer list if buf_free_count changed. 406 * Also checks if b_fnum is still the same, a :bwipe followed by :new might get 407 * the same allocated memory, but it's a different buffer. 408 */ 409 int 410 bufref_valid(bufref_T *bufref) 411 { 412 return bufref->br_buf_free_count == buf_free_count 413 ? TRUE : buf_valid(bufref->br_buf) 414 && bufref->br_fnum == bufref->br_buf->b_fnum; 415 } 416 417 /* 418 * Return TRUE if "buf" points to a valid buffer (in the buffer list). 419 * This can be slow if there are many buffers, prefer using bufref_valid(). 420 */ 421 int 422 buf_valid(buf_T *buf) 423 { 424 buf_T *bp; 425 426 // Assume that we more often have a recent buffer, start with the last 427 // one. 428 FOR_ALL_BUFS_FROM_LAST(bp) 429 if (bp == buf) 430 return TRUE; 431 return FALSE; 432 } 433 434 /* 435 * A hash table used to quickly lookup a buffer by its number. 436 */ 437 static hashtab_T buf_hashtab; 438 439 static void 440 buf_hashtab_add(buf_T *buf) 441 { 442 sprintf((char *)buf->b_key, "%x", buf->b_fnum); 443 if (hash_add(&buf_hashtab, buf->b_key) == FAIL) 444 emsg(_("E931: Buffer cannot be registered")); 445 } 446 447 static void 448 buf_hashtab_remove(buf_T *buf) 449 { 450 hashitem_T *hi = hash_find(&buf_hashtab, buf->b_key); 451 452 if (!HASHITEM_EMPTY(hi)) 453 hash_remove(&buf_hashtab, hi); 454 } 455 456 /* 457 * Return TRUE when buffer "buf" can be unloaded. 458 * Give an error message and return FALSE when the buffer is locked or the 459 * screen is being redrawn and the buffer is in a window. 460 */ 461 static int 462 can_unload_buffer(buf_T *buf) 463 { 464 int can_unload = !buf->b_locked; 465 466 if (can_unload && updating_screen) 467 { 468 win_T *wp; 469 470 FOR_ALL_WINDOWS(wp) 471 if (wp->w_buffer == buf) 472 { 473 can_unload = FALSE; 474 break; 475 } 476 } 477 if (!can_unload) 478 semsg(_("E937: Attempt to delete a buffer that is in use: %s"), 479 buf->b_fname); 480 return can_unload; 481 } 482 483 /* 484 * Close the link to a buffer. 485 * "action" is used when there is no longer a window for the buffer. 486 * It can be: 487 * 0 buffer becomes hidden 488 * DOBUF_UNLOAD buffer is unloaded 489 * DOBUF_DELETE buffer is unloaded and removed from buffer list 490 * DOBUF_WIPE buffer is unloaded and really deleted 491 * DOBUF_WIPE_REUSE idem, and add to buf_reuse list 492 * When doing all but the first one on the current buffer, the caller should 493 * get a new buffer very soon! 494 * 495 * The 'bufhidden' option can force freeing and deleting. 496 * 497 * When "abort_if_last" is TRUE then do not close the buffer if autocommands 498 * cause there to be only one window with this buffer. e.g. when ":quit" is 499 * supposed to close the window but autocommands close all other windows. 500 * 501 * When "ignore_abort" is TRUE don't abort even when aborting() returns TRUE. 502 * 503 * Return TRUE when we got to the end and b_nwindows was decremented. 504 */ 505 int 506 close_buffer( 507 win_T *win, // if not NULL, set b_last_cursor 508 buf_T *buf, 509 int action, 510 int abort_if_last, 511 int ignore_abort) 512 { 513 int is_curbuf; 514 int nwindows; 515 bufref_T bufref; 516 int is_curwin = (curwin != NULL && curwin->w_buffer == buf); 517 win_T *the_curwin = curwin; 518 tabpage_T *the_curtab = curtab; 519 int unload_buf = (action != 0); 520 int wipe_buf = (action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE); 521 int del_buf = (action == DOBUF_DEL || wipe_buf); 522 523 CHECK_CURBUF; 524 /* 525 * Force unloading or deleting when 'bufhidden' says so. 526 * The caller must take care of NOT deleting/freeing when 'bufhidden' is 527 * "hide" (otherwise we could never free or delete a buffer). 528 */ 529 if (buf->b_p_bh[0] == 'd') // 'bufhidden' == "delete" 530 { 531 del_buf = TRUE; 532 unload_buf = TRUE; 533 } 534 else if (buf->b_p_bh[0] == 'w') // 'bufhidden' == "wipe" 535 { 536 del_buf = TRUE; 537 unload_buf = TRUE; 538 wipe_buf = TRUE; 539 } 540 else if (buf->b_p_bh[0] == 'u') // 'bufhidden' == "unload" 541 unload_buf = TRUE; 542 543 #ifdef FEAT_TERMINAL 544 if (bt_terminal(buf) && (buf->b_nwindows == 1 || del_buf)) 545 { 546 CHECK_CURBUF; 547 if (term_job_running(buf->b_term)) 548 { 549 if (wipe_buf || unload_buf) 550 { 551 if (!can_unload_buffer(buf)) 552 return FALSE; 553 554 // Wiping out or unloading a terminal buffer kills the job. 555 free_terminal(buf); 556 } 557 else 558 { 559 // The job keeps running, hide the buffer. 560 del_buf = FALSE; 561 unload_buf = FALSE; 562 } 563 } 564 else if (buf->b_p_bh[0] == 'h' && !del_buf) 565 { 566 // Hide a terminal buffer. 567 unload_buf = FALSE; 568 } 569 else 570 { 571 // A terminal buffer is wiped out if the job has finished. 572 del_buf = TRUE; 573 unload_buf = TRUE; 574 wipe_buf = TRUE; 575 } 576 CHECK_CURBUF; 577 } 578 #endif 579 580 // Disallow deleting the buffer when it is locked (already being closed or 581 // halfway a command that relies on it). Unloading is allowed. 582 if ((del_buf || wipe_buf) && !can_unload_buffer(buf)) 583 return FALSE; 584 585 // check no autocommands closed the window 586 if (win != NULL && win_valid_any_tab(win)) 587 { 588 // Set b_last_cursor when closing the last window for the buffer. 589 // Remember the last cursor position and window options of the buffer. 590 // This used to be only for the current window, but then options like 591 // 'foldmethod' may be lost with a ":only" command. 592 if (buf->b_nwindows == 1) 593 set_last_cursor(win); 594 buflist_setfpos(buf, win, 595 win->w_cursor.lnum == 1 ? 0 : win->w_cursor.lnum, 596 win->w_cursor.col, TRUE); 597 } 598 599 set_bufref(&bufref, buf); 600 601 // When the buffer is no longer in a window, trigger BufWinLeave 602 if (buf->b_nwindows == 1) 603 { 604 ++buf->b_locked; 605 ++buf->b_locked_split; 606 if (apply_autocmds(EVENT_BUFWINLEAVE, buf->b_fname, buf->b_fname, 607 FALSE, buf) 608 && !bufref_valid(&bufref)) 609 { 610 // Autocommands deleted the buffer. 611 aucmd_abort: 612 emsg(_(e_auabort)); 613 return FALSE; 614 } 615 --buf->b_locked; 616 --buf->b_locked_split; 617 if (abort_if_last && one_window()) 618 // Autocommands made this the only window. 619 goto aucmd_abort; 620 621 // When the buffer becomes hidden, but is not unloaded, trigger 622 // BufHidden 623 if (!unload_buf) 624 { 625 ++buf->b_locked; 626 ++buf->b_locked_split; 627 if (apply_autocmds(EVENT_BUFHIDDEN, buf->b_fname, buf->b_fname, 628 FALSE, buf) 629 && !bufref_valid(&bufref)) 630 // Autocommands deleted the buffer. 631 goto aucmd_abort; 632 --buf->b_locked; 633 --buf->b_locked_split; 634 if (abort_if_last && one_window()) 635 // Autocommands made this the only window. 636 goto aucmd_abort; 637 } 638 #ifdef FEAT_EVAL 639 // autocmds may abort script processing 640 if (!ignore_abort && aborting()) 641 return FALSE; 642 #endif 643 } 644 645 // If the buffer was in curwin and the window has changed, go back to that 646 // window, if it still exists. This avoids that ":edit x" triggering a 647 // "tabnext" BufUnload autocmd leaves a window behind without a buffer. 648 if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin)) 649 { 650 block_autocmds(); 651 goto_tabpage_win(the_curtab, the_curwin); 652 unblock_autocmds(); 653 } 654 655 nwindows = buf->b_nwindows; 656 657 // decrease the link count from windows (unless not in any window) 658 if (buf->b_nwindows > 0) 659 --buf->b_nwindows; 660 661 #ifdef FEAT_DIFF 662 if (diffopt_hiddenoff() && !unload_buf && buf->b_nwindows == 0) 663 diff_buf_delete(buf); // Clear 'diff' for hidden buffer. 664 #endif 665 666 // Return when a window is displaying the buffer or when it's not 667 // unloaded. 668 if (buf->b_nwindows > 0 || !unload_buf) 669 return FALSE; 670 671 // Always remove the buffer when there is no file name. 672 if (buf->b_ffname == NULL) 673 del_buf = TRUE; 674 675 // When closing the current buffer stop Visual mode before freeing 676 // anything. 677 if (buf == curbuf && VIsual_active 678 #if defined(EXITFREE) 679 && !entered_free_all_mem 680 #endif 681 ) 682 end_visual_mode(); 683 684 /* 685 * Free all things allocated for this buffer. 686 * Also calls the "BufDelete" autocommands when del_buf is TRUE. 687 */ 688 // Remember if we are closing the current buffer. Restore the number of 689 // windows, so that autocommands in buf_freeall() don't get confused. 690 is_curbuf = (buf == curbuf); 691 buf->b_nwindows = nwindows; 692 693 buf_freeall(buf, (del_buf ? BFA_DEL : 0) 694 + (wipe_buf ? BFA_WIPE : 0) 695 + (ignore_abort ? BFA_IGNORE_ABORT : 0)); 696 697 // Autocommands may have deleted the buffer. 698 if (!bufref_valid(&bufref)) 699 return FALSE; 700 #ifdef FEAT_EVAL 701 // autocmds may abort script processing 702 if (!ignore_abort && aborting()) 703 return FALSE; 704 #endif 705 706 /* 707 * It's possible that autocommands change curbuf to the one being deleted. 708 * This might cause the previous curbuf to be deleted unexpectedly. But 709 * in some cases it's OK to delete the curbuf, because a new one is 710 * obtained anyway. Therefore only return if curbuf changed to the 711 * deleted buffer. 712 */ 713 if (buf == curbuf && !is_curbuf) 714 return FALSE; 715 716 if (win_valid_any_tab(win) && win->w_buffer == buf) 717 win->w_buffer = NULL; // make sure we don't use the buffer now 718 719 // Autocommands may have opened or closed windows for this buffer. 720 // Decrement the count for the close we do here. 721 if (buf->b_nwindows > 0) 722 --buf->b_nwindows; 723 724 /* 725 * Remove the buffer from the list. 726 */ 727 if (wipe_buf) 728 { 729 if (action == DOBUF_WIPE_REUSE) 730 { 731 // we can re-use this buffer number, store it 732 if (buf_reuse.ga_itemsize == 0) 733 ga_init2(&buf_reuse, sizeof(int), 50); 734 if (ga_grow(&buf_reuse, 1) == OK) 735 ((int *)buf_reuse.ga_data)[buf_reuse.ga_len++] = buf->b_fnum; 736 } 737 if (buf->b_sfname != buf->b_ffname) 738 VIM_CLEAR(buf->b_sfname); 739 else 740 buf->b_sfname = NULL; 741 VIM_CLEAR(buf->b_ffname); 742 if (buf->b_prev == NULL) 743 firstbuf = buf->b_next; 744 else 745 buf->b_prev->b_next = buf->b_next; 746 if (buf->b_next == NULL) 747 lastbuf = buf->b_prev; 748 else 749 buf->b_next->b_prev = buf->b_prev; 750 free_buffer(buf); 751 } 752 else 753 { 754 if (del_buf) 755 { 756 // Free all internal variables and reset option values, to make 757 // ":bdel" compatible with Vim 5.7. 758 free_buffer_stuff(buf, TRUE); 759 760 // Make it look like a new buffer. 761 buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED; 762 763 // Init the options when loaded again. 764 buf->b_p_initialized = FALSE; 765 } 766 buf_clear_file(buf); 767 if (del_buf) 768 buf->b_p_bl = FALSE; 769 } 770 // NOTE: at this point "curbuf" may be invalid! 771 return TRUE; 772 } 773 774 /* 775 * Make buffer not contain a file. 776 */ 777 void 778 buf_clear_file(buf_T *buf) 779 { 780 buf->b_ml.ml_line_count = 1; 781 unchanged(buf, TRUE, TRUE); 782 buf->b_shortname = FALSE; 783 buf->b_p_eol = TRUE; 784 buf->b_start_eol = TRUE; 785 buf->b_p_bomb = FALSE; 786 buf->b_start_bomb = FALSE; 787 buf->b_ml.ml_mfp = NULL; 788 buf->b_ml.ml_flags = ML_EMPTY; // empty buffer 789 #ifdef FEAT_NETBEANS_INTG 790 netbeans_deleted_all_lines(buf); 791 #endif 792 } 793 794 /* 795 * buf_freeall() - free all things allocated for a buffer that are related to 796 * the file. Careful: get here with "curwin" NULL when exiting. 797 * flags: 798 * BFA_DEL buffer is going to be deleted 799 * BFA_WIPE buffer is going to be wiped out 800 * BFA_KEEP_UNDO do not free undo information 801 * BFA_IGNORE_ABORT don't abort even when aborting() returns TRUE 802 */ 803 void 804 buf_freeall(buf_T *buf, int flags) 805 { 806 int is_curbuf = (buf == curbuf); 807 bufref_T bufref; 808 int is_curwin = (curwin != NULL && curwin->w_buffer == buf); 809 win_T *the_curwin = curwin; 810 tabpage_T *the_curtab = curtab; 811 812 // Make sure the buffer isn't closed by autocommands. 813 ++buf->b_locked; 814 ++buf->b_locked_split; 815 set_bufref(&bufref, buf); 816 if (buf->b_ml.ml_mfp != NULL) 817 { 818 if (apply_autocmds(EVENT_BUFUNLOAD, buf->b_fname, buf->b_fname, 819 FALSE, buf) 820 && !bufref_valid(&bufref)) 821 // autocommands deleted the buffer 822 return; 823 } 824 if ((flags & BFA_DEL) && buf->b_p_bl) 825 { 826 if (apply_autocmds(EVENT_BUFDELETE, buf->b_fname, buf->b_fname, 827 FALSE, buf) 828 && !bufref_valid(&bufref)) 829 // autocommands deleted the buffer 830 return; 831 } 832 if (flags & BFA_WIPE) 833 { 834 if (apply_autocmds(EVENT_BUFWIPEOUT, buf->b_fname, buf->b_fname, 835 FALSE, buf) 836 && !bufref_valid(&bufref)) 837 // autocommands deleted the buffer 838 return; 839 } 840 --buf->b_locked; 841 --buf->b_locked_split; 842 843 // If the buffer was in curwin and the window has changed, go back to that 844 // window, if it still exists. This avoids that ":edit x" triggering a 845 // "tabnext" BufUnload autocmd leaves a window behind without a buffer. 846 if (is_curwin && curwin != the_curwin && win_valid_any_tab(the_curwin)) 847 { 848 block_autocmds(); 849 goto_tabpage_win(the_curtab, the_curwin); 850 unblock_autocmds(); 851 } 852 853 #ifdef FEAT_EVAL 854 // autocmds may abort script processing 855 if ((flags & BFA_IGNORE_ABORT) == 0 && aborting()) 856 return; 857 #endif 858 859 /* 860 * It's possible that autocommands change curbuf to the one being deleted. 861 * This might cause curbuf to be deleted unexpectedly. But in some cases 862 * it's OK to delete the curbuf, because a new one is obtained anyway. 863 * Therefore only return if curbuf changed to the deleted buffer. 864 */ 865 if (buf == curbuf && !is_curbuf) 866 return; 867 #ifdef FEAT_DIFF 868 diff_buf_delete(buf); // Can't use 'diff' for unloaded buffer. 869 #endif 870 #ifdef FEAT_SYN_HL 871 // Remove any ownsyntax, unless exiting. 872 if (curwin != NULL && curwin->w_buffer == buf) 873 reset_synblock(curwin); 874 #endif 875 876 #ifdef FEAT_FOLDING 877 // No folds in an empty buffer. 878 { 879 win_T *win; 880 tabpage_T *tp; 881 882 FOR_ALL_TAB_WINDOWS(tp, win) 883 if (win->w_buffer == buf) 884 clearFolding(win); 885 } 886 #endif 887 888 #ifdef FEAT_TCL 889 tcl_buffer_free(buf); 890 #endif 891 ml_close(buf, TRUE); // close and delete the memline/memfile 892 buf->b_ml.ml_line_count = 0; // no lines in buffer 893 if ((flags & BFA_KEEP_UNDO) == 0) 894 { 895 u_blockfree(buf); // free the memory allocated for undo 896 u_clearall(buf); // reset all undo information 897 } 898 #ifdef FEAT_SYN_HL 899 syntax_clear(&buf->b_s); // reset syntax info 900 #endif 901 #ifdef FEAT_PROP_POPUP 902 clear_buf_prop_types(buf); 903 #endif 904 buf->b_flags &= ~BF_READERR; // a read error is no longer relevant 905 } 906 907 /* 908 * Free a buffer structure and the things it contains related to the buffer 909 * itself (not the file, that must have been done already). 910 */ 911 static void 912 free_buffer(buf_T *buf) 913 { 914 ++buf_free_count; 915 free_buffer_stuff(buf, TRUE); 916 #ifdef FEAT_EVAL 917 // b:changedtick uses an item in buf_T, remove it now 918 dictitem_remove(buf->b_vars, (dictitem_T *)&buf->b_ct_di); 919 unref_var_dict(buf->b_vars); 920 remove_listeners(buf); 921 #endif 922 #ifdef FEAT_LUA 923 lua_buffer_free(buf); 924 #endif 925 #ifdef FEAT_MZSCHEME 926 mzscheme_buffer_free(buf); 927 #endif 928 #ifdef FEAT_PERL 929 perl_buf_free(buf); 930 #endif 931 #ifdef FEAT_PYTHON 932 python_buffer_free(buf); 933 #endif 934 #ifdef FEAT_PYTHON3 935 python3_buffer_free(buf); 936 #endif 937 #ifdef FEAT_RUBY 938 ruby_buffer_free(buf); 939 #endif 940 #ifdef FEAT_JOB_CHANNEL 941 channel_buffer_free(buf); 942 #endif 943 #ifdef FEAT_TERMINAL 944 free_terminal(buf); 945 #endif 946 #ifdef FEAT_JOB_CHANNEL 947 vim_free(buf->b_prompt_text); 948 free_callback(&buf->b_prompt_callback); 949 free_callback(&buf->b_prompt_interrupt); 950 #endif 951 952 buf_hashtab_remove(buf); 953 954 aubuflocal_remove(buf); 955 956 if (autocmd_busy) 957 { 958 // Do not free the buffer structure while autocommands are executing, 959 // it's still needed. Free it when autocmd_busy is reset. 960 buf->b_next = au_pending_free_buf; 961 au_pending_free_buf = buf; 962 } 963 else 964 { 965 vim_free(buf); 966 if (curbuf == buf) 967 curbuf = NULL; // make clear it's not to be used 968 } 969 } 970 971 /* 972 * Initializes b:changedtick. 973 */ 974 static void 975 init_changedtick(buf_T *buf) 976 { 977 dictitem_T *di = (dictitem_T *)&buf->b_ct_di; 978 979 di->di_flags = DI_FLAGS_FIX | DI_FLAGS_RO; 980 di->di_tv.v_type = VAR_NUMBER; 981 di->di_tv.v_lock = VAR_FIXED; 982 di->di_tv.vval.v_number = 0; 983 984 #ifdef FEAT_EVAL 985 STRCPY(buf->b_ct_di.di_key, "changedtick"); 986 (void)dict_add(buf->b_vars, di); 987 #endif 988 } 989 990 /* 991 * Free stuff in the buffer for ":bdel" and when wiping out the buffer. 992 */ 993 static void 994 free_buffer_stuff( 995 buf_T *buf, 996 int free_options) // free options as well 997 { 998 if (free_options) 999 { 1000 clear_wininfo(buf); // including window-local options 1001 free_buf_options(buf, TRUE); 1002 #ifdef FEAT_SPELL 1003 ga_clear(&buf->b_s.b_langp); 1004 #endif 1005 } 1006 #ifdef FEAT_EVAL 1007 { 1008 varnumber_T tick = CHANGEDTICK(buf); 1009 1010 vars_clear(&buf->b_vars->dv_hashtab); // free all buffer variables 1011 hash_init(&buf->b_vars->dv_hashtab); 1012 init_changedtick(buf); 1013 CHANGEDTICK(buf) = tick; 1014 remove_listeners(buf); 1015 } 1016 #endif 1017 uc_clear(&buf->b_ucmds); // clear local user commands 1018 #ifdef FEAT_SIGNS 1019 buf_delete_signs(buf, (char_u *)"*"); // delete any signs 1020 #endif 1021 #ifdef FEAT_NETBEANS_INTG 1022 netbeans_file_killed(buf); 1023 #endif 1024 map_clear_int(buf, MAP_ALL_MODES, TRUE, FALSE); // clear local mappings 1025 map_clear_int(buf, MAP_ALL_MODES, TRUE, TRUE); // clear local abbrevs 1026 VIM_CLEAR(buf->b_start_fenc); 1027 } 1028 1029 /* 1030 * Free one wininfo_T. 1031 */ 1032 void 1033 free_wininfo(wininfo_T *wip) 1034 { 1035 if (wip->wi_optset) 1036 { 1037 clear_winopt(&wip->wi_opt); 1038 #ifdef FEAT_FOLDING 1039 deleteFoldRecurse(&wip->wi_folds); 1040 #endif 1041 } 1042 vim_free(wip); 1043 } 1044 1045 /* 1046 * Free the b_wininfo list for buffer "buf". 1047 */ 1048 static void 1049 clear_wininfo(buf_T *buf) 1050 { 1051 wininfo_T *wip; 1052 1053 while (buf->b_wininfo != NULL) 1054 { 1055 wip = buf->b_wininfo; 1056 buf->b_wininfo = wip->wi_next; 1057 free_wininfo(wip); 1058 } 1059 } 1060 1061 /* 1062 * Go to another buffer. Handles the result of the ATTENTION dialog. 1063 */ 1064 void 1065 goto_buffer( 1066 exarg_T *eap, 1067 int start, 1068 int dir, 1069 int count) 1070 { 1071 bufref_T old_curbuf; 1072 1073 set_bufref(&old_curbuf, curbuf); 1074 1075 swap_exists_action = SEA_DIALOG; 1076 (void)do_buffer(*eap->cmd == 's' ? DOBUF_SPLIT : DOBUF_GOTO, 1077 start, dir, count, eap->forceit); 1078 if (swap_exists_action == SEA_QUIT && *eap->cmd == 's') 1079 { 1080 #if defined(FEAT_EVAL) 1081 cleanup_T cs; 1082 1083 // Reset the error/interrupt/exception state here so that 1084 // aborting() returns FALSE when closing a window. 1085 enter_cleanup(&cs); 1086 #endif 1087 1088 // Quitting means closing the split window, nothing else. 1089 win_close(curwin, TRUE); 1090 swap_exists_action = SEA_NONE; 1091 swap_exists_did_quit = TRUE; 1092 1093 #if defined(FEAT_EVAL) 1094 // Restore the error/interrupt/exception state if not discarded by a 1095 // new aborting error, interrupt, or uncaught exception. 1096 leave_cleanup(&cs); 1097 #endif 1098 } 1099 else 1100 handle_swap_exists(&old_curbuf); 1101 } 1102 1103 /* 1104 * Handle the situation of swap_exists_action being set. 1105 * It is allowed for "old_curbuf" to be NULL or invalid. 1106 */ 1107 void 1108 handle_swap_exists(bufref_T *old_curbuf) 1109 { 1110 #if defined(FEAT_EVAL) 1111 cleanup_T cs; 1112 #endif 1113 #ifdef FEAT_SYN_HL 1114 long old_tw = curbuf->b_p_tw; 1115 #endif 1116 buf_T *buf; 1117 1118 if (swap_exists_action == SEA_QUIT) 1119 { 1120 #if defined(FEAT_EVAL) 1121 // Reset the error/interrupt/exception state here so that 1122 // aborting() returns FALSE when closing a buffer. 1123 enter_cleanup(&cs); 1124 #endif 1125 1126 // User selected Quit at ATTENTION prompt. Go back to previous 1127 // buffer. If that buffer is gone or the same as the current one, 1128 // open a new, empty buffer. 1129 swap_exists_action = SEA_NONE; // don't want it again 1130 swap_exists_did_quit = TRUE; 1131 close_buffer(curwin, curbuf, DOBUF_UNLOAD, FALSE, FALSE); 1132 if (old_curbuf == NULL || !bufref_valid(old_curbuf) 1133 || old_curbuf->br_buf == curbuf) 1134 { 1135 // Block autocommands here because curwin->w_buffer is NULL. 1136 block_autocmds(); 1137 buf = buflist_new(NULL, NULL, 1L, BLN_CURBUF | BLN_LISTED); 1138 unblock_autocmds(); 1139 } 1140 else 1141 buf = old_curbuf->br_buf; 1142 if (buf != NULL) 1143 { 1144 int old_msg_silent = msg_silent; 1145 1146 if (shortmess(SHM_FILEINFO)) 1147 msg_silent = 1; // prevent fileinfo message 1148 enter_buffer(buf); 1149 // restore msg_silent, so that the command line will be shown 1150 msg_silent = old_msg_silent; 1151 1152 #ifdef FEAT_SYN_HL 1153 if (old_tw != curbuf->b_p_tw) 1154 check_colorcolumn(curwin); 1155 #endif 1156 } 1157 // If "old_curbuf" is NULL we are in big trouble here... 1158 1159 #if defined(FEAT_EVAL) 1160 // Restore the error/interrupt/exception state if not discarded by a 1161 // new aborting error, interrupt, or uncaught exception. 1162 leave_cleanup(&cs); 1163 #endif 1164 } 1165 else if (swap_exists_action == SEA_RECOVER) 1166 { 1167 #if defined(FEAT_EVAL) 1168 // Reset the error/interrupt/exception state here so that 1169 // aborting() returns FALSE when closing a buffer. 1170 enter_cleanup(&cs); 1171 #endif 1172 1173 // User selected Recover at ATTENTION prompt. 1174 msg_scroll = TRUE; 1175 ml_recover(FALSE); 1176 msg_puts("\n"); // don't overwrite the last message 1177 cmdline_row = msg_row; 1178 do_modelines(0); 1179 1180 #if defined(FEAT_EVAL) 1181 // Restore the error/interrupt/exception state if not discarded by a 1182 // new aborting error, interrupt, or uncaught exception. 1183 leave_cleanup(&cs); 1184 #endif 1185 } 1186 swap_exists_action = SEA_NONE; 1187 } 1188 1189 /* 1190 * Make the current buffer empty. 1191 * Used when it is wiped out and it's the last buffer. 1192 */ 1193 static int 1194 empty_curbuf( 1195 int close_others, 1196 int forceit, 1197 int action) 1198 { 1199 int retval; 1200 buf_T *buf = curbuf; 1201 bufref_T bufref; 1202 1203 if (action == DOBUF_UNLOAD) 1204 { 1205 emsg(_("E90: Cannot unload last buffer")); 1206 return FAIL; 1207 } 1208 1209 set_bufref(&bufref, buf); 1210 if (close_others) 1211 // Close any other windows on this buffer, then make it empty. 1212 close_windows(buf, TRUE); 1213 1214 setpcmark(); 1215 retval = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, 1216 forceit ? ECMD_FORCEIT : 0, curwin); 1217 1218 /* 1219 * do_ecmd() may create a new buffer, then we have to delete 1220 * the old one. But do_ecmd() may have done that already, check 1221 * if the buffer still exists. 1222 */ 1223 if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows == 0) 1224 close_buffer(NULL, buf, action, FALSE, FALSE); 1225 if (!close_others) 1226 need_fileinfo = FALSE; 1227 return retval; 1228 } 1229 1230 /* 1231 * Implementation of the commands for the buffer list. 1232 * 1233 * action == DOBUF_GOTO go to specified buffer 1234 * action == DOBUF_SPLIT split window and go to specified buffer 1235 * action == DOBUF_UNLOAD unload specified buffer(s) 1236 * action == DOBUF_DEL delete specified buffer(s) from buffer list 1237 * action == DOBUF_WIPE delete specified buffer(s) really 1238 * action == DOBUF_WIPE_REUSE idem, and add number to "buf_reuse" 1239 * 1240 * start == DOBUF_CURRENT go to "count" buffer from current buffer 1241 * start == DOBUF_FIRST go to "count" buffer from first buffer 1242 * start == DOBUF_LAST go to "count" buffer from last buffer 1243 * start == DOBUF_MOD go to "count" modified buffer from current buffer 1244 * 1245 * Return FAIL or OK. 1246 */ 1247 static int 1248 do_buffer_ext( 1249 int action, 1250 int start, 1251 int dir, // FORWARD or BACKWARD 1252 int count, // buffer number or number of buffers 1253 int flags) // DOBUF_FORCEIT etc. 1254 { 1255 buf_T *buf; 1256 buf_T *bp; 1257 int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL 1258 || action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE); 1259 1260 switch (start) 1261 { 1262 case DOBUF_FIRST: buf = firstbuf; break; 1263 case DOBUF_LAST: buf = lastbuf; break; 1264 default: buf = curbuf; break; 1265 } 1266 if (start == DOBUF_MOD) // find next modified buffer 1267 { 1268 while (count-- > 0) 1269 { 1270 do 1271 { 1272 buf = buf->b_next; 1273 if (buf == NULL) 1274 buf = firstbuf; 1275 } 1276 while (buf != curbuf && !bufIsChanged(buf)); 1277 } 1278 if (!bufIsChanged(buf)) 1279 { 1280 emsg(_("E84: No modified buffer found")); 1281 return FAIL; 1282 } 1283 } 1284 else if (start == DOBUF_FIRST && count) // find specified buffer number 1285 { 1286 while (buf != NULL && buf->b_fnum != count) 1287 buf = buf->b_next; 1288 } 1289 else 1290 { 1291 bp = NULL; 1292 while (count > 0 || (!unload && !buf->b_p_bl && bp != buf)) 1293 { 1294 // remember the buffer where we start, we come back there when all 1295 // buffers are unlisted. 1296 if (bp == NULL) 1297 bp = buf; 1298 if (dir == FORWARD) 1299 { 1300 buf = buf->b_next; 1301 if (buf == NULL) 1302 buf = firstbuf; 1303 } 1304 else 1305 { 1306 buf = buf->b_prev; 1307 if (buf == NULL) 1308 buf = lastbuf; 1309 } 1310 // don't count unlisted buffers 1311 if (unload || buf->b_p_bl) 1312 { 1313 --count; 1314 bp = NULL; // use this buffer as new starting point 1315 } 1316 if (bp == buf) 1317 { 1318 // back where we started, didn't find anything. 1319 emsg(_("E85: There is no listed buffer")); 1320 return FAIL; 1321 } 1322 } 1323 } 1324 1325 if (buf == NULL) // could not find it 1326 { 1327 if (start == DOBUF_FIRST) 1328 { 1329 // don't warn when deleting 1330 if (!unload) 1331 semsg(_(e_nobufnr), count); 1332 } 1333 else if (dir == FORWARD) 1334 emsg(_("E87: Cannot go beyond last buffer")); 1335 else 1336 emsg(_("E88: Cannot go before first buffer")); 1337 return FAIL; 1338 } 1339 #ifdef FEAT_PROP_POPUP 1340 if ((flags & DOBUF_NOPOPUP) && bt_popup(buf) 1341 # ifdef FEAT_TERMINAL 1342 && !bt_terminal(buf) 1343 #endif 1344 ) 1345 return OK; 1346 #endif 1347 1348 #ifdef FEAT_GUI 1349 need_mouse_correct = TRUE; 1350 #endif 1351 1352 /* 1353 * delete buffer buf from memory and/or the list 1354 */ 1355 if (unload) 1356 { 1357 int forward; 1358 bufref_T bufref; 1359 1360 if (!can_unload_buffer(buf)) 1361 return FAIL; 1362 1363 set_bufref(&bufref, buf); 1364 1365 // When unloading or deleting a buffer that's already unloaded and 1366 // unlisted: fail silently. 1367 if (action != DOBUF_WIPE && action != DOBUF_WIPE_REUSE 1368 && buf->b_ml.ml_mfp == NULL && !buf->b_p_bl) 1369 return FAIL; 1370 1371 if ((flags & DOBUF_FORCEIT) == 0 && bufIsChanged(buf)) 1372 { 1373 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 1374 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && p_write) 1375 { 1376 dialog_changed(buf, FALSE); 1377 if (!bufref_valid(&bufref)) 1378 // Autocommand deleted buffer, oops! It's not changed 1379 // now. 1380 return FAIL; 1381 // If it's still changed fail silently, the dialog already 1382 // mentioned why it fails. 1383 if (bufIsChanged(buf)) 1384 return FAIL; 1385 } 1386 else 1387 #endif 1388 { 1389 semsg(_("E89: No write since last change for buffer %d (add ! to override)"), 1390 buf->b_fnum); 1391 return FAIL; 1392 } 1393 } 1394 1395 // When closing the current buffer stop Visual mode. 1396 if (buf == curbuf && VIsual_active) 1397 end_visual_mode(); 1398 1399 /* 1400 * If deleting the last (listed) buffer, make it empty. 1401 * The last (listed) buffer cannot be unloaded. 1402 */ 1403 FOR_ALL_BUFFERS(bp) 1404 if (bp->b_p_bl && bp != buf) 1405 break; 1406 if (bp == NULL && buf == curbuf) 1407 return empty_curbuf(TRUE, (flags & DOBUF_FORCEIT), action); 1408 1409 /* 1410 * If the deleted buffer is the current one, close the current window 1411 * (unless it's the only window). Repeat this so long as we end up in 1412 * a window with this buffer. 1413 */ 1414 while (buf == curbuf 1415 && !(curwin->w_closing || curwin->w_buffer->b_locked > 0) 1416 && (!ONE_WINDOW || first_tabpage->tp_next != NULL)) 1417 { 1418 if (win_close(curwin, FALSE) == FAIL) 1419 break; 1420 } 1421 1422 /* 1423 * If the buffer to be deleted is not the current one, delete it here. 1424 */ 1425 if (buf != curbuf) 1426 { 1427 close_windows(buf, FALSE); 1428 if (buf != curbuf && bufref_valid(&bufref) && buf->b_nwindows <= 0) 1429 close_buffer(NULL, buf, action, FALSE, FALSE); 1430 return OK; 1431 } 1432 1433 /* 1434 * Deleting the current buffer: Need to find another buffer to go to. 1435 * There should be another, otherwise it would have been handled 1436 * above. However, autocommands may have deleted all buffers. 1437 * First use au_new_curbuf.br_buf, if it is valid. 1438 * Then prefer the buffer we most recently visited. 1439 * Else try to find one that is loaded, after the current buffer, 1440 * then before the current buffer. 1441 * Finally use any buffer. 1442 */ 1443 buf = NULL; // selected buffer 1444 bp = NULL; // used when no loaded buffer found 1445 if (au_new_curbuf.br_buf != NULL && bufref_valid(&au_new_curbuf)) 1446 buf = au_new_curbuf.br_buf; 1447 #ifdef FEAT_JUMPLIST 1448 else if (curwin->w_jumplistlen > 0) 1449 { 1450 int jumpidx; 1451 1452 jumpidx = curwin->w_jumplistidx - 1; 1453 if (jumpidx < 0) 1454 jumpidx = curwin->w_jumplistlen - 1; 1455 1456 forward = jumpidx; 1457 while (jumpidx != curwin->w_jumplistidx) 1458 { 1459 buf = buflist_findnr(curwin->w_jumplist[jumpidx].fmark.fnum); 1460 if (buf != NULL) 1461 { 1462 if (buf == curbuf || !buf->b_p_bl) 1463 buf = NULL; // skip current and unlisted bufs 1464 else if (buf->b_ml.ml_mfp == NULL) 1465 { 1466 // skip unloaded buf, but may keep it for later 1467 if (bp == NULL) 1468 bp = buf; 1469 buf = NULL; 1470 } 1471 } 1472 if (buf != NULL) // found a valid buffer: stop searching 1473 break; 1474 // advance to older entry in jump list 1475 if (!jumpidx && curwin->w_jumplistidx == curwin->w_jumplistlen) 1476 break; 1477 if (--jumpidx < 0) 1478 jumpidx = curwin->w_jumplistlen - 1; 1479 if (jumpidx == forward) // List exhausted for sure 1480 break; 1481 } 1482 } 1483 #endif 1484 1485 if (buf == NULL) // No previous buffer, Try 2'nd approach 1486 { 1487 forward = TRUE; 1488 buf = curbuf->b_next; 1489 for (;;) 1490 { 1491 if (buf == NULL) 1492 { 1493 if (!forward) // tried both directions 1494 break; 1495 buf = curbuf->b_prev; 1496 forward = FALSE; 1497 continue; 1498 } 1499 // in non-help buffer, try to skip help buffers, and vv 1500 if (buf->b_help == curbuf->b_help && buf->b_p_bl) 1501 { 1502 if (buf->b_ml.ml_mfp != NULL) // found loaded buffer 1503 break; 1504 if (bp == NULL) // remember unloaded buf for later 1505 bp = buf; 1506 } 1507 if (forward) 1508 buf = buf->b_next; 1509 else 1510 buf = buf->b_prev; 1511 } 1512 } 1513 if (buf == NULL) // No loaded buffer, use unloaded one 1514 buf = bp; 1515 if (buf == NULL) // No loaded buffer, find listed one 1516 { 1517 FOR_ALL_BUFFERS(buf) 1518 if (buf->b_p_bl && buf != curbuf) 1519 break; 1520 } 1521 if (buf == NULL) // Still no buffer, just take one 1522 { 1523 if (curbuf->b_next != NULL) 1524 buf = curbuf->b_next; 1525 else 1526 buf = curbuf->b_prev; 1527 } 1528 } 1529 1530 if (buf == NULL) 1531 { 1532 // Autocommands must have wiped out all other buffers. Only option 1533 // now is to make the current buffer empty. 1534 return empty_curbuf(FALSE, (flags & DOBUF_FORCEIT), action); 1535 } 1536 1537 /* 1538 * make buf current buffer 1539 */ 1540 if (action == DOBUF_SPLIT) // split window first 1541 { 1542 // If 'switchbuf' contains "useopen": jump to first window containing 1543 // "buf" if one exists 1544 if ((swb_flags & SWB_USEOPEN) && buf_jump_open_win(buf)) 1545 return OK; 1546 // If 'switchbuf' contains "usetab": jump to first window in any tab 1547 // page containing "buf" if one exists 1548 if ((swb_flags & SWB_USETAB) && buf_jump_open_tab(buf)) 1549 return OK; 1550 if (win_split(0, 0) == FAIL) 1551 return FAIL; 1552 } 1553 1554 // go to current buffer - nothing to do 1555 if (buf == curbuf) 1556 return OK; 1557 1558 /* 1559 * Check if the current buffer may be abandoned. 1560 */ 1561 if (action == DOBUF_GOTO && !can_abandon(curbuf, (flags & DOBUF_FORCEIT))) 1562 { 1563 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 1564 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && p_write) 1565 { 1566 bufref_T bufref; 1567 1568 set_bufref(&bufref, buf); 1569 dialog_changed(curbuf, FALSE); 1570 if (!bufref_valid(&bufref)) 1571 // Autocommand deleted buffer, oops! 1572 return FAIL; 1573 } 1574 if (bufIsChanged(curbuf)) 1575 #endif 1576 { 1577 no_write_message(); 1578 return FAIL; 1579 } 1580 } 1581 1582 // Go to the other buffer. 1583 set_curbuf(buf, action); 1584 1585 if (action == DOBUF_SPLIT) 1586 RESET_BINDING(curwin); // reset 'scrollbind' and 'cursorbind' 1587 1588 #if defined(FEAT_EVAL) 1589 if (aborting()) // autocmds may abort script processing 1590 return FAIL; 1591 #endif 1592 1593 return OK; 1594 } 1595 1596 int 1597 do_buffer( 1598 int action, 1599 int start, 1600 int dir, // FORWARD or BACKWARD 1601 int count, // buffer number or number of buffers 1602 int forceit) // TRUE when using ! 1603 { 1604 return do_buffer_ext(action, start, dir, count, 1605 forceit ? DOBUF_FORCEIT : 0); 1606 } 1607 1608 /* 1609 * do_bufdel() - delete or unload buffer(s) 1610 * 1611 * addr_count == 0: ":bdel" - delete current buffer 1612 * addr_count == 1: ":N bdel" or ":bdel N [N ..]" - first delete 1613 * buffer "end_bnr", then any other arguments. 1614 * addr_count == 2: ":N,N bdel" - delete buffers in range 1615 * 1616 * command can be DOBUF_UNLOAD (":bunload"), DOBUF_WIPE (":bwipeout") or 1617 * DOBUF_DEL (":bdel") 1618 * 1619 * Returns error message or NULL 1620 */ 1621 char * 1622 do_bufdel( 1623 int command, 1624 char_u *arg, // pointer to extra arguments 1625 int addr_count, 1626 int start_bnr, // first buffer number in a range 1627 int end_bnr, // buffer nr or last buffer nr in a range 1628 int forceit) 1629 { 1630 int do_current = 0; // delete current buffer? 1631 int deleted = 0; // number of buffers deleted 1632 char *errormsg = NULL; // return value 1633 int bnr; // buffer number 1634 char_u *p; 1635 1636 if (addr_count == 0) 1637 { 1638 (void)do_buffer(command, DOBUF_CURRENT, FORWARD, 0, forceit); 1639 } 1640 else 1641 { 1642 if (addr_count == 2) 1643 { 1644 if (*arg) // both range and argument is not allowed 1645 return ex_errmsg(e_trailing_arg, arg); 1646 bnr = start_bnr; 1647 } 1648 else // addr_count == 1 1649 bnr = end_bnr; 1650 1651 for ( ;!got_int; ui_breakcheck()) 1652 { 1653 /* 1654 * Delete the current buffer last, otherwise when the 1655 * current buffer is deleted, the next buffer becomes 1656 * the current one and will be loaded, which may then 1657 * also be deleted, etc. 1658 */ 1659 if (bnr == curbuf->b_fnum) 1660 do_current = bnr; 1661 else if (do_buffer_ext(command, DOBUF_FIRST, FORWARD, (int)bnr, 1662 DOBUF_NOPOPUP | (forceit ? DOBUF_FORCEIT : 0)) == OK) 1663 ++deleted; 1664 1665 /* 1666 * find next buffer number to delete/unload 1667 */ 1668 if (addr_count == 2) 1669 { 1670 if (++bnr > end_bnr) 1671 break; 1672 } 1673 else // addr_count == 1 1674 { 1675 arg = skipwhite(arg); 1676 if (*arg == NUL) 1677 break; 1678 if (!VIM_ISDIGIT(*arg)) 1679 { 1680 p = skiptowhite_esc(arg); 1681 bnr = buflist_findpat(arg, p, 1682 command == DOBUF_WIPE || command == DOBUF_WIPE_REUSE, 1683 FALSE, FALSE); 1684 if (bnr < 0) // failed 1685 break; 1686 arg = p; 1687 } 1688 else 1689 bnr = getdigits(&arg); 1690 } 1691 } 1692 if (!got_int && do_current && do_buffer(command, DOBUF_FIRST, 1693 FORWARD, do_current, forceit) == OK) 1694 ++deleted; 1695 1696 if (deleted == 0) 1697 { 1698 if (command == DOBUF_UNLOAD) 1699 STRCPY(IObuff, _("E515: No buffers were unloaded")); 1700 else if (command == DOBUF_DEL) 1701 STRCPY(IObuff, _("E516: No buffers were deleted")); 1702 else 1703 STRCPY(IObuff, _("E517: No buffers were wiped out")); 1704 errormsg = (char *)IObuff; 1705 } 1706 else if (deleted >= p_report) 1707 { 1708 if (command == DOBUF_UNLOAD) 1709 smsg(NGETTEXT("%d buffer unloaded", 1710 "%d buffers unloaded", deleted), deleted); 1711 else if (command == DOBUF_DEL) 1712 smsg(NGETTEXT("%d buffer deleted", 1713 "%d buffers deleted", deleted), deleted); 1714 else 1715 smsg(NGETTEXT("%d buffer wiped out", 1716 "%d buffers wiped out", deleted), deleted); 1717 } 1718 } 1719 1720 1721 return errormsg; 1722 } 1723 1724 /* 1725 * Set current buffer to "buf". Executes autocommands and closes current 1726 * buffer. "action" tells how to close the current buffer: 1727 * DOBUF_GOTO free or hide it 1728 * DOBUF_SPLIT nothing 1729 * DOBUF_UNLOAD unload it 1730 * DOBUF_DEL delete it 1731 * DOBUF_WIPE wipe it out 1732 * DOBUF_WIPE_REUSE wipe it out and add to "buf_reuse" 1733 */ 1734 void 1735 set_curbuf(buf_T *buf, int action) 1736 { 1737 buf_T *prevbuf; 1738 int unload = (action == DOBUF_UNLOAD || action == DOBUF_DEL 1739 || action == DOBUF_WIPE || action == DOBUF_WIPE_REUSE); 1740 #ifdef FEAT_SYN_HL 1741 long old_tw = curbuf->b_p_tw; 1742 #endif 1743 bufref_T newbufref; 1744 bufref_T prevbufref; 1745 1746 setpcmark(); 1747 if ((cmdmod.cmod_flags & CMOD_KEEPALT) == 0) 1748 curwin->w_alt_fnum = curbuf->b_fnum; // remember alternate file 1749 buflist_altfpos(curwin); // remember curpos 1750 1751 // Don't restart Select mode after switching to another buffer. 1752 VIsual_reselect = FALSE; 1753 1754 // close_windows() or apply_autocmds() may change curbuf and wipe out "buf" 1755 prevbuf = curbuf; 1756 set_bufref(&prevbufref, prevbuf); 1757 set_bufref(&newbufref, buf); 1758 1759 // Autocommands may delete the current buffer and/or the buffer we want to 1760 // go to. In those cases don't close the buffer. 1761 if (!apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf) 1762 || (bufref_valid(&prevbufref) 1763 && bufref_valid(&newbufref) 1764 #ifdef FEAT_EVAL 1765 && !aborting() 1766 #endif 1767 )) 1768 { 1769 #ifdef FEAT_SYN_HL 1770 if (prevbuf == curwin->w_buffer) 1771 reset_synblock(curwin); 1772 #endif 1773 if (unload) 1774 close_windows(prevbuf, FALSE); 1775 #if defined(FEAT_EVAL) 1776 if (bufref_valid(&prevbufref) && !aborting()) 1777 #else 1778 if (bufref_valid(&prevbufref)) 1779 #endif 1780 { 1781 win_T *previouswin = curwin; 1782 1783 if (prevbuf == curbuf) 1784 u_sync(FALSE); 1785 close_buffer(prevbuf == curwin->w_buffer ? curwin : NULL, prevbuf, 1786 unload ? action : (action == DOBUF_GOTO 1787 && !buf_hide(prevbuf) 1788 && !bufIsChanged(prevbuf)) ? DOBUF_UNLOAD : 0, 1789 FALSE, FALSE); 1790 if (curwin != previouswin && win_valid(previouswin)) 1791 // autocommands changed curwin, Grr! 1792 curwin = previouswin; 1793 } 1794 } 1795 // An autocommand may have deleted "buf", already entered it (e.g., when 1796 // it did ":bunload") or aborted the script processing. 1797 // If curwin->w_buffer is null, enter_buffer() will make it valid again 1798 if ((buf_valid(buf) && buf != curbuf 1799 #ifdef FEAT_EVAL 1800 && !aborting() 1801 #endif 1802 ) || curwin->w_buffer == NULL) 1803 { 1804 enter_buffer(buf); 1805 #ifdef FEAT_SYN_HL 1806 if (old_tw != curbuf->b_p_tw) 1807 check_colorcolumn(curwin); 1808 #endif 1809 } 1810 } 1811 1812 /* 1813 * Enter a new current buffer. 1814 * Old curbuf must have been abandoned already! This also means "curbuf" may 1815 * be pointing to freed memory. 1816 */ 1817 static void 1818 enter_buffer(buf_T *buf) 1819 { 1820 // Get the buffer in the current window. 1821 curwin->w_buffer = buf; 1822 curbuf = buf; 1823 ++curbuf->b_nwindows; 1824 1825 // Copy buffer and window local option values. Not for a help buffer. 1826 buf_copy_options(buf, BCO_ENTER | BCO_NOHELP); 1827 if (!buf->b_help) 1828 get_winopts(buf); 1829 #ifdef FEAT_FOLDING 1830 else 1831 // Remove all folds in the window. 1832 clearFolding(curwin); 1833 foldUpdateAll(curwin); // update folds (later). 1834 #endif 1835 1836 #ifdef FEAT_DIFF 1837 if (curwin->w_p_diff) 1838 diff_buf_add(curbuf); 1839 #endif 1840 1841 #ifdef FEAT_SYN_HL 1842 curwin->w_s = &(curbuf->b_s); 1843 #endif 1844 1845 // Cursor on first line by default. 1846 curwin->w_cursor.lnum = 1; 1847 curwin->w_cursor.col = 0; 1848 curwin->w_cursor.coladd = 0; 1849 curwin->w_set_curswant = TRUE; 1850 curwin->w_topline_was_set = FALSE; 1851 1852 // mark cursor position as being invalid 1853 curwin->w_valid = 0; 1854 1855 buflist_setfpos(curbuf, curwin, curbuf->b_last_cursor.lnum, 1856 curbuf->b_last_cursor.col, TRUE); 1857 1858 // Make sure the buffer is loaded. 1859 if (curbuf->b_ml.ml_mfp == NULL) // need to load the file 1860 { 1861 // If there is no filetype, allow for detecting one. Esp. useful for 1862 // ":ball" used in a autocommand. If there already is a filetype we 1863 // might prefer to keep it. 1864 if (*curbuf->b_p_ft == NUL) 1865 did_filetype = FALSE; 1866 1867 open_buffer(FALSE, NULL, 0); 1868 } 1869 else 1870 { 1871 if (!msg_silent && !shortmess(SHM_FILEINFO)) 1872 need_fileinfo = TRUE; // display file info after redraw 1873 1874 // check if file changed 1875 (void)buf_check_timestamp(curbuf, FALSE); 1876 1877 curwin->w_topline = 1; 1878 #ifdef FEAT_DIFF 1879 curwin->w_topfill = 0; 1880 #endif 1881 apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf); 1882 apply_autocmds(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf); 1883 } 1884 1885 // If autocommands did not change the cursor position, restore cursor lnum 1886 // and possibly cursor col. 1887 if (curwin->w_cursor.lnum == 1 && inindent(0)) 1888 buflist_getfpos(); 1889 1890 check_arg_idx(curwin); // check for valid arg_idx 1891 #ifdef FEAT_TITLE 1892 maketitle(); 1893 #endif 1894 // when autocmds didn't change it 1895 if (curwin->w_topline == 1 && !curwin->w_topline_was_set) 1896 scroll_cursor_halfway(FALSE); // redisplay at correct position 1897 1898 #ifdef FEAT_NETBEANS_INTG 1899 // Send fileOpened event because we've changed buffers. 1900 netbeans_file_activated(curbuf); 1901 #endif 1902 1903 // Change directories when the 'acd' option is set. 1904 DO_AUTOCHDIR; 1905 1906 #ifdef FEAT_KEYMAP 1907 if (curbuf->b_kmap_state & KEYMAP_INIT) 1908 (void)keymap_init(); 1909 #endif 1910 #ifdef FEAT_SPELL 1911 // May need to set the spell language. Can only do this after the buffer 1912 // has been properly setup. 1913 if (!curbuf->b_help && curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL) 1914 (void)did_set_spelllang(curwin); 1915 #endif 1916 #ifdef FEAT_VIMINFO 1917 curbuf->b_last_used = vim_time(); 1918 #endif 1919 1920 redraw_later(NOT_VALID); 1921 } 1922 1923 #if defined(FEAT_AUTOCHDIR) || defined(PROTO) 1924 /* 1925 * Change to the directory of the current buffer. 1926 * Don't do this while still starting up. 1927 */ 1928 void 1929 do_autochdir(void) 1930 { 1931 if ((starting == 0 || test_autochdir) 1932 && curbuf->b_ffname != NULL 1933 && vim_chdirfile(curbuf->b_ffname, "auto") == OK) 1934 shorten_fnames(TRUE); 1935 } 1936 #endif 1937 1938 void 1939 no_write_message(void) 1940 { 1941 #ifdef FEAT_TERMINAL 1942 if (term_job_running(curbuf->b_term)) 1943 emsg(_("E948: Job still running (add ! to end the job)")); 1944 else 1945 #endif 1946 emsg(_(e_no_write_since_last_change_add_bang_to_override)); 1947 } 1948 1949 void 1950 no_write_message_nobang(buf_T *buf UNUSED) 1951 { 1952 #ifdef FEAT_TERMINAL 1953 if (term_job_running(buf->b_term)) 1954 emsg(_("E948: Job still running")); 1955 else 1956 #endif 1957 emsg(_(e_no_write_since_last_change)); 1958 } 1959 1960 /* 1961 * functions for dealing with the buffer list 1962 */ 1963 1964 /* 1965 * Return TRUE if the current buffer is empty, unnamed, unmodified and used in 1966 * only one window. That means it can be re-used. 1967 */ 1968 int 1969 curbuf_reusable(void) 1970 { 1971 return (curbuf != NULL 1972 && curbuf->b_ffname == NULL 1973 && curbuf->b_nwindows <= 1 1974 && (curbuf->b_ml.ml_mfp == NULL || BUFEMPTY()) 1975 #if defined(FEAT_QUICKFIX) 1976 && !bt_quickfix(curbuf) 1977 #endif 1978 && !curbufIsChanged()); 1979 } 1980 1981 /* 1982 * Add a file name to the buffer list. Return a pointer to the buffer. 1983 * If the same file name already exists return a pointer to that buffer. 1984 * If it does not exist, or if fname == NULL, a new entry is created. 1985 * If (flags & BLN_CURBUF) is TRUE, may use current buffer. 1986 * If (flags & BLN_LISTED) is TRUE, add new buffer to buffer list. 1987 * If (flags & BLN_DUMMY) is TRUE, don't count it as a real buffer. 1988 * If (flags & BLN_NEW) is TRUE, don't use an existing buffer. 1989 * If (flags & BLN_NOOPT) is TRUE, don't copy options from the current buffer 1990 * if the buffer already exists. 1991 * If (flags & BLN_REUSE) is TRUE, may use buffer number from "buf_reuse". 1992 * This is the ONLY way to create a new buffer. 1993 */ 1994 buf_T * 1995 buflist_new( 1996 char_u *ffname_arg, // full path of fname or relative 1997 char_u *sfname_arg, // short fname or NULL 1998 linenr_T lnum, // preferred cursor line 1999 int flags) // BLN_ defines 2000 { 2001 char_u *ffname = ffname_arg; 2002 char_u *sfname = sfname_arg; 2003 buf_T *buf; 2004 #ifdef UNIX 2005 stat_T st; 2006 #endif 2007 2008 if (top_file_num == 1) 2009 hash_init(&buf_hashtab); 2010 2011 fname_expand(curbuf, &ffname, &sfname); // will allocate ffname 2012 2013 /* 2014 * If file name already exists in the list, update the entry. 2015 */ 2016 #ifdef UNIX 2017 // On Unix we can use inode numbers when the file exists. Works better 2018 // for hard links. 2019 if (sfname == NULL || mch_stat((char *)sfname, &st) < 0) 2020 st.st_dev = (dev_T)-1; 2021 #endif 2022 if (ffname != NULL && !(flags & (BLN_DUMMY | BLN_NEW)) && (buf = 2023 #ifdef UNIX 2024 buflist_findname_stat(ffname, &st) 2025 #else 2026 buflist_findname(ffname) 2027 #endif 2028 ) != NULL) 2029 { 2030 vim_free(ffname); 2031 if (lnum != 0) 2032 buflist_setfpos(buf, (flags & BLN_NOCURWIN) ? NULL : curwin, 2033 lnum, (colnr_T)0, FALSE); 2034 2035 if ((flags & BLN_NOOPT) == 0) 2036 // copy the options now, if 'cpo' doesn't have 's' and not done 2037 // already 2038 buf_copy_options(buf, 0); 2039 2040 if ((flags & BLN_LISTED) && !buf->b_p_bl) 2041 { 2042 bufref_T bufref; 2043 2044 buf->b_p_bl = TRUE; 2045 set_bufref(&bufref, buf); 2046 if (!(flags & BLN_DUMMY)) 2047 { 2048 if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf) 2049 && !bufref_valid(&bufref)) 2050 return NULL; 2051 } 2052 } 2053 return buf; 2054 } 2055 2056 /* 2057 * If the current buffer has no name and no contents, use the current 2058 * buffer. Otherwise: Need to allocate a new buffer structure. 2059 * 2060 * This is the ONLY place where a new buffer structure is allocated! 2061 * (A spell file buffer is allocated in spell.c, but that's not a normal 2062 * buffer.) 2063 */ 2064 buf = NULL; 2065 if ((flags & BLN_CURBUF) && curbuf_reusable()) 2066 { 2067 buf = curbuf; 2068 // It's like this buffer is deleted. Watch out for autocommands that 2069 // change curbuf! If that happens, allocate a new buffer anyway. 2070 if (curbuf->b_p_bl) 2071 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf); 2072 if (buf == curbuf) 2073 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf); 2074 #ifdef FEAT_EVAL 2075 if (aborting()) // autocmds may abort script processing 2076 { 2077 vim_free(ffname); 2078 return NULL; 2079 } 2080 #endif 2081 if (buf == curbuf) 2082 { 2083 // Make sure 'bufhidden' and 'buftype' are empty 2084 clear_string_option(&buf->b_p_bh); 2085 clear_string_option(&buf->b_p_bt); 2086 } 2087 } 2088 if (buf != curbuf || curbuf == NULL) 2089 { 2090 buf = ALLOC_CLEAR_ONE(buf_T); 2091 if (buf == NULL) 2092 { 2093 vim_free(ffname); 2094 return NULL; 2095 } 2096 #ifdef FEAT_EVAL 2097 // init b: variables 2098 buf->b_vars = dict_alloc(); 2099 if (buf->b_vars == NULL) 2100 { 2101 vim_free(ffname); 2102 vim_free(buf); 2103 return NULL; 2104 } 2105 init_var_dict(buf->b_vars, &buf->b_bufvar, VAR_SCOPE); 2106 #endif 2107 init_changedtick(buf); 2108 } 2109 2110 if (ffname != NULL) 2111 { 2112 buf->b_ffname = ffname; 2113 buf->b_sfname = vim_strsave(sfname); 2114 } 2115 2116 clear_wininfo(buf); 2117 buf->b_wininfo = ALLOC_CLEAR_ONE(wininfo_T); 2118 2119 if ((ffname != NULL && (buf->b_ffname == NULL || buf->b_sfname == NULL)) 2120 || buf->b_wininfo == NULL) 2121 { 2122 if (buf->b_sfname != buf->b_ffname) 2123 VIM_CLEAR(buf->b_sfname); 2124 else 2125 buf->b_sfname = NULL; 2126 VIM_CLEAR(buf->b_ffname); 2127 if (buf != curbuf) 2128 free_buffer(buf); 2129 return NULL; 2130 } 2131 2132 if (buf == curbuf) 2133 { 2134 // free all things allocated for this buffer 2135 buf_freeall(buf, 0); 2136 if (buf != curbuf) // autocommands deleted the buffer! 2137 return NULL; 2138 #if defined(FEAT_EVAL) 2139 if (aborting()) // autocmds may abort script processing 2140 return NULL; 2141 #endif 2142 free_buffer_stuff(buf, FALSE); // delete local variables et al. 2143 2144 // Init the options. 2145 buf->b_p_initialized = FALSE; 2146 buf_copy_options(buf, BCO_ENTER); 2147 2148 #ifdef FEAT_KEYMAP 2149 // need to reload lmaps and set b:keymap_name 2150 curbuf->b_kmap_state |= KEYMAP_INIT; 2151 #endif 2152 } 2153 else 2154 { 2155 /* 2156 * put new buffer at the end of the buffer list 2157 */ 2158 buf->b_next = NULL; 2159 if (firstbuf == NULL) // buffer list is empty 2160 { 2161 buf->b_prev = NULL; 2162 firstbuf = buf; 2163 } 2164 else // append new buffer at end of list 2165 { 2166 lastbuf->b_next = buf; 2167 buf->b_prev = lastbuf; 2168 } 2169 lastbuf = buf; 2170 2171 if ((flags & BLN_REUSE) && buf_reuse.ga_len > 0) 2172 { 2173 // Recycle a previously used buffer number. Used for buffers which 2174 // are normally hidden, e.g. in a popup window. Avoids that the 2175 // buffer number grows rapidly. 2176 --buf_reuse.ga_len; 2177 buf->b_fnum = ((int *)buf_reuse.ga_data)[buf_reuse.ga_len]; 2178 2179 // Move buffer to the right place in the buffer list. 2180 while (buf->b_prev != NULL && buf->b_fnum < buf->b_prev->b_fnum) 2181 { 2182 buf_T *prev = buf->b_prev; 2183 2184 prev->b_next = buf->b_next; 2185 if (prev->b_next != NULL) 2186 prev->b_next->b_prev = prev; 2187 buf->b_next = prev; 2188 buf->b_prev = prev->b_prev; 2189 if (buf->b_prev != NULL) 2190 buf->b_prev->b_next = buf; 2191 prev->b_prev = buf; 2192 if (lastbuf == buf) 2193 lastbuf = prev; 2194 if (firstbuf == prev) 2195 firstbuf = buf; 2196 } 2197 } 2198 else 2199 buf->b_fnum = top_file_num++; 2200 if (top_file_num < 0) // wrap around (may cause duplicates) 2201 { 2202 emsg(_("W14: Warning: List of file names overflow")); 2203 if (emsg_silent == 0 && !in_assert_fails) 2204 { 2205 out_flush(); 2206 ui_delay(3001L, TRUE); // make sure it is noticed 2207 } 2208 top_file_num = 1; 2209 } 2210 buf_hashtab_add(buf); 2211 2212 /* 2213 * Always copy the options from the current buffer. 2214 */ 2215 buf_copy_options(buf, BCO_ALWAYS); 2216 } 2217 2218 buf->b_wininfo->wi_fpos.lnum = lnum; 2219 buf->b_wininfo->wi_win = curwin; 2220 2221 #ifdef FEAT_SYN_HL 2222 hash_init(&buf->b_s.b_keywtab); 2223 hash_init(&buf->b_s.b_keywtab_ic); 2224 #endif 2225 2226 buf->b_fname = buf->b_sfname; 2227 #ifdef UNIX 2228 if (st.st_dev == (dev_T)-1) 2229 buf->b_dev_valid = FALSE; 2230 else 2231 { 2232 buf->b_dev_valid = TRUE; 2233 buf->b_dev = st.st_dev; 2234 buf->b_ino = st.st_ino; 2235 } 2236 #endif 2237 buf->b_u_synced = TRUE; 2238 buf->b_flags = BF_CHECK_RO | BF_NEVERLOADED; 2239 if (flags & BLN_DUMMY) 2240 buf->b_flags |= BF_DUMMY; 2241 buf_clear_file(buf); 2242 clrallmarks(buf); // clear marks 2243 fmarks_check_names(buf); // check file marks for this file 2244 buf->b_p_bl = (flags & BLN_LISTED) ? TRUE : FALSE; // init 'buflisted' 2245 if (!(flags & BLN_DUMMY)) 2246 { 2247 bufref_T bufref; 2248 2249 // Tricky: these autocommands may change the buffer list. They could 2250 // also split the window with re-using the one empty buffer. This may 2251 // result in unexpectedly losing the empty buffer. 2252 set_bufref(&bufref, buf); 2253 if (apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, buf) 2254 && !bufref_valid(&bufref)) 2255 return NULL; 2256 if (flags & BLN_LISTED) 2257 { 2258 if (apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, buf) 2259 && !bufref_valid(&bufref)) 2260 return NULL; 2261 } 2262 #ifdef FEAT_EVAL 2263 if (aborting()) // autocmds may abort script processing 2264 return NULL; 2265 #endif 2266 } 2267 2268 return buf; 2269 } 2270 2271 /* 2272 * Free the memory for the options of a buffer. 2273 * If "free_p_ff" is TRUE also free 'fileformat', 'buftype' and 2274 * 'fileencoding'. 2275 */ 2276 void 2277 free_buf_options( 2278 buf_T *buf, 2279 int free_p_ff) 2280 { 2281 if (free_p_ff) 2282 { 2283 clear_string_option(&buf->b_p_fenc); 2284 clear_string_option(&buf->b_p_ff); 2285 clear_string_option(&buf->b_p_bh); 2286 clear_string_option(&buf->b_p_bt); 2287 } 2288 #ifdef FEAT_FIND_ID 2289 clear_string_option(&buf->b_p_def); 2290 clear_string_option(&buf->b_p_inc); 2291 # ifdef FEAT_EVAL 2292 clear_string_option(&buf->b_p_inex); 2293 # endif 2294 #endif 2295 #if defined(FEAT_CINDENT) && defined(FEAT_EVAL) 2296 clear_string_option(&buf->b_p_inde); 2297 clear_string_option(&buf->b_p_indk); 2298 #endif 2299 #if defined(FEAT_BEVAL) && defined(FEAT_EVAL) 2300 clear_string_option(&buf->b_p_bexpr); 2301 #endif 2302 #if defined(FEAT_CRYPT) 2303 clear_string_option(&buf->b_p_cm); 2304 #endif 2305 clear_string_option(&buf->b_p_fp); 2306 #if defined(FEAT_EVAL) 2307 clear_string_option(&buf->b_p_fex); 2308 #endif 2309 #ifdef FEAT_CRYPT 2310 # ifdef FEAT_SODIUM 2311 if (buf->b_p_key != NULL && (crypt_get_method_nr(buf) == CRYPT_M_SOD)) 2312 sodium_munlock(buf->b_p_key, STRLEN(buf->b_p_key)); 2313 # endif 2314 clear_string_option(&buf->b_p_key); 2315 #endif 2316 clear_string_option(&buf->b_p_kp); 2317 clear_string_option(&buf->b_p_mps); 2318 clear_string_option(&buf->b_p_fo); 2319 clear_string_option(&buf->b_p_flp); 2320 clear_string_option(&buf->b_p_isk); 2321 #ifdef FEAT_VARTABS 2322 clear_string_option(&buf->b_p_vsts); 2323 vim_free(buf->b_p_vsts_nopaste); 2324 buf->b_p_vsts_nopaste = NULL; 2325 vim_free(buf->b_p_vsts_array); 2326 buf->b_p_vsts_array = NULL; 2327 clear_string_option(&buf->b_p_vts); 2328 VIM_CLEAR(buf->b_p_vts_array); 2329 #endif 2330 #ifdef FEAT_KEYMAP 2331 clear_string_option(&buf->b_p_keymap); 2332 keymap_clear(&buf->b_kmap_ga); 2333 ga_clear(&buf->b_kmap_ga); 2334 #endif 2335 clear_string_option(&buf->b_p_com); 2336 #ifdef FEAT_FOLDING 2337 clear_string_option(&buf->b_p_cms); 2338 #endif 2339 clear_string_option(&buf->b_p_nf); 2340 #ifdef FEAT_SYN_HL 2341 clear_string_option(&buf->b_p_syn); 2342 clear_string_option(&buf->b_s.b_syn_isk); 2343 #endif 2344 #ifdef FEAT_SPELL 2345 clear_string_option(&buf->b_s.b_p_spc); 2346 clear_string_option(&buf->b_s.b_p_spf); 2347 vim_regfree(buf->b_s.b_cap_prog); 2348 buf->b_s.b_cap_prog = NULL; 2349 clear_string_option(&buf->b_s.b_p_spl); 2350 clear_string_option(&buf->b_s.b_p_spo); 2351 #endif 2352 #ifdef FEAT_SEARCHPATH 2353 clear_string_option(&buf->b_p_sua); 2354 #endif 2355 clear_string_option(&buf->b_p_ft); 2356 #ifdef FEAT_CINDENT 2357 clear_string_option(&buf->b_p_cink); 2358 clear_string_option(&buf->b_p_cino); 2359 #endif 2360 #if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT) 2361 clear_string_option(&buf->b_p_cinw); 2362 #endif 2363 clear_string_option(&buf->b_p_cpt); 2364 #ifdef FEAT_COMPL_FUNC 2365 clear_string_option(&buf->b_p_cfu); 2366 clear_string_option(&buf->b_p_ofu); 2367 #endif 2368 #ifdef FEAT_QUICKFIX 2369 clear_string_option(&buf->b_p_gp); 2370 clear_string_option(&buf->b_p_mp); 2371 clear_string_option(&buf->b_p_efm); 2372 #endif 2373 clear_string_option(&buf->b_p_ep); 2374 clear_string_option(&buf->b_p_path); 2375 clear_string_option(&buf->b_p_tags); 2376 clear_string_option(&buf->b_p_tc); 2377 #ifdef FEAT_EVAL 2378 clear_string_option(&buf->b_p_tfu); 2379 #endif 2380 clear_string_option(&buf->b_p_dict); 2381 clear_string_option(&buf->b_p_tsr); 2382 #ifdef FEAT_TEXTOBJ 2383 clear_string_option(&buf->b_p_qe); 2384 #endif 2385 buf->b_p_ar = -1; 2386 buf->b_p_ul = NO_LOCAL_UNDOLEVEL; 2387 #ifdef FEAT_LISP 2388 clear_string_option(&buf->b_p_lw); 2389 #endif 2390 clear_string_option(&buf->b_p_bkc); 2391 clear_string_option(&buf->b_p_menc); 2392 } 2393 2394 /* 2395 * Get alternate file "n". 2396 * Set linenr to "lnum" or altfpos.lnum if "lnum" == 0. 2397 * Also set cursor column to altfpos.col if 'startofline' is not set. 2398 * if (options & GETF_SETMARK) call setpcmark() 2399 * if (options & GETF_ALT) we are jumping to an alternate file. 2400 * if (options & GETF_SWITCH) respect 'switchbuf' settings when jumping 2401 * 2402 * Return FAIL for failure, OK for success. 2403 */ 2404 int 2405 buflist_getfile( 2406 int n, 2407 linenr_T lnum, 2408 int options, 2409 int forceit) 2410 { 2411 buf_T *buf; 2412 win_T *wp = NULL; 2413 pos_T *fpos; 2414 colnr_T col; 2415 2416 buf = buflist_findnr(n); 2417 if (buf == NULL) 2418 { 2419 if ((options & GETF_ALT) && n == 0) 2420 emsg(_(e_no_alternate_file)); 2421 else 2422 semsg(_("E92: Buffer %d not found"), n); 2423 return FAIL; 2424 } 2425 2426 // if alternate file is the current buffer, nothing to do 2427 if (buf == curbuf) 2428 return OK; 2429 2430 if (text_locked()) 2431 { 2432 text_locked_msg(); 2433 return FAIL; 2434 } 2435 if (curbuf_locked()) 2436 return FAIL; 2437 2438 // altfpos may be changed by getfile(), get it now 2439 if (lnum == 0) 2440 { 2441 fpos = buflist_findfpos(buf); 2442 lnum = fpos->lnum; 2443 col = fpos->col; 2444 } 2445 else 2446 col = 0; 2447 2448 if (options & GETF_SWITCH) 2449 { 2450 // If 'switchbuf' contains "useopen": jump to first window containing 2451 // "buf" if one exists 2452 if (swb_flags & SWB_USEOPEN) 2453 wp = buf_jump_open_win(buf); 2454 2455 // If 'switchbuf' contains "usetab": jump to first window in any tab 2456 // page containing "buf" if one exists 2457 if (wp == NULL && (swb_flags & SWB_USETAB)) 2458 wp = buf_jump_open_tab(buf); 2459 2460 // If 'switchbuf' contains "split", "vsplit" or "newtab" and the 2461 // current buffer isn't empty: open new tab or window 2462 if (wp == NULL && (swb_flags & (SWB_VSPLIT | SWB_SPLIT | SWB_NEWTAB)) 2463 && !BUFEMPTY()) 2464 { 2465 if (swb_flags & SWB_NEWTAB) 2466 tabpage_new(); 2467 else if (win_split(0, (swb_flags & SWB_VSPLIT) ? WSP_VERT : 0) 2468 == FAIL) 2469 return FAIL; 2470 RESET_BINDING(curwin); 2471 } 2472 } 2473 2474 ++RedrawingDisabled; 2475 if (GETFILE_SUCCESS(getfile(buf->b_fnum, NULL, NULL, 2476 (options & GETF_SETMARK), lnum, forceit))) 2477 { 2478 --RedrawingDisabled; 2479 2480 // cursor is at to BOL and w_cursor.lnum is checked due to getfile() 2481 if (!p_sol && col != 0) 2482 { 2483 curwin->w_cursor.col = col; 2484 check_cursor_col(); 2485 curwin->w_cursor.coladd = 0; 2486 curwin->w_set_curswant = TRUE; 2487 } 2488 return OK; 2489 } 2490 --RedrawingDisabled; 2491 return FAIL; 2492 } 2493 2494 /* 2495 * go to the last know line number for the current buffer 2496 */ 2497 static void 2498 buflist_getfpos(void) 2499 { 2500 pos_T *fpos; 2501 2502 fpos = buflist_findfpos(curbuf); 2503 2504 curwin->w_cursor.lnum = fpos->lnum; 2505 check_cursor_lnum(); 2506 2507 if (p_sol) 2508 curwin->w_cursor.col = 0; 2509 else 2510 { 2511 curwin->w_cursor.col = fpos->col; 2512 check_cursor_col(); 2513 curwin->w_cursor.coladd = 0; 2514 curwin->w_set_curswant = TRUE; 2515 } 2516 } 2517 2518 #if defined(FEAT_QUICKFIX) || defined(FEAT_EVAL) || defined(PROTO) 2519 /* 2520 * Find file in buffer list by name (it has to be for the current window). 2521 * Returns NULL if not found. 2522 */ 2523 buf_T * 2524 buflist_findname_exp(char_u *fname) 2525 { 2526 char_u *ffname; 2527 buf_T *buf = NULL; 2528 2529 // First make the name into a full path name 2530 ffname = FullName_save(fname, 2531 #ifdef UNIX 2532 TRUE // force expansion, get rid of symbolic links 2533 #else 2534 FALSE 2535 #endif 2536 ); 2537 if (ffname != NULL) 2538 { 2539 buf = buflist_findname(ffname); 2540 vim_free(ffname); 2541 } 2542 return buf; 2543 } 2544 #endif 2545 2546 /* 2547 * Find file in buffer list by name (it has to be for the current window). 2548 * "ffname" must have a full path. 2549 * Skips dummy buffers. 2550 * Returns NULL if not found. 2551 */ 2552 buf_T * 2553 buflist_findname(char_u *ffname) 2554 { 2555 #ifdef UNIX 2556 stat_T st; 2557 2558 if (mch_stat((char *)ffname, &st) < 0) 2559 st.st_dev = (dev_T)-1; 2560 return buflist_findname_stat(ffname, &st); 2561 } 2562 2563 /* 2564 * Same as buflist_findname(), but pass the stat structure to avoid getting it 2565 * twice for the same file. 2566 * Returns NULL if not found. 2567 */ 2568 static buf_T * 2569 buflist_findname_stat( 2570 char_u *ffname, 2571 stat_T *stp) 2572 { 2573 #endif 2574 buf_T *buf; 2575 2576 // Start at the last buffer, expect to find a match sooner. 2577 FOR_ALL_BUFS_FROM_LAST(buf) 2578 if ((buf->b_flags & BF_DUMMY) == 0 && !otherfile_buf(buf, ffname 2579 #ifdef UNIX 2580 , stp 2581 #endif 2582 )) 2583 return buf; 2584 return NULL; 2585 } 2586 2587 /* 2588 * Find file in buffer list by a regexp pattern. 2589 * Return fnum of the found buffer. 2590 * Return < 0 for error. 2591 */ 2592 int 2593 buflist_findpat( 2594 char_u *pattern, 2595 char_u *pattern_end, // pointer to first char after pattern 2596 int unlisted, // find unlisted buffers 2597 int diffmode UNUSED, // find diff-mode buffers only 2598 int curtab_only) // find buffers in current tab only 2599 { 2600 buf_T *buf; 2601 int match = -1; 2602 int find_listed; 2603 char_u *pat; 2604 char_u *patend; 2605 int attempt; 2606 char_u *p; 2607 int toggledollar; 2608 2609 // "%" is current file, "%%" or "#" is alternate file 2610 if ((pattern_end == pattern + 1 && (*pattern == '%' || *pattern == '#')) 2611 || (in_vim9script() && pattern_end == pattern + 2 2612 && pattern[0] == '%' && pattern[1] == '%')) 2613 { 2614 if (*pattern == '#' || pattern_end == pattern + 2) 2615 match = curwin->w_alt_fnum; 2616 else 2617 match = curbuf->b_fnum; 2618 #ifdef FEAT_DIFF 2619 if (diffmode && !diff_mode_buf(buflist_findnr(match))) 2620 match = -1; 2621 #endif 2622 } 2623 2624 /* 2625 * Try four ways of matching a listed buffer: 2626 * attempt == 0: without '^' or '$' (at any position) 2627 * attempt == 1: with '^' at start (only at position 0) 2628 * attempt == 2: with '$' at end (only match at end) 2629 * attempt == 3: with '^' at start and '$' at end (only full match) 2630 * Repeat this for finding an unlisted buffer if there was no matching 2631 * listed buffer. 2632 */ 2633 else 2634 { 2635 pat = file_pat_to_reg_pat(pattern, pattern_end, NULL, FALSE); 2636 if (pat == NULL) 2637 return -1; 2638 patend = pat + STRLEN(pat) - 1; 2639 toggledollar = (patend > pat && *patend == '$'); 2640 2641 // First try finding a listed buffer. If not found and "unlisted" 2642 // is TRUE, try finding an unlisted buffer. 2643 find_listed = TRUE; 2644 for (;;) 2645 { 2646 for (attempt = 0; attempt <= 3; ++attempt) 2647 { 2648 regmatch_T regmatch; 2649 2650 // may add '^' and '$' 2651 if (toggledollar) 2652 *patend = (attempt < 2) ? NUL : '$'; // add/remove '$' 2653 p = pat; 2654 if (*p == '^' && !(attempt & 1)) // add/remove '^' 2655 ++p; 2656 regmatch.regprog = vim_regcomp(p, magic_isset() ? RE_MAGIC : 0); 2657 if (regmatch.regprog == NULL) 2658 { 2659 vim_free(pat); 2660 return -1; 2661 } 2662 2663 FOR_ALL_BUFS_FROM_LAST(buf) 2664 if (buf->b_p_bl == find_listed 2665 #ifdef FEAT_DIFF 2666 && (!diffmode || diff_mode_buf(buf)) 2667 #endif 2668 && buflist_match(®match, buf, FALSE) != NULL) 2669 { 2670 if (curtab_only) 2671 { 2672 // Ignore the match if the buffer is not open in 2673 // the current tab. 2674 win_T *wp; 2675 2676 FOR_ALL_WINDOWS(wp) 2677 if (wp->w_buffer == buf) 2678 break; 2679 if (wp == NULL) 2680 continue; 2681 } 2682 if (match >= 0) // already found a match 2683 { 2684 match = -2; 2685 break; 2686 } 2687 match = buf->b_fnum; // remember first match 2688 } 2689 2690 vim_regfree(regmatch.regprog); 2691 if (match >= 0) // found one match 2692 break; 2693 } 2694 2695 // Only search for unlisted buffers if there was no match with 2696 // a listed buffer. 2697 if (!unlisted || !find_listed || match != -1) 2698 break; 2699 find_listed = FALSE; 2700 } 2701 2702 vim_free(pat); 2703 } 2704 2705 if (match == -2) 2706 semsg(_("E93: More than one match for %s"), pattern); 2707 else if (match < 0) 2708 semsg(_("E94: No matching buffer for %s"), pattern); 2709 return match; 2710 } 2711 2712 #ifdef FEAT_VIMINFO 2713 typedef struct { 2714 buf_T *buf; 2715 char_u *match; 2716 } bufmatch_T; 2717 #endif 2718 2719 /* 2720 * Find all buffer names that match. 2721 * For command line expansion of ":buf" and ":sbuf". 2722 * Return OK if matches found, FAIL otherwise. 2723 */ 2724 int 2725 ExpandBufnames( 2726 char_u *pat, 2727 int *num_file, 2728 char_u ***file, 2729 int options) 2730 { 2731 int count = 0; 2732 buf_T *buf; 2733 int round; 2734 char_u *p; 2735 int attempt; 2736 char_u *patc; 2737 #ifdef FEAT_VIMINFO 2738 bufmatch_T *matches = NULL; 2739 #endif 2740 2741 *num_file = 0; // return values in case of FAIL 2742 *file = NULL; 2743 2744 #ifdef FEAT_DIFF 2745 if ((options & BUF_DIFF_FILTER) && !curwin->w_p_diff) 2746 return FAIL; 2747 #endif 2748 2749 // Make a copy of "pat" and change "^" to "\(^\|[\/]\)". 2750 if (*pat == '^') 2751 { 2752 patc = alloc(STRLEN(pat) + 11); 2753 if (patc == NULL) 2754 return FAIL; 2755 STRCPY(patc, "\\(^\\|[\\/]\\)"); 2756 STRCPY(patc + 11, pat + 1); 2757 } 2758 else 2759 patc = pat; 2760 2761 /* 2762 * attempt == 0: try match with '\<', match at start of word 2763 * attempt == 1: try match without '\<', match anywhere 2764 */ 2765 for (attempt = 0; attempt <= 1; ++attempt) 2766 { 2767 regmatch_T regmatch; 2768 2769 if (attempt > 0 && patc == pat) 2770 break; // there was no anchor, no need to try again 2771 regmatch.regprog = vim_regcomp(patc + attempt * 11, RE_MAGIC); 2772 if (regmatch.regprog == NULL) 2773 { 2774 if (patc != pat) 2775 vim_free(patc); 2776 return FAIL; 2777 } 2778 2779 /* 2780 * round == 1: Count the matches. 2781 * round == 2: Build the array to keep the matches. 2782 */ 2783 for (round = 1; round <= 2; ++round) 2784 { 2785 count = 0; 2786 FOR_ALL_BUFFERS(buf) 2787 { 2788 if (!buf->b_p_bl) // skip unlisted buffers 2789 continue; 2790 #ifdef FEAT_DIFF 2791 if (options & BUF_DIFF_FILTER) 2792 // Skip buffers not suitable for 2793 // :diffget or :diffput completion. 2794 if (buf == curbuf || !diff_mode_buf(buf)) 2795 continue; 2796 #endif 2797 2798 p = buflist_match(®match, buf, p_wic); 2799 if (p != NULL) 2800 { 2801 if (round == 1) 2802 ++count; 2803 else 2804 { 2805 if (options & WILD_HOME_REPLACE) 2806 p = home_replace_save(buf, p); 2807 else 2808 p = vim_strsave(p); 2809 #ifdef FEAT_VIMINFO 2810 if (matches != NULL) 2811 { 2812 matches[count].buf = buf; 2813 matches[count].match = p; 2814 count++; 2815 } 2816 else 2817 #endif 2818 (*file)[count++] = p; 2819 } 2820 } 2821 } 2822 if (count == 0) // no match found, break here 2823 break; 2824 if (round == 1) 2825 { 2826 *file = ALLOC_MULT(char_u *, count); 2827 if (*file == NULL) 2828 { 2829 vim_regfree(regmatch.regprog); 2830 if (patc != pat) 2831 vim_free(patc); 2832 return FAIL; 2833 } 2834 #ifdef FEAT_VIMINFO 2835 if (options & WILD_BUFLASTUSED) 2836 matches = ALLOC_MULT(bufmatch_T, count); 2837 #endif 2838 } 2839 } 2840 vim_regfree(regmatch.regprog); 2841 if (count) // match(es) found, break here 2842 break; 2843 } 2844 2845 if (patc != pat) 2846 vim_free(patc); 2847 2848 #ifdef FEAT_VIMINFO 2849 if (matches != NULL) 2850 { 2851 int i; 2852 if (count > 1) 2853 qsort(matches, count, sizeof(bufmatch_T), buf_compare); 2854 // if the current buffer is first in the list, place it at the end 2855 if (matches[0].buf == curbuf) 2856 { 2857 for (i = 1; i < count; i++) 2858 (*file)[i-1] = matches[i].match; 2859 (*file)[count-1] = matches[0].match; 2860 } 2861 else 2862 { 2863 for (i = 0; i < count; i++) 2864 (*file)[i] = matches[i].match; 2865 } 2866 vim_free(matches); 2867 } 2868 #endif 2869 2870 *num_file = count; 2871 return (count == 0 ? FAIL : OK); 2872 } 2873 2874 /* 2875 * Check for a match on the file name for buffer "buf" with regprog "prog". 2876 */ 2877 static char_u * 2878 buflist_match( 2879 regmatch_T *rmp, 2880 buf_T *buf, 2881 int ignore_case) // when TRUE ignore case, when FALSE use 'fic' 2882 { 2883 char_u *match; 2884 2885 // First try the short file name, then the long file name. 2886 match = fname_match(rmp, buf->b_sfname, ignore_case); 2887 if (match == NULL) 2888 match = fname_match(rmp, buf->b_ffname, ignore_case); 2889 2890 return match; 2891 } 2892 2893 /* 2894 * Try matching the regexp in "prog" with file name "name". 2895 * Return "name" when there is a match, NULL when not. 2896 */ 2897 static char_u * 2898 fname_match( 2899 regmatch_T *rmp, 2900 char_u *name, 2901 int ignore_case) // when TRUE ignore case, when FALSE use 'fic' 2902 { 2903 char_u *match = NULL; 2904 char_u *p; 2905 2906 if (name != NULL) 2907 { 2908 // Ignore case when 'fileignorecase' or the argument is set. 2909 rmp->rm_ic = p_fic || ignore_case; 2910 if (vim_regexec(rmp, name, (colnr_T)0)) 2911 match = name; 2912 else 2913 { 2914 // Replace $(HOME) with '~' and try matching again. 2915 p = home_replace_save(NULL, name); 2916 if (p != NULL && vim_regexec(rmp, p, (colnr_T)0)) 2917 match = name; 2918 vim_free(p); 2919 } 2920 } 2921 2922 return match; 2923 } 2924 2925 /* 2926 * Find a file in the buffer list by buffer number. 2927 */ 2928 buf_T * 2929 buflist_findnr(int nr) 2930 { 2931 char_u key[VIM_SIZEOF_INT * 2 + 1]; 2932 hashitem_T *hi; 2933 2934 if (nr == 0) 2935 nr = curwin->w_alt_fnum; 2936 sprintf((char *)key, "%x", nr); 2937 hi = hash_find(&buf_hashtab, key); 2938 2939 if (!HASHITEM_EMPTY(hi)) 2940 return (buf_T *)(hi->hi_key 2941 - ((unsigned)(curbuf->b_key - (char_u *)curbuf))); 2942 return NULL; 2943 } 2944 2945 /* 2946 * Get name of file 'n' in the buffer list. 2947 * When the file has no name an empty string is returned. 2948 * home_replace() is used to shorten the file name (used for marks). 2949 * Returns a pointer to allocated memory, of NULL when failed. 2950 */ 2951 char_u * 2952 buflist_nr2name( 2953 int n, 2954 int fullname, 2955 int helptail) // for help buffers return tail only 2956 { 2957 buf_T *buf; 2958 2959 buf = buflist_findnr(n); 2960 if (buf == NULL) 2961 return NULL; 2962 return home_replace_save(helptail ? buf : NULL, 2963 fullname ? buf->b_ffname : buf->b_fname); 2964 } 2965 2966 /* 2967 * Set the "lnum" and "col" for the buffer "buf" and the current window. 2968 * When "copy_options" is TRUE save the local window option values. 2969 * When "lnum" is 0 only do the options. 2970 */ 2971 void 2972 buflist_setfpos( 2973 buf_T *buf, 2974 win_T *win, // may be NULL when using :badd 2975 linenr_T lnum, 2976 colnr_T col, 2977 int copy_options) 2978 { 2979 wininfo_T *wip; 2980 2981 FOR_ALL_BUF_WININFO(buf, wip) 2982 if (wip->wi_win == win) 2983 break; 2984 if (wip == NULL) 2985 { 2986 // allocate a new entry 2987 wip = ALLOC_CLEAR_ONE(wininfo_T); 2988 if (wip == NULL) 2989 return; 2990 wip->wi_win = win; 2991 if (lnum == 0) // set lnum even when it's 0 2992 lnum = 1; 2993 } 2994 else 2995 { 2996 // remove the entry from the list 2997 if (wip->wi_prev) 2998 wip->wi_prev->wi_next = wip->wi_next; 2999 else 3000 buf->b_wininfo = wip->wi_next; 3001 if (wip->wi_next) 3002 wip->wi_next->wi_prev = wip->wi_prev; 3003 if (copy_options && wip->wi_optset) 3004 { 3005 clear_winopt(&wip->wi_opt); 3006 #ifdef FEAT_FOLDING 3007 deleteFoldRecurse(&wip->wi_folds); 3008 #endif 3009 } 3010 } 3011 if (lnum != 0) 3012 { 3013 wip->wi_fpos.lnum = lnum; 3014 wip->wi_fpos.col = col; 3015 } 3016 if (copy_options && win != NULL) 3017 { 3018 // Save the window-specific option values. 3019 copy_winopt(&win->w_onebuf_opt, &wip->wi_opt); 3020 #ifdef FEAT_FOLDING 3021 wip->wi_fold_manual = win->w_fold_manual; 3022 cloneFoldGrowArray(&win->w_folds, &wip->wi_folds); 3023 #endif 3024 wip->wi_optset = TRUE; 3025 } 3026 3027 // insert the entry in front of the list 3028 wip->wi_next = buf->b_wininfo; 3029 buf->b_wininfo = wip; 3030 wip->wi_prev = NULL; 3031 if (wip->wi_next) 3032 wip->wi_next->wi_prev = wip; 3033 } 3034 3035 #ifdef FEAT_DIFF 3036 /* 3037 * Return TRUE when "wip" has 'diff' set and the diff is only for another tab 3038 * page. That's because a diff is local to a tab page. 3039 */ 3040 static int 3041 wininfo_other_tab_diff(wininfo_T *wip) 3042 { 3043 win_T *wp; 3044 3045 if (wip->wi_opt.wo_diff) 3046 { 3047 FOR_ALL_WINDOWS(wp) 3048 // return FALSE when it's a window in the current tab page, thus 3049 // the buffer was in diff mode here 3050 if (wip->wi_win == wp) 3051 return FALSE; 3052 return TRUE; 3053 } 3054 return FALSE; 3055 } 3056 #endif 3057 3058 /* 3059 * Find info for the current window in buffer "buf". 3060 * If not found, return the info for the most recently used window. 3061 * When "need_options" is TRUE skip entries where wi_optset is FALSE. 3062 * When "skip_diff_buffer" is TRUE avoid windows with 'diff' set that is in 3063 * another tab page. 3064 * Returns NULL when there isn't any info. 3065 */ 3066 static wininfo_T * 3067 find_wininfo( 3068 buf_T *buf, 3069 int need_options, 3070 int skip_diff_buffer UNUSED) 3071 { 3072 wininfo_T *wip; 3073 3074 FOR_ALL_BUF_WININFO(buf, wip) 3075 if (wip->wi_win == curwin 3076 #ifdef FEAT_DIFF 3077 && (!skip_diff_buffer || !wininfo_other_tab_diff(wip)) 3078 #endif 3079 3080 && (!need_options || wip->wi_optset)) 3081 break; 3082 3083 // If no wininfo for curwin, use the first in the list (that doesn't have 3084 // 'diff' set and is in another tab page). 3085 // If "need_options" is TRUE skip entries that don't have options set, 3086 // unless the window is editing "buf", so we can copy from the window 3087 // itself. 3088 if (wip == NULL) 3089 { 3090 #ifdef FEAT_DIFF 3091 if (skip_diff_buffer) 3092 { 3093 FOR_ALL_BUF_WININFO(buf, wip) 3094 if (!wininfo_other_tab_diff(wip) 3095 && (!need_options || wip->wi_optset 3096 || (wip->wi_win != NULL 3097 && wip->wi_win->w_buffer == buf))) 3098 break; 3099 } 3100 else 3101 #endif 3102 wip = buf->b_wininfo; 3103 } 3104 return wip; 3105 } 3106 3107 /* 3108 * Reset the local window options to the values last used in this window. 3109 * If the buffer wasn't used in this window before, use the values from 3110 * the most recently used window. If the values were never set, use the 3111 * global values for the window. 3112 */ 3113 void 3114 get_winopts(buf_T *buf) 3115 { 3116 wininfo_T *wip; 3117 3118 clear_winopt(&curwin->w_onebuf_opt); 3119 #ifdef FEAT_FOLDING 3120 clearFolding(curwin); 3121 #endif 3122 3123 wip = find_wininfo(buf, TRUE, TRUE); 3124 if (wip != NULL && wip->wi_win != NULL 3125 && wip->wi_win != curwin && wip->wi_win->w_buffer == buf) 3126 { 3127 // The buffer is currently displayed in the window: use the actual 3128 // option values instead of the saved (possibly outdated) values. 3129 win_T *wp = wip->wi_win; 3130 3131 copy_winopt(&wp->w_onebuf_opt, &curwin->w_onebuf_opt); 3132 #ifdef FEAT_FOLDING 3133 curwin->w_fold_manual = wp->w_fold_manual; 3134 curwin->w_foldinvalid = TRUE; 3135 cloneFoldGrowArray(&wp->w_folds, &curwin->w_folds); 3136 #endif 3137 } 3138 else if (wip != NULL && wip->wi_optset) 3139 { 3140 // the buffer was displayed in the current window earlier 3141 copy_winopt(&wip->wi_opt, &curwin->w_onebuf_opt); 3142 #ifdef FEAT_FOLDING 3143 curwin->w_fold_manual = wip->wi_fold_manual; 3144 curwin->w_foldinvalid = TRUE; 3145 cloneFoldGrowArray(&wip->wi_folds, &curwin->w_folds); 3146 #endif 3147 } 3148 else 3149 copy_winopt(&curwin->w_allbuf_opt, &curwin->w_onebuf_opt); 3150 3151 #ifdef FEAT_FOLDING 3152 // Set 'foldlevel' to 'foldlevelstart' if it's not negative. 3153 if (p_fdls >= 0) 3154 curwin->w_p_fdl = p_fdls; 3155 #endif 3156 after_copy_winopt(curwin); 3157 } 3158 3159 /* 3160 * Find the position (lnum and col) for the buffer 'buf' for the current 3161 * window. 3162 * Returns a pointer to no_position if no position is found. 3163 */ 3164 pos_T * 3165 buflist_findfpos(buf_T *buf) 3166 { 3167 wininfo_T *wip; 3168 static pos_T no_position = {1, 0, 0}; 3169 3170 wip = find_wininfo(buf, FALSE, FALSE); 3171 if (wip != NULL) 3172 return &(wip->wi_fpos); 3173 else 3174 return &no_position; 3175 } 3176 3177 /* 3178 * Find the lnum for the buffer 'buf' for the current window. 3179 */ 3180 linenr_T 3181 buflist_findlnum(buf_T *buf) 3182 { 3183 return buflist_findfpos(buf)->lnum; 3184 } 3185 3186 /* 3187 * List all known file names (for :files and :buffers command). 3188 */ 3189 void 3190 buflist_list(exarg_T *eap) 3191 { 3192 buf_T *buf = firstbuf; 3193 int len; 3194 int i; 3195 int ro_char; 3196 int changed_char; 3197 #ifdef FEAT_TERMINAL 3198 int job_running; 3199 int job_none_open; 3200 #endif 3201 3202 #ifdef FEAT_VIMINFO 3203 garray_T buflist; 3204 buf_T **buflist_data = NULL, **p; 3205 3206 if (vim_strchr(eap->arg, 't')) 3207 { 3208 ga_init2(&buflist, sizeof(buf_T *), 50); 3209 FOR_ALL_BUFFERS(buf) 3210 { 3211 if (ga_grow(&buflist, 1) == OK) 3212 ((buf_T **)buflist.ga_data)[buflist.ga_len++] = buf; 3213 } 3214 3215 qsort(buflist.ga_data, (size_t)buflist.ga_len, 3216 sizeof(buf_T *), buf_compare); 3217 3218 buflist_data = (buf_T **)buflist.ga_data; 3219 buf = *buflist_data; 3220 } 3221 p = buflist_data; 3222 3223 for (; buf != NULL && !got_int; buf = buflist_data != NULL 3224 ? (++p < buflist_data + buflist.ga_len ? *p : NULL) 3225 : buf->b_next) 3226 #else 3227 for (buf = firstbuf; buf != NULL && !got_int; buf = buf->b_next) 3228 #endif 3229 { 3230 #ifdef FEAT_TERMINAL 3231 job_running = term_job_running(buf->b_term); 3232 job_none_open = job_running && term_none_open(buf->b_term); 3233 #endif 3234 // skip unlisted buffers, unless ! was used 3235 if ((!buf->b_p_bl && !eap->forceit && !vim_strchr(eap->arg, 'u')) 3236 || (vim_strchr(eap->arg, 'u') && buf->b_p_bl) 3237 || (vim_strchr(eap->arg, '+') 3238 && ((buf->b_flags & BF_READERR) || !bufIsChanged(buf))) 3239 || (vim_strchr(eap->arg, 'a') 3240 && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows == 0)) 3241 || (vim_strchr(eap->arg, 'h') 3242 && (buf->b_ml.ml_mfp == NULL || buf->b_nwindows != 0)) 3243 #ifdef FEAT_TERMINAL 3244 || (vim_strchr(eap->arg, 'R') 3245 && (!job_running || (job_running && job_none_open))) 3246 || (vim_strchr(eap->arg, '?') 3247 && (!job_running || (job_running && !job_none_open))) 3248 || (vim_strchr(eap->arg, 'F') 3249 && (job_running || buf->b_term == NULL)) 3250 #endif 3251 || (vim_strchr(eap->arg, '-') && buf->b_p_ma) 3252 || (vim_strchr(eap->arg, '=') && !buf->b_p_ro) 3253 || (vim_strchr(eap->arg, 'x') && !(buf->b_flags & BF_READERR)) 3254 || (vim_strchr(eap->arg, '%') && buf != curbuf) 3255 || (vim_strchr(eap->arg, '#') 3256 && (buf == curbuf || curwin->w_alt_fnum != buf->b_fnum))) 3257 continue; 3258 if (buf_spname(buf) != NULL) 3259 vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1); 3260 else 3261 home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE); 3262 if (message_filtered(NameBuff)) 3263 continue; 3264 3265 changed_char = (buf->b_flags & BF_READERR) ? 'x' 3266 : (bufIsChanged(buf) ? '+' : ' '); 3267 #ifdef FEAT_TERMINAL 3268 if (term_job_running(buf->b_term)) 3269 { 3270 if (term_none_open(buf->b_term)) 3271 ro_char = '?'; 3272 else 3273 ro_char = 'R'; 3274 changed_char = ' '; // bufIsChanged() returns TRUE to avoid 3275 // closing, but it's not actually changed. 3276 } 3277 else if (buf->b_term != NULL) 3278 ro_char = 'F'; 3279 else 3280 #endif 3281 ro_char = !buf->b_p_ma ? '-' : (buf->b_p_ro ? '=' : ' '); 3282 3283 msg_putchar('\n'); 3284 len = vim_snprintf((char *)IObuff, IOSIZE - 20, "%3d%c%c%c%c%c \"%s\"", 3285 buf->b_fnum, 3286 buf->b_p_bl ? ' ' : 'u', 3287 buf == curbuf ? '%' : 3288 (curwin->w_alt_fnum == buf->b_fnum ? '#' : ' '), 3289 buf->b_ml.ml_mfp == NULL ? ' ' : 3290 (buf->b_nwindows == 0 ? 'h' : 'a'), 3291 ro_char, 3292 changed_char, 3293 NameBuff); 3294 if (len > IOSIZE - 20) 3295 len = IOSIZE - 20; 3296 3297 // put "line 999" in column 40 or after the file name 3298 i = 40 - vim_strsize(IObuff); 3299 do 3300 IObuff[len++] = ' '; 3301 while (--i > 0 && len < IOSIZE - 18); 3302 #ifdef FEAT_VIMINFO 3303 if (vim_strchr(eap->arg, 't') && buf->b_last_used) 3304 add_time(IObuff + len, (size_t)(IOSIZE - len), buf->b_last_used); 3305 else 3306 #endif 3307 vim_snprintf((char *)IObuff + len, (size_t)(IOSIZE - len), 3308 _("line %ld"), buf == curbuf ? curwin->w_cursor.lnum 3309 : (long)buflist_findlnum(buf)); 3310 msg_outtrans(IObuff); 3311 out_flush(); // output one line at a time 3312 ui_breakcheck(); 3313 } 3314 3315 #ifdef FEAT_VIMINFO 3316 if (buflist_data) 3317 ga_clear(&buflist); 3318 #endif 3319 } 3320 3321 /* 3322 * Get file name and line number for file 'fnum'. 3323 * Used by DoOneCmd() for translating '%' and '#'. 3324 * Used by insert_reg() and cmdline_paste() for '#' register. 3325 * Return FAIL if not found, OK for success. 3326 */ 3327 int 3328 buflist_name_nr( 3329 int fnum, 3330 char_u **fname, 3331 linenr_T *lnum) 3332 { 3333 buf_T *buf; 3334 3335 buf = buflist_findnr(fnum); 3336 if (buf == NULL || buf->b_fname == NULL) 3337 return FAIL; 3338 3339 *fname = buf->b_fname; 3340 *lnum = buflist_findlnum(buf); 3341 3342 return OK; 3343 } 3344 3345 /* 3346 * Set the file name for "buf"' to "ffname_arg", short file name to 3347 * "sfname_arg". 3348 * The file name with the full path is also remembered, for when :cd is used. 3349 * Returns FAIL for failure (file name already in use by other buffer) 3350 * OK otherwise. 3351 */ 3352 int 3353 setfname( 3354 buf_T *buf, 3355 char_u *ffname_arg, 3356 char_u *sfname_arg, 3357 int message) // give message when buffer already exists 3358 { 3359 char_u *ffname = ffname_arg; 3360 char_u *sfname = sfname_arg; 3361 buf_T *obuf = NULL; 3362 #ifdef UNIX 3363 stat_T st; 3364 #endif 3365 3366 if (ffname == NULL || *ffname == NUL) 3367 { 3368 // Removing the name. 3369 if (buf->b_sfname != buf->b_ffname) 3370 VIM_CLEAR(buf->b_sfname); 3371 else 3372 buf->b_sfname = NULL; 3373 VIM_CLEAR(buf->b_ffname); 3374 #ifdef UNIX 3375 st.st_dev = (dev_T)-1; 3376 #endif 3377 } 3378 else 3379 { 3380 fname_expand(buf, &ffname, &sfname); // will allocate ffname 3381 if (ffname == NULL) // out of memory 3382 return FAIL; 3383 3384 /* 3385 * if the file name is already used in another buffer: 3386 * - if the buffer is loaded, fail 3387 * - if the buffer is not loaded, delete it from the list 3388 */ 3389 #ifdef UNIX 3390 if (mch_stat((char *)ffname, &st) < 0) 3391 st.st_dev = (dev_T)-1; 3392 #endif 3393 if (!(buf->b_flags & BF_DUMMY)) 3394 #ifdef UNIX 3395 obuf = buflist_findname_stat(ffname, &st); 3396 #else 3397 obuf = buflist_findname(ffname); 3398 #endif 3399 if (obuf != NULL && obuf != buf) 3400 { 3401 win_T *win; 3402 tabpage_T *tab; 3403 int in_use = FALSE; 3404 3405 // during startup a window may use a buffer that is not loaded yet 3406 FOR_ALL_TAB_WINDOWS(tab, win) 3407 if (win->w_buffer == obuf) 3408 in_use = TRUE; 3409 3410 // it's loaded or used in a window, fail 3411 if (obuf->b_ml.ml_mfp != NULL || in_use) 3412 { 3413 if (message) 3414 emsg(_("E95: Buffer with this name already exists")); 3415 vim_free(ffname); 3416 return FAIL; 3417 } 3418 // delete from the list 3419 close_buffer(NULL, obuf, DOBUF_WIPE, FALSE, FALSE); 3420 } 3421 sfname = vim_strsave(sfname); 3422 if (ffname == NULL || sfname == NULL) 3423 { 3424 vim_free(sfname); 3425 vim_free(ffname); 3426 return FAIL; 3427 } 3428 #ifdef USE_FNAME_CASE 3429 fname_case(sfname, 0); // set correct case for short file name 3430 #endif 3431 if (buf->b_sfname != buf->b_ffname) 3432 vim_free(buf->b_sfname); 3433 vim_free(buf->b_ffname); 3434 buf->b_ffname = ffname; 3435 buf->b_sfname = sfname; 3436 } 3437 buf->b_fname = buf->b_sfname; 3438 #ifdef UNIX 3439 if (st.st_dev == (dev_T)-1) 3440 buf->b_dev_valid = FALSE; 3441 else 3442 { 3443 buf->b_dev_valid = TRUE; 3444 buf->b_dev = st.st_dev; 3445 buf->b_ino = st.st_ino; 3446 } 3447 #endif 3448 3449 buf->b_shortname = FALSE; 3450 3451 buf_name_changed(buf); 3452 return OK; 3453 } 3454 3455 /* 3456 * Crude way of changing the name of a buffer. Use with care! 3457 * The name should be relative to the current directory. 3458 */ 3459 void 3460 buf_set_name(int fnum, char_u *name) 3461 { 3462 buf_T *buf; 3463 3464 buf = buflist_findnr(fnum); 3465 if (buf != NULL) 3466 { 3467 if (buf->b_sfname != buf->b_ffname) 3468 vim_free(buf->b_sfname); 3469 vim_free(buf->b_ffname); 3470 buf->b_ffname = vim_strsave(name); 3471 buf->b_sfname = NULL; 3472 // Allocate ffname and expand into full path. Also resolves .lnk 3473 // files on Win32. 3474 fname_expand(buf, &buf->b_ffname, &buf->b_sfname); 3475 buf->b_fname = buf->b_sfname; 3476 } 3477 } 3478 3479 /* 3480 * Take care of what needs to be done when the name of buffer "buf" has 3481 * changed. 3482 */ 3483 void 3484 buf_name_changed(buf_T *buf) 3485 { 3486 /* 3487 * If the file name changed, also change the name of the swapfile 3488 */ 3489 if (buf->b_ml.ml_mfp != NULL) 3490 ml_setname(buf); 3491 3492 if (curwin->w_buffer == buf) 3493 check_arg_idx(curwin); // check file name for arg list 3494 #ifdef FEAT_TITLE 3495 maketitle(); // set window title 3496 #endif 3497 status_redraw_all(); // status lines need to be redrawn 3498 fmarks_check_names(buf); // check named file marks 3499 ml_timestamp(buf); // reset timestamp 3500 } 3501 3502 /* 3503 * set alternate file name for current window 3504 * 3505 * Used by do_one_cmd(), do_write() and do_ecmd(). 3506 * Return the buffer. 3507 */ 3508 buf_T * 3509 setaltfname( 3510 char_u *ffname, 3511 char_u *sfname, 3512 linenr_T lnum) 3513 { 3514 buf_T *buf; 3515 3516 // Create a buffer. 'buflisted' is not set if it's a new buffer 3517 buf = buflist_new(ffname, sfname, lnum, 0); 3518 if (buf != NULL && (cmdmod.cmod_flags & CMOD_KEEPALT) == 0) 3519 curwin->w_alt_fnum = buf->b_fnum; 3520 return buf; 3521 } 3522 3523 /* 3524 * Get alternate file name for current window. 3525 * Return NULL if there isn't any, and give error message if requested. 3526 */ 3527 char_u * 3528 getaltfname( 3529 int errmsg) // give error message 3530 { 3531 char_u *fname; 3532 linenr_T dummy; 3533 3534 if (buflist_name_nr(0, &fname, &dummy) == FAIL) 3535 { 3536 if (errmsg) 3537 emsg(_(e_no_alternate_file)); 3538 return NULL; 3539 } 3540 return fname; 3541 } 3542 3543 /* 3544 * Add a file name to the buflist and return its number. 3545 * Uses same flags as buflist_new(), except BLN_DUMMY. 3546 * 3547 * used by qf_init(), main() and doarglist() 3548 */ 3549 int 3550 buflist_add(char_u *fname, int flags) 3551 { 3552 buf_T *buf; 3553 3554 buf = buflist_new(fname, NULL, (linenr_T)0, flags); 3555 if (buf != NULL) 3556 return buf->b_fnum; 3557 return 0; 3558 } 3559 3560 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO) 3561 /* 3562 * Adjust slashes in file names. Called after 'shellslash' was set. 3563 */ 3564 void 3565 buflist_slash_adjust(void) 3566 { 3567 buf_T *bp; 3568 3569 FOR_ALL_BUFFERS(bp) 3570 { 3571 if (bp->b_ffname != NULL) 3572 slash_adjust(bp->b_ffname); 3573 if (bp->b_sfname != NULL) 3574 slash_adjust(bp->b_sfname); 3575 } 3576 } 3577 #endif 3578 3579 /* 3580 * Set alternate cursor position for the current buffer and window "win". 3581 * Also save the local window option values. 3582 */ 3583 void 3584 buflist_altfpos(win_T *win) 3585 { 3586 buflist_setfpos(curbuf, win, win->w_cursor.lnum, win->w_cursor.col, TRUE); 3587 } 3588 3589 /* 3590 * Return TRUE if 'ffname' is not the same file as current file. 3591 * Fname must have a full path (expanded by mch_FullName()). 3592 */ 3593 int 3594 otherfile(char_u *ffname) 3595 { 3596 return otherfile_buf(curbuf, ffname 3597 #ifdef UNIX 3598 , NULL 3599 #endif 3600 ); 3601 } 3602 3603 static int 3604 otherfile_buf( 3605 buf_T *buf, 3606 char_u *ffname 3607 #ifdef UNIX 3608 , stat_T *stp 3609 #endif 3610 ) 3611 { 3612 // no name is different 3613 if (ffname == NULL || *ffname == NUL || buf->b_ffname == NULL) 3614 return TRUE; 3615 if (fnamecmp(ffname, buf->b_ffname) == 0) 3616 return FALSE; 3617 #ifdef UNIX 3618 { 3619 stat_T st; 3620 3621 // If no stat_T given, get it now 3622 if (stp == NULL) 3623 { 3624 if (!buf->b_dev_valid || mch_stat((char *)ffname, &st) < 0) 3625 st.st_dev = (dev_T)-1; 3626 stp = &st; 3627 } 3628 // Use dev/ino to check if the files are the same, even when the names 3629 // are different (possible with links). Still need to compare the 3630 // name above, for when the file doesn't exist yet. 3631 // Problem: The dev/ino changes when a file is deleted (and created 3632 // again) and remains the same when renamed/moved. We don't want to 3633 // mch_stat() each buffer each time, that would be too slow. Get the 3634 // dev/ino again when they appear to match, but not when they appear 3635 // to be different: Could skip a buffer when it's actually the same 3636 // file. 3637 if (buf_same_ino(buf, stp)) 3638 { 3639 buf_setino(buf); 3640 if (buf_same_ino(buf, stp)) 3641 return FALSE; 3642 } 3643 } 3644 #endif 3645 return TRUE; 3646 } 3647 3648 #if defined(UNIX) || defined(PROTO) 3649 /* 3650 * Set inode and device number for a buffer. 3651 * Must always be called when b_fname is changed!. 3652 */ 3653 void 3654 buf_setino(buf_T *buf) 3655 { 3656 stat_T st; 3657 3658 if (buf->b_fname != NULL && mch_stat((char *)buf->b_fname, &st) >= 0) 3659 { 3660 buf->b_dev_valid = TRUE; 3661 buf->b_dev = st.st_dev; 3662 buf->b_ino = st.st_ino; 3663 } 3664 else 3665 buf->b_dev_valid = FALSE; 3666 } 3667 3668 /* 3669 * Return TRUE if dev/ino in buffer "buf" matches with "stp". 3670 */ 3671 static int 3672 buf_same_ino( 3673 buf_T *buf, 3674 stat_T *stp) 3675 { 3676 return (buf->b_dev_valid 3677 && stp->st_dev == buf->b_dev 3678 && stp->st_ino == buf->b_ino); 3679 } 3680 #endif 3681 3682 /* 3683 * Print info about the current buffer. 3684 */ 3685 void 3686 fileinfo( 3687 int fullname, // when non-zero print full path 3688 int shorthelp, 3689 int dont_truncate) 3690 { 3691 char_u *name; 3692 int n; 3693 char *p; 3694 char *buffer; 3695 size_t len; 3696 3697 buffer = alloc(IOSIZE); 3698 if (buffer == NULL) 3699 return; 3700 3701 if (fullname > 1) // 2 CTRL-G: include buffer number 3702 { 3703 vim_snprintf(buffer, IOSIZE, "buf %d: ", curbuf->b_fnum); 3704 p = buffer + STRLEN(buffer); 3705 } 3706 else 3707 p = buffer; 3708 3709 *p++ = '"'; 3710 if (buf_spname(curbuf) != NULL) 3711 vim_strncpy((char_u *)p, buf_spname(curbuf), IOSIZE - (p - buffer) - 1); 3712 else 3713 { 3714 if (!fullname && curbuf->b_fname != NULL) 3715 name = curbuf->b_fname; 3716 else 3717 name = curbuf->b_ffname; 3718 home_replace(shorthelp ? curbuf : NULL, name, (char_u *)p, 3719 (int)(IOSIZE - (p - buffer)), TRUE); 3720 } 3721 3722 vim_snprintf_add(buffer, IOSIZE, "\"%s%s%s%s%s%s", 3723 curbufIsChanged() ? (shortmess(SHM_MOD) 3724 ? " [+]" : _(" [Modified]")) : " ", 3725 (curbuf->b_flags & BF_NOTEDITED) 3726 #ifdef FEAT_QUICKFIX 3727 && !bt_dontwrite(curbuf) 3728 #endif 3729 ? _("[Not edited]") : "", 3730 (curbuf->b_flags & BF_NEW) 3731 #ifdef FEAT_QUICKFIX 3732 && !bt_dontwrite(curbuf) 3733 #endif 3734 ? new_file_message() : "", 3735 (curbuf->b_flags & BF_READERR) ? _("[Read errors]") : "", 3736 curbuf->b_p_ro ? (shortmess(SHM_RO) ? _("[RO]") 3737 : _("[readonly]")) : "", 3738 (curbufIsChanged() || (curbuf->b_flags & BF_WRITE_MASK) 3739 || curbuf->b_p_ro) ? 3740 " " : ""); 3741 // With 32 bit longs and more than 21,474,836 lines multiplying by 100 3742 // causes an overflow, thus for large numbers divide instead. 3743 if (curwin->w_cursor.lnum > 1000000L) 3744 n = (int)(((long)curwin->w_cursor.lnum) / 3745 ((long)curbuf->b_ml.ml_line_count / 100L)); 3746 else 3747 n = (int)(((long)curwin->w_cursor.lnum * 100L) / 3748 (long)curbuf->b_ml.ml_line_count); 3749 if (curbuf->b_ml.ml_flags & ML_EMPTY) 3750 vim_snprintf_add(buffer, IOSIZE, "%s", _(no_lines_msg)); 3751 #ifdef FEAT_CMDL_INFO 3752 else if (p_ru) 3753 // Current line and column are already on the screen -- webb 3754 vim_snprintf_add(buffer, IOSIZE, 3755 NGETTEXT("%ld line --%d%%--", "%ld lines --%d%%--", 3756 curbuf->b_ml.ml_line_count), 3757 (long)curbuf->b_ml.ml_line_count, n); 3758 #endif 3759 else 3760 { 3761 vim_snprintf_add(buffer, IOSIZE, 3762 _("line %ld of %ld --%d%%-- col "), 3763 (long)curwin->w_cursor.lnum, 3764 (long)curbuf->b_ml.ml_line_count, 3765 n); 3766 validate_virtcol(); 3767 len = STRLEN(buffer); 3768 col_print((char_u *)buffer + len, IOSIZE - len, 3769 (int)curwin->w_cursor.col + 1, (int)curwin->w_virtcol + 1); 3770 } 3771 3772 (void)append_arg_number(curwin, (char_u *)buffer, IOSIZE, 3773 !shortmess(SHM_FILE)); 3774 3775 if (dont_truncate) 3776 { 3777 // Temporarily set msg_scroll to avoid the message being truncated. 3778 // First call msg_start() to get the message in the right place. 3779 msg_start(); 3780 n = msg_scroll; 3781 msg_scroll = TRUE; 3782 msg(buffer); 3783 msg_scroll = n; 3784 } 3785 else 3786 { 3787 p = (char *)msg_trunc_attr(buffer, FALSE, 0); 3788 if (restart_edit != 0 || (msg_scrolled && !need_wait_return)) 3789 // Need to repeat the message after redrawing when: 3790 // - When restart_edit is set (otherwise there will be a delay 3791 // before redrawing). 3792 // - When the screen was scrolled but there is no wait-return 3793 // prompt. 3794 set_keep_msg((char_u *)p, 0); 3795 } 3796 3797 vim_free(buffer); 3798 } 3799 3800 void 3801 col_print( 3802 char_u *buf, 3803 size_t buflen, 3804 int col, 3805 int vcol) 3806 { 3807 if (col == vcol) 3808 vim_snprintf((char *)buf, buflen, "%d", col); 3809 else 3810 vim_snprintf((char *)buf, buflen, "%d-%d", col, vcol); 3811 } 3812 3813 #if defined(FEAT_TITLE) || defined(PROTO) 3814 static char_u *lasttitle = NULL; 3815 static char_u *lasticon = NULL; 3816 3817 /* 3818 * Put the file name in the title bar and icon of the window. 3819 */ 3820 void 3821 maketitle(void) 3822 { 3823 char_u *p; 3824 char_u *title_str = NULL; 3825 char_u *icon_str = NULL; 3826 int maxlen = 0; 3827 int len; 3828 int mustset; 3829 char_u buf[IOSIZE]; 3830 int off; 3831 3832 if (!redrawing()) 3833 { 3834 // Postpone updating the title when 'lazyredraw' is set. 3835 need_maketitle = TRUE; 3836 return; 3837 } 3838 3839 need_maketitle = FALSE; 3840 if (!p_title && !p_icon && lasttitle == NULL && lasticon == NULL) 3841 return; // nothing to do 3842 3843 if (p_title) 3844 { 3845 if (p_titlelen > 0) 3846 { 3847 maxlen = p_titlelen * Columns / 100; 3848 if (maxlen < 10) 3849 maxlen = 10; 3850 } 3851 3852 title_str = buf; 3853 if (*p_titlestring != NUL) 3854 { 3855 #ifdef FEAT_STL_OPT 3856 if (stl_syntax & STL_IN_TITLE) 3857 { 3858 int use_sandbox = FALSE; 3859 int called_emsg_before = called_emsg; 3860 3861 # ifdef FEAT_EVAL 3862 use_sandbox = was_set_insecurely((char_u *)"titlestring", 0); 3863 # endif 3864 build_stl_str_hl(curwin, title_str, sizeof(buf), 3865 p_titlestring, use_sandbox, 3866 0, maxlen, NULL, NULL); 3867 if (called_emsg > called_emsg_before) 3868 set_string_option_direct((char_u *)"titlestring", -1, 3869 (char_u *)"", OPT_FREE, SID_ERROR); 3870 } 3871 else 3872 #endif 3873 title_str = p_titlestring; 3874 } 3875 else 3876 { 3877 // format: "fname + (path) (1 of 2) - VIM" 3878 3879 #define SPACE_FOR_FNAME (IOSIZE - 100) 3880 #define SPACE_FOR_DIR (IOSIZE - 20) 3881 #define SPACE_FOR_ARGNR (IOSIZE - 10) // at least room for " - VIM" 3882 if (curbuf->b_fname == NULL) 3883 vim_strncpy(buf, (char_u *)_("[No Name]"), SPACE_FOR_FNAME); 3884 #ifdef FEAT_TERMINAL 3885 else if (curbuf->b_term != NULL) 3886 { 3887 vim_strncpy(buf, term_get_status_text(curbuf->b_term), 3888 SPACE_FOR_FNAME); 3889 } 3890 #endif 3891 else 3892 { 3893 p = transstr(gettail(curbuf->b_fname)); 3894 vim_strncpy(buf, p, SPACE_FOR_FNAME); 3895 vim_free(p); 3896 } 3897 3898 #ifdef FEAT_TERMINAL 3899 if (curbuf->b_term == NULL) 3900 #endif 3901 switch (bufIsChanged(curbuf) 3902 + (curbuf->b_p_ro * 2) 3903 + (!curbuf->b_p_ma * 4)) 3904 { 3905 case 1: STRCAT(buf, " +"); break; 3906 case 2: STRCAT(buf, " ="); break; 3907 case 3: STRCAT(buf, " =+"); break; 3908 case 4: 3909 case 6: STRCAT(buf, " -"); break; 3910 case 5: 3911 case 7: STRCAT(buf, " -+"); break; 3912 } 3913 3914 if (curbuf->b_fname != NULL 3915 #ifdef FEAT_TERMINAL 3916 && curbuf->b_term == NULL 3917 #endif 3918 ) 3919 { 3920 // Get path of file, replace home dir with ~ 3921 off = (int)STRLEN(buf); 3922 buf[off++] = ' '; 3923 buf[off++] = '('; 3924 home_replace(curbuf, curbuf->b_ffname, 3925 buf + off, SPACE_FOR_DIR - off, TRUE); 3926 #ifdef BACKSLASH_IN_FILENAME 3927 // avoid "c:/name" to be reduced to "c" 3928 if (isalpha(buf[off]) && buf[off + 1] == ':') 3929 off += 2; 3930 #endif 3931 // remove the file name 3932 p = gettail_sep(buf + off); 3933 if (p == buf + off) 3934 { 3935 // must be a help buffer 3936 vim_strncpy(buf + off, (char_u *)_("help"), 3937 (size_t)(SPACE_FOR_DIR - off - 1)); 3938 } 3939 else 3940 *p = NUL; 3941 3942 // Translate unprintable chars and concatenate. Keep some 3943 // room for the server name. When there is no room (very long 3944 // file name) use (...). 3945 if (off < SPACE_FOR_DIR) 3946 { 3947 p = transstr(buf + off); 3948 vim_strncpy(buf + off, p, (size_t)(SPACE_FOR_DIR - off)); 3949 vim_free(p); 3950 } 3951 else 3952 { 3953 vim_strncpy(buf + off, (char_u *)"...", 3954 (size_t)(SPACE_FOR_ARGNR - off)); 3955 } 3956 STRCAT(buf, ")"); 3957 } 3958 3959 append_arg_number(curwin, buf, SPACE_FOR_ARGNR, FALSE); 3960 3961 #if defined(FEAT_CLIENTSERVER) 3962 if (serverName != NULL) 3963 { 3964 STRCAT(buf, " - "); 3965 vim_strcat(buf, serverName, IOSIZE); 3966 } 3967 else 3968 #endif 3969 STRCAT(buf, " - VIM"); 3970 3971 if (maxlen > 0) 3972 { 3973 // make it shorter by removing a bit in the middle 3974 if (vim_strsize(buf) > maxlen) 3975 trunc_string(buf, buf, maxlen, IOSIZE); 3976 } 3977 } 3978 } 3979 mustset = value_changed(title_str, &lasttitle); 3980 3981 if (p_icon) 3982 { 3983 icon_str = buf; 3984 if (*p_iconstring != NUL) 3985 { 3986 #ifdef FEAT_STL_OPT 3987 if (stl_syntax & STL_IN_ICON) 3988 { 3989 int use_sandbox = FALSE; 3990 int called_emsg_before = called_emsg; 3991 3992 # ifdef FEAT_EVAL 3993 use_sandbox = was_set_insecurely((char_u *)"iconstring", 0); 3994 # endif 3995 build_stl_str_hl(curwin, icon_str, sizeof(buf), 3996 p_iconstring, use_sandbox, 3997 0, 0, NULL, NULL); 3998 if (called_emsg > called_emsg_before) 3999 set_string_option_direct((char_u *)"iconstring", -1, 4000 (char_u *)"", OPT_FREE, SID_ERROR); 4001 } 4002 else 4003 #endif 4004 icon_str = p_iconstring; 4005 } 4006 else 4007 { 4008 if (buf_spname(curbuf) != NULL) 4009 p = buf_spname(curbuf); 4010 else // use file name only in icon 4011 p = gettail(curbuf->b_ffname); 4012 *icon_str = NUL; 4013 // Truncate name at 100 bytes. 4014 len = (int)STRLEN(p); 4015 if (len > 100) 4016 { 4017 len -= 100; 4018 if (has_mbyte) 4019 len += (*mb_tail_off)(p, p + len) + 1; 4020 p += len; 4021 } 4022 STRCPY(icon_str, p); 4023 trans_characters(icon_str, IOSIZE); 4024 } 4025 } 4026 4027 mustset |= value_changed(icon_str, &lasticon); 4028 4029 if (mustset) 4030 resettitle(); 4031 } 4032 4033 /* 4034 * Used for title and icon: Check if "str" differs from "*last". Set "*last" 4035 * from "str" if it does. 4036 * Return TRUE if resettitle() is to be called. 4037 */ 4038 static int 4039 value_changed(char_u *str, char_u **last) 4040 { 4041 if ((str == NULL) != (*last == NULL) 4042 || (str != NULL && *last != NULL && STRCMP(str, *last) != 0)) 4043 { 4044 vim_free(*last); 4045 if (str == NULL) 4046 { 4047 *last = NULL; 4048 mch_restore_title( 4049 last == &lasttitle ? SAVE_RESTORE_TITLE : SAVE_RESTORE_ICON); 4050 } 4051 else 4052 { 4053 *last = vim_strsave(str); 4054 return TRUE; 4055 } 4056 } 4057 return FALSE; 4058 } 4059 4060 /* 4061 * Put current window title back (used after calling a shell) 4062 */ 4063 void 4064 resettitle(void) 4065 { 4066 mch_settitle(lasttitle, lasticon); 4067 } 4068 4069 # if defined(EXITFREE) || defined(PROTO) 4070 void 4071 free_titles(void) 4072 { 4073 vim_free(lasttitle); 4074 vim_free(lasticon); 4075 } 4076 # endif 4077 4078 #endif // FEAT_TITLE 4079 4080 #if defined(FEAT_STL_OPT) || defined(FEAT_GUI_TABLINE) || defined(PROTO) 4081 4082 /* 4083 * Used for building in the status line. 4084 */ 4085 typedef struct 4086 { 4087 char_u *stl_start; 4088 int stl_minwid; 4089 int stl_maxwid; 4090 enum { 4091 Normal, 4092 Empty, 4093 Group, 4094 Middle, 4095 Highlight, 4096 TabPage, 4097 Trunc 4098 } stl_type; 4099 } stl_item_T; 4100 4101 static size_t stl_items_len = 20; // Initial value, grows as needed. 4102 static stl_item_T *stl_items = NULL; 4103 static int *stl_groupitem = NULL; 4104 static stl_hlrec_T *stl_hltab = NULL; 4105 static stl_hlrec_T *stl_tabtab = NULL; 4106 4107 /* 4108 * Build a string from the status line items in "fmt". 4109 * Return length of string in screen cells. 4110 * 4111 * Normally works for window "wp", except when working for 'tabline' then it 4112 * is "curwin". 4113 * 4114 * Items are drawn interspersed with the text that surrounds it 4115 * Specials: %-<wid>(xxx%) => group, %= => middle marker, %< => truncation 4116 * Item: %-<minwid>.<maxwid><itemch> All but <itemch> are optional 4117 * 4118 * If maxwidth is not zero, the string will be filled at any middle marker 4119 * or truncated if too long, fillchar is used for all whitespace. 4120 */ 4121 int 4122 build_stl_str_hl( 4123 win_T *wp, 4124 char_u *out, // buffer to write into != NameBuff 4125 size_t outlen, // length of out[] 4126 char_u *fmt, 4127 int use_sandbox UNUSED, // "fmt" was set insecurely, use sandbox 4128 int fillchar, 4129 int maxwidth, 4130 stl_hlrec_T **hltab, // return: HL attributes (can be NULL) 4131 stl_hlrec_T **tabtab) // return: tab page nrs (can be NULL) 4132 { 4133 linenr_T lnum; 4134 size_t len; 4135 char_u *p; 4136 char_u *s; 4137 char_u *t; 4138 int byteval; 4139 #ifdef FEAT_EVAL 4140 win_T *save_curwin; 4141 buf_T *save_curbuf; 4142 int save_VIsual_active; 4143 #endif 4144 int empty_line; 4145 colnr_T virtcol; 4146 long l; 4147 long n; 4148 int prevchar_isflag; 4149 int prevchar_isitem; 4150 int itemisflag; 4151 int fillable; 4152 char_u *str; 4153 long num; 4154 int width; 4155 int itemcnt; 4156 int curitem; 4157 int group_end_userhl; 4158 int group_start_userhl; 4159 int groupdepth; 4160 #ifdef FEAT_EVAL 4161 int evaldepth; 4162 #endif 4163 int minwid; 4164 int maxwid; 4165 int zeropad; 4166 char_u base; 4167 char_u opt; 4168 #define TMPLEN 70 4169 char_u buf_tmp[TMPLEN]; 4170 char_u win_tmp[TMPLEN]; 4171 char_u *usefmt = fmt; 4172 stl_hlrec_T *sp; 4173 int save_must_redraw = must_redraw; 4174 int save_redr_type = curwin->w_redr_type; 4175 4176 if (stl_items == NULL) 4177 { 4178 stl_items = ALLOC_MULT(stl_item_T, stl_items_len); 4179 stl_groupitem = ALLOC_MULT(int, stl_items_len); 4180 stl_hltab = ALLOC_MULT(stl_hlrec_T, stl_items_len); 4181 stl_tabtab = ALLOC_MULT(stl_hlrec_T, stl_items_len); 4182 } 4183 4184 #ifdef FEAT_EVAL 4185 /* 4186 * When the format starts with "%!" then evaluate it as an expression and 4187 * use the result as the actual format string. 4188 */ 4189 if (fmt[0] == '%' && fmt[1] == '!') 4190 { 4191 typval_T tv; 4192 4193 tv.v_type = VAR_NUMBER; 4194 tv.vval.v_number = wp->w_id; 4195 set_var((char_u *)"g:statusline_winid", &tv, FALSE); 4196 4197 usefmt = eval_to_string_safe(fmt + 2, use_sandbox); 4198 if (usefmt == NULL) 4199 usefmt = fmt; 4200 4201 do_unlet((char_u *)"g:statusline_winid", TRUE); 4202 } 4203 #endif 4204 4205 if (fillchar == 0) 4206 fillchar = ' '; 4207 4208 // The cursor in windows other than the current one isn't always 4209 // up-to-date, esp. because of autocommands and timers. 4210 lnum = wp->w_cursor.lnum; 4211 if (lnum > wp->w_buffer->b_ml.ml_line_count) 4212 { 4213 lnum = wp->w_buffer->b_ml.ml_line_count; 4214 wp->w_cursor.lnum = lnum; 4215 } 4216 4217 // Get line & check if empty (cursorpos will show "0-1"). Note that 4218 // p will become invalid when getting another buffer line. 4219 p = ml_get_buf(wp->w_buffer, lnum, FALSE); 4220 empty_line = (*p == NUL); 4221 4222 // Get the byte value now, in case we need it below. This is more efficient 4223 // than making a copy of the line. 4224 len = STRLEN(p); 4225 if (wp->w_cursor.col > (colnr_T)len) 4226 { 4227 // Line may have changed since checking the cursor column, or the lnum 4228 // was adjusted above. 4229 wp->w_cursor.col = (colnr_T)len; 4230 wp->w_cursor.coladd = 0; 4231 byteval = 0; 4232 } 4233 else 4234 byteval = (*mb_ptr2char)(p + wp->w_cursor.col); 4235 4236 groupdepth = 0; 4237 #ifdef FEAT_EVAL 4238 evaldepth = 0; 4239 #endif 4240 p = out; 4241 curitem = 0; 4242 prevchar_isflag = TRUE; 4243 prevchar_isitem = FALSE; 4244 for (s = usefmt; *s; ) 4245 { 4246 if (curitem == (int)stl_items_len) 4247 { 4248 size_t new_len = stl_items_len * 3 / 2; 4249 stl_item_T *new_items; 4250 int *new_groupitem; 4251 stl_hlrec_T *new_hlrec; 4252 4253 new_items = vim_realloc(stl_items, sizeof(stl_item_T) * new_len); 4254 if (new_items == NULL) 4255 break; 4256 stl_items = new_items; 4257 new_groupitem = vim_realloc(stl_groupitem, sizeof(int) * new_len); 4258 if (new_groupitem == NULL) 4259 break; 4260 stl_groupitem = new_groupitem; 4261 new_hlrec = vim_realloc(stl_hltab, sizeof(stl_hlrec_T) * new_len); 4262 if (new_hlrec == NULL) 4263 break; 4264 stl_hltab = new_hlrec; 4265 new_hlrec = vim_realloc(stl_tabtab, sizeof(stl_hlrec_T) * new_len); 4266 if (new_hlrec == NULL) 4267 break; 4268 stl_tabtab = new_hlrec; 4269 stl_items_len = new_len; 4270 } 4271 4272 if (*s != NUL && *s != '%') 4273 prevchar_isflag = prevchar_isitem = FALSE; 4274 4275 /* 4276 * Handle up to the next '%' or the end. 4277 */ 4278 while (*s != NUL && *s != '%' && p + 1 < out + outlen) 4279 *p++ = *s++; 4280 if (*s == NUL || p + 1 >= out + outlen) 4281 break; 4282 4283 /* 4284 * Handle one '%' item. 4285 */ 4286 s++; 4287 if (*s == NUL) // ignore trailing % 4288 break; 4289 if (*s == '%') 4290 { 4291 if (p + 1 >= out + outlen) 4292 break; 4293 *p++ = *s++; 4294 prevchar_isflag = prevchar_isitem = FALSE; 4295 continue; 4296 } 4297 if (*s == STL_MIDDLEMARK) 4298 { 4299 s++; 4300 if (groupdepth > 0) 4301 continue; 4302 stl_items[curitem].stl_type = Middle; 4303 stl_items[curitem++].stl_start = p; 4304 continue; 4305 } 4306 if (*s == STL_TRUNCMARK) 4307 { 4308 s++; 4309 stl_items[curitem].stl_type = Trunc; 4310 stl_items[curitem++].stl_start = p; 4311 continue; 4312 } 4313 if (*s == ')') 4314 { 4315 s++; 4316 if (groupdepth < 1) 4317 continue; 4318 groupdepth--; 4319 4320 t = stl_items[stl_groupitem[groupdepth]].stl_start; 4321 *p = NUL; 4322 l = vim_strsize(t); 4323 if (curitem > stl_groupitem[groupdepth] + 1 4324 && stl_items[stl_groupitem[groupdepth]].stl_minwid == 0) 4325 { 4326 // remove group if all items are empty and highlight group 4327 // doesn't change 4328 group_start_userhl = group_end_userhl = 0; 4329 for (n = stl_groupitem[groupdepth] - 1; n >= 0; n--) 4330 { 4331 if (stl_items[n].stl_type == Highlight) 4332 { 4333 group_start_userhl = group_end_userhl = 4334 stl_items[n].stl_minwid; 4335 break; 4336 } 4337 } 4338 for (n = stl_groupitem[groupdepth] + 1; n < curitem; n++) 4339 { 4340 if (stl_items[n].stl_type == Normal) 4341 break; 4342 if (stl_items[n].stl_type == Highlight) 4343 group_end_userhl = stl_items[n].stl_minwid; 4344 } 4345 if (n == curitem && group_start_userhl == group_end_userhl) 4346 { 4347 // empty group 4348 p = t; 4349 l = 0; 4350 for (n = stl_groupitem[groupdepth] + 1; n < curitem; n++) 4351 { 4352 // do not use the highlighting from the removed group 4353 if (stl_items[n].stl_type == Highlight) 4354 stl_items[n].stl_type = Empty; 4355 // adjust the start position of TabPage to the next 4356 // item position 4357 if (stl_items[n].stl_type == TabPage) 4358 stl_items[n].stl_start = p; 4359 } 4360 } 4361 } 4362 if (l > stl_items[stl_groupitem[groupdepth]].stl_maxwid) 4363 { 4364 // truncate, remove n bytes of text at the start 4365 if (has_mbyte) 4366 { 4367 // Find the first character that should be included. 4368 n = 0; 4369 while (l >= stl_items[stl_groupitem[groupdepth]].stl_maxwid) 4370 { 4371 l -= ptr2cells(t + n); 4372 n += (*mb_ptr2len)(t + n); 4373 } 4374 } 4375 else 4376 n = (long)(p - t) - stl_items[stl_groupitem[groupdepth]] 4377 .stl_maxwid + 1; 4378 4379 *t = '<'; 4380 mch_memmove(t + 1, t + n, (size_t)(p - (t + n))); 4381 p = p - n + 1; 4382 4383 // Fill up space left over by half a double-wide char. 4384 while (++l < stl_items[stl_groupitem[groupdepth]].stl_minwid) 4385 MB_CHAR2BYTES(fillchar, p); 4386 4387 // correct the start of the items for the truncation 4388 for (l = stl_groupitem[groupdepth] + 1; l < curitem; l++) 4389 { 4390 stl_items[l].stl_start -= n; 4391 if (stl_items[l].stl_start < t) 4392 stl_items[l].stl_start = t; 4393 } 4394 } 4395 else if (abs(stl_items[stl_groupitem[groupdepth]].stl_minwid) > l) 4396 { 4397 // fill 4398 n = stl_items[stl_groupitem[groupdepth]].stl_minwid; 4399 if (n < 0) 4400 { 4401 // fill by appending characters 4402 n = 0 - n; 4403 while (l++ < n && p + 1 < out + outlen) 4404 MB_CHAR2BYTES(fillchar, p); 4405 } 4406 else 4407 { 4408 // fill by inserting characters 4409 l = (n - l) * MB_CHAR2LEN(fillchar); 4410 mch_memmove(t + l, t, (size_t)(p - t)); 4411 if (p + l >= out + outlen) 4412 l = (long)((out + outlen) - p - 1); 4413 p += l; 4414 for (n = stl_groupitem[groupdepth] + 1; n < curitem; n++) 4415 stl_items[n].stl_start += l; 4416 for ( ; l > 0; l--) 4417 MB_CHAR2BYTES(fillchar, t); 4418 } 4419 } 4420 continue; 4421 } 4422 minwid = 0; 4423 maxwid = 9999; 4424 zeropad = FALSE; 4425 l = 1; 4426 if (*s == '0') 4427 { 4428 s++; 4429 zeropad = TRUE; 4430 } 4431 if (*s == '-') 4432 { 4433 s++; 4434 l = -1; 4435 } 4436 if (VIM_ISDIGIT(*s)) 4437 { 4438 minwid = (int)getdigits(&s); 4439 if (minwid < 0) // overflow 4440 minwid = 0; 4441 } 4442 if (*s == STL_USER_HL) 4443 { 4444 stl_items[curitem].stl_type = Highlight; 4445 stl_items[curitem].stl_start = p; 4446 stl_items[curitem].stl_minwid = minwid > 9 ? 1 : minwid; 4447 s++; 4448 curitem++; 4449 continue; 4450 } 4451 if (*s == STL_TABPAGENR || *s == STL_TABCLOSENR) 4452 { 4453 if (*s == STL_TABCLOSENR) 4454 { 4455 if (minwid == 0) 4456 { 4457 // %X ends the close label, go back to the previously 4458 // define tab label nr. 4459 for (n = curitem - 1; n >= 0; --n) 4460 if (stl_items[n].stl_type == TabPage 4461 && stl_items[n].stl_minwid >= 0) 4462 { 4463 minwid = stl_items[n].stl_minwid; 4464 break; 4465 } 4466 } 4467 else 4468 // close nrs are stored as negative values 4469 minwid = - minwid; 4470 } 4471 stl_items[curitem].stl_type = TabPage; 4472 stl_items[curitem].stl_start = p; 4473 stl_items[curitem].stl_minwid = minwid; 4474 s++; 4475 curitem++; 4476 continue; 4477 } 4478 if (*s == '.') 4479 { 4480 s++; 4481 if (VIM_ISDIGIT(*s)) 4482 { 4483 maxwid = (int)getdigits(&s); 4484 if (maxwid <= 0) // overflow 4485 maxwid = 50; 4486 } 4487 } 4488 minwid = (minwid > 50 ? 50 : minwid) * l; 4489 if (*s == '(') 4490 { 4491 stl_groupitem[groupdepth++] = curitem; 4492 stl_items[curitem].stl_type = Group; 4493 stl_items[curitem].stl_start = p; 4494 stl_items[curitem].stl_minwid = minwid; 4495 stl_items[curitem].stl_maxwid = maxwid; 4496 s++; 4497 curitem++; 4498 continue; 4499 } 4500 #ifdef FEAT_EVAL 4501 // Denotes end of expanded %{} block 4502 if (*s == '}' && evaldepth > 0) 4503 { 4504 s++; 4505 evaldepth--; 4506 continue; 4507 } 4508 #endif 4509 if (vim_strchr(STL_ALL, *s) == NULL) 4510 { 4511 s++; 4512 continue; 4513 } 4514 opt = *s++; 4515 4516 // OK - now for the real work 4517 base = 'D'; 4518 itemisflag = FALSE; 4519 fillable = TRUE; 4520 num = -1; 4521 str = NULL; 4522 switch (opt) 4523 { 4524 case STL_FILEPATH: 4525 case STL_FULLPATH: 4526 case STL_FILENAME: 4527 fillable = FALSE; // don't change ' ' to fillchar 4528 if (buf_spname(wp->w_buffer) != NULL) 4529 vim_strncpy(NameBuff, buf_spname(wp->w_buffer), MAXPATHL - 1); 4530 else 4531 { 4532 t = (opt == STL_FULLPATH) ? wp->w_buffer->b_ffname 4533 : wp->w_buffer->b_fname; 4534 home_replace(wp->w_buffer, t, NameBuff, MAXPATHL, TRUE); 4535 } 4536 trans_characters(NameBuff, MAXPATHL); 4537 if (opt != STL_FILENAME) 4538 str = NameBuff; 4539 else 4540 str = gettail(NameBuff); 4541 break; 4542 4543 case STL_VIM_EXPR: // '{' 4544 { 4545 #ifdef FEAT_EVAL 4546 char_u *block_start = s - 1; 4547 #endif 4548 int reevaluate = (*s == '%'); 4549 4550 if (reevaluate) 4551 s++; 4552 itemisflag = TRUE; 4553 t = p; 4554 while ((*s != '}' || (reevaluate && s[-1] != '%')) 4555 && *s != NUL && p + 1 < out + outlen) 4556 *p++ = *s++; 4557 if (*s != '}') // missing '}' or out of space 4558 break; 4559 s++; 4560 if (reevaluate) 4561 p[-1] = 0; // remove the % at the end of %{% expr %} 4562 else 4563 *p = 0; 4564 p = t; 4565 #ifdef FEAT_EVAL 4566 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), 4567 "%d", curbuf->b_fnum); 4568 set_internal_string_var((char_u *)"g:actual_curbuf", buf_tmp); 4569 vim_snprintf((char *)win_tmp, sizeof(win_tmp), "%d", curwin->w_id); 4570 set_internal_string_var((char_u *)"g:actual_curwin", win_tmp); 4571 4572 save_curbuf = curbuf; 4573 save_curwin = curwin; 4574 save_VIsual_active = VIsual_active; 4575 curwin = wp; 4576 curbuf = wp->w_buffer; 4577 // Visual mode is only valid in the current window. 4578 if (curwin != save_curwin) 4579 VIsual_active = FALSE; 4580 4581 str = eval_to_string_safe(p, use_sandbox); 4582 4583 curwin = save_curwin; 4584 curbuf = save_curbuf; 4585 VIsual_active = save_VIsual_active; 4586 do_unlet((char_u *)"g:actual_curbuf", TRUE); 4587 do_unlet((char_u *)"g:actual_curwin", TRUE); 4588 4589 if (str != NULL && *str != 0) 4590 { 4591 if (*skipdigits(str) == NUL) 4592 { 4593 num = atoi((char *)str); 4594 VIM_CLEAR(str); 4595 itemisflag = FALSE; 4596 } 4597 } 4598 4599 // If the output of the expression needs to be evaluated 4600 // replace the %{} block with the result of evaluation 4601 if (reevaluate && str != NULL && *str != 0 4602 && strchr((const char *)str, '%') != NULL 4603 && evaldepth < MAX_STL_EVAL_DEPTH) 4604 { 4605 size_t parsed_usefmt = (size_t)(block_start - usefmt); 4606 size_t str_length = strlen((const char *)str); 4607 size_t fmt_length = strlen((const char *)s); 4608 size_t new_fmt_len = parsed_usefmt 4609 + str_length + fmt_length + 3; 4610 char_u *new_fmt = (char_u *)alloc(new_fmt_len * sizeof(char_u)); 4611 char_u *new_fmt_p = new_fmt; 4612 4613 new_fmt_p = (char_u *)memcpy(new_fmt_p, usefmt, parsed_usefmt) 4614 + parsed_usefmt; 4615 new_fmt_p = (char_u *)memcpy(new_fmt_p , str, str_length) 4616 + str_length; 4617 new_fmt_p = (char_u *)memcpy(new_fmt_p, "%}", 2) + 2; 4618 new_fmt_p = (char_u *)memcpy(new_fmt_p , s, fmt_length) 4619 + fmt_length; 4620 *new_fmt_p = 0; 4621 new_fmt_p = NULL; 4622 4623 if (usefmt != fmt) 4624 vim_free(usefmt); 4625 VIM_CLEAR(str); 4626 usefmt = new_fmt; 4627 s = usefmt + parsed_usefmt; 4628 evaldepth++; 4629 continue; 4630 } 4631 #endif 4632 break; 4633 } 4634 case STL_LINE: 4635 num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) 4636 ? 0L : (long)(wp->w_cursor.lnum); 4637 break; 4638 4639 case STL_NUMLINES: 4640 num = wp->w_buffer->b_ml.ml_line_count; 4641 break; 4642 4643 case STL_COLUMN: 4644 num = !(State & INSERT) && empty_line 4645 ? 0 : (int)wp->w_cursor.col + 1; 4646 break; 4647 4648 case STL_VIRTCOL: 4649 case STL_VIRTCOL_ALT: 4650 // In list mode virtcol needs to be recomputed 4651 virtcol = wp->w_virtcol; 4652 if (wp->w_p_list && wp->w_lcs_chars.tab1 == NUL) 4653 { 4654 wp->w_p_list = FALSE; 4655 getvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL); 4656 wp->w_p_list = TRUE; 4657 } 4658 ++virtcol; 4659 // Don't display %V if it's the same as %c. 4660 if (opt == STL_VIRTCOL_ALT 4661 && (virtcol == (colnr_T)(!(State & INSERT) && empty_line 4662 ? 0 : (int)wp->w_cursor.col + 1))) 4663 break; 4664 num = (long)virtcol; 4665 break; 4666 4667 case STL_PERCENTAGE: 4668 num = (int)(((long)wp->w_cursor.lnum * 100L) / 4669 (long)wp->w_buffer->b_ml.ml_line_count); 4670 break; 4671 4672 case STL_ALTPERCENT: 4673 str = buf_tmp; 4674 get_rel_pos(wp, str, TMPLEN); 4675 break; 4676 4677 case STL_ARGLISTSTAT: 4678 fillable = FALSE; 4679 buf_tmp[0] = 0; 4680 if (append_arg_number(wp, buf_tmp, (int)sizeof(buf_tmp), FALSE)) 4681 str = buf_tmp; 4682 break; 4683 4684 case STL_KEYMAP: 4685 fillable = FALSE; 4686 if (get_keymap_str(wp, (char_u *)"<%s>", buf_tmp, TMPLEN)) 4687 str = buf_tmp; 4688 break; 4689 case STL_PAGENUM: 4690 #if defined(FEAT_PRINTER) || defined(FEAT_GUI_TABLINE) 4691 num = printer_page_num; 4692 #else 4693 num = 0; 4694 #endif 4695 break; 4696 4697 case STL_BUFNO: 4698 num = wp->w_buffer->b_fnum; 4699 break; 4700 4701 case STL_OFFSET_X: 4702 base = 'X'; 4703 // FALLTHROUGH 4704 case STL_OFFSET: 4705 #ifdef FEAT_BYTEOFF 4706 l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL); 4707 num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ? 4708 0L : l + 1 + (!(State & INSERT) && empty_line ? 4709 0 : (int)wp->w_cursor.col); 4710 #endif 4711 break; 4712 4713 case STL_BYTEVAL_X: 4714 base = 'X'; 4715 // FALLTHROUGH 4716 case STL_BYTEVAL: 4717 num = byteval; 4718 if (num == NL) 4719 num = 0; 4720 else if (num == CAR && get_fileformat(wp->w_buffer) == EOL_MAC) 4721 num = NL; 4722 break; 4723 4724 case STL_ROFLAG: 4725 case STL_ROFLAG_ALT: 4726 itemisflag = TRUE; 4727 if (wp->w_buffer->b_p_ro) 4728 str = (char_u *)((opt == STL_ROFLAG_ALT) ? ",RO" : _("[RO]")); 4729 break; 4730 4731 case STL_HELPFLAG: 4732 case STL_HELPFLAG_ALT: 4733 itemisflag = TRUE; 4734 if (wp->w_buffer->b_help) 4735 str = (char_u *)((opt == STL_HELPFLAG_ALT) ? ",HLP" 4736 : _("[Help]")); 4737 break; 4738 4739 case STL_FILETYPE: 4740 if (*wp->w_buffer->b_p_ft != NUL 4741 && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 3) 4742 { 4743 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), "[%s]", 4744 wp->w_buffer->b_p_ft); 4745 str = buf_tmp; 4746 } 4747 break; 4748 4749 case STL_FILETYPE_ALT: 4750 itemisflag = TRUE; 4751 if (*wp->w_buffer->b_p_ft != NUL 4752 && STRLEN(wp->w_buffer->b_p_ft) < TMPLEN - 2) 4753 { 4754 vim_snprintf((char *)buf_tmp, sizeof(buf_tmp), ",%s", 4755 wp->w_buffer->b_p_ft); 4756 for (t = buf_tmp; *t != 0; t++) 4757 *t = TOUPPER_LOC(*t); 4758 str = buf_tmp; 4759 } 4760 break; 4761 4762 #if defined(FEAT_QUICKFIX) 4763 case STL_PREVIEWFLAG: 4764 case STL_PREVIEWFLAG_ALT: 4765 itemisflag = TRUE; 4766 if (wp->w_p_pvw) 4767 str = (char_u *)((opt == STL_PREVIEWFLAG_ALT) ? ",PRV" 4768 : _("[Preview]")); 4769 break; 4770 4771 case STL_QUICKFIX: 4772 if (bt_quickfix(wp->w_buffer)) 4773 str = (char_u *)(wp->w_llist_ref 4774 ? _(msg_loclist) 4775 : _(msg_qflist)); 4776 break; 4777 #endif 4778 4779 case STL_MODIFIED: 4780 case STL_MODIFIED_ALT: 4781 itemisflag = TRUE; 4782 switch ((opt == STL_MODIFIED_ALT) 4783 + bufIsChanged(wp->w_buffer) * 2 4784 + (!wp->w_buffer->b_p_ma) * 4) 4785 { 4786 case 2: str = (char_u *)"[+]"; break; 4787 case 3: str = (char_u *)",+"; break; 4788 case 4: str = (char_u *)"[-]"; break; 4789 case 5: str = (char_u *)",-"; break; 4790 case 6: str = (char_u *)"[+-]"; break; 4791 case 7: str = (char_u *)",+-"; break; 4792 } 4793 break; 4794 4795 case STL_HIGHLIGHT: 4796 t = s; 4797 while (*s != '#' && *s != NUL) 4798 ++s; 4799 if (*s == '#') 4800 { 4801 stl_items[curitem].stl_type = Highlight; 4802 stl_items[curitem].stl_start = p; 4803 stl_items[curitem].stl_minwid = -syn_namen2id(t, (int)(s - t)); 4804 curitem++; 4805 } 4806 if (*s != NUL) 4807 ++s; 4808 continue; 4809 } 4810 4811 stl_items[curitem].stl_start = p; 4812 stl_items[curitem].stl_type = Normal; 4813 if (str != NULL && *str) 4814 { 4815 t = str; 4816 if (itemisflag) 4817 { 4818 if ((t[0] && t[1]) 4819 && ((!prevchar_isitem && *t == ',') 4820 || (prevchar_isflag && *t == ' '))) 4821 t++; 4822 prevchar_isflag = TRUE; 4823 } 4824 l = vim_strsize(t); 4825 if (l > 0) 4826 prevchar_isitem = TRUE; 4827 if (l > maxwid) 4828 { 4829 while (l >= maxwid) 4830 if (has_mbyte) 4831 { 4832 l -= ptr2cells(t); 4833 t += (*mb_ptr2len)(t); 4834 } 4835 else 4836 l -= byte2cells(*t++); 4837 if (p + 1 >= out + outlen) 4838 break; 4839 *p++ = '<'; 4840 } 4841 if (minwid > 0) 4842 { 4843 for (; l < minwid && p + 1 < out + outlen; l++) 4844 { 4845 // Don't put a "-" in front of a digit. 4846 if (l + 1 == minwid && fillchar == '-' && VIM_ISDIGIT(*t)) 4847 *p++ = ' '; 4848 else 4849 MB_CHAR2BYTES(fillchar, p); 4850 } 4851 minwid = 0; 4852 } 4853 else 4854 minwid *= -1; 4855 for (; *t && p + 1 < out + outlen; t++) 4856 { 4857 // Change a space by fillchar, unless fillchar is '-' and a 4858 // digit follows. 4859 if (fillable && *t == ' ' 4860 && (!VIM_ISDIGIT(*(t + 1)) || fillchar != '-')) 4861 MB_CHAR2BYTES(fillchar, p); 4862 else 4863 *p++ = *t; 4864 } 4865 for (; l < minwid && p + 1 < out + outlen; l++) 4866 MB_CHAR2BYTES(fillchar, p); 4867 } 4868 else if (num >= 0) 4869 { 4870 int nbase = (base == 'D' ? 10 : (base == 'O' ? 8 : 16)); 4871 char_u nstr[20]; 4872 4873 if (p + 20 >= out + outlen) 4874 break; // not sufficient space 4875 prevchar_isitem = TRUE; 4876 t = nstr; 4877 if (opt == STL_VIRTCOL_ALT) 4878 { 4879 *t++ = '-'; 4880 minwid--; 4881 } 4882 *t++ = '%'; 4883 if (zeropad) 4884 *t++ = '0'; 4885 *t++ = '*'; 4886 *t++ = nbase == 16 ? base : (char_u)(nbase == 8 ? 'o' : 'd'); 4887 *t = 0; 4888 4889 for (n = num, l = 1; n >= nbase; n /= nbase) 4890 l++; 4891 if (opt == STL_VIRTCOL_ALT) 4892 l++; 4893 if (l > maxwid) 4894 { 4895 l += 2; 4896 n = l - maxwid; 4897 while (l-- > maxwid) 4898 num /= nbase; 4899 *t++ = '>'; 4900 *t++ = '%'; 4901 *t = t[-3]; 4902 *++t = 0; 4903 vim_snprintf((char *)p, outlen - (p - out), (char *)nstr, 4904 0, num, n); 4905 } 4906 else 4907 vim_snprintf((char *)p, outlen - (p - out), (char *)nstr, 4908 minwid, num); 4909 p += STRLEN(p); 4910 } 4911 else 4912 stl_items[curitem].stl_type = Empty; 4913 4914 if (opt == STL_VIM_EXPR) 4915 vim_free(str); 4916 4917 if (num >= 0 || (!itemisflag && str && *str)) 4918 prevchar_isflag = FALSE; // Item not NULL, but not a flag 4919 curitem++; 4920 } 4921 *p = NUL; 4922 itemcnt = curitem; 4923 4924 #ifdef FEAT_EVAL 4925 if (usefmt != fmt) 4926 vim_free(usefmt); 4927 #endif 4928 4929 width = vim_strsize(out); 4930 if (maxwidth > 0 && width > maxwidth) 4931 { 4932 // Result is too long, must truncate somewhere. 4933 l = 0; 4934 if (itemcnt == 0) 4935 s = out; 4936 else 4937 { 4938 for ( ; l < itemcnt; l++) 4939 if (stl_items[l].stl_type == Trunc) 4940 { 4941 // Truncate at %< item. 4942 s = stl_items[l].stl_start; 4943 break; 4944 } 4945 if (l == itemcnt) 4946 { 4947 // No %< item, truncate first item. 4948 s = stl_items[0].stl_start; 4949 l = 0; 4950 } 4951 } 4952 4953 if (width - vim_strsize(s) >= maxwidth) 4954 { 4955 // Truncation mark is beyond max length 4956 if (has_mbyte) 4957 { 4958 s = out; 4959 width = 0; 4960 for (;;) 4961 { 4962 width += ptr2cells(s); 4963 if (width >= maxwidth) 4964 break; 4965 s += (*mb_ptr2len)(s); 4966 } 4967 // Fill up for half a double-wide character. 4968 while (++width < maxwidth) 4969 MB_CHAR2BYTES(fillchar, s); 4970 } 4971 else 4972 s = out + maxwidth - 1; 4973 for (l = 0; l < itemcnt; l++) 4974 if (stl_items[l].stl_start > s) 4975 break; 4976 itemcnt = l; 4977 *s++ = '>'; 4978 *s = 0; 4979 } 4980 else 4981 { 4982 if (has_mbyte) 4983 { 4984 n = 0; 4985 while (width >= maxwidth) 4986 { 4987 width -= ptr2cells(s + n); 4988 n += (*mb_ptr2len)(s + n); 4989 } 4990 } 4991 else 4992 n = width - maxwidth + 1; 4993 p = s + n; 4994 STRMOVE(s + 1, p); 4995 *s = '<'; 4996 4997 // Fill up for half a double-wide character. 4998 while (++width < maxwidth) 4999 { 5000 s = s + STRLEN(s); 5001 MB_CHAR2BYTES(fillchar, s); 5002 *s = NUL; 5003 } 5004 5005 --n; // count the '<' 5006 for (; l < itemcnt; l++) 5007 { 5008 if (stl_items[l].stl_start - n >= s) 5009 stl_items[l].stl_start -= n; 5010 else 5011 stl_items[l].stl_start = s; 5012 } 5013 } 5014 width = maxwidth; 5015 } 5016 else if (width < maxwidth && STRLEN(out) + maxwidth - width + 1 < outlen) 5017 { 5018 // Apply STL_MIDDLE if any 5019 for (l = 0; l < itemcnt; l++) 5020 if (stl_items[l].stl_type == Middle) 5021 break; 5022 if (l < itemcnt) 5023 { 5024 int middlelength = (maxwidth - width) * MB_CHAR2LEN(fillchar); 5025 p = stl_items[l].stl_start + middlelength; 5026 STRMOVE(p, stl_items[l].stl_start); 5027 for (s = stl_items[l].stl_start; s < p;) 5028 MB_CHAR2BYTES(fillchar, s); 5029 for (l++; l < itemcnt; l++) 5030 stl_items[l].stl_start += middlelength; 5031 width = maxwidth; 5032 } 5033 } 5034 5035 // Store the info about highlighting. 5036 if (hltab != NULL) 5037 { 5038 *hltab = stl_hltab; 5039 sp = stl_hltab; 5040 for (l = 0; l < itemcnt; l++) 5041 { 5042 if (stl_items[l].stl_type == Highlight) 5043 { 5044 sp->start = stl_items[l].stl_start; 5045 sp->userhl = stl_items[l].stl_minwid; 5046 sp++; 5047 } 5048 } 5049 sp->start = NULL; 5050 sp->userhl = 0; 5051 } 5052 5053 // Store the info about tab pages labels. 5054 if (tabtab != NULL) 5055 { 5056 *tabtab = stl_tabtab; 5057 sp = stl_tabtab; 5058 for (l = 0; l < itemcnt; l++) 5059 { 5060 if (stl_items[l].stl_type == TabPage) 5061 { 5062 sp->start = stl_items[l].stl_start; 5063 sp->userhl = stl_items[l].stl_minwid; 5064 sp++; 5065 } 5066 } 5067 sp->start = NULL; 5068 sp->userhl = 0; 5069 } 5070 5071 // When inside update_screen we do not want redrawing a stausline, ruler, 5072 // title, etc. to trigger another redraw, it may cause an endless loop. 5073 if (updating_screen) 5074 { 5075 must_redraw = save_must_redraw; 5076 curwin->w_redr_type = save_redr_type; 5077 } 5078 5079 return width; 5080 } 5081 #endif // FEAT_STL_OPT 5082 5083 #if defined(FEAT_STL_OPT) || defined(FEAT_CMDL_INFO) \ 5084 || defined(FEAT_GUI_TABLINE) || defined(PROTO) 5085 /* 5086 * Get relative cursor position in window into "buf[buflen]", in the form 99%, 5087 * using "Top", "Bot" or "All" when appropriate. 5088 */ 5089 void 5090 get_rel_pos( 5091 win_T *wp, 5092 char_u *buf, 5093 int buflen) 5094 { 5095 long above; // number of lines above window 5096 long below; // number of lines below window 5097 5098 if (buflen < 3) // need at least 3 chars for writing 5099 return; 5100 above = wp->w_topline - 1; 5101 #ifdef FEAT_DIFF 5102 above += diff_check_fill(wp, wp->w_topline) - wp->w_topfill; 5103 if (wp->w_topline == 1 && wp->w_topfill >= 1) 5104 above = 0; // All buffer lines are displayed and there is an 5105 // indication of filler lines, that can be considered 5106 // seeing all lines. 5107 #endif 5108 below = wp->w_buffer->b_ml.ml_line_count - wp->w_botline + 1; 5109 if (below <= 0) 5110 vim_strncpy(buf, (char_u *)(above == 0 ? _("All") : _("Bot")), 5111 (size_t)(buflen - 1)); 5112 else if (above <= 0) 5113 vim_strncpy(buf, (char_u *)_("Top"), (size_t)(buflen - 1)); 5114 else 5115 vim_snprintf((char *)buf, (size_t)buflen, "%2d%%", above > 1000000L 5116 ? (int)(above / ((above + below) / 100L)) 5117 : (int)(above * 100L / (above + below))); 5118 } 5119 #endif 5120 5121 /* 5122 * Append (file 2 of 8) to "buf[buflen]", if editing more than one file. 5123 * Return TRUE if it was appended. 5124 */ 5125 static int 5126 append_arg_number( 5127 win_T *wp, 5128 char_u *buf, 5129 int buflen, 5130 int add_file) // Add "file" before the arg number 5131 { 5132 char_u *p; 5133 5134 if (ARGCOUNT <= 1) // nothing to do 5135 return FALSE; 5136 5137 p = buf + STRLEN(buf); // go to the end of the buffer 5138 if (p - buf + 35 >= buflen) // getting too long 5139 return FALSE; 5140 *p++ = ' '; 5141 *p++ = '('; 5142 if (add_file) 5143 { 5144 STRCPY(p, "file "); 5145 p += 5; 5146 } 5147 vim_snprintf((char *)p, (size_t)(buflen - (p - buf)), 5148 wp->w_arg_idx_invalid ? "(%d) of %d)" 5149 : "%d of %d)", wp->w_arg_idx + 1, ARGCOUNT); 5150 return TRUE; 5151 } 5152 5153 /* 5154 * If fname is not a full path, make it a full path. 5155 * Returns pointer to allocated memory (NULL for failure). 5156 */ 5157 char_u * 5158 fix_fname(char_u *fname) 5159 { 5160 /* 5161 * Force expanding the path always for Unix, because symbolic links may 5162 * mess up the full path name, even though it starts with a '/'. 5163 * Also expand when there is ".." in the file name, try to remove it, 5164 * because "c:/src/../README" is equal to "c:/README". 5165 * Similarly "c:/src//file" is equal to "c:/src/file". 5166 * For MS-Windows also expand names like "longna~1" to "longname". 5167 */ 5168 #ifdef UNIX 5169 return FullName_save(fname, TRUE); 5170 #else 5171 if (!vim_isAbsName(fname) 5172 || strstr((char *)fname, "..") != NULL 5173 || strstr((char *)fname, "//") != NULL 5174 # ifdef BACKSLASH_IN_FILENAME 5175 || strstr((char *)fname, "\\\\") != NULL 5176 # endif 5177 # if defined(MSWIN) 5178 || vim_strchr(fname, '~') != NULL 5179 # endif 5180 ) 5181 return FullName_save(fname, FALSE); 5182 5183 fname = vim_strsave(fname); 5184 5185 # ifdef USE_FNAME_CASE 5186 if (fname != NULL) 5187 fname_case(fname, 0); // set correct case for file name 5188 # endif 5189 5190 return fname; 5191 #endif 5192 } 5193 5194 /* 5195 * Make "*ffname" a full file name, set "*sfname" to "*ffname" if not NULL. 5196 * "*ffname" becomes a pointer to allocated memory (or NULL). 5197 * When resolving a link both "*sfname" and "*ffname" will point to the same 5198 * allocated memory. 5199 * The "*ffname" and "*sfname" pointer values on call will not be freed. 5200 * Note that the resulting "*ffname" pointer should be considered not allocated. 5201 */ 5202 void 5203 fname_expand( 5204 buf_T *buf UNUSED, 5205 char_u **ffname, 5206 char_u **sfname) 5207 { 5208 if (*ffname == NULL) // no file name given, nothing to do 5209 return; 5210 if (*sfname == NULL) // no short file name given, use ffname 5211 *sfname = *ffname; 5212 *ffname = fix_fname(*ffname); // expand to full path 5213 5214 #ifdef FEAT_SHORTCUT 5215 if (!buf->b_p_bin) 5216 { 5217 char_u *rfname; 5218 5219 // If the file name is a shortcut file, use the file it links to. 5220 rfname = mch_resolve_path(*ffname, FALSE); 5221 if (rfname != NULL) 5222 { 5223 vim_free(*ffname); 5224 *ffname = rfname; 5225 *sfname = rfname; 5226 } 5227 } 5228 #endif 5229 } 5230 5231 /* 5232 * Open a window for a number of buffers. 5233 */ 5234 void 5235 ex_buffer_all(exarg_T *eap) 5236 { 5237 buf_T *buf; 5238 win_T *wp, *wpnext; 5239 int split_ret = OK; 5240 int p_ea_save; 5241 int open_wins = 0; 5242 int r; 5243 int count; // Maximum number of windows to open. 5244 int all; // When TRUE also load inactive buffers. 5245 int had_tab = cmdmod.cmod_tab; 5246 tabpage_T *tpnext; 5247 5248 if (eap->addr_count == 0) // make as many windows as possible 5249 count = 9999; 5250 else 5251 count = eap->line2; // make as many windows as specified 5252 if (eap->cmdidx == CMD_unhide || eap->cmdidx == CMD_sunhide) 5253 all = FALSE; 5254 else 5255 all = TRUE; 5256 5257 setpcmark(); 5258 5259 #ifdef FEAT_GUI 5260 need_mouse_correct = TRUE; 5261 #endif 5262 5263 /* 5264 * Close superfluous windows (two windows for the same buffer). 5265 * Also close windows that are not full-width. 5266 */ 5267 if (had_tab > 0) 5268 goto_tabpage_tp(first_tabpage, TRUE, TRUE); 5269 for (;;) 5270 { 5271 tpnext = curtab->tp_next; 5272 for (wp = firstwin; wp != NULL; wp = wpnext) 5273 { 5274 wpnext = wp->w_next; 5275 if ((wp->w_buffer->b_nwindows > 1 5276 || ((cmdmod.cmod_split & WSP_VERT) 5277 ? wp->w_height + wp->w_status_height < Rows - p_ch 5278 - tabline_height() 5279 : wp->w_width != Columns) 5280 || (had_tab > 0 && wp != firstwin)) && !ONE_WINDOW 5281 && !(wp->w_closing || wp->w_buffer->b_locked > 0)) 5282 { 5283 win_close(wp, FALSE); 5284 wpnext = firstwin; // just in case an autocommand does 5285 // something strange with windows 5286 tpnext = first_tabpage; // start all over... 5287 open_wins = 0; 5288 } 5289 else 5290 ++open_wins; 5291 } 5292 5293 // Without the ":tab" modifier only do the current tab page. 5294 if (had_tab == 0 || tpnext == NULL) 5295 break; 5296 goto_tabpage_tp(tpnext, TRUE, TRUE); 5297 } 5298 5299 /* 5300 * Go through the buffer list. When a buffer doesn't have a window yet, 5301 * open one. Otherwise move the window to the right position. 5302 * Watch out for autocommands that delete buffers or windows! 5303 */ 5304 // Don't execute Win/Buf Enter/Leave autocommands here. 5305 ++autocmd_no_enter; 5306 win_enter(lastwin, FALSE); 5307 ++autocmd_no_leave; 5308 for (buf = firstbuf; buf != NULL && open_wins < count; buf = buf->b_next) 5309 { 5310 // Check if this buffer needs a window 5311 if ((!all && buf->b_ml.ml_mfp == NULL) || !buf->b_p_bl) 5312 continue; 5313 5314 if (had_tab != 0) 5315 { 5316 // With the ":tab" modifier don't move the window. 5317 if (buf->b_nwindows > 0) 5318 wp = lastwin; // buffer has a window, skip it 5319 else 5320 wp = NULL; 5321 } 5322 else 5323 { 5324 // Check if this buffer already has a window 5325 FOR_ALL_WINDOWS(wp) 5326 if (wp->w_buffer == buf) 5327 break; 5328 // If the buffer already has a window, move it 5329 if (wp != NULL) 5330 win_move_after(wp, curwin); 5331 } 5332 5333 if (wp == NULL && split_ret == OK) 5334 { 5335 bufref_T bufref; 5336 5337 set_bufref(&bufref, buf); 5338 5339 // Split the window and put the buffer in it 5340 p_ea_save = p_ea; 5341 p_ea = TRUE; // use space from all windows 5342 split_ret = win_split(0, WSP_ROOM | WSP_BELOW); 5343 ++open_wins; 5344 p_ea = p_ea_save; 5345 if (split_ret == FAIL) 5346 continue; 5347 5348 // Open the buffer in this window. 5349 swap_exists_action = SEA_DIALOG; 5350 set_curbuf(buf, DOBUF_GOTO); 5351 if (!bufref_valid(&bufref)) 5352 { 5353 // autocommands deleted the buffer!!! 5354 swap_exists_action = SEA_NONE; 5355 break; 5356 } 5357 if (swap_exists_action == SEA_QUIT) 5358 { 5359 #if defined(FEAT_EVAL) 5360 cleanup_T cs; 5361 5362 // Reset the error/interrupt/exception state here so that 5363 // aborting() returns FALSE when closing a window. 5364 enter_cleanup(&cs); 5365 #endif 5366 5367 // User selected Quit at ATTENTION prompt; close this window. 5368 win_close(curwin, TRUE); 5369 --open_wins; 5370 swap_exists_action = SEA_NONE; 5371 swap_exists_did_quit = TRUE; 5372 5373 #if defined(FEAT_EVAL) 5374 // Restore the error/interrupt/exception state if not 5375 // discarded by a new aborting error, interrupt, or uncaught 5376 // exception. 5377 leave_cleanup(&cs); 5378 #endif 5379 } 5380 else 5381 handle_swap_exists(NULL); 5382 } 5383 5384 ui_breakcheck(); 5385 if (got_int) 5386 { 5387 (void)vgetc(); // only break the file loading, not the rest 5388 break; 5389 } 5390 #ifdef FEAT_EVAL 5391 // Autocommands deleted the buffer or aborted script processing!!! 5392 if (aborting()) 5393 break; 5394 #endif 5395 // When ":tab" was used open a new tab for a new window repeatedly. 5396 if (had_tab > 0 && tabpage_index(NULL) <= p_tpm) 5397 cmdmod.cmod_tab = 9999; 5398 } 5399 --autocmd_no_enter; 5400 win_enter(firstwin, FALSE); // back to first window 5401 --autocmd_no_leave; 5402 5403 /* 5404 * Close superfluous windows. 5405 */ 5406 for (wp = lastwin; open_wins > count; ) 5407 { 5408 r = (buf_hide(wp->w_buffer) || !bufIsChanged(wp->w_buffer) 5409 || autowrite(wp->w_buffer, FALSE) == OK); 5410 if (!win_valid(wp)) 5411 { 5412 // BufWrite Autocommands made the window invalid, start over 5413 wp = lastwin; 5414 } 5415 else if (r) 5416 { 5417 win_close(wp, !buf_hide(wp->w_buffer)); 5418 --open_wins; 5419 wp = lastwin; 5420 } 5421 else 5422 { 5423 wp = wp->w_prev; 5424 if (wp == NULL) 5425 break; 5426 } 5427 } 5428 } 5429 5430 5431 static int chk_modeline(linenr_T, int); 5432 5433 /* 5434 * do_modelines() - process mode lines for the current file 5435 * 5436 * "flags" can be: 5437 * OPT_WINONLY only set options local to window 5438 * OPT_NOWIN don't set options local to window 5439 * 5440 * Returns immediately if the "ml" option isn't set. 5441 */ 5442 void 5443 do_modelines(int flags) 5444 { 5445 linenr_T lnum; 5446 int nmlines; 5447 static int entered = 0; 5448 5449 if (!curbuf->b_p_ml || (nmlines = (int)p_mls) == 0) 5450 return; 5451 5452 // Disallow recursive entry here. Can happen when executing a modeline 5453 // triggers an autocommand, which reloads modelines with a ":do". 5454 if (entered) 5455 return; 5456 5457 ++entered; 5458 for (lnum = 1; curbuf->b_p_ml && lnum <= curbuf->b_ml.ml_line_count && lnum <= nmlines; 5459 ++lnum) 5460 if (chk_modeline(lnum, flags) == FAIL) 5461 nmlines = 0; 5462 5463 for (lnum = curbuf->b_ml.ml_line_count; curbuf->b_p_ml && lnum > 0 && lnum > nmlines 5464 && lnum > curbuf->b_ml.ml_line_count - nmlines; --lnum) 5465 if (chk_modeline(lnum, flags) == FAIL) 5466 nmlines = 0; 5467 --entered; 5468 } 5469 5470 #include "version.h" // for version number 5471 5472 /* 5473 * chk_modeline() - check a single line for a mode string 5474 * Return FAIL if an error encountered. 5475 */ 5476 static int 5477 chk_modeline( 5478 linenr_T lnum, 5479 int flags) // Same as for do_modelines(). 5480 { 5481 char_u *s; 5482 char_u *e; 5483 char_u *linecopy; // local copy of any modeline found 5484 int prev; 5485 int vers; 5486 int end; 5487 int retval = OK; 5488 sctx_T save_current_sctx; 5489 5490 ESTACK_CHECK_DECLARATION 5491 5492 prev = -1; 5493 for (s = ml_get(lnum); *s != NUL; ++s) 5494 { 5495 if (prev == -1 || vim_isspace(prev)) 5496 { 5497 if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0) 5498 || STRNCMP(s, "vi:", (size_t)3) == 0) 5499 break; 5500 // Accept both "vim" and "Vim". 5501 if ((s[0] == 'v' || s[0] == 'V') && s[1] == 'i' && s[2] == 'm') 5502 { 5503 if (s[3] == '<' || s[3] == '=' || s[3] == '>') 5504 e = s + 4; 5505 else 5506 e = s + 3; 5507 vers = getdigits(&e); 5508 if (*e == ':' 5509 && (s[0] != 'V' 5510 || STRNCMP(skipwhite(e + 1), "set", 3) == 0) 5511 && (s[3] == ':' 5512 || (VIM_VERSION_100 >= vers && isdigit(s[3])) 5513 || (VIM_VERSION_100 < vers && s[3] == '<') 5514 || (VIM_VERSION_100 > vers && s[3] == '>') 5515 || (VIM_VERSION_100 == vers && s[3] == '='))) 5516 break; 5517 } 5518 } 5519 prev = *s; 5520 } 5521 5522 if (*s) 5523 { 5524 do // skip over "ex:", "vi:" or "vim:" 5525 ++s; 5526 while (s[-1] != ':'); 5527 5528 s = linecopy = vim_strsave(s); // copy the line, it will change 5529 if (linecopy == NULL) 5530 return FAIL; 5531 5532 // prepare for emsg() 5533 estack_push(ETYPE_MODELINE, (char_u *)"modelines", lnum); 5534 ESTACK_CHECK_SETUP 5535 5536 end = FALSE; 5537 while (end == FALSE) 5538 { 5539 s = skipwhite(s); 5540 if (*s == NUL) 5541 break; 5542 5543 /* 5544 * Find end of set command: ':' or end of line. 5545 * Skip over "\:", replacing it with ":". 5546 */ 5547 for (e = s; *e != ':' && *e != NUL; ++e) 5548 if (e[0] == '\\' && e[1] == ':') 5549 STRMOVE(e, e + 1); 5550 if (*e == NUL) 5551 end = TRUE; 5552 5553 /* 5554 * If there is a "set" command, require a terminating ':' and 5555 * ignore the stuff after the ':'. 5556 * "vi:set opt opt opt: foo" -- foo not interpreted 5557 * "vi:opt opt opt: foo" -- foo interpreted 5558 * Accept "se" for compatibility with Elvis. 5559 */ 5560 if (STRNCMP(s, "set ", (size_t)4) == 0 5561 || STRNCMP(s, "se ", (size_t)3) == 0) 5562 { 5563 if (*e != ':') // no terminating ':'? 5564 break; 5565 end = TRUE; 5566 s = vim_strchr(s, ' ') + 1; 5567 } 5568 *e = NUL; // truncate the set command 5569 5570 if (*s != NUL) // skip over an empty "::" 5571 { 5572 int secure_save = secure; 5573 5574 save_current_sctx = current_sctx; 5575 current_sctx.sc_version = 1; 5576 #ifdef FEAT_EVAL 5577 current_sctx.sc_sid = SID_MODELINE; 5578 current_sctx.sc_seq = 0; 5579 current_sctx.sc_lnum = lnum; 5580 #endif 5581 5582 // Make sure no risky things are executed as a side effect. 5583 secure = 1; 5584 5585 retval = do_set(s, OPT_MODELINE | OPT_LOCAL | flags); 5586 5587 secure = secure_save; 5588 current_sctx = save_current_sctx; 5589 if (retval == FAIL) // stop if error found 5590 break; 5591 } 5592 s = e + 1; // advance to next part 5593 } 5594 5595 ESTACK_CHECK_NOW 5596 estack_pop(); 5597 vim_free(linecopy); 5598 } 5599 return retval; 5600 } 5601 5602 /* 5603 * Return TRUE if "buf" is a normal buffer, 'buftype' is empty. 5604 */ 5605 int 5606 bt_normal(buf_T *buf) 5607 { 5608 return buf != NULL && buf->b_p_bt[0] == NUL; 5609 } 5610 5611 #if defined(FEAT_QUICKFIX) || defined(PROTO) 5612 /* 5613 * Return TRUE if "buf" is the quickfix buffer. 5614 */ 5615 int 5616 bt_quickfix(buf_T *buf) 5617 { 5618 return buf != NULL && buf->b_p_bt[0] == 'q'; 5619 } 5620 #endif 5621 5622 #if defined(FEAT_TERMINAL) || defined(PROTO) 5623 /* 5624 * Return TRUE if "buf" is a terminal buffer. 5625 */ 5626 int 5627 bt_terminal(buf_T *buf) 5628 { 5629 return buf != NULL && buf->b_p_bt[0] == 't'; 5630 } 5631 #endif 5632 5633 /* 5634 * Return TRUE if "buf" is a help buffer. 5635 */ 5636 int 5637 bt_help(buf_T *buf) 5638 { 5639 return buf != NULL && buf->b_help; 5640 } 5641 5642 /* 5643 * Return TRUE if "buf" is a prompt buffer. 5644 */ 5645 int 5646 bt_prompt(buf_T *buf) 5647 { 5648 return buf != NULL && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'r'; 5649 } 5650 5651 /* 5652 * Return TRUE if "buf" is a buffer for a popup window. 5653 */ 5654 int 5655 bt_popup(buf_T *buf) 5656 { 5657 return buf != NULL && buf->b_p_bt != NULL 5658 && buf->b_p_bt[0] == 'p' && buf->b_p_bt[1] == 'o'; 5659 } 5660 5661 /* 5662 * Return TRUE if "buf" is a "nofile", "acwrite", "terminal" or "prompt" 5663 * buffer. This means the buffer name is not a file name. 5664 */ 5665 int 5666 bt_nofilename(buf_T *buf) 5667 { 5668 return buf != NULL && ((buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f') 5669 || buf->b_p_bt[0] == 'a' 5670 || buf->b_p_bt[0] == 't' 5671 || buf->b_p_bt[0] == 'p'); 5672 } 5673 5674 /* 5675 * Return TRUE if "buf" has 'buftype' set to "nofile". 5676 */ 5677 int 5678 bt_nofile(buf_T *buf) 5679 { 5680 return buf != NULL && buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f'; 5681 } 5682 5683 /* 5684 * Return TRUE if "buf" is a "nowrite", "nofile", "terminal" or "prompt" 5685 * buffer. 5686 */ 5687 int 5688 bt_dontwrite(buf_T *buf) 5689 { 5690 return buf != NULL && (buf->b_p_bt[0] == 'n' 5691 || buf->b_p_bt[0] == 't' 5692 || buf->b_p_bt[0] == 'p'); 5693 } 5694 5695 #if defined(FEAT_QUICKFIX) || defined(PROTO) 5696 int 5697 bt_dontwrite_msg(buf_T *buf) 5698 { 5699 if (bt_dontwrite(buf)) 5700 { 5701 emsg(_("E382: Cannot write, 'buftype' option is set")); 5702 return TRUE; 5703 } 5704 return FALSE; 5705 } 5706 #endif 5707 5708 /* 5709 * Return TRUE if the buffer should be hidden, according to 'hidden', ":hide" 5710 * and 'bufhidden'. 5711 */ 5712 int 5713 buf_hide(buf_T *buf) 5714 { 5715 // 'bufhidden' overrules 'hidden' and ":hide", check it first 5716 switch (buf->b_p_bh[0]) 5717 { 5718 case 'u': // "unload" 5719 case 'w': // "wipe" 5720 case 'd': return FALSE; // "delete" 5721 case 'h': return TRUE; // "hide" 5722 } 5723 return (p_hid || (cmdmod.cmod_flags & CMOD_HIDE)); 5724 } 5725 5726 /* 5727 * Return special buffer name. 5728 * Returns NULL when the buffer has a normal file name. 5729 */ 5730 char_u * 5731 buf_spname(buf_T *buf) 5732 { 5733 #if defined(FEAT_QUICKFIX) 5734 if (bt_quickfix(buf)) 5735 { 5736 /* 5737 * Differentiate between the quickfix and location list buffers using 5738 * the buffer number stored in the global quickfix stack. 5739 */ 5740 if (buf->b_fnum == qf_stack_get_bufnr()) 5741 return (char_u *)_(msg_qflist); 5742 else 5743 return (char_u *)_(msg_loclist); 5744 } 5745 #endif 5746 5747 // There is no _file_ when 'buftype' is "nofile", b_sfname 5748 // contains the name as specified by the user. 5749 if (bt_nofilename(buf)) 5750 { 5751 #ifdef FEAT_TERMINAL 5752 if (buf->b_term != NULL) 5753 return term_get_status_text(buf->b_term); 5754 #endif 5755 if (buf->b_fname != NULL) 5756 return buf->b_fname; 5757 #ifdef FEAT_JOB_CHANNEL 5758 if (bt_prompt(buf)) 5759 return (char_u *)_("[Prompt]"); 5760 #endif 5761 #ifdef FEAT_PROP_POPUP 5762 if (bt_popup(buf)) 5763 return (char_u *)_("[Popup]"); 5764 #endif 5765 return (char_u *)_("[Scratch]"); 5766 } 5767 5768 if (buf->b_fname == NULL) 5769 return buf_get_fname(buf); 5770 return NULL; 5771 } 5772 5773 /* 5774 * Get "buf->b_fname", use "[No Name]" if it is NULL. 5775 */ 5776 char_u * 5777 buf_get_fname(buf_T *buf) 5778 { 5779 if (buf->b_fname == NULL) 5780 return (char_u *)_("[No Name]"); 5781 return buf->b_fname; 5782 } 5783 5784 /* 5785 * Set 'buflisted' for curbuf to "on" and trigger autocommands if it changed. 5786 */ 5787 void 5788 set_buflisted(int on) 5789 { 5790 if (on != curbuf->b_p_bl) 5791 { 5792 curbuf->b_p_bl = on; 5793 if (on) 5794 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf); 5795 else 5796 apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf); 5797 } 5798 } 5799 5800 /* 5801 * Read the file for "buf" again and check if the contents changed. 5802 * Return TRUE if it changed or this could not be checked. 5803 */ 5804 int 5805 buf_contents_changed(buf_T *buf) 5806 { 5807 buf_T *newbuf; 5808 int differ = TRUE; 5809 linenr_T lnum; 5810 aco_save_T aco; 5811 exarg_T ea; 5812 5813 // Allocate a buffer without putting it in the buffer list. 5814 newbuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY); 5815 if (newbuf == NULL) 5816 return TRUE; 5817 5818 // Force the 'fileencoding' and 'fileformat' to be equal. 5819 if (prep_exarg(&ea, buf) == FAIL) 5820 { 5821 wipe_buffer(newbuf, FALSE); 5822 return TRUE; 5823 } 5824 5825 // set curwin/curbuf to buf and save a few things 5826 aucmd_prepbuf(&aco, newbuf); 5827 5828 if (ml_open(curbuf) == OK 5829 && readfile(buf->b_ffname, buf->b_fname, 5830 (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, 5831 &ea, READ_NEW | READ_DUMMY) == OK) 5832 { 5833 // compare the two files line by line 5834 if (buf->b_ml.ml_line_count == curbuf->b_ml.ml_line_count) 5835 { 5836 differ = FALSE; 5837 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) 5838 if (STRCMP(ml_get_buf(buf, lnum, FALSE), ml_get(lnum)) != 0) 5839 { 5840 differ = TRUE; 5841 break; 5842 } 5843 } 5844 } 5845 vim_free(ea.cmd); 5846 5847 // restore curwin/curbuf and a few other things 5848 aucmd_restbuf(&aco); 5849 5850 if (curbuf != newbuf) // safety check 5851 wipe_buffer(newbuf, FALSE); 5852 5853 return differ; 5854 } 5855 5856 /* 5857 * Wipe out a buffer and decrement the last buffer number if it was used for 5858 * this buffer. Call this to wipe out a temp buffer that does not contain any 5859 * marks. 5860 */ 5861 void 5862 wipe_buffer( 5863 buf_T *buf, 5864 int aucmd) // When TRUE trigger autocommands. 5865 { 5866 if (buf->b_fnum == top_file_num - 1) 5867 --top_file_num; 5868 5869 if (!aucmd) // Don't trigger BufDelete autocommands here. 5870 block_autocmds(); 5871 5872 close_buffer(NULL, buf, DOBUF_WIPE, FALSE, TRUE); 5873 5874 if (!aucmd) 5875 unblock_autocmds(); 5876 } 5877