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