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