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