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