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