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