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