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 * ex_cmds.c: some functions for command line commands 12 */ 13 14 #include "vim.h" 15 #include "version.h" 16 17 #ifdef FEAT_FLOAT 18 # include <float.h> 19 #endif 20 21 static int linelen(int *has_tab); 22 static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd, int do_in, int do_out); 23 #ifdef FEAT_VIMINFO 24 static char_u *viminfo_filename(char_u *); 25 static void do_viminfo(FILE *fp_in, FILE *fp_out, int flags); 26 static int viminfo_encoding(vir_T *virp); 27 static int read_viminfo_up_to_marks(vir_T *virp, int forceit, int writing); 28 #endif 29 30 static int check_readonly(int *forceit, buf_T *buf); 31 static void delbuf_msg(char_u *name); 32 static int 33 #ifdef __BORLANDC__ 34 _RTLENTRYF 35 #endif 36 help_compare(const void *s1, const void *s2); 37 static void prepare_help_buffer(void); 38 39 /* 40 * ":ascii" and "ga". 41 */ 42 void 43 do_ascii(exarg_T *eap UNUSED) 44 { 45 int c; 46 int cval; 47 char buf1[20]; 48 char buf2[20]; 49 char_u buf3[7]; 50 #ifdef FEAT_DIGRAPHS 51 char_u *dig; 52 #endif 53 int cc[MAX_MCO]; 54 int ci = 0; 55 int len; 56 57 if (enc_utf8) 58 c = utfc_ptr2char(ml_get_cursor(), cc); 59 else 60 c = gchar_cursor(); 61 if (c == NUL) 62 { 63 msg("NUL"); 64 return; 65 } 66 67 IObuff[0] = NUL; 68 if (!has_mbyte || (enc_dbcs != 0 && c < 0x100) || c < 0x80) 69 { 70 if (c == NL) /* NUL is stored as NL */ 71 c = NUL; 72 if (c == CAR && get_fileformat(curbuf) == EOL_MAC) 73 cval = NL; /* NL is stored as CR */ 74 else 75 cval = c; 76 if (vim_isprintc_strict(c) && (c < ' ' 77 #ifndef EBCDIC 78 || c > '~' 79 #endif 80 )) 81 { 82 transchar_nonprint(buf3, c); 83 vim_snprintf(buf1, sizeof(buf1), " <%s>", (char *)buf3); 84 } 85 else 86 buf1[0] = NUL; 87 #ifndef EBCDIC 88 if (c >= 0x80) 89 vim_snprintf(buf2, sizeof(buf2), " <M-%s>", 90 (char *)transchar(c & 0x7f)); 91 else 92 #endif 93 buf2[0] = NUL; 94 #ifdef FEAT_DIGRAPHS 95 dig = get_digraph_for_char(cval); 96 if (dig != NULL) 97 vim_snprintf((char *)IObuff, IOSIZE, 98 _("<%s>%s%s %d, Hex %02x, Oct %03o, Digr %s"), 99 transchar(c), buf1, buf2, cval, cval, cval, dig); 100 else 101 #endif 102 vim_snprintf((char *)IObuff, IOSIZE, 103 _("<%s>%s%s %d, Hex %02x, Octal %03o"), 104 transchar(c), buf1, buf2, cval, cval, cval); 105 if (enc_utf8) 106 c = cc[ci++]; 107 else 108 c = 0; 109 } 110 111 /* Repeat for combining characters. */ 112 while (has_mbyte && (c >= 0x100 || (enc_utf8 && c >= 0x80))) 113 { 114 len = (int)STRLEN(IObuff); 115 /* This assumes every multi-byte char is printable... */ 116 if (len > 0) 117 IObuff[len++] = ' '; 118 IObuff[len++] = '<'; 119 if (enc_utf8 && utf_iscomposing(c) 120 # ifdef USE_GUI 121 && !gui.in_use 122 # endif 123 ) 124 IObuff[len++] = ' '; /* draw composing char on top of a space */ 125 len += (*mb_char2bytes)(c, IObuff + len); 126 #ifdef FEAT_DIGRAPHS 127 dig = get_digraph_for_char(c); 128 if (dig != NULL) 129 vim_snprintf((char *)IObuff + len, IOSIZE - len, 130 c < 0x10000 ? _("> %d, Hex %04x, Oct %o, Digr %s") 131 : _("> %d, Hex %08x, Oct %o, Digr %s"), 132 c, c, c, dig); 133 else 134 #endif 135 vim_snprintf((char *)IObuff + len, IOSIZE - len, 136 c < 0x10000 ? _("> %d, Hex %04x, Octal %o") 137 : _("> %d, Hex %08x, Octal %o"), 138 c, c, c); 139 if (ci == MAX_MCO) 140 break; 141 if (enc_utf8) 142 c = cc[ci++]; 143 else 144 c = 0; 145 } 146 147 msg((char *)IObuff); 148 } 149 150 /* 151 * ":left", ":center" and ":right": align text. 152 */ 153 void 154 ex_align(exarg_T *eap) 155 { 156 pos_T save_curpos; 157 int len; 158 int indent = 0; 159 int new_indent; 160 int has_tab; 161 int width; 162 163 #ifdef FEAT_RIGHTLEFT 164 if (curwin->w_p_rl) 165 { 166 /* switch left and right aligning */ 167 if (eap->cmdidx == CMD_right) 168 eap->cmdidx = CMD_left; 169 else if (eap->cmdidx == CMD_left) 170 eap->cmdidx = CMD_right; 171 } 172 #endif 173 174 width = atoi((char *)eap->arg); 175 save_curpos = curwin->w_cursor; 176 if (eap->cmdidx == CMD_left) /* width is used for new indent */ 177 { 178 if (width >= 0) 179 indent = width; 180 } 181 else 182 { 183 /* 184 * if 'textwidth' set, use it 185 * else if 'wrapmargin' set, use it 186 * if invalid value, use 80 187 */ 188 if (width <= 0) 189 width = curbuf->b_p_tw; 190 if (width == 0 && curbuf->b_p_wm > 0) 191 width = curwin->w_width - curbuf->b_p_wm; 192 if (width <= 0) 193 width = 80; 194 } 195 196 if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL) 197 return; 198 199 for (curwin->w_cursor.lnum = eap->line1; 200 curwin->w_cursor.lnum <= eap->line2; ++curwin->w_cursor.lnum) 201 { 202 if (eap->cmdidx == CMD_left) /* left align */ 203 new_indent = indent; 204 else 205 { 206 has_tab = FALSE; /* avoid uninit warnings */ 207 len = linelen(eap->cmdidx == CMD_right ? &has_tab 208 : NULL) - get_indent(); 209 210 if (len <= 0) /* skip blank lines */ 211 continue; 212 213 if (eap->cmdidx == CMD_center) 214 new_indent = (width - len) / 2; 215 else 216 { 217 new_indent = width - len; /* right align */ 218 219 /* 220 * Make sure that embedded TABs don't make the text go too far 221 * to the right. 222 */ 223 if (has_tab) 224 while (new_indent > 0) 225 { 226 (void)set_indent(new_indent, 0); 227 if (linelen(NULL) <= width) 228 { 229 /* 230 * Now try to move the line as much as possible to 231 * the right. Stop when it moves too far. 232 */ 233 do 234 (void)set_indent(++new_indent, 0); 235 while (linelen(NULL) <= width); 236 --new_indent; 237 break; 238 } 239 --new_indent; 240 } 241 } 242 } 243 if (new_indent < 0) 244 new_indent = 0; 245 (void)set_indent(new_indent, 0); /* set indent */ 246 } 247 changed_lines(eap->line1, 0, eap->line2 + 1, 0L); 248 curwin->w_cursor = save_curpos; 249 beginline(BL_WHITE | BL_FIX); 250 } 251 252 /* 253 * Get the length of the current line, excluding trailing white space. 254 */ 255 static int 256 linelen(int *has_tab) 257 { 258 char_u *line; 259 char_u *first; 260 char_u *last; 261 int save; 262 int len; 263 264 /* find the first non-blank character */ 265 line = ml_get_curline(); 266 first = skipwhite(line); 267 268 /* find the character after the last non-blank character */ 269 for (last = first + STRLEN(first); 270 last > first && VIM_ISWHITE(last[-1]); --last) 271 ; 272 save = *last; 273 *last = NUL; 274 len = linetabsize(line); /* get line length */ 275 if (has_tab != NULL) /* check for embedded TAB */ 276 *has_tab = (vim_strchr(first, TAB) != NULL); 277 *last = save; 278 279 return len; 280 } 281 282 /* Buffer for two lines used during sorting. They are allocated to 283 * contain the longest line being sorted. */ 284 static char_u *sortbuf1; 285 static char_u *sortbuf2; 286 287 static int sort_ic; /* ignore case */ 288 static int sort_nr; /* sort on number */ 289 static int sort_rx; /* sort on regex instead of skipping it */ 290 #ifdef FEAT_FLOAT 291 static int sort_flt; /* sort on floating number */ 292 #endif 293 294 static int sort_abort; /* flag to indicate if sorting has been interrupted */ 295 296 /* Struct to store info to be sorted. */ 297 typedef struct 298 { 299 linenr_T lnum; /* line number */ 300 union { 301 struct 302 { 303 varnumber_T start_col_nr; /* starting column number */ 304 varnumber_T end_col_nr; /* ending column number */ 305 } line; 306 varnumber_T value; /* value if sorting by integer */ 307 #ifdef FEAT_FLOAT 308 float_T value_flt; /* value if sorting by float */ 309 #endif 310 } st_u; 311 } sorti_T; 312 313 static int 314 #ifdef __BORLANDC__ 315 _RTLENTRYF 316 #endif 317 sort_compare(const void *s1, const void *s2); 318 319 static int 320 #ifdef __BORLANDC__ 321 _RTLENTRYF 322 #endif 323 sort_compare(const void *s1, const void *s2) 324 { 325 sorti_T l1 = *(sorti_T *)s1; 326 sorti_T l2 = *(sorti_T *)s2; 327 int result = 0; 328 329 /* If the user interrupts, there's no way to stop qsort() immediately, but 330 * if we return 0 every time, qsort will assume it's done sorting and 331 * exit. */ 332 if (sort_abort) 333 return 0; 334 fast_breakcheck(); 335 if (got_int) 336 sort_abort = TRUE; 337 338 /* When sorting numbers "start_col_nr" is the number, not the column 339 * number. */ 340 if (sort_nr) 341 result = l1.st_u.value == l2.st_u.value ? 0 342 : l1.st_u.value > l2.st_u.value ? 1 : -1; 343 #ifdef FEAT_FLOAT 344 else if (sort_flt) 345 result = l1.st_u.value_flt == l2.st_u.value_flt ? 0 346 : l1.st_u.value_flt > l2.st_u.value_flt ? 1 : -1; 347 #endif 348 else 349 { 350 /* We need to copy one line into "sortbuf1", because there is no 351 * guarantee that the first pointer becomes invalid when obtaining the 352 * second one. */ 353 STRNCPY(sortbuf1, ml_get(l1.lnum) + l1.st_u.line.start_col_nr, 354 l1.st_u.line.end_col_nr - l1.st_u.line.start_col_nr + 1); 355 sortbuf1[l1.st_u.line.end_col_nr - l1.st_u.line.start_col_nr] = 0; 356 STRNCPY(sortbuf2, ml_get(l2.lnum) + l2.st_u.line.start_col_nr, 357 l2.st_u.line.end_col_nr - l2.st_u.line.start_col_nr + 1); 358 sortbuf2[l2.st_u.line.end_col_nr - l2.st_u.line.start_col_nr] = 0; 359 360 result = sort_ic ? STRICMP(sortbuf1, sortbuf2) 361 : STRCMP(sortbuf1, sortbuf2); 362 } 363 364 /* If two lines have the same value, preserve the original line order. */ 365 if (result == 0) 366 return (int)(l1.lnum - l2.lnum); 367 return result; 368 } 369 370 /* 371 * ":sort". 372 */ 373 void 374 ex_sort(exarg_T *eap) 375 { 376 regmatch_T regmatch; 377 int len; 378 linenr_T lnum; 379 long maxlen = 0; 380 sorti_T *nrs; 381 size_t count = (size_t)(eap->line2 - eap->line1 + 1); 382 size_t i; 383 char_u *p; 384 char_u *s; 385 char_u *s2; 386 char_u c; /* temporary character storage */ 387 int unique = FALSE; 388 long deleted; 389 colnr_T start_col; 390 colnr_T end_col; 391 int sort_what = 0; 392 int format_found = 0; 393 int change_occurred = FALSE; // Buffer contents changed. 394 395 /* Sorting one line is really quick! */ 396 if (count <= 1) 397 return; 398 399 if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL) 400 return; 401 sortbuf1 = NULL; 402 sortbuf2 = NULL; 403 regmatch.regprog = NULL; 404 nrs = (sorti_T *)lalloc((long_u)(count * sizeof(sorti_T)), TRUE); 405 if (nrs == NULL) 406 goto sortend; 407 408 sort_abort = sort_ic = sort_rx = sort_nr = 0; 409 #ifdef FEAT_FLOAT 410 sort_flt = 0; 411 #endif 412 413 for (p = eap->arg; *p != NUL; ++p) 414 { 415 if (VIM_ISWHITE(*p)) 416 ; 417 else if (*p == 'i') 418 sort_ic = TRUE; 419 else if (*p == 'r') 420 sort_rx = TRUE; 421 else if (*p == 'n') 422 { 423 sort_nr = 1; 424 ++format_found; 425 } 426 #ifdef FEAT_FLOAT 427 else if (*p == 'f') 428 { 429 sort_flt = 1; 430 ++format_found; 431 } 432 #endif 433 else if (*p == 'b') 434 { 435 sort_what = STR2NR_BIN + STR2NR_FORCE; 436 ++format_found; 437 } 438 else if (*p == 'o') 439 { 440 sort_what = STR2NR_OCT + STR2NR_FORCE; 441 ++format_found; 442 } 443 else if (*p == 'x') 444 { 445 sort_what = STR2NR_HEX + STR2NR_FORCE; 446 ++format_found; 447 } 448 else if (*p == 'u') 449 unique = TRUE; 450 else if (*p == '"') /* comment start */ 451 break; 452 else if (check_nextcmd(p) != NULL) 453 { 454 eap->nextcmd = check_nextcmd(p); 455 break; 456 } 457 else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL) 458 { 459 s = skip_regexp(p + 1, *p, TRUE, NULL); 460 if (*s != *p) 461 { 462 emsg(_(e_invalpat)); 463 goto sortend; 464 } 465 *s = NUL; 466 /* Use last search pattern if sort pattern is empty. */ 467 if (s == p + 1) 468 { 469 if (last_search_pat() == NULL) 470 { 471 emsg(_(e_noprevre)); 472 goto sortend; 473 } 474 regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC); 475 } 476 else 477 regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC); 478 if (regmatch.regprog == NULL) 479 goto sortend; 480 p = s; /* continue after the regexp */ 481 regmatch.rm_ic = p_ic; 482 } 483 else 484 { 485 semsg(_(e_invarg2), p); 486 goto sortend; 487 } 488 } 489 490 /* Can only have one of 'n', 'b', 'o' and 'x'. */ 491 if (format_found > 1) 492 { 493 emsg(_(e_invarg)); 494 goto sortend; 495 } 496 497 /* From here on "sort_nr" is used as a flag for any integer number 498 * sorting. */ 499 sort_nr += sort_what; 500 501 /* 502 * Make an array with all line numbers. This avoids having to copy all 503 * the lines into allocated memory. 504 * When sorting on strings "start_col_nr" is the offset in the line, for 505 * numbers sorting it's the number to sort on. This means the pattern 506 * matching and number conversion only has to be done once per line. 507 * Also get the longest line length for allocating "sortbuf". 508 */ 509 for (lnum = eap->line1; lnum <= eap->line2; ++lnum) 510 { 511 s = ml_get(lnum); 512 len = (int)STRLEN(s); 513 if (maxlen < len) 514 maxlen = len; 515 516 start_col = 0; 517 end_col = len; 518 if (regmatch.regprog != NULL && vim_regexec(®match, s, 0)) 519 { 520 if (sort_rx) 521 { 522 start_col = (colnr_T)(regmatch.startp[0] - s); 523 end_col = (colnr_T)(regmatch.endp[0] - s); 524 } 525 else 526 start_col = (colnr_T)(regmatch.endp[0] - s); 527 } 528 else 529 if (regmatch.regprog != NULL) 530 end_col = 0; 531 532 if (sort_nr 533 #ifdef FEAT_FLOAT 534 || sort_flt 535 #endif 536 ) 537 { 538 /* Make sure vim_str2nr doesn't read any digits past the end 539 * of the match, by temporarily terminating the string there */ 540 s2 = s + end_col; 541 c = *s2; 542 *s2 = NUL; 543 /* Sorting on number: Store the number itself. */ 544 p = s + start_col; 545 if (sort_nr) 546 { 547 if (sort_what & STR2NR_HEX) 548 s = skiptohex(p); 549 else if (sort_what & STR2NR_BIN) 550 s = skiptobin(p); 551 else 552 s = skiptodigit(p); 553 if (s > p && s[-1] == '-') 554 --s; /* include preceding negative sign */ 555 if (*s == NUL) 556 /* empty line should sort before any number */ 557 nrs[lnum - eap->line1].st_u.value = -MAXLNUM; 558 else 559 vim_str2nr(s, NULL, NULL, sort_what, 560 &nrs[lnum - eap->line1].st_u.value, NULL, 0); 561 } 562 #ifdef FEAT_FLOAT 563 else 564 { 565 s = skipwhite(p); 566 if (*s == '+') 567 s = skipwhite(s + 1); 568 569 if (*s == NUL) 570 /* empty line should sort before any number */ 571 nrs[lnum - eap->line1].st_u.value_flt = -DBL_MAX; 572 else 573 nrs[lnum - eap->line1].st_u.value_flt = 574 strtod((char *)s, NULL); 575 } 576 #endif 577 *s2 = c; 578 } 579 else 580 { 581 /* Store the column to sort at. */ 582 nrs[lnum - eap->line1].st_u.line.start_col_nr = start_col; 583 nrs[lnum - eap->line1].st_u.line.end_col_nr = end_col; 584 } 585 586 nrs[lnum - eap->line1].lnum = lnum; 587 588 if (regmatch.regprog != NULL) 589 fast_breakcheck(); 590 if (got_int) 591 goto sortend; 592 } 593 594 /* Allocate a buffer that can hold the longest line. */ 595 sortbuf1 = alloc((unsigned)maxlen + 1); 596 if (sortbuf1 == NULL) 597 goto sortend; 598 sortbuf2 = alloc((unsigned)maxlen + 1); 599 if (sortbuf2 == NULL) 600 goto sortend; 601 602 /* Sort the array of line numbers. Note: can't be interrupted! */ 603 qsort((void *)nrs, count, sizeof(sorti_T), sort_compare); 604 605 if (sort_abort) 606 goto sortend; 607 608 /* Insert the lines in the sorted order below the last one. */ 609 lnum = eap->line2; 610 for (i = 0; i < count; ++i) 611 { 612 linenr_T get_lnum = nrs[eap->forceit ? count - i - 1 : i].lnum; 613 614 // If the original line number of the line being placed is not the same 615 // as "lnum" (accounting for offset), we know that the buffer changed. 616 if (get_lnum + ((linenr_T)count - 1) != lnum) 617 change_occurred = TRUE; 618 619 s = ml_get(get_lnum); 620 if (!unique || i == 0 621 || (sort_ic ? STRICMP(s, sortbuf1) : STRCMP(s, sortbuf1)) != 0) 622 { 623 // Copy the line into a buffer, it may become invalid in 624 // ml_append(). And it's needed for "unique". 625 STRCPY(sortbuf1, s); 626 if (ml_append(lnum++, sortbuf1, (colnr_T)0, FALSE) == FAIL) 627 break; 628 } 629 fast_breakcheck(); 630 if (got_int) 631 goto sortend; 632 } 633 634 /* delete the original lines if appending worked */ 635 if (i == count) 636 for (i = 0; i < count; ++i) 637 ml_delete(eap->line1, FALSE); 638 else 639 count = 0; 640 641 /* Adjust marks for deleted (or added) lines and prepare for displaying. */ 642 deleted = (long)(count - (lnum - eap->line2)); 643 if (deleted > 0) 644 { 645 mark_adjust(eap->line2 - deleted, eap->line2, (long)MAXLNUM, -deleted); 646 msgmore(-deleted); 647 } 648 else if (deleted < 0) 649 mark_adjust(eap->line2, MAXLNUM, -deleted, 0L); 650 651 if (change_occurred || deleted != 0) 652 changed_lines(eap->line1, 0, eap->line2 + 1, -deleted); 653 654 curwin->w_cursor.lnum = eap->line1; 655 beginline(BL_WHITE | BL_FIX); 656 657 sortend: 658 vim_free(nrs); 659 vim_free(sortbuf1); 660 vim_free(sortbuf2); 661 vim_regfree(regmatch.regprog); 662 if (got_int) 663 emsg(_(e_interr)); 664 } 665 666 /* 667 * ":retab". 668 */ 669 void 670 ex_retab(exarg_T *eap) 671 { 672 linenr_T lnum; 673 int got_tab = FALSE; 674 long num_spaces = 0; 675 long num_tabs; 676 long len; 677 long col; 678 long vcol; 679 long start_col = 0; /* For start of white-space string */ 680 long start_vcol = 0; /* For start of white-space string */ 681 long old_len; 682 char_u *ptr; 683 char_u *new_line = (char_u *)1; /* init to non-NULL */ 684 int did_undo; /* called u_save for current line */ 685 #ifdef FEAT_VARTABS 686 int *new_vts_array = NULL; 687 char_u *new_ts_str; /* string value of tab argument */ 688 #else 689 int temp; 690 int new_ts; 691 #endif 692 int save_list; 693 linenr_T first_line = 0; /* first changed line */ 694 linenr_T last_line = 0; /* last changed line */ 695 696 save_list = curwin->w_p_list; 697 curwin->w_p_list = 0; /* don't want list mode here */ 698 699 #ifdef FEAT_VARTABS 700 new_ts_str = eap->arg; 701 if (!tabstop_set(eap->arg, &new_vts_array)) 702 return; 703 while (vim_isdigit(*(eap->arg)) || *(eap->arg) == ',') 704 ++(eap->arg); 705 706 // This ensures that either new_vts_array and new_ts_str are freshly 707 // allocated, or new_vts_array points to an existing array and new_ts_str 708 // is null. 709 if (new_vts_array == NULL) 710 { 711 new_vts_array = curbuf->b_p_vts_array; 712 new_ts_str = NULL; 713 } 714 else 715 new_ts_str = vim_strnsave(new_ts_str, eap->arg - new_ts_str); 716 #else 717 new_ts = getdigits(&(eap->arg)); 718 if (new_ts < 0) 719 { 720 emsg(_(e_positive)); 721 return; 722 } 723 if (new_ts == 0) 724 new_ts = curbuf->b_p_ts; 725 #endif 726 for (lnum = eap->line1; !got_int && lnum <= eap->line2; ++lnum) 727 { 728 ptr = ml_get(lnum); 729 col = 0; 730 vcol = 0; 731 did_undo = FALSE; 732 for (;;) 733 { 734 if (VIM_ISWHITE(ptr[col])) 735 { 736 if (!got_tab && num_spaces == 0) 737 { 738 /* First consecutive white-space */ 739 start_vcol = vcol; 740 start_col = col; 741 } 742 if (ptr[col] == ' ') 743 num_spaces++; 744 else 745 got_tab = TRUE; 746 } 747 else 748 { 749 if (got_tab || (eap->forceit && num_spaces > 1)) 750 { 751 /* Retabulate this string of white-space */ 752 753 /* len is virtual length of white string */ 754 len = num_spaces = vcol - start_vcol; 755 num_tabs = 0; 756 if (!curbuf->b_p_et) 757 { 758 #ifdef FEAT_VARTABS 759 int t, s; 760 761 tabstop_fromto(start_vcol, vcol, 762 curbuf->b_p_ts, new_vts_array, &t, &s); 763 num_tabs = t; 764 num_spaces = s; 765 #else 766 temp = new_ts - (start_vcol % new_ts); 767 if (num_spaces >= temp) 768 { 769 num_spaces -= temp; 770 num_tabs++; 771 } 772 num_tabs += num_spaces / new_ts; 773 num_spaces -= (num_spaces / new_ts) * new_ts; 774 #endif 775 } 776 if (curbuf->b_p_et || got_tab || 777 (num_spaces + num_tabs < len)) 778 { 779 if (did_undo == FALSE) 780 { 781 did_undo = TRUE; 782 if (u_save((linenr_T)(lnum - 1), 783 (linenr_T)(lnum + 1)) == FAIL) 784 { 785 new_line = NULL; /* flag out-of-memory */ 786 break; 787 } 788 } 789 790 /* len is actual number of white characters used */ 791 len = num_spaces + num_tabs; 792 old_len = (long)STRLEN(ptr); 793 new_line = lalloc(old_len - col + start_col + len + 1, 794 TRUE); 795 if (new_line == NULL) 796 break; 797 if (start_col > 0) 798 mch_memmove(new_line, ptr, (size_t)start_col); 799 mch_memmove(new_line + start_col + len, 800 ptr + col, (size_t)(old_len - col + 1)); 801 ptr = new_line + start_col; 802 for (col = 0; col < len; col++) 803 ptr[col] = (col < num_tabs) ? '\t' : ' '; 804 ml_replace(lnum, new_line, FALSE); 805 if (first_line == 0) 806 first_line = lnum; 807 last_line = lnum; 808 ptr = new_line; 809 col = start_col + len; 810 } 811 } 812 got_tab = FALSE; 813 num_spaces = 0; 814 } 815 if (ptr[col] == NUL) 816 break; 817 vcol += chartabsize(ptr + col, (colnr_T)vcol); 818 if (has_mbyte) 819 col += (*mb_ptr2len)(ptr + col); 820 else 821 ++col; 822 } 823 if (new_line == NULL) /* out of memory */ 824 break; 825 line_breakcheck(); 826 } 827 if (got_int) 828 emsg(_(e_interr)); 829 830 #ifdef FEAT_VARTABS 831 // If a single value was given then it can be considered equal to 832 // either the value of 'tabstop' or the value of 'vartabstop'. 833 if (tabstop_count(curbuf->b_p_vts_array) == 0 834 && tabstop_count(new_vts_array) == 1 835 && curbuf->b_p_ts == tabstop_first(new_vts_array)) 836 ; /* not changed */ 837 else if (tabstop_count(curbuf->b_p_vts_array) > 0 838 && tabstop_eq(curbuf->b_p_vts_array, new_vts_array)) 839 ; /* not changed */ 840 else 841 redraw_curbuf_later(NOT_VALID); 842 #else 843 if (curbuf->b_p_ts != new_ts) 844 redraw_curbuf_later(NOT_VALID); 845 #endif 846 if (first_line != 0) 847 changed_lines(first_line, 0, last_line + 1, 0L); 848 849 curwin->w_p_list = save_list; /* restore 'list' */ 850 851 #ifdef FEAT_VARTABS 852 if (new_ts_str != NULL) /* set the new tabstop */ 853 { 854 // If 'vartabstop' is in use or if the value given to retab has more 855 // than one tabstop then update 'vartabstop'. 856 int *old_vts_ary = curbuf->b_p_vts_array; 857 858 if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1) 859 { 860 set_string_option_direct((char_u *)"vts", -1, new_ts_str, 861 OPT_FREE|OPT_LOCAL, 0); 862 curbuf->b_p_vts_array = new_vts_array; 863 vim_free(old_vts_ary); 864 } 865 else 866 { 867 // 'vartabstop' wasn't in use and a single value was given to 868 // retab then update 'tabstop'. 869 curbuf->b_p_ts = tabstop_first(new_vts_array); 870 vim_free(new_vts_array); 871 } 872 vim_free(new_ts_str); 873 } 874 #else 875 curbuf->b_p_ts = new_ts; 876 #endif 877 coladvance(curwin->w_curswant); 878 879 u_clearline(); 880 } 881 882 /* 883 * :move command - move lines line1-line2 to line dest 884 * 885 * return FAIL for failure, OK otherwise 886 */ 887 int 888 do_move(linenr_T line1, linenr_T line2, linenr_T dest) 889 { 890 char_u *str; 891 linenr_T l; 892 linenr_T extra; // Num lines added before line1 893 linenr_T num_lines; // Num lines moved 894 linenr_T last_line; // Last line in file after adding new text 895 #ifdef FEAT_FOLDING 896 win_T *win; 897 tabpage_T *tp; 898 #endif 899 900 if (dest >= line1 && dest < line2) 901 { 902 emsg(_("E134: Cannot move a range of lines into itself")); 903 return FAIL; 904 } 905 906 // Do nothing if we are not actually moving any lines. This will prevent 907 // the 'modified' flag from being set without cause. 908 if (dest == line1 - 1 || dest == line2) 909 { 910 // Move the cursor as if lines were moved (see below) to be backwards 911 // compatible. 912 if (dest >= line1) 913 curwin->w_cursor.lnum = dest; 914 else 915 curwin->w_cursor.lnum = dest + (line2 - line1) + 1; 916 917 return OK; 918 } 919 920 num_lines = line2 - line1 + 1; 921 922 /* 923 * First we copy the old text to its new location -- webb 924 * Also copy the flag that ":global" command uses. 925 */ 926 if (u_save(dest, dest + 1) == FAIL) 927 return FAIL; 928 for (extra = 0, l = line1; l <= line2; l++) 929 { 930 str = vim_strsave(ml_get(l + extra)); 931 if (str != NULL) 932 { 933 ml_append(dest + l - line1, str, (colnr_T)0, FALSE); 934 vim_free(str); 935 if (dest < line1) 936 extra++; 937 } 938 } 939 940 /* 941 * Now we must be careful adjusting our marks so that we don't overlap our 942 * mark_adjust() calls. 943 * 944 * We adjust the marks within the old text so that they refer to the 945 * last lines of the file (temporarily), because we know no other marks 946 * will be set there since these line numbers did not exist until we added 947 * our new lines. 948 * 949 * Then we adjust the marks on lines between the old and new text positions 950 * (either forwards or backwards). 951 * 952 * And Finally we adjust the marks we put at the end of the file back to 953 * their final destination at the new text position -- webb 954 */ 955 last_line = curbuf->b_ml.ml_line_count; 956 mark_adjust_nofold(line1, line2, last_line - line2, 0L); 957 if (dest >= line2) 958 { 959 mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L); 960 #ifdef FEAT_FOLDING 961 FOR_ALL_TAB_WINDOWS(tp, win) { 962 if (win->w_buffer == curbuf) 963 foldMoveRange(&win->w_folds, line1, line2, dest); 964 } 965 #endif 966 curbuf->b_op_start.lnum = dest - num_lines + 1; 967 curbuf->b_op_end.lnum = dest; 968 } 969 else 970 { 971 mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L); 972 #ifdef FEAT_FOLDING 973 FOR_ALL_TAB_WINDOWS(tp, win) { 974 if (win->w_buffer == curbuf) 975 foldMoveRange(&win->w_folds, dest + 1, line1 - 1, line2); 976 } 977 #endif 978 curbuf->b_op_start.lnum = dest + 1; 979 curbuf->b_op_end.lnum = dest + num_lines; 980 } 981 curbuf->b_op_start.col = curbuf->b_op_end.col = 0; 982 mark_adjust_nofold(last_line - num_lines + 1, last_line, 983 -(last_line - dest - extra), 0L); 984 985 /* 986 * Now we delete the original text -- webb 987 */ 988 if (u_save(line1 + extra - 1, line2 + extra + 1) == FAIL) 989 return FAIL; 990 991 for (l = line1; l <= line2; l++) 992 ml_delete(line1 + extra, TRUE); 993 994 if (!global_busy && num_lines > p_report) 995 smsg(NGETTEXT("%ld line moved", "%ld lines moved", num_lines), 996 (long)num_lines); 997 998 /* 999 * Leave the cursor on the last of the moved lines. 1000 */ 1001 if (dest >= line1) 1002 curwin->w_cursor.lnum = dest; 1003 else 1004 curwin->w_cursor.lnum = dest + (line2 - line1) + 1; 1005 1006 if (line1 < dest) 1007 { 1008 dest += num_lines + 1; 1009 last_line = curbuf->b_ml.ml_line_count; 1010 if (dest > last_line + 1) 1011 dest = last_line + 1; 1012 changed_lines(line1, 0, dest, 0L); 1013 } 1014 else 1015 changed_lines(dest + 1, 0, line1 + num_lines, 0L); 1016 1017 return OK; 1018 } 1019 1020 /* 1021 * ":copy" 1022 */ 1023 void 1024 ex_copy(linenr_T line1, linenr_T line2, linenr_T n) 1025 { 1026 linenr_T count; 1027 char_u *p; 1028 1029 count = line2 - line1 + 1; 1030 curbuf->b_op_start.lnum = n + 1; 1031 curbuf->b_op_end.lnum = n + count; 1032 curbuf->b_op_start.col = curbuf->b_op_end.col = 0; 1033 1034 /* 1035 * there are three situations: 1036 * 1. destination is above line1 1037 * 2. destination is between line1 and line2 1038 * 3. destination is below line2 1039 * 1040 * n = destination (when starting) 1041 * curwin->w_cursor.lnum = destination (while copying) 1042 * line1 = start of source (while copying) 1043 * line2 = end of source (while copying) 1044 */ 1045 if (u_save(n, n + 1) == FAIL) 1046 return; 1047 1048 curwin->w_cursor.lnum = n; 1049 while (line1 <= line2) 1050 { 1051 /* need to use vim_strsave() because the line will be unlocked within 1052 * ml_append() */ 1053 p = vim_strsave(ml_get(line1)); 1054 if (p != NULL) 1055 { 1056 ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, FALSE); 1057 vim_free(p); 1058 } 1059 /* situation 2: skip already copied lines */ 1060 if (line1 == n) 1061 line1 = curwin->w_cursor.lnum; 1062 ++line1; 1063 if (curwin->w_cursor.lnum < line1) 1064 ++line1; 1065 if (curwin->w_cursor.lnum < line2) 1066 ++line2; 1067 ++curwin->w_cursor.lnum; 1068 } 1069 1070 appended_lines_mark(n, count); 1071 1072 msgmore((long)count); 1073 } 1074 1075 static char_u *prevcmd = NULL; /* the previous command */ 1076 1077 #if defined(EXITFREE) || defined(PROTO) 1078 void 1079 free_prev_shellcmd(void) 1080 { 1081 vim_free(prevcmd); 1082 } 1083 #endif 1084 1085 /* 1086 * Handle the ":!cmd" command. Also for ":r !cmd" and ":w !cmd" 1087 * Bangs in the argument are replaced with the previously entered command. 1088 * Remember the argument. 1089 */ 1090 void 1091 do_bang( 1092 int addr_count, 1093 exarg_T *eap, 1094 int forceit, 1095 int do_in, 1096 int do_out) 1097 { 1098 char_u *arg = eap->arg; /* command */ 1099 linenr_T line1 = eap->line1; /* start of range */ 1100 linenr_T line2 = eap->line2; /* end of range */ 1101 char_u *newcmd = NULL; /* the new command */ 1102 int free_newcmd = FALSE; /* need to free() newcmd */ 1103 int ins_prevcmd; 1104 char_u *t; 1105 char_u *p; 1106 char_u *trailarg; 1107 int len; 1108 int scroll_save = msg_scroll; 1109 1110 /* 1111 * Disallow shell commands for "rvim". 1112 * Disallow shell commands from .exrc and .vimrc in current directory for 1113 * security reasons. 1114 */ 1115 if (check_restricted() || check_secure()) 1116 return; 1117 1118 if (addr_count == 0) /* :! */ 1119 { 1120 msg_scroll = FALSE; /* don't scroll here */ 1121 autowrite_all(); 1122 msg_scroll = scroll_save; 1123 } 1124 1125 /* 1126 * Try to find an embedded bang, like in :!<cmd> ! [args] 1127 * (:!! is indicated by the 'forceit' variable) 1128 */ 1129 ins_prevcmd = forceit; 1130 trailarg = arg; 1131 do 1132 { 1133 len = (int)STRLEN(trailarg) + 1; 1134 if (newcmd != NULL) 1135 len += (int)STRLEN(newcmd); 1136 if (ins_prevcmd) 1137 { 1138 if (prevcmd == NULL) 1139 { 1140 emsg(_(e_noprev)); 1141 vim_free(newcmd); 1142 return; 1143 } 1144 len += (int)STRLEN(prevcmd); 1145 } 1146 if ((t = alloc((unsigned)len)) == NULL) 1147 { 1148 vim_free(newcmd); 1149 return; 1150 } 1151 *t = NUL; 1152 if (newcmd != NULL) 1153 STRCAT(t, newcmd); 1154 if (ins_prevcmd) 1155 STRCAT(t, prevcmd); 1156 p = t + STRLEN(t); 1157 STRCAT(t, trailarg); 1158 vim_free(newcmd); 1159 newcmd = t; 1160 1161 /* 1162 * Scan the rest of the argument for '!', which is replaced by the 1163 * previous command. "\!" is replaced by "!" (this is vi compatible). 1164 */ 1165 trailarg = NULL; 1166 while (*p) 1167 { 1168 if (*p == '!') 1169 { 1170 if (p > newcmd && p[-1] == '\\') 1171 STRMOVE(p - 1, p); 1172 else 1173 { 1174 trailarg = p; 1175 *trailarg++ = NUL; 1176 ins_prevcmd = TRUE; 1177 break; 1178 } 1179 } 1180 ++p; 1181 } 1182 } while (trailarg != NULL); 1183 1184 vim_free(prevcmd); 1185 prevcmd = newcmd; 1186 1187 if (bangredo) /* put cmd in redo buffer for ! command */ 1188 { 1189 /* If % or # appears in the command, it must have been escaped. 1190 * Reescape them, so that redoing them does not substitute them by the 1191 * buffername. */ 1192 char_u *cmd = vim_strsave_escaped(prevcmd, (char_u *)"%#"); 1193 1194 if (cmd != NULL) 1195 { 1196 AppendToRedobuffLit(cmd, -1); 1197 vim_free(cmd); 1198 } 1199 else 1200 AppendToRedobuffLit(prevcmd, -1); 1201 AppendToRedobuff((char_u *)"\n"); 1202 bangredo = FALSE; 1203 } 1204 /* 1205 * Add quotes around the command, for shells that need them. 1206 */ 1207 if (*p_shq != NUL) 1208 { 1209 newcmd = alloc((unsigned)(STRLEN(prevcmd) + 2 * STRLEN(p_shq) + 1)); 1210 if (newcmd == NULL) 1211 return; 1212 STRCPY(newcmd, p_shq); 1213 STRCAT(newcmd, prevcmd); 1214 STRCAT(newcmd, p_shq); 1215 free_newcmd = TRUE; 1216 } 1217 if (addr_count == 0) /* :! */ 1218 { 1219 /* echo the command */ 1220 msg_start(); 1221 msg_putchar(':'); 1222 msg_putchar('!'); 1223 msg_outtrans(newcmd); 1224 msg_clr_eos(); 1225 windgoto(msg_row, msg_col); 1226 1227 do_shell(newcmd, 0); 1228 } 1229 else /* :range! */ 1230 { 1231 /* Careful: This may recursively call do_bang() again! (because of 1232 * autocommands) */ 1233 do_filter(line1, line2, eap, newcmd, do_in, do_out); 1234 apply_autocmds(EVENT_SHELLFILTERPOST, NULL, NULL, FALSE, curbuf); 1235 } 1236 if (free_newcmd) 1237 vim_free(newcmd); 1238 } 1239 1240 /* 1241 * do_filter: filter lines through a command given by the user 1242 * 1243 * We mostly use temp files and the call_shell() routine here. This would 1244 * normally be done using pipes on a UNIX machine, but this is more portable 1245 * to non-unix machines. The call_shell() routine needs to be able 1246 * to deal with redirection somehow, and should handle things like looking 1247 * at the PATH env. variable, and adding reasonable extensions to the 1248 * command name given by the user. All reasonable versions of call_shell() 1249 * do this. 1250 * Alternatively, if on Unix and redirecting input or output, but not both, 1251 * and the 'shelltemp' option isn't set, use pipes. 1252 * We use input redirection if do_in is TRUE. 1253 * We use output redirection if do_out is TRUE. 1254 */ 1255 static void 1256 do_filter( 1257 linenr_T line1, 1258 linenr_T line2, 1259 exarg_T *eap, /* for forced 'ff' and 'fenc' */ 1260 char_u *cmd, 1261 int do_in, 1262 int do_out) 1263 { 1264 char_u *itmp = NULL; 1265 char_u *otmp = NULL; 1266 linenr_T linecount; 1267 linenr_T read_linecount; 1268 pos_T cursor_save; 1269 char_u *cmd_buf; 1270 buf_T *old_curbuf = curbuf; 1271 int shell_flags = 0; 1272 1273 if (*cmd == NUL) /* no filter command */ 1274 return; 1275 1276 cursor_save = curwin->w_cursor; 1277 linecount = line2 - line1 + 1; 1278 curwin->w_cursor.lnum = line1; 1279 curwin->w_cursor.col = 0; 1280 changed_line_abv_curs(); 1281 invalidate_botline(); 1282 1283 /* 1284 * When using temp files: 1285 * 1. * Form temp file names 1286 * 2. * Write the lines to a temp file 1287 * 3. Run the filter command on the temp file 1288 * 4. * Read the output of the command into the buffer 1289 * 5. * Delete the original lines to be filtered 1290 * 6. * Remove the temp files 1291 * 1292 * When writing the input with a pipe or when catching the output with a 1293 * pipe only need to do 3. 1294 */ 1295 1296 if (do_out) 1297 shell_flags |= SHELL_DOOUT; 1298 1299 #ifdef FEAT_FILTERPIPE 1300 if (!do_in && do_out && !p_stmp) 1301 { 1302 /* Use a pipe to fetch stdout of the command, do not use a temp file. */ 1303 shell_flags |= SHELL_READ; 1304 curwin->w_cursor.lnum = line2; 1305 } 1306 else if (do_in && !do_out && !p_stmp) 1307 { 1308 /* Use a pipe to write stdin of the command, do not use a temp file. */ 1309 shell_flags |= SHELL_WRITE; 1310 curbuf->b_op_start.lnum = line1; 1311 curbuf->b_op_end.lnum = line2; 1312 } 1313 else if (do_in && do_out && !p_stmp) 1314 { 1315 /* Use a pipe to write stdin and fetch stdout of the command, do not 1316 * use a temp file. */ 1317 shell_flags |= SHELL_READ|SHELL_WRITE; 1318 curbuf->b_op_start.lnum = line1; 1319 curbuf->b_op_end.lnum = line2; 1320 curwin->w_cursor.lnum = line2; 1321 } 1322 else 1323 #endif 1324 if ((do_in && (itmp = vim_tempname('i', FALSE)) == NULL) 1325 || (do_out && (otmp = vim_tempname('o', FALSE)) == NULL)) 1326 { 1327 emsg(_(e_notmp)); 1328 goto filterend; 1329 } 1330 1331 /* 1332 * The writing and reading of temp files will not be shown. 1333 * Vi also doesn't do this and the messages are not very informative. 1334 */ 1335 ++no_wait_return; /* don't call wait_return() while busy */ 1336 if (itmp != NULL && buf_write(curbuf, itmp, NULL, line1, line2, eap, 1337 FALSE, FALSE, FALSE, TRUE) == FAIL) 1338 { 1339 msg_putchar('\n'); /* keep message from buf_write() */ 1340 --no_wait_return; 1341 #if defined(FEAT_EVAL) 1342 if (!aborting()) 1343 #endif 1344 (void)semsg(_(e_notcreate), itmp); /* will call wait_return */ 1345 goto filterend; 1346 } 1347 if (curbuf != old_curbuf) 1348 goto filterend; 1349 1350 if (!do_out) 1351 msg_putchar('\n'); 1352 1353 /* Create the shell command in allocated memory. */ 1354 cmd_buf = make_filter_cmd(cmd, itmp, otmp); 1355 if (cmd_buf == NULL) 1356 goto filterend; 1357 1358 windgoto((int)Rows - 1, 0); 1359 cursor_on(); 1360 1361 /* 1362 * When not redirecting the output the command can write anything to the 1363 * screen. If 'shellredir' is equal to ">", screen may be messed up by 1364 * stderr output of external command. Clear the screen later. 1365 * If do_in is FALSE, this could be something like ":r !cat", which may 1366 * also mess up the screen, clear it later. 1367 */ 1368 if (!do_out || STRCMP(p_srr, ">") == 0 || !do_in) 1369 redraw_later_clear(); 1370 1371 if (do_out) 1372 { 1373 if (u_save((linenr_T)(line2), (linenr_T)(line2 + 1)) == FAIL) 1374 { 1375 vim_free(cmd_buf); 1376 goto error; 1377 } 1378 redraw_curbuf_later(VALID); 1379 } 1380 read_linecount = curbuf->b_ml.ml_line_count; 1381 1382 /* 1383 * When call_shell() fails wait_return() is called to give the user a 1384 * chance to read the error messages. Otherwise errors are ignored, so you 1385 * can see the error messages from the command that appear on stdout; use 1386 * 'u' to fix the text 1387 * Switch to cooked mode when not redirecting stdin, avoids that something 1388 * like ":r !cat" hangs. 1389 * Pass on the SHELL_DOOUT flag when the output is being redirected. 1390 */ 1391 if (call_shell(cmd_buf, SHELL_FILTER | SHELL_COOKED | shell_flags)) 1392 { 1393 redraw_later_clear(); 1394 wait_return(FALSE); 1395 } 1396 vim_free(cmd_buf); 1397 1398 did_check_timestamps = FALSE; 1399 need_check_timestamps = TRUE; 1400 1401 /* When interrupting the shell command, it may still have produced some 1402 * useful output. Reset got_int here, so that readfile() won't cancel 1403 * reading. */ 1404 ui_breakcheck(); 1405 got_int = FALSE; 1406 1407 if (do_out) 1408 { 1409 if (otmp != NULL) 1410 { 1411 if (readfile(otmp, NULL, line2, (linenr_T)0, (linenr_T)MAXLNUM, 1412 eap, READ_FILTER) != OK) 1413 { 1414 #if defined(FEAT_EVAL) 1415 if (!aborting()) 1416 #endif 1417 { 1418 msg_putchar('\n'); 1419 semsg(_(e_notread), otmp); 1420 } 1421 goto error; 1422 } 1423 if (curbuf != old_curbuf) 1424 goto filterend; 1425 } 1426 1427 read_linecount = curbuf->b_ml.ml_line_count - read_linecount; 1428 1429 if (shell_flags & SHELL_READ) 1430 { 1431 curbuf->b_op_start.lnum = line2 + 1; 1432 curbuf->b_op_end.lnum = curwin->w_cursor.lnum; 1433 appended_lines_mark(line2, read_linecount); 1434 } 1435 1436 if (do_in) 1437 { 1438 if (cmdmod.keepmarks || vim_strchr(p_cpo, CPO_REMMARK) == NULL) 1439 { 1440 if (read_linecount >= linecount) 1441 /* move all marks from old lines to new lines */ 1442 mark_adjust(line1, line2, linecount, 0L); 1443 else 1444 { 1445 /* move marks from old lines to new lines, delete marks 1446 * that are in deleted lines */ 1447 mark_adjust(line1, line1 + read_linecount - 1, 1448 linecount, 0L); 1449 mark_adjust(line1 + read_linecount, line2, MAXLNUM, 0L); 1450 } 1451 } 1452 1453 /* 1454 * Put cursor on first filtered line for ":range!cmd". 1455 * Adjust '[ and '] (set by buf_write()). 1456 */ 1457 curwin->w_cursor.lnum = line1; 1458 del_lines(linecount, TRUE); 1459 curbuf->b_op_start.lnum -= linecount; /* adjust '[ */ 1460 curbuf->b_op_end.lnum -= linecount; /* adjust '] */ 1461 write_lnum_adjust(-linecount); /* adjust last line 1462 for next write */ 1463 #ifdef FEAT_FOLDING 1464 foldUpdate(curwin, curbuf->b_op_start.lnum, curbuf->b_op_end.lnum); 1465 #endif 1466 } 1467 else 1468 { 1469 /* 1470 * Put cursor on last new line for ":r !cmd". 1471 */ 1472 linecount = curbuf->b_op_end.lnum - curbuf->b_op_start.lnum + 1; 1473 curwin->w_cursor.lnum = curbuf->b_op_end.lnum; 1474 } 1475 1476 beginline(BL_WHITE | BL_FIX); /* cursor on first non-blank */ 1477 --no_wait_return; 1478 1479 if (linecount > p_report) 1480 { 1481 if (do_in) 1482 { 1483 vim_snprintf(msg_buf, sizeof(msg_buf), 1484 _("%ld lines filtered"), (long)linecount); 1485 if (msg(msg_buf) && !msg_scroll) 1486 /* save message to display it after redraw */ 1487 set_keep_msg((char_u *)msg_buf, 0); 1488 } 1489 else 1490 msgmore((long)linecount); 1491 } 1492 } 1493 else 1494 { 1495 error: 1496 /* put cursor back in same position for ":w !cmd" */ 1497 curwin->w_cursor = cursor_save; 1498 --no_wait_return; 1499 wait_return(FALSE); 1500 } 1501 1502 filterend: 1503 1504 if (curbuf != old_curbuf) 1505 { 1506 --no_wait_return; 1507 emsg(_("E135: *Filter* Autocommands must not change current buffer")); 1508 } 1509 if (itmp != NULL) 1510 mch_remove(itmp); 1511 if (otmp != NULL) 1512 mch_remove(otmp); 1513 vim_free(itmp); 1514 vim_free(otmp); 1515 } 1516 1517 /* 1518 * Call a shell to execute a command. 1519 * When "cmd" is NULL start an interactive shell. 1520 */ 1521 void 1522 do_shell( 1523 char_u *cmd, 1524 int flags) /* may be SHELL_DOOUT when output is redirected */ 1525 { 1526 buf_T *buf; 1527 #ifndef FEAT_GUI_MSWIN 1528 int save_nwr; 1529 #endif 1530 #ifdef MSWIN 1531 int winstart = FALSE; 1532 #endif 1533 1534 /* 1535 * Disallow shell commands for "rvim". 1536 * Disallow shell commands from .exrc and .vimrc in current directory for 1537 * security reasons. 1538 */ 1539 if (check_restricted() || check_secure()) 1540 { 1541 msg_end(); 1542 return; 1543 } 1544 1545 #ifdef MSWIN 1546 /* 1547 * Check if ":!start" is used. 1548 */ 1549 if (cmd != NULL) 1550 winstart = (STRNICMP(cmd, "start ", 6) == 0); 1551 #endif 1552 1553 /* 1554 * For autocommands we want to get the output on the current screen, to 1555 * avoid having to type return below. 1556 */ 1557 msg_putchar('\r'); /* put cursor at start of line */ 1558 if (!autocmd_busy) 1559 { 1560 #ifdef MSWIN 1561 if (!winstart) 1562 #endif 1563 stoptermcap(); 1564 } 1565 #ifdef MSWIN 1566 if (!winstart) 1567 #endif 1568 msg_putchar('\n'); /* may shift screen one line up */ 1569 1570 /* warning message before calling the shell */ 1571 if (p_warn && !autocmd_busy && msg_silent == 0) 1572 FOR_ALL_BUFFERS(buf) 1573 if (bufIsChangedNotTerm(buf)) 1574 { 1575 #ifdef FEAT_GUI_MSWIN 1576 if (!winstart) 1577 starttermcap(); /* don't want a message box here */ 1578 #endif 1579 msg_puts(_("[No write since last change]\n")); 1580 #ifdef FEAT_GUI_MSWIN 1581 if (!winstart) 1582 stoptermcap(); 1583 #endif 1584 break; 1585 } 1586 1587 /* This windgoto is required for when the '\n' resulted in a "delete line 1588 * 1" command to the terminal. */ 1589 if (!swapping_screen()) 1590 windgoto(msg_row, msg_col); 1591 cursor_on(); 1592 (void)call_shell(cmd, SHELL_COOKED | flags); 1593 did_check_timestamps = FALSE; 1594 need_check_timestamps = TRUE; 1595 1596 /* 1597 * put the message cursor at the end of the screen, avoids wait_return() 1598 * to overwrite the text that the external command showed 1599 */ 1600 if (!swapping_screen()) 1601 { 1602 msg_row = Rows - 1; 1603 msg_col = 0; 1604 } 1605 1606 if (autocmd_busy) 1607 { 1608 if (msg_silent == 0) 1609 redraw_later_clear(); 1610 } 1611 else 1612 { 1613 /* 1614 * For ":sh" there is no need to call wait_return(), just redraw. 1615 * Also for the Win32 GUI (the output is in a console window). 1616 * Otherwise there is probably text on the screen that the user wants 1617 * to read before redrawing, so call wait_return(). 1618 */ 1619 #ifndef FEAT_GUI_MSWIN 1620 if (cmd == NULL 1621 # ifdef WIN3264 1622 || (winstart && !need_wait_return) 1623 # endif 1624 ) 1625 { 1626 if (msg_silent == 0) 1627 redraw_later_clear(); 1628 need_wait_return = FALSE; 1629 } 1630 else 1631 { 1632 /* 1633 * If we switch screens when starttermcap() is called, we really 1634 * want to wait for "hit return to continue". 1635 */ 1636 save_nwr = no_wait_return; 1637 if (swapping_screen()) 1638 no_wait_return = FALSE; 1639 # ifdef AMIGA 1640 wait_return(term_console ? -1 : msg_silent == 0); /* see below */ 1641 # else 1642 wait_return(msg_silent == 0); 1643 # endif 1644 no_wait_return = save_nwr; 1645 } 1646 #endif /* FEAT_GUI_W32 */ 1647 1648 #ifdef MSWIN 1649 if (!winstart) /* if winstart==TRUE, never stopped termcap! */ 1650 #endif 1651 starttermcap(); /* start termcap if not done by wait_return() */ 1652 1653 /* 1654 * In an Amiga window redrawing is caused by asking the window size. 1655 * If we got an interrupt this will not work. The chance that the 1656 * window size is wrong is very small, but we need to redraw the 1657 * screen. Don't do this if ':' hit in wait_return(). THIS IS UGLY 1658 * but it saves an extra redraw. 1659 */ 1660 #ifdef AMIGA 1661 if (skip_redraw) /* ':' hit in wait_return() */ 1662 { 1663 if (msg_silent == 0) 1664 redraw_later_clear(); 1665 } 1666 else if (term_console) 1667 { 1668 OUT_STR(IF_EB("\033[0 q", ESC_STR "[0 q")); /* get window size */ 1669 if (got_int && msg_silent == 0) 1670 redraw_later_clear(); /* if got_int is TRUE, redraw needed */ 1671 else 1672 must_redraw = 0; /* no extra redraw needed */ 1673 } 1674 #endif 1675 } 1676 1677 /* display any error messages now */ 1678 display_errors(); 1679 1680 apply_autocmds(EVENT_SHELLCMDPOST, NULL, NULL, FALSE, curbuf); 1681 } 1682 1683 #if !defined(UNIX) 1684 static char_u * 1685 find_pipe(char_u *cmd) 1686 { 1687 char_u *p; 1688 int inquote = FALSE; 1689 1690 for (p = cmd; *p != NUL; ++p) 1691 { 1692 if (!inquote && *p == '|') 1693 return p; 1694 if (*p == '"') 1695 inquote = !inquote; 1696 else if (rem_backslash(p)) 1697 ++p; 1698 } 1699 return NULL; 1700 } 1701 #endif 1702 1703 /* 1704 * Create a shell command from a command string, input redirection file and 1705 * output redirection file. 1706 * Returns an allocated string with the shell command, or NULL for failure. 1707 */ 1708 char_u * 1709 make_filter_cmd( 1710 char_u *cmd, /* command */ 1711 char_u *itmp, /* NULL or name of input file */ 1712 char_u *otmp) /* NULL or name of output file */ 1713 { 1714 char_u *buf; 1715 long_u len; 1716 1717 #if defined(UNIX) 1718 int is_fish_shell; 1719 char_u *shell_name = get_isolated_shell_name(); 1720 1721 /* Account for fish's different syntax for subshells */ 1722 is_fish_shell = (fnamecmp(shell_name, "fish") == 0); 1723 vim_free(shell_name); 1724 if (is_fish_shell) 1725 len = (long_u)STRLEN(cmd) + 13; /* "begin; " + "; end" + NUL */ 1726 else 1727 #endif 1728 len = (long_u)STRLEN(cmd) + 3; /* "()" + NUL */ 1729 if (itmp != NULL) 1730 len += (long_u)STRLEN(itmp) + 9; /* " { < " + " } " */ 1731 if (otmp != NULL) 1732 len += (long_u)STRLEN(otmp) + (long_u)STRLEN(p_srr) + 2; /* " " */ 1733 buf = lalloc(len, TRUE); 1734 if (buf == NULL) 1735 return NULL; 1736 1737 #if defined(UNIX) 1738 /* 1739 * Put braces around the command (for concatenated commands) when 1740 * redirecting input and/or output. 1741 */ 1742 if (itmp != NULL || otmp != NULL) 1743 { 1744 if (is_fish_shell) 1745 vim_snprintf((char *)buf, len, "begin; %s; end", (char *)cmd); 1746 else 1747 vim_snprintf((char *)buf, len, "(%s)", (char *)cmd); 1748 } 1749 else 1750 STRCPY(buf, cmd); 1751 if (itmp != NULL) 1752 { 1753 STRCAT(buf, " < "); 1754 STRCAT(buf, itmp); 1755 } 1756 #else 1757 /* 1758 * For shells that don't understand braces around commands, at least allow 1759 * the use of commands in a pipe. 1760 */ 1761 STRCPY(buf, cmd); 1762 if (itmp != NULL) 1763 { 1764 char_u *p; 1765 1766 /* 1767 * If there is a pipe, we have to put the '<' in front of it. 1768 * Don't do this when 'shellquote' is not empty, otherwise the 1769 * redirection would be inside the quotes. 1770 */ 1771 if (*p_shq == NUL) 1772 { 1773 p = find_pipe(buf); 1774 if (p != NULL) 1775 *p = NUL; 1776 } 1777 STRCAT(buf, " <"); /* " < " causes problems on Amiga */ 1778 STRCAT(buf, itmp); 1779 if (*p_shq == NUL) 1780 { 1781 p = find_pipe(cmd); 1782 if (p != NULL) 1783 { 1784 STRCAT(buf, " "); /* insert a space before the '|' for DOS */ 1785 STRCAT(buf, p); 1786 } 1787 } 1788 } 1789 #endif 1790 if (otmp != NULL) 1791 append_redir(buf, (int)len, p_srr, otmp); 1792 1793 return buf; 1794 } 1795 1796 /* 1797 * Append output redirection for file "fname" to the end of string buffer 1798 * "buf[buflen]" 1799 * Works with the 'shellredir' and 'shellpipe' options. 1800 * The caller should make sure that there is enough room: 1801 * STRLEN(opt) + STRLEN(fname) + 3 1802 */ 1803 void 1804 append_redir( 1805 char_u *buf, 1806 int buflen, 1807 char_u *opt, 1808 char_u *fname) 1809 { 1810 char_u *p; 1811 char_u *end; 1812 1813 end = buf + STRLEN(buf); 1814 /* find "%s" */ 1815 for (p = opt; (p = vim_strchr(p, '%')) != NULL; ++p) 1816 { 1817 if (p[1] == 's') /* found %s */ 1818 break; 1819 if (p[1] == '%') /* skip %% */ 1820 ++p; 1821 } 1822 if (p != NULL) 1823 { 1824 *end = ' '; /* not really needed? Not with sh, ksh or bash */ 1825 vim_snprintf((char *)end + 1, (size_t)(buflen - (end + 1 - buf)), 1826 (char *)opt, (char *)fname); 1827 } 1828 else 1829 vim_snprintf((char *)end, (size_t)(buflen - (end - buf)), 1830 #ifdef FEAT_QUICKFIX 1831 " %s %s", 1832 #else 1833 " %s%s", /* " > %s" causes problems on Amiga */ 1834 #endif 1835 (char *)opt, (char *)fname); 1836 } 1837 1838 #if defined(FEAT_VIMINFO) || defined(PROTO) 1839 1840 static int read_viminfo_barline(vir_T *virp, int got_encoding, int force, int writing); 1841 static void write_viminfo_version(FILE *fp_out); 1842 static void write_viminfo_barlines(vir_T *virp, FILE *fp_out); 1843 static int viminfo_errcnt; 1844 1845 static int 1846 no_viminfo(void) 1847 { 1848 /* "vim -i NONE" does not read or write a viminfo file */ 1849 return STRCMP(p_viminfofile, "NONE") == 0; 1850 } 1851 1852 /* 1853 * Report an error for reading a viminfo file. 1854 * Count the number of errors. When there are more than 10, return TRUE. 1855 */ 1856 int 1857 viminfo_error(char *errnum, char *message, char_u *line) 1858 { 1859 vim_snprintf((char *)IObuff, IOSIZE, _("%sviminfo: %s in line: "), 1860 errnum, message); 1861 STRNCAT(IObuff, line, IOSIZE - STRLEN(IObuff) - 1); 1862 if (IObuff[STRLEN(IObuff) - 1] == '\n') 1863 IObuff[STRLEN(IObuff) - 1] = NUL; 1864 emsg((char *)IObuff); 1865 if (++viminfo_errcnt >= 10) 1866 { 1867 emsg(_("E136: viminfo: Too many errors, skipping rest of file")); 1868 return TRUE; 1869 } 1870 return FALSE; 1871 } 1872 1873 /* 1874 * read_viminfo() -- Read the viminfo file. Registers etc. which are already 1875 * set are not over-written unless "flags" includes VIF_FORCEIT. -- webb 1876 */ 1877 int 1878 read_viminfo( 1879 char_u *file, /* file name or NULL to use default name */ 1880 int flags) /* VIF_WANT_INFO et al. */ 1881 { 1882 FILE *fp; 1883 char_u *fname; 1884 1885 if (no_viminfo()) 1886 return FAIL; 1887 1888 fname = viminfo_filename(file); /* get file name in allocated buffer */ 1889 if (fname == NULL) 1890 return FAIL; 1891 fp = mch_fopen((char *)fname, READBIN); 1892 1893 if (p_verbose > 0) 1894 { 1895 verbose_enter(); 1896 smsg(_("Reading viminfo file \"%s\"%s%s%s"), 1897 fname, 1898 (flags & VIF_WANT_INFO) ? _(" info") : "", 1899 (flags & VIF_WANT_MARKS) ? _(" marks") : "", 1900 (flags & VIF_GET_OLDFILES) ? _(" oldfiles") : "", 1901 fp == NULL ? _(" FAILED") : ""); 1902 verbose_leave(); 1903 } 1904 1905 vim_free(fname); 1906 if (fp == NULL) 1907 return FAIL; 1908 1909 viminfo_errcnt = 0; 1910 do_viminfo(fp, NULL, flags); 1911 1912 fclose(fp); 1913 return OK; 1914 } 1915 1916 /* 1917 * Write the viminfo file. The old one is read in first so that effectively a 1918 * merge of current info and old info is done. This allows multiple vims to 1919 * run simultaneously, without losing any marks etc. 1920 * If "forceit" is TRUE, then the old file is not read in, and only internal 1921 * info is written to the file. 1922 */ 1923 void 1924 write_viminfo(char_u *file, int forceit) 1925 { 1926 char_u *fname; 1927 FILE *fp_in = NULL; /* input viminfo file, if any */ 1928 FILE *fp_out = NULL; /* output viminfo file */ 1929 char_u *tempname = NULL; /* name of temp viminfo file */ 1930 stat_T st_new; /* mch_stat() of potential new file */ 1931 #if defined(UNIX) || defined(VMS) 1932 mode_t umask_save; 1933 #endif 1934 #ifdef UNIX 1935 int shortname = FALSE; /* use 8.3 file name */ 1936 stat_T st_old; /* mch_stat() of existing viminfo file */ 1937 #endif 1938 #ifdef WIN3264 1939 int hidden = FALSE; 1940 #endif 1941 1942 if (no_viminfo()) 1943 return; 1944 1945 fname = viminfo_filename(file); /* may set to default if NULL */ 1946 if (fname == NULL) 1947 return; 1948 1949 fp_in = mch_fopen((char *)fname, READBIN); 1950 if (fp_in == NULL) 1951 { 1952 int fd; 1953 1954 /* if it does exist, but we can't read it, don't try writing */ 1955 if (mch_stat((char *)fname, &st_new) == 0) 1956 goto end; 1957 1958 /* Create the new .viminfo non-accessible for others, because it may 1959 * contain text from non-accessible documents. It is up to the user to 1960 * widen access (e.g. to a group). This may also fail if there is a 1961 * race condition, then just give up. */ 1962 fd = mch_open((char *)fname, 1963 O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 0600); 1964 if (fd < 0) 1965 goto end; 1966 fp_out = fdopen(fd, WRITEBIN); 1967 } 1968 else 1969 { 1970 /* 1971 * There is an existing viminfo file. Create a temporary file to 1972 * write the new viminfo into, in the same directory as the 1973 * existing viminfo file, which will be renamed once all writing is 1974 * successful. 1975 */ 1976 #ifdef UNIX 1977 /* 1978 * For Unix we check the owner of the file. It's not very nice to 1979 * overwrite a user's viminfo file after a "su root", with a 1980 * viminfo file that the user can't read. 1981 */ 1982 st_old.st_dev = (dev_t)0; 1983 st_old.st_ino = 0; 1984 st_old.st_mode = 0600; 1985 if (mch_stat((char *)fname, &st_old) == 0 1986 && getuid() != ROOT_UID 1987 && !(st_old.st_uid == getuid() 1988 ? (st_old.st_mode & 0200) 1989 : (st_old.st_gid == getgid() 1990 ? (st_old.st_mode & 0020) 1991 : (st_old.st_mode & 0002)))) 1992 { 1993 int tt = msg_didany; 1994 1995 /* avoid a wait_return for this message, it's annoying */ 1996 semsg(_("E137: Viminfo file is not writable: %s"), fname); 1997 msg_didany = tt; 1998 fclose(fp_in); 1999 goto end; 2000 } 2001 #endif 2002 #ifdef WIN3264 2003 /* Get the file attributes of the existing viminfo file. */ 2004 hidden = mch_ishidden(fname); 2005 #endif 2006 2007 /* 2008 * Make tempname, find one that does not exist yet. 2009 * Beware of a race condition: If someone logs out and all Vim 2010 * instances exit at the same time a temp file might be created between 2011 * stat() and open(). Use mch_open() with O_EXCL to avoid that. 2012 * May try twice: Once normal and once with shortname set, just in 2013 * case somebody puts his viminfo file in an 8.3 filesystem. 2014 */ 2015 for (;;) 2016 { 2017 int next_char = 'z'; 2018 char_u *wp; 2019 2020 tempname = buf_modname( 2021 #ifdef UNIX 2022 shortname, 2023 #else 2024 FALSE, 2025 #endif 2026 fname, 2027 #ifdef VMS 2028 (char_u *)"-tmp", 2029 #else 2030 (char_u *)".tmp", 2031 #endif 2032 FALSE); 2033 if (tempname == NULL) /* out of memory */ 2034 break; 2035 2036 /* 2037 * Try a series of names. Change one character, just before 2038 * the extension. This should also work for an 8.3 2039 * file name, when after adding the extension it still is 2040 * the same file as the original. 2041 */ 2042 wp = tempname + STRLEN(tempname) - 5; 2043 if (wp < gettail(tempname)) /* empty file name? */ 2044 wp = gettail(tempname); 2045 for (;;) 2046 { 2047 /* 2048 * Check if tempfile already exists. Never overwrite an 2049 * existing file! 2050 */ 2051 if (mch_stat((char *)tempname, &st_new) == 0) 2052 { 2053 #ifdef UNIX 2054 /* 2055 * Check if tempfile is same as original file. May happen 2056 * when modname() gave the same file back. E.g. silly 2057 * link, or file name-length reached. Try again with 2058 * shortname set. 2059 */ 2060 if (!shortname && st_new.st_dev == st_old.st_dev 2061 && st_new.st_ino == st_old.st_ino) 2062 { 2063 VIM_CLEAR(tempname); 2064 shortname = TRUE; 2065 break; 2066 } 2067 #endif 2068 } 2069 else 2070 { 2071 /* Try creating the file exclusively. This may fail if 2072 * another Vim tries to do it at the same time. */ 2073 #ifdef VMS 2074 /* fdopen() fails for some reason */ 2075 umask_save = umask(077); 2076 fp_out = mch_fopen((char *)tempname, WRITEBIN); 2077 (void)umask(umask_save); 2078 #else 2079 int fd; 2080 2081 /* Use mch_open() to be able to use O_NOFOLLOW and set file 2082 * protection: 2083 * Unix: same as original file, but strip s-bit. Reset 2084 * umask to avoid it getting in the way. 2085 * Others: r&w for user only. */ 2086 # ifdef UNIX 2087 umask_save = umask(0); 2088 fd = mch_open((char *)tempname, 2089 O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 2090 (int)((st_old.st_mode & 0777) | 0600)); 2091 (void)umask(umask_save); 2092 # else 2093 fd = mch_open((char *)tempname, 2094 O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 0600); 2095 # endif 2096 if (fd < 0) 2097 { 2098 fp_out = NULL; 2099 # ifdef EEXIST 2100 /* Avoid trying lots of names while the problem is lack 2101 * of premission, only retry if the file already 2102 * exists. */ 2103 if (errno != EEXIST) 2104 break; 2105 # endif 2106 } 2107 else 2108 fp_out = fdopen(fd, WRITEBIN); 2109 #endif /* VMS */ 2110 if (fp_out != NULL) 2111 break; 2112 } 2113 2114 /* Assume file exists, try again with another name. */ 2115 if (next_char == 'a' - 1) 2116 { 2117 /* They all exist? Must be something wrong! Don't write 2118 * the viminfo file then. */ 2119 semsg(_("E929: Too many viminfo temp files, like %s!"), 2120 tempname); 2121 break; 2122 } 2123 *wp = next_char; 2124 --next_char; 2125 } 2126 2127 if (tempname != NULL) 2128 break; 2129 /* continue if shortname was set */ 2130 } 2131 2132 #if defined(UNIX) && defined(HAVE_FCHOWN) 2133 if (tempname != NULL && fp_out != NULL) 2134 { 2135 stat_T tmp_st; 2136 2137 /* 2138 * Make sure the original owner can read/write the tempfile and 2139 * otherwise preserve permissions, making sure the group matches. 2140 */ 2141 if (mch_stat((char *)tempname, &tmp_st) >= 0) 2142 { 2143 if (st_old.st_uid != tmp_st.st_uid) 2144 /* Changing the owner might fail, in which case the 2145 * file will now owned by the current user, oh well. */ 2146 vim_ignored = fchown(fileno(fp_out), st_old.st_uid, -1); 2147 if (st_old.st_gid != tmp_st.st_gid 2148 && fchown(fileno(fp_out), -1, st_old.st_gid) == -1) 2149 /* can't set the group to what it should be, remove 2150 * group permissions */ 2151 (void)mch_setperm(tempname, 0600); 2152 } 2153 else 2154 /* can't stat the file, set conservative permissions */ 2155 (void)mch_setperm(tempname, 0600); 2156 } 2157 #endif 2158 } 2159 2160 /* 2161 * Check if the new viminfo file can be written to. 2162 */ 2163 if (fp_out == NULL) 2164 { 2165 semsg(_("E138: Can't write viminfo file %s!"), 2166 (fp_in == NULL || tempname == NULL) ? fname : tempname); 2167 if (fp_in != NULL) 2168 fclose(fp_in); 2169 goto end; 2170 } 2171 2172 if (p_verbose > 0) 2173 { 2174 verbose_enter(); 2175 smsg(_("Writing viminfo file \"%s\""), fname); 2176 verbose_leave(); 2177 } 2178 2179 viminfo_errcnt = 0; 2180 do_viminfo(fp_in, fp_out, forceit ? 0 : (VIF_WANT_INFO | VIF_WANT_MARKS)); 2181 2182 if (fclose(fp_out) == EOF) 2183 ++viminfo_errcnt; 2184 2185 if (fp_in != NULL) 2186 { 2187 fclose(fp_in); 2188 2189 /* In case of an error keep the original viminfo file. Otherwise 2190 * rename the newly written file. Give an error if that fails. */ 2191 if (viminfo_errcnt == 0) 2192 { 2193 if (vim_rename(tempname, fname) == -1) 2194 { 2195 ++viminfo_errcnt; 2196 semsg(_("E886: Can't rename viminfo file to %s!"), fname); 2197 } 2198 # ifdef WIN3264 2199 /* If the viminfo file was hidden then also hide the new file. */ 2200 else if (hidden) 2201 mch_hide(fname); 2202 # endif 2203 } 2204 if (viminfo_errcnt > 0) 2205 mch_remove(tempname); 2206 } 2207 2208 end: 2209 vim_free(fname); 2210 vim_free(tempname); 2211 } 2212 2213 /* 2214 * Get the viminfo file name to use. 2215 * If "file" is given and not empty, use it (has already been expanded by 2216 * cmdline functions). 2217 * Otherwise use "-i file_name", value from 'viminfo' or the default, and 2218 * expand environment variables. 2219 * Returns an allocated string. NULL when out of memory. 2220 */ 2221 static char_u * 2222 viminfo_filename(char_u *file) 2223 { 2224 if (file == NULL || *file == NUL) 2225 { 2226 if (*p_viminfofile != NUL) 2227 file = p_viminfofile; 2228 else if ((file = find_viminfo_parameter('n')) == NULL || *file == NUL) 2229 { 2230 #ifdef VIMINFO_FILE2 2231 # ifdef VMS 2232 if (mch_getenv((char_u *)"SYS$LOGIN") == NULL) 2233 # else 2234 # ifdef MSWIN 2235 /* Use $VIM only if $HOME is the default "C:/". */ 2236 if (STRCMP(vim_getenv((char_u *)"HOME", NULL), "C:/") == 0 2237 && mch_getenv((char_u *)"HOME") == NULL) 2238 # else 2239 if (mch_getenv((char_u *)"HOME") == NULL) 2240 # endif 2241 # endif 2242 { 2243 /* don't use $VIM when not available. */ 2244 expand_env((char_u *)"$VIM", NameBuff, MAXPATHL); 2245 if (STRCMP("$VIM", NameBuff) != 0) /* $VIM was expanded */ 2246 file = (char_u *)VIMINFO_FILE2; 2247 else 2248 file = (char_u *)VIMINFO_FILE; 2249 } 2250 else 2251 #endif 2252 file = (char_u *)VIMINFO_FILE; 2253 } 2254 expand_env(file, NameBuff, MAXPATHL); 2255 file = NameBuff; 2256 } 2257 return vim_strsave(file); 2258 } 2259 2260 /* 2261 * do_viminfo() -- Should only be called from read_viminfo() & write_viminfo(). 2262 */ 2263 static void 2264 do_viminfo(FILE *fp_in, FILE *fp_out, int flags) 2265 { 2266 int eof = FALSE; 2267 vir_T vir; 2268 int merge = FALSE; 2269 int do_copy_marks = FALSE; 2270 garray_T buflist; 2271 2272 if ((vir.vir_line = alloc(LSIZE)) == NULL) 2273 return; 2274 vir.vir_fd = fp_in; 2275 vir.vir_conv.vc_type = CONV_NONE; 2276 ga_init2(&vir.vir_barlines, (int)sizeof(char_u *), 100); 2277 vir.vir_version = -1; 2278 2279 if (fp_in != NULL) 2280 { 2281 if (flags & VIF_WANT_INFO) 2282 { 2283 if (fp_out != NULL) 2284 { 2285 /* Registers and marks are read and kept separate from what 2286 * this Vim is using. They are merged when writing. */ 2287 prepare_viminfo_registers(); 2288 prepare_viminfo_marks(); 2289 } 2290 2291 eof = read_viminfo_up_to_marks(&vir, 2292 flags & VIF_FORCEIT, fp_out != NULL); 2293 merge = TRUE; 2294 } 2295 else if (flags != 0) 2296 /* Skip info, find start of marks */ 2297 while (!(eof = viminfo_readline(&vir)) 2298 && vir.vir_line[0] != '>') 2299 ; 2300 2301 do_copy_marks = (flags & 2302 (VIF_WANT_MARKS | VIF_GET_OLDFILES | VIF_FORCEIT)); 2303 } 2304 2305 if (fp_out != NULL) 2306 { 2307 /* Write the info: */ 2308 fprintf(fp_out, _("# This viminfo file was generated by Vim %s.\n"), 2309 VIM_VERSION_MEDIUM); 2310 fputs(_("# You may edit it if you're careful!\n\n"), fp_out); 2311 write_viminfo_version(fp_out); 2312 fputs(_("# Value of 'encoding' when this file was written\n"), fp_out); 2313 fprintf(fp_out, "*encoding=%s\n\n", p_enc); 2314 write_viminfo_search_pattern(fp_out); 2315 write_viminfo_sub_string(fp_out); 2316 #ifdef FEAT_CMDHIST 2317 write_viminfo_history(fp_out, merge); 2318 #endif 2319 write_viminfo_registers(fp_out); 2320 finish_viminfo_registers(); 2321 #ifdef FEAT_EVAL 2322 write_viminfo_varlist(fp_out); 2323 #endif 2324 write_viminfo_filemarks(fp_out); 2325 finish_viminfo_marks(); 2326 write_viminfo_bufferlist(fp_out); 2327 write_viminfo_barlines(&vir, fp_out); 2328 2329 if (do_copy_marks) 2330 ga_init2(&buflist, sizeof(buf_T *), 50); 2331 write_viminfo_marks(fp_out, do_copy_marks ? &buflist : NULL); 2332 } 2333 2334 if (do_copy_marks) 2335 { 2336 copy_viminfo_marks(&vir, fp_out, &buflist, eof, flags); 2337 if (fp_out != NULL) 2338 ga_clear(&buflist); 2339 } 2340 2341 vim_free(vir.vir_line); 2342 if (vir.vir_conv.vc_type != CONV_NONE) 2343 convert_setup(&vir.vir_conv, NULL, NULL); 2344 ga_clear_strings(&vir.vir_barlines); 2345 } 2346 2347 /* 2348 * read_viminfo_up_to_marks() -- Only called from do_viminfo(). Reads in the 2349 * first part of the viminfo file which contains everything but the marks that 2350 * are local to a file. Returns TRUE when end-of-file is reached. -- webb 2351 */ 2352 static int 2353 read_viminfo_up_to_marks( 2354 vir_T *virp, 2355 int forceit, 2356 int writing) 2357 { 2358 int eof; 2359 buf_T *buf; 2360 int got_encoding = FALSE; 2361 2362 #ifdef FEAT_CMDHIST 2363 prepare_viminfo_history(forceit ? 9999 : 0, writing); 2364 #endif 2365 2366 eof = viminfo_readline(virp); 2367 while (!eof && virp->vir_line[0] != '>') 2368 { 2369 switch (virp->vir_line[0]) 2370 { 2371 /* Characters reserved for future expansion, ignored now */ 2372 case '+': /* "+40 /path/dir file", for running vim without args */ 2373 case '^': /* to be defined */ 2374 case '<': /* long line - ignored */ 2375 /* A comment or empty line. */ 2376 case NUL: 2377 case '\r': 2378 case '\n': 2379 case '#': 2380 eof = viminfo_readline(virp); 2381 break; 2382 case '|': 2383 eof = read_viminfo_barline(virp, got_encoding, 2384 forceit, writing); 2385 break; 2386 case '*': /* "*encoding=value" */ 2387 got_encoding = TRUE; 2388 eof = viminfo_encoding(virp); 2389 break; 2390 case '!': /* global variable */ 2391 #ifdef FEAT_EVAL 2392 eof = read_viminfo_varlist(virp, writing); 2393 #else 2394 eof = viminfo_readline(virp); 2395 #endif 2396 break; 2397 case '%': /* entry for buffer list */ 2398 eof = read_viminfo_bufferlist(virp, writing); 2399 break; 2400 case '"': 2401 /* When registers are in bar lines skip the old style register 2402 * lines. */ 2403 if (virp->vir_version < VIMINFO_VERSION_WITH_REGISTERS) 2404 eof = read_viminfo_register(virp, forceit); 2405 else 2406 do { 2407 eof = viminfo_readline(virp); 2408 } while (!eof && (virp->vir_line[0] == TAB 2409 || virp->vir_line[0] == '<')); 2410 break; 2411 case '/': /* Search string */ 2412 case '&': /* Substitute search string */ 2413 case '~': /* Last search string, followed by '/' or '&' */ 2414 eof = read_viminfo_search_pattern(virp, forceit); 2415 break; 2416 case '$': 2417 eof = read_viminfo_sub_string(virp, forceit); 2418 break; 2419 case ':': 2420 case '?': 2421 case '=': 2422 case '@': 2423 #ifdef FEAT_CMDHIST 2424 /* When history is in bar lines skip the old style history 2425 * lines. */ 2426 if (virp->vir_version < VIMINFO_VERSION_WITH_HISTORY) 2427 eof = read_viminfo_history(virp, writing); 2428 else 2429 #endif 2430 eof = viminfo_readline(virp); 2431 break; 2432 case '-': 2433 case '\'': 2434 /* When file marks are in bar lines skip the old style lines. */ 2435 if (virp->vir_version < VIMINFO_VERSION_WITH_MARKS) 2436 eof = read_viminfo_filemark(virp, forceit); 2437 else 2438 eof = viminfo_readline(virp); 2439 break; 2440 default: 2441 if (viminfo_error("E575: ", _("Illegal starting char"), 2442 virp->vir_line)) 2443 eof = TRUE; 2444 else 2445 eof = viminfo_readline(virp); 2446 break; 2447 } 2448 } 2449 2450 #ifdef FEAT_CMDHIST 2451 /* Finish reading history items. */ 2452 if (!writing) 2453 finish_viminfo_history(virp); 2454 #endif 2455 2456 /* Change file names to buffer numbers for fmarks. */ 2457 FOR_ALL_BUFFERS(buf) 2458 fmarks_check_names(buf); 2459 2460 return eof; 2461 } 2462 2463 /* 2464 * Compare the 'encoding' value in the viminfo file with the current value of 2465 * 'encoding'. If different and the 'c' flag is in 'viminfo', setup for 2466 * conversion of text with iconv() in viminfo_readstring(). 2467 */ 2468 static int 2469 viminfo_encoding(vir_T *virp) 2470 { 2471 char_u *p; 2472 int i; 2473 2474 if (get_viminfo_parameter('c') != 0) 2475 { 2476 p = vim_strchr(virp->vir_line, '='); 2477 if (p != NULL) 2478 { 2479 /* remove trailing newline */ 2480 ++p; 2481 for (i = 0; vim_isprintc(p[i]); ++i) 2482 ; 2483 p[i] = NUL; 2484 2485 convert_setup(&virp->vir_conv, p, p_enc); 2486 } 2487 } 2488 return viminfo_readline(virp); 2489 } 2490 2491 /* 2492 * Read a line from the viminfo file. 2493 * Returns TRUE for end-of-file; 2494 */ 2495 int 2496 viminfo_readline(vir_T *virp) 2497 { 2498 return vim_fgets(virp->vir_line, LSIZE, virp->vir_fd); 2499 } 2500 2501 /* 2502 * Check string read from viminfo file. 2503 * Remove '\n' at the end of the line. 2504 * - replace CTRL-V CTRL-V with CTRL-V 2505 * - replace CTRL-V 'n' with '\n' 2506 * 2507 * Check for a long line as written by viminfo_writestring(). 2508 * 2509 * Return the string in allocated memory (NULL when out of memory). 2510 */ 2511 char_u * 2512 viminfo_readstring( 2513 vir_T *virp, 2514 int off, /* offset for virp->vir_line */ 2515 int convert UNUSED) /* convert the string */ 2516 { 2517 char_u *retval; 2518 char_u *s, *d; 2519 long len; 2520 2521 if (virp->vir_line[off] == Ctrl_V && vim_isdigit(virp->vir_line[off + 1])) 2522 { 2523 len = atol((char *)virp->vir_line + off + 1); 2524 retval = lalloc(len, TRUE); 2525 if (retval == NULL) 2526 { 2527 /* Line too long? File messed up? Skip next line. */ 2528 (void)vim_fgets(virp->vir_line, 10, virp->vir_fd); 2529 return NULL; 2530 } 2531 (void)vim_fgets(retval, (int)len, virp->vir_fd); 2532 s = retval + 1; /* Skip the leading '<' */ 2533 } 2534 else 2535 { 2536 retval = vim_strsave(virp->vir_line + off); 2537 if (retval == NULL) 2538 return NULL; 2539 s = retval; 2540 } 2541 2542 /* Change CTRL-V CTRL-V to CTRL-V and CTRL-V n to \n in-place. */ 2543 d = retval; 2544 while (*s != NUL && *s != '\n') 2545 { 2546 if (s[0] == Ctrl_V && s[1] != NUL) 2547 { 2548 if (s[1] == 'n') 2549 *d++ = '\n'; 2550 else 2551 *d++ = Ctrl_V; 2552 s += 2; 2553 } 2554 else 2555 *d++ = *s++; 2556 } 2557 *d = NUL; 2558 2559 if (convert && virp->vir_conv.vc_type != CONV_NONE && *retval != NUL) 2560 { 2561 d = string_convert(&virp->vir_conv, retval, NULL); 2562 if (d != NULL) 2563 { 2564 vim_free(retval); 2565 retval = d; 2566 } 2567 } 2568 2569 return retval; 2570 } 2571 2572 /* 2573 * write string to viminfo file 2574 * - replace CTRL-V with CTRL-V CTRL-V 2575 * - replace '\n' with CTRL-V 'n' 2576 * - add a '\n' at the end 2577 * 2578 * For a long line: 2579 * - write " CTRL-V <length> \n " in first line 2580 * - write " < <string> \n " in second line 2581 */ 2582 void 2583 viminfo_writestring(FILE *fd, char_u *p) 2584 { 2585 int c; 2586 char_u *s; 2587 int len = 0; 2588 2589 for (s = p; *s != NUL; ++s) 2590 { 2591 if (*s == Ctrl_V || *s == '\n') 2592 ++len; 2593 ++len; 2594 } 2595 2596 /* If the string will be too long, write its length and put it in the next 2597 * line. Take into account that some room is needed for what comes before 2598 * the string (e.g., variable name). Add something to the length for the 2599 * '<', NL and trailing NUL. */ 2600 if (len > LSIZE / 2) 2601 fprintf(fd, IF_EB("\026%d\n<", CTRL_V_STR "%d\n<"), len + 3); 2602 2603 while ((c = *p++) != NUL) 2604 { 2605 if (c == Ctrl_V || c == '\n') 2606 { 2607 putc(Ctrl_V, fd); 2608 if (c == '\n') 2609 c = 'n'; 2610 } 2611 putc(c, fd); 2612 } 2613 putc('\n', fd); 2614 } 2615 2616 /* 2617 * Write a string in quotes that barline_parse() can read back. 2618 * Breaks the line in less than LSIZE pieces when needed. 2619 * Returns remaining characters in the line. 2620 */ 2621 int 2622 barline_writestring(FILE *fd, char_u *s, int remaining_start) 2623 { 2624 char_u *p; 2625 int remaining = remaining_start; 2626 int len = 2; 2627 2628 /* Count the number of characters produced, including quotes. */ 2629 for (p = s; *p != NUL; ++p) 2630 { 2631 if (*p == NL) 2632 len += 2; 2633 else if (*p == '"' || *p == '\\') 2634 len += 2; 2635 else 2636 ++len; 2637 } 2638 if (len > remaining - 2) 2639 { 2640 fprintf(fd, ">%d\n|<", len); 2641 remaining = LSIZE - 20; 2642 } 2643 2644 putc('"', fd); 2645 for (p = s; *p != NUL; ++p) 2646 { 2647 if (*p == NL) 2648 { 2649 putc('\\', fd); 2650 putc('n', fd); 2651 --remaining; 2652 } 2653 else if (*p == '"' || *p == '\\') 2654 { 2655 putc('\\', fd); 2656 putc(*p, fd); 2657 --remaining; 2658 } 2659 else 2660 putc(*p, fd); 2661 --remaining; 2662 2663 if (remaining < 3) 2664 { 2665 putc('\n', fd); 2666 putc('|', fd); 2667 putc('<', fd); 2668 /* Leave enough space for another continuation. */ 2669 remaining = LSIZE - 20; 2670 } 2671 } 2672 putc('"', fd); 2673 return remaining - 2; 2674 } 2675 2676 /* 2677 * Parse a viminfo line starting with '|'. 2678 * Add each decoded value to "values". 2679 * Returns TRUE if the next line is to be read after using the parsed values. 2680 */ 2681 static int 2682 barline_parse(vir_T *virp, char_u *text, garray_T *values) 2683 { 2684 char_u *p = text; 2685 char_u *nextp = NULL; 2686 char_u *buf = NULL; 2687 bval_T *value; 2688 int i; 2689 int allocated = FALSE; 2690 int eof; 2691 char_u *sconv; 2692 int converted; 2693 2694 while (*p == ',') 2695 { 2696 ++p; 2697 if (ga_grow(values, 1) == FAIL) 2698 break; 2699 value = (bval_T *)(values->ga_data) + values->ga_len; 2700 2701 if (*p == '>') 2702 { 2703 /* Need to read a continuation line. Put strings in allocated 2704 * memory, because virp->vir_line is overwritten. */ 2705 if (!allocated) 2706 { 2707 for (i = 0; i < values->ga_len; ++i) 2708 { 2709 bval_T *vp = (bval_T *)(values->ga_data) + i; 2710 2711 if (vp->bv_type == BVAL_STRING && !vp->bv_allocated) 2712 { 2713 vp->bv_string = vim_strnsave(vp->bv_string, vp->bv_len); 2714 vp->bv_allocated = TRUE; 2715 } 2716 } 2717 allocated = TRUE; 2718 } 2719 2720 if (vim_isdigit(p[1])) 2721 { 2722 size_t len; 2723 size_t todo; 2724 size_t n; 2725 2726 /* String value was split into lines that are each shorter 2727 * than LSIZE: 2728 * |{bartype},>{length of "{text}{text2}"} 2729 * |<"{text1} 2730 * |<{text2}",{value} 2731 * Length includes the quotes. 2732 */ 2733 ++p; 2734 len = getdigits(&p); 2735 buf = alloc((int)(len + 1)); 2736 if (buf == NULL) 2737 return TRUE; 2738 p = buf; 2739 for (todo = len; todo > 0; todo -= n) 2740 { 2741 eof = viminfo_readline(virp); 2742 if (eof || virp->vir_line[0] != '|' 2743 || virp->vir_line[1] != '<') 2744 { 2745 /* File was truncated or garbled. Read another line if 2746 * this one starts with '|'. */ 2747 vim_free(buf); 2748 return eof || virp->vir_line[0] == '|'; 2749 } 2750 /* Get length of text, excluding |< and NL chars. */ 2751 n = STRLEN(virp->vir_line); 2752 while (n > 0 && (virp->vir_line[n - 1] == NL 2753 || virp->vir_line[n - 1] == CAR)) 2754 --n; 2755 n -= 2; 2756 if (n > todo) 2757 { 2758 /* more values follow after the string */ 2759 nextp = virp->vir_line + 2 + todo; 2760 n = todo; 2761 } 2762 mch_memmove(p, virp->vir_line + 2, n); 2763 p += n; 2764 } 2765 *p = NUL; 2766 p = buf; 2767 } 2768 else 2769 { 2770 /* Line ending in ">" continues in the next line: 2771 * |{bartype},{lots of values},> 2772 * |<{value},{value} 2773 */ 2774 eof = viminfo_readline(virp); 2775 if (eof || virp->vir_line[0] != '|' 2776 || virp->vir_line[1] != '<') 2777 /* File was truncated or garbled. Read another line if 2778 * this one starts with '|'. */ 2779 return eof || virp->vir_line[0] == '|'; 2780 p = virp->vir_line + 2; 2781 } 2782 } 2783 2784 if (isdigit(*p)) 2785 { 2786 value->bv_type = BVAL_NR; 2787 value->bv_nr = getdigits(&p); 2788 ++values->ga_len; 2789 } 2790 else if (*p == '"') 2791 { 2792 int len = 0; 2793 char_u *s = p; 2794 2795 /* Unescape special characters in-place. */ 2796 ++p; 2797 while (*p != '"') 2798 { 2799 if (*p == NL || *p == NUL) 2800 return TRUE; /* syntax error, drop the value */ 2801 if (*p == '\\') 2802 { 2803 ++p; 2804 if (*p == 'n') 2805 s[len++] = '\n'; 2806 else 2807 s[len++] = *p; 2808 ++p; 2809 } 2810 else 2811 s[len++] = *p++; 2812 } 2813 ++p; 2814 s[len] = NUL; 2815 2816 converted = FALSE; 2817 if (virp->vir_conv.vc_type != CONV_NONE && *s != NUL) 2818 { 2819 sconv = string_convert(&virp->vir_conv, s, NULL); 2820 if (sconv != NULL) 2821 { 2822 if (s == buf) 2823 vim_free(s); 2824 s = sconv; 2825 buf = s; 2826 converted = TRUE; 2827 } 2828 } 2829 2830 /* Need to copy in allocated memory if the string wasn't allocated 2831 * above and we did allocate before, thus vir_line may change. */ 2832 if (s != buf && allocated) 2833 s = vim_strsave(s); 2834 value->bv_string = s; 2835 value->bv_type = BVAL_STRING; 2836 value->bv_len = len; 2837 value->bv_allocated = allocated || converted; 2838 ++values->ga_len; 2839 if (nextp != NULL) 2840 { 2841 /* values following a long string */ 2842 p = nextp; 2843 nextp = NULL; 2844 } 2845 } 2846 else if (*p == ',') 2847 { 2848 value->bv_type = BVAL_EMPTY; 2849 ++values->ga_len; 2850 } 2851 else 2852 break; 2853 } 2854 return TRUE; 2855 } 2856 2857 static int 2858 read_viminfo_barline(vir_T *virp, int got_encoding, int force, int writing) 2859 { 2860 char_u *p = virp->vir_line + 1; 2861 int bartype; 2862 garray_T values; 2863 bval_T *vp; 2864 int i; 2865 int read_next = TRUE; 2866 2867 /* The format is: |{bartype},{value},... 2868 * For a very long string: 2869 * |{bartype},>{length of "{text}{text2}"} 2870 * |<{text1} 2871 * |<{text2},{value} 2872 * For a long line not using a string 2873 * |{bartype},{lots of values},> 2874 * |<{value},{value} 2875 */ 2876 if (*p == '<') 2877 { 2878 /* Continuation line of an unrecognized item. */ 2879 if (writing) 2880 ga_add_string(&virp->vir_barlines, virp->vir_line); 2881 } 2882 else 2883 { 2884 ga_init2(&values, sizeof(bval_T), 20); 2885 bartype = getdigits(&p); 2886 switch (bartype) 2887 { 2888 case BARTYPE_VERSION: 2889 /* Only use the version when it comes before the encoding. 2890 * If it comes later it was copied by a Vim version that 2891 * doesn't understand the version. */ 2892 if (!got_encoding) 2893 { 2894 read_next = barline_parse(virp, p, &values); 2895 vp = (bval_T *)values.ga_data; 2896 if (values.ga_len > 0 && vp->bv_type == BVAL_NR) 2897 virp->vir_version = vp->bv_nr; 2898 } 2899 break; 2900 2901 case BARTYPE_HISTORY: 2902 read_next = barline_parse(virp, p, &values); 2903 handle_viminfo_history(&values, writing); 2904 break; 2905 2906 case BARTYPE_REGISTER: 2907 read_next = barline_parse(virp, p, &values); 2908 handle_viminfo_register(&values, force); 2909 break; 2910 2911 case BARTYPE_MARK: 2912 read_next = barline_parse(virp, p, &values); 2913 handle_viminfo_mark(&values, force); 2914 break; 2915 2916 default: 2917 /* copy unrecognized line (for future use) */ 2918 if (writing) 2919 ga_add_string(&virp->vir_barlines, virp->vir_line); 2920 } 2921 for (i = 0; i < values.ga_len; ++i) 2922 { 2923 vp = (bval_T *)values.ga_data + i; 2924 if (vp->bv_type == BVAL_STRING && vp->bv_allocated) 2925 vim_free(vp->bv_string); 2926 } 2927 ga_clear(&values); 2928 } 2929 2930 if (read_next) 2931 return viminfo_readline(virp); 2932 return FALSE; 2933 } 2934 2935 static void 2936 write_viminfo_version(FILE *fp_out) 2937 { 2938 fprintf(fp_out, "# Viminfo version\n|%d,%d\n\n", 2939 BARTYPE_VERSION, VIMINFO_VERSION); 2940 } 2941 2942 static void 2943 write_viminfo_barlines(vir_T *virp, FILE *fp_out) 2944 { 2945 int i; 2946 garray_T *gap = &virp->vir_barlines; 2947 int seen_useful = FALSE; 2948 char *line; 2949 2950 if (gap->ga_len > 0) 2951 { 2952 fputs(_("\n# Bar lines, copied verbatim:\n"), fp_out); 2953 2954 /* Skip over continuation lines until seeing a useful line. */ 2955 for (i = 0; i < gap->ga_len; ++i) 2956 { 2957 line = ((char **)(gap->ga_data))[i]; 2958 if (seen_useful || line[1] != '<') 2959 { 2960 fputs(line, fp_out); 2961 seen_useful = TRUE; 2962 } 2963 } 2964 } 2965 } 2966 #endif /* FEAT_VIMINFO */ 2967 2968 /* 2969 * Return the current time in seconds. Calls time(), unless test_settime() 2970 * was used. 2971 */ 2972 time_T 2973 vim_time(void) 2974 { 2975 # ifdef FEAT_EVAL 2976 return time_for_testing == 0 ? time(NULL) : time_for_testing; 2977 # else 2978 return time(NULL); 2979 # endif 2980 } 2981 2982 /* 2983 * Implementation of ":fixdel", also used by get_stty(). 2984 * <BS> resulting <Del> 2985 * ^? ^H 2986 * not ^? ^? 2987 */ 2988 void 2989 do_fixdel(exarg_T *eap UNUSED) 2990 { 2991 char_u *p; 2992 2993 p = find_termcode((char_u *)"kb"); 2994 add_termcode((char_u *)"kD", p != NULL 2995 && *p == DEL ? (char_u *)CTRL_H_STR : DEL_STR, FALSE); 2996 } 2997 2998 void 2999 print_line_no_prefix( 3000 linenr_T lnum, 3001 int use_number, 3002 int list) 3003 { 3004 char numbuf[30]; 3005 3006 if (curwin->w_p_nu || use_number) 3007 { 3008 vim_snprintf(numbuf, sizeof(numbuf), 3009 "%*ld ", number_width(curwin), (long)lnum); 3010 msg_puts_attr(numbuf, HL_ATTR(HLF_N)); /* Highlight line nrs */ 3011 } 3012 msg_prt_line(ml_get(lnum), list); 3013 } 3014 3015 /* 3016 * Print a text line. Also in silent mode ("ex -s"). 3017 */ 3018 void 3019 print_line(linenr_T lnum, int use_number, int list) 3020 { 3021 int save_silent = silent_mode; 3022 3023 /* apply :filter /pat/ */ 3024 if (message_filtered(ml_get(lnum))) 3025 return; 3026 3027 msg_start(); 3028 silent_mode = FALSE; 3029 info_message = TRUE; /* use mch_msg(), not mch_errmsg() */ 3030 print_line_no_prefix(lnum, use_number, list); 3031 if (save_silent) 3032 { 3033 msg_putchar('\n'); 3034 cursor_on(); /* msg_start() switches it off */ 3035 out_flush(); 3036 silent_mode = save_silent; 3037 } 3038 info_message = FALSE; 3039 } 3040 3041 int 3042 rename_buffer(char_u *new_fname) 3043 { 3044 char_u *fname, *sfname, *xfname; 3045 buf_T *buf; 3046 3047 buf = curbuf; 3048 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf); 3049 /* buffer changed, don't change name now */ 3050 if (buf != curbuf) 3051 return FAIL; 3052 #ifdef FEAT_EVAL 3053 if (aborting()) /* autocmds may abort script processing */ 3054 return FAIL; 3055 #endif 3056 /* 3057 * The name of the current buffer will be changed. 3058 * A new (unlisted) buffer entry needs to be made to hold the old file 3059 * name, which will become the alternate file name. 3060 * But don't set the alternate file name if the buffer didn't have a 3061 * name. 3062 */ 3063 fname = curbuf->b_ffname; 3064 sfname = curbuf->b_sfname; 3065 xfname = curbuf->b_fname; 3066 curbuf->b_ffname = NULL; 3067 curbuf->b_sfname = NULL; 3068 if (setfname(curbuf, new_fname, NULL, TRUE) == FAIL) 3069 { 3070 curbuf->b_ffname = fname; 3071 curbuf->b_sfname = sfname; 3072 return FAIL; 3073 } 3074 curbuf->b_flags |= BF_NOTEDITED; 3075 if (xfname != NULL && *xfname != NUL) 3076 { 3077 buf = buflist_new(fname, xfname, curwin->w_cursor.lnum, 0); 3078 if (buf != NULL && !cmdmod.keepalt) 3079 curwin->w_alt_fnum = buf->b_fnum; 3080 } 3081 vim_free(fname); 3082 vim_free(sfname); 3083 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf); 3084 3085 /* Change directories when the 'acd' option is set. */ 3086 DO_AUTOCHDIR; 3087 return OK; 3088 } 3089 3090 /* 3091 * ":file[!] [fname]". 3092 */ 3093 void 3094 ex_file(exarg_T *eap) 3095 { 3096 /* ":0file" removes the file name. Check for illegal uses ":3file", 3097 * "0file name", etc. */ 3098 if (eap->addr_count > 0 3099 && (*eap->arg != NUL 3100 || eap->line2 > 0 3101 || eap->addr_count > 1)) 3102 { 3103 emsg(_(e_invarg)); 3104 return; 3105 } 3106 3107 if (*eap->arg != NUL || eap->addr_count == 1) 3108 { 3109 if (rename_buffer(eap->arg) == FAIL) 3110 return; 3111 redraw_tabline = TRUE; 3112 } 3113 3114 // print file name if no argument or 'F' is not in 'shortmess' 3115 if (*eap->arg == NUL || !shortmess(SHM_FILEINFO)) 3116 fileinfo(FALSE, FALSE, eap->forceit); 3117 } 3118 3119 /* 3120 * ":update". 3121 */ 3122 void 3123 ex_update(exarg_T *eap) 3124 { 3125 if (curbufIsChanged()) 3126 (void)do_write(eap); 3127 } 3128 3129 /* 3130 * ":write" and ":saveas". 3131 */ 3132 void 3133 ex_write(exarg_T *eap) 3134 { 3135 if (eap->usefilter) /* input lines to shell command */ 3136 do_bang(1, eap, FALSE, TRUE, FALSE); 3137 else 3138 (void)do_write(eap); 3139 } 3140 3141 /* 3142 * write current buffer to file 'eap->arg' 3143 * if 'eap->append' is TRUE, append to the file 3144 * 3145 * if *eap->arg == NUL write to current file 3146 * 3147 * return FAIL for failure, OK otherwise 3148 */ 3149 int 3150 do_write(exarg_T *eap) 3151 { 3152 int other; 3153 char_u *fname = NULL; /* init to shut up gcc */ 3154 char_u *ffname; 3155 int retval = FAIL; 3156 char_u *free_fname = NULL; 3157 #ifdef FEAT_BROWSE 3158 char_u *browse_file = NULL; 3159 #endif 3160 buf_T *alt_buf = NULL; 3161 int name_was_missing; 3162 3163 if (not_writing()) /* check 'write' option */ 3164 return FAIL; 3165 3166 ffname = eap->arg; 3167 #ifdef FEAT_BROWSE 3168 if (cmdmod.browse) 3169 { 3170 browse_file = do_browse(BROWSE_SAVE, (char_u *)_("Save As"), ffname, 3171 NULL, NULL, NULL, curbuf); 3172 if (browse_file == NULL) 3173 goto theend; 3174 ffname = browse_file; 3175 } 3176 #endif 3177 if (*ffname == NUL) 3178 { 3179 if (eap->cmdidx == CMD_saveas) 3180 { 3181 emsg(_(e_argreq)); 3182 goto theend; 3183 } 3184 other = FALSE; 3185 } 3186 else 3187 { 3188 fname = ffname; 3189 free_fname = fix_fname(ffname); 3190 /* 3191 * When out-of-memory, keep unexpanded file name, because we MUST be 3192 * able to write the file in this situation. 3193 */ 3194 if (free_fname != NULL) 3195 ffname = free_fname; 3196 other = otherfile(ffname); 3197 } 3198 3199 /* 3200 * If we have a new file, put its name in the list of alternate file names. 3201 */ 3202 if (other) 3203 { 3204 if (vim_strchr(p_cpo, CPO_ALTWRITE) != NULL 3205 || eap->cmdidx == CMD_saveas) 3206 alt_buf = setaltfname(ffname, fname, (linenr_T)1); 3207 else 3208 alt_buf = buflist_findname(ffname); 3209 if (alt_buf != NULL && alt_buf->b_ml.ml_mfp != NULL) 3210 { 3211 /* Overwriting a file that is loaded in another buffer is not a 3212 * good idea. */ 3213 emsg(_(e_bufloaded)); 3214 goto theend; 3215 } 3216 } 3217 3218 /* 3219 * Writing to the current file is not allowed in readonly mode 3220 * and a file name is required. 3221 * "nofile" and "nowrite" buffers cannot be written implicitly either. 3222 */ 3223 if (!other && ( 3224 #ifdef FEAT_QUICKFIX 3225 bt_dontwrite_msg(curbuf) || 3226 #endif 3227 check_fname() == FAIL || check_readonly(&eap->forceit, curbuf))) 3228 goto theend; 3229 3230 if (!other) 3231 { 3232 ffname = curbuf->b_ffname; 3233 fname = curbuf->b_fname; 3234 /* 3235 * Not writing the whole file is only allowed with '!'. 3236 */ 3237 if ( (eap->line1 != 1 3238 || eap->line2 != curbuf->b_ml.ml_line_count) 3239 && !eap->forceit 3240 && !eap->append 3241 && !p_wa) 3242 { 3243 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 3244 if (p_confirm || cmdmod.confirm) 3245 { 3246 if (vim_dialog_yesno(VIM_QUESTION, NULL, 3247 (char_u *)_("Write partial file?"), 2) != VIM_YES) 3248 goto theend; 3249 eap->forceit = TRUE; 3250 } 3251 else 3252 #endif 3253 { 3254 emsg(_("E140: Use ! to write partial buffer")); 3255 goto theend; 3256 } 3257 } 3258 } 3259 3260 if (check_overwrite(eap, curbuf, fname, ffname, other) == OK) 3261 { 3262 if (eap->cmdidx == CMD_saveas && alt_buf != NULL) 3263 { 3264 buf_T *was_curbuf = curbuf; 3265 3266 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf); 3267 apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, alt_buf); 3268 #ifdef FEAT_EVAL 3269 if (curbuf != was_curbuf || aborting()) 3270 #else 3271 if (curbuf != was_curbuf) 3272 #endif 3273 { 3274 /* buffer changed, don't change name now */ 3275 retval = FAIL; 3276 goto theend; 3277 } 3278 /* Exchange the file names for the current and the alternate 3279 * buffer. This makes it look like we are now editing the buffer 3280 * under the new name. Must be done before buf_write(), because 3281 * if there is no file name and 'cpo' contains 'F', it will set 3282 * the file name. */ 3283 fname = alt_buf->b_fname; 3284 alt_buf->b_fname = curbuf->b_fname; 3285 curbuf->b_fname = fname; 3286 fname = alt_buf->b_ffname; 3287 alt_buf->b_ffname = curbuf->b_ffname; 3288 curbuf->b_ffname = fname; 3289 fname = alt_buf->b_sfname; 3290 alt_buf->b_sfname = curbuf->b_sfname; 3291 curbuf->b_sfname = fname; 3292 buf_name_changed(curbuf); 3293 3294 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf); 3295 apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, alt_buf); 3296 if (!alt_buf->b_p_bl) 3297 { 3298 alt_buf->b_p_bl = TRUE; 3299 apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, alt_buf); 3300 } 3301 #ifdef FEAT_EVAL 3302 if (curbuf != was_curbuf || aborting()) 3303 #else 3304 if (curbuf != was_curbuf) 3305 #endif 3306 { 3307 /* buffer changed, don't write the file */ 3308 retval = FAIL; 3309 goto theend; 3310 } 3311 3312 /* If 'filetype' was empty try detecting it now. */ 3313 if (*curbuf->b_p_ft == NUL) 3314 { 3315 if (au_has_group((char_u *)"filetypedetect")) 3316 (void)do_doautocmd((char_u *)"filetypedetect BufRead", 3317 TRUE, NULL); 3318 do_modelines(0); 3319 } 3320 3321 /* Autocommands may have changed buffer names, esp. when 3322 * 'autochdir' is set. */ 3323 fname = curbuf->b_sfname; 3324 } 3325 3326 name_was_missing = curbuf->b_ffname == NULL; 3327 3328 retval = buf_write(curbuf, ffname, fname, eap->line1, eap->line2, 3329 eap, eap->append, eap->forceit, TRUE, FALSE); 3330 3331 /* After ":saveas fname" reset 'readonly'. */ 3332 if (eap->cmdidx == CMD_saveas) 3333 { 3334 if (retval == OK) 3335 { 3336 curbuf->b_p_ro = FALSE; 3337 redraw_tabline = TRUE; 3338 } 3339 } 3340 3341 /* Change directories when the 'acd' option is set and the file name 3342 * got changed or set. */ 3343 if (eap->cmdidx == CMD_saveas || name_was_missing) 3344 { 3345 DO_AUTOCHDIR; 3346 } 3347 } 3348 3349 theend: 3350 #ifdef FEAT_BROWSE 3351 vim_free(browse_file); 3352 #endif 3353 vim_free(free_fname); 3354 return retval; 3355 } 3356 3357 /* 3358 * Check if it is allowed to overwrite a file. If b_flags has BF_NOTEDITED, 3359 * BF_NEW or BF_READERR, check for overwriting current file. 3360 * May set eap->forceit if a dialog says it's OK to overwrite. 3361 * Return OK if it's OK, FAIL if it is not. 3362 */ 3363 int 3364 check_overwrite( 3365 exarg_T *eap, 3366 buf_T *buf, 3367 char_u *fname, /* file name to be used (can differ from 3368 buf->ffname) */ 3369 char_u *ffname, /* full path version of fname */ 3370 int other) /* writing under other name */ 3371 { 3372 /* 3373 * write to other file or b_flags set or not writing the whole file: 3374 * overwriting only allowed with '!' 3375 */ 3376 if ( (other 3377 || (buf->b_flags & BF_NOTEDITED) 3378 || ((buf->b_flags & BF_NEW) 3379 && vim_strchr(p_cpo, CPO_OVERNEW) == NULL) 3380 || (buf->b_flags & BF_READERR)) 3381 && !p_wa 3382 #ifdef FEAT_QUICKFIX 3383 && !bt_nofile(buf) 3384 #endif 3385 && vim_fexists(ffname)) 3386 { 3387 if (!eap->forceit && !eap->append) 3388 { 3389 #ifdef UNIX 3390 /* with UNIX it is possible to open a directory */ 3391 if (mch_isdir(ffname)) 3392 { 3393 semsg(_(e_isadir2), ffname); 3394 return FAIL; 3395 } 3396 #endif 3397 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 3398 if (p_confirm || cmdmod.confirm) 3399 { 3400 char_u buff[DIALOG_MSG_SIZE]; 3401 3402 dialog_msg(buff, _("Overwrite existing file \"%s\"?"), fname); 3403 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) != VIM_YES) 3404 return FAIL; 3405 eap->forceit = TRUE; 3406 } 3407 else 3408 #endif 3409 { 3410 emsg(_(e_exists)); 3411 return FAIL; 3412 } 3413 } 3414 3415 /* For ":w! filename" check that no swap file exists for "filename". */ 3416 if (other && !emsg_silent) 3417 { 3418 char_u *dir; 3419 char_u *p; 3420 int r; 3421 char_u *swapname; 3422 3423 /* We only try the first entry in 'directory', without checking if 3424 * it's writable. If the "." directory is not writable the write 3425 * will probably fail anyway. 3426 * Use 'shortname' of the current buffer, since there is no buffer 3427 * for the written file. */ 3428 if (*p_dir == NUL) 3429 { 3430 dir = alloc(5); 3431 if (dir == NULL) 3432 return FAIL; 3433 STRCPY(dir, "."); 3434 } 3435 else 3436 { 3437 dir = alloc(MAXPATHL); 3438 if (dir == NULL) 3439 return FAIL; 3440 p = p_dir; 3441 copy_option_part(&p, dir, MAXPATHL, ","); 3442 } 3443 swapname = makeswapname(fname, ffname, curbuf, dir); 3444 vim_free(dir); 3445 r = vim_fexists(swapname); 3446 if (r) 3447 { 3448 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 3449 if (p_confirm || cmdmod.confirm) 3450 { 3451 char_u buff[DIALOG_MSG_SIZE]; 3452 3453 dialog_msg(buff, 3454 _("Swap file \"%s\" exists, overwrite anyway?"), 3455 swapname); 3456 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) 3457 != VIM_YES) 3458 { 3459 vim_free(swapname); 3460 return FAIL; 3461 } 3462 eap->forceit = TRUE; 3463 } 3464 else 3465 #endif 3466 { 3467 semsg(_("E768: Swap file exists: %s (:silent! overrides)"), 3468 swapname); 3469 vim_free(swapname); 3470 return FAIL; 3471 } 3472 } 3473 vim_free(swapname); 3474 } 3475 } 3476 return OK; 3477 } 3478 3479 /* 3480 * Handle ":wnext", ":wNext" and ":wprevious" commands. 3481 */ 3482 void 3483 ex_wnext(exarg_T *eap) 3484 { 3485 int i; 3486 3487 if (eap->cmd[1] == 'n') 3488 i = curwin->w_arg_idx + (int)eap->line2; 3489 else 3490 i = curwin->w_arg_idx - (int)eap->line2; 3491 eap->line1 = 1; 3492 eap->line2 = curbuf->b_ml.ml_line_count; 3493 if (do_write(eap) != FAIL) 3494 do_argfile(eap, i); 3495 } 3496 3497 /* 3498 * ":wall", ":wqall" and ":xall": Write all changed files (and exit). 3499 */ 3500 void 3501 do_wqall(exarg_T *eap) 3502 { 3503 buf_T *buf; 3504 int error = 0; 3505 int save_forceit = eap->forceit; 3506 3507 if (eap->cmdidx == CMD_xall || eap->cmdidx == CMD_wqall) 3508 exiting = TRUE; 3509 3510 FOR_ALL_BUFFERS(buf) 3511 { 3512 #ifdef FEAT_TERMINAL 3513 if (exiting && term_job_running(buf->b_term)) 3514 { 3515 no_write_message_nobang(buf); 3516 ++error; 3517 } 3518 else 3519 #endif 3520 if (bufIsChanged(buf) && !bt_dontwrite(buf)) 3521 { 3522 /* 3523 * Check if there is a reason the buffer cannot be written: 3524 * 1. if the 'write' option is set 3525 * 2. if there is no file name (even after browsing) 3526 * 3. if the 'readonly' is set (even after a dialog) 3527 * 4. if overwriting is allowed (even after a dialog) 3528 */ 3529 if (not_writing()) 3530 { 3531 ++error; 3532 break; 3533 } 3534 #ifdef FEAT_BROWSE 3535 /* ":browse wall": ask for file name if there isn't one */ 3536 if (buf->b_ffname == NULL && cmdmod.browse) 3537 browse_save_fname(buf); 3538 #endif 3539 if (buf->b_ffname == NULL) 3540 { 3541 semsg(_("E141: No file name for buffer %ld"), (long)buf->b_fnum); 3542 ++error; 3543 } 3544 else if (check_readonly(&eap->forceit, buf) 3545 || check_overwrite(eap, buf, buf->b_fname, buf->b_ffname, 3546 FALSE) == FAIL) 3547 { 3548 ++error; 3549 } 3550 else 3551 { 3552 bufref_T bufref; 3553 3554 set_bufref(&bufref, buf); 3555 if (buf_write_all(buf, eap->forceit) == FAIL) 3556 ++error; 3557 /* an autocommand may have deleted the buffer */ 3558 if (!bufref_valid(&bufref)) 3559 buf = firstbuf; 3560 } 3561 eap->forceit = save_forceit; /* check_overwrite() may set it */ 3562 } 3563 } 3564 if (exiting) 3565 { 3566 if (!error) 3567 getout(0); /* exit Vim */ 3568 not_exiting(); 3569 } 3570 } 3571 3572 /* 3573 * Check the 'write' option. 3574 * Return TRUE and give a message when it's not st. 3575 */ 3576 int 3577 not_writing(void) 3578 { 3579 if (p_write) 3580 return FALSE; 3581 emsg(_("E142: File not written: Writing is disabled by 'write' option")); 3582 return TRUE; 3583 } 3584 3585 /* 3586 * Check if a buffer is read-only (either 'readonly' option is set or file is 3587 * read-only). Ask for overruling in a dialog. Return TRUE and give an error 3588 * message when the buffer is readonly. 3589 */ 3590 static int 3591 check_readonly(int *forceit, buf_T *buf) 3592 { 3593 stat_T st; 3594 3595 /* Handle a file being readonly when the 'readonly' option is set or when 3596 * the file exists and permissions are read-only. 3597 * We will send 0777 to check_file_readonly(), as the "perm" variable is 3598 * important for device checks but not here. */ 3599 if (!*forceit && (buf->b_p_ro 3600 || (mch_stat((char *)buf->b_ffname, &st) >= 0 3601 && check_file_readonly(buf->b_ffname, 0777)))) 3602 { 3603 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 3604 if ((p_confirm || cmdmod.confirm) && buf->b_fname != NULL) 3605 { 3606 char_u buff[DIALOG_MSG_SIZE]; 3607 3608 if (buf->b_p_ro) 3609 dialog_msg(buff, _("'readonly' option is set for \"%s\".\nDo you wish to write anyway?"), 3610 buf->b_fname); 3611 else 3612 dialog_msg(buff, _("File permissions of \"%s\" are read-only.\nIt may still be possible to write it.\nDo you wish to try?"), 3613 buf->b_fname); 3614 3615 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES) 3616 { 3617 /* Set forceit, to force the writing of a readonly file */ 3618 *forceit = TRUE; 3619 return FALSE; 3620 } 3621 else 3622 return TRUE; 3623 } 3624 else 3625 #endif 3626 if (buf->b_p_ro) 3627 emsg(_(e_readonly)); 3628 else 3629 semsg(_("E505: \"%s\" is read-only (add ! to override)"), 3630 buf->b_fname); 3631 return TRUE; 3632 } 3633 3634 return FALSE; 3635 } 3636 3637 /* 3638 * Try to abandon the current file and edit a new or existing file. 3639 * "fnum" is the number of the file, if zero use "ffname_arg"/"sfname_arg". 3640 * "lnum" is the line number for the cursor in the new file (if non-zero). 3641 * 3642 * Return: 3643 * GETFILE_ERROR for "normal" error, 3644 * GETFILE_NOT_WRITTEN for "not written" error, 3645 * GETFILE_SAME_FILE for success 3646 * GETFILE_OPEN_OTHER for successfully opening another file. 3647 */ 3648 int 3649 getfile( 3650 int fnum, 3651 char_u *ffname_arg, 3652 char_u *sfname_arg, 3653 int setpm, 3654 linenr_T lnum, 3655 int forceit) 3656 { 3657 char_u *ffname = ffname_arg; 3658 char_u *sfname = sfname_arg; 3659 int other; 3660 int retval; 3661 char_u *free_me = NULL; 3662 3663 if (text_locked()) 3664 return GETFILE_ERROR; 3665 if (curbuf_locked()) 3666 return GETFILE_ERROR; 3667 3668 if (fnum == 0) 3669 { 3670 /* make ffname full path, set sfname */ 3671 fname_expand(curbuf, &ffname, &sfname); 3672 other = otherfile(ffname); 3673 free_me = ffname; /* has been allocated, free() later */ 3674 } 3675 else 3676 other = (fnum != curbuf->b_fnum); 3677 3678 if (other) 3679 ++no_wait_return; /* don't wait for autowrite message */ 3680 if (other && !forceit && curbuf->b_nwindows == 1 && !buf_hide(curbuf) 3681 && curbufIsChanged() && autowrite(curbuf, forceit) == FAIL) 3682 { 3683 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) 3684 if (p_confirm && p_write) 3685 dialog_changed(curbuf, FALSE); 3686 if (curbufIsChanged()) 3687 #endif 3688 { 3689 if (other) 3690 --no_wait_return; 3691 no_write_message(); 3692 retval = GETFILE_NOT_WRITTEN; /* file has been changed */ 3693 goto theend; 3694 } 3695 } 3696 if (other) 3697 --no_wait_return; 3698 if (setpm) 3699 setpcmark(); 3700 if (!other) 3701 { 3702 if (lnum != 0) 3703 curwin->w_cursor.lnum = lnum; 3704 check_cursor_lnum(); 3705 beginline(BL_SOL | BL_FIX); 3706 retval = GETFILE_SAME_FILE; /* it's in the same file */ 3707 } 3708 else if (do_ecmd(fnum, ffname, sfname, NULL, lnum, 3709 (buf_hide(curbuf) ? ECMD_HIDE : 0) + (forceit ? ECMD_FORCEIT : 0), 3710 curwin) == OK) 3711 retval = GETFILE_OPEN_OTHER; /* opened another file */ 3712 else 3713 retval = GETFILE_ERROR; /* error encountered */ 3714 3715 theend: 3716 vim_free(free_me); 3717 return retval; 3718 } 3719 3720 /* 3721 * start editing a new file 3722 * 3723 * fnum: file number; if zero use ffname/sfname 3724 * ffname: the file name 3725 * - full path if sfname used, 3726 * - any file name if sfname is NULL 3727 * - empty string to re-edit with the same file name (but may be 3728 * in a different directory) 3729 * - NULL to start an empty buffer 3730 * sfname: the short file name (or NULL) 3731 * eap: contains the command to be executed after loading the file and 3732 * forced 'ff' and 'fenc' 3733 * newlnum: if > 0: put cursor on this line number (if possible) 3734 * if ECMD_LASTL: use last position in loaded file 3735 * if ECMD_LAST: use last position in all files 3736 * if ECMD_ONE: use first line 3737 * flags: 3738 * ECMD_HIDE: if TRUE don't free the current buffer 3739 * ECMD_SET_HELP: set b_help flag of (new) buffer before opening file 3740 * ECMD_OLDBUF: use existing buffer if it exists 3741 * ECMD_FORCEIT: ! used for Ex command 3742 * ECMD_ADDBUF: don't edit, just add to buffer list 3743 * oldwin: Should be "curwin" when editing a new buffer in the current 3744 * window, NULL when splitting the window first. When not NULL info 3745 * of the previous buffer for "oldwin" is stored. 3746 * 3747 * return FAIL for failure, OK otherwise 3748 */ 3749 int 3750 do_ecmd( 3751 int fnum, 3752 char_u *ffname, 3753 char_u *sfname, 3754 exarg_T *eap, /* can be NULL! */ 3755 linenr_T newlnum, 3756 int flags, 3757 win_T *oldwin) 3758 { 3759 int other_file; /* TRUE if editing another file */ 3760 int oldbuf; /* TRUE if using existing buffer */ 3761 int auto_buf = FALSE; /* TRUE if autocommands brought us 3762 into the buffer unexpectedly */ 3763 char_u *new_name = NULL; 3764 #if defined(FEAT_EVAL) 3765 int did_set_swapcommand = FALSE; 3766 #endif 3767 buf_T *buf; 3768 bufref_T bufref; 3769 bufref_T old_curbuf; 3770 char_u *free_fname = NULL; 3771 #ifdef FEAT_BROWSE 3772 char_u *browse_file = NULL; 3773 #endif 3774 int retval = FAIL; 3775 long n; 3776 pos_T orig_pos; 3777 linenr_T topline = 0; 3778 int newcol = -1; 3779 int solcol = -1; 3780 pos_T *pos; 3781 char_u *command = NULL; 3782 #ifdef FEAT_SPELL 3783 int did_get_winopts = FALSE; 3784 #endif 3785 int readfile_flags = 0; 3786 int did_inc_redrawing_disabled = FALSE; 3787 long *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so; 3788 3789 if (eap != NULL) 3790 command = eap->do_ecmd_cmd; 3791 set_bufref(&old_curbuf, curbuf); 3792 3793 if (fnum != 0) 3794 { 3795 if (fnum == curbuf->b_fnum) /* file is already being edited */ 3796 return OK; /* nothing to do */ 3797 other_file = TRUE; 3798 } 3799 else 3800 { 3801 #ifdef FEAT_BROWSE 3802 if (cmdmod.browse) 3803 { 3804 if ( 3805 # ifdef FEAT_GUI 3806 !gui.in_use && 3807 # endif 3808 au_has_group((char_u *)"FileExplorer")) 3809 { 3810 /* No browsing supported but we do have the file explorer: 3811 * Edit the directory. */ 3812 if (ffname == NULL || !mch_isdir(ffname)) 3813 ffname = (char_u *)"."; 3814 } 3815 else 3816 { 3817 browse_file = do_browse(0, (char_u *)_("Edit File"), ffname, 3818 NULL, NULL, NULL, curbuf); 3819 if (browse_file == NULL) 3820 goto theend; 3821 ffname = browse_file; 3822 } 3823 } 3824 #endif 3825 /* if no short name given, use ffname for short name */ 3826 if (sfname == NULL) 3827 sfname = ffname; 3828 #ifdef USE_FNAME_CASE 3829 # ifdef USE_LONG_FNAME 3830 if (USE_LONG_FNAME) 3831 # endif 3832 if (sfname != NULL) 3833 fname_case(sfname, 0); /* set correct case for sfname */ 3834 #endif 3835 3836 if ((flags & ECMD_ADDBUF) && (ffname == NULL || *ffname == NUL)) 3837 goto theend; 3838 3839 if (ffname == NULL) 3840 other_file = TRUE; 3841 /* there is no file name */ 3842 else if (*ffname == NUL && curbuf->b_ffname == NULL) 3843 other_file = FALSE; 3844 else 3845 { 3846 if (*ffname == NUL) /* re-edit with same file name */ 3847 { 3848 ffname = curbuf->b_ffname; 3849 sfname = curbuf->b_fname; 3850 } 3851 free_fname = fix_fname(ffname); /* may expand to full path name */ 3852 if (free_fname != NULL) 3853 ffname = free_fname; 3854 other_file = otherfile(ffname); 3855 } 3856 } 3857 3858 /* 3859 * if the file was changed we may not be allowed to abandon it 3860 * - if we are going to re-edit the same file 3861 * - or if we are the only window on this file and if ECMD_HIDE is FALSE 3862 */ 3863 if ( ((!other_file && !(flags & ECMD_OLDBUF)) 3864 || (curbuf->b_nwindows == 1 3865 && !(flags & (ECMD_HIDE | ECMD_ADDBUF)))) 3866 && check_changed(curbuf, (p_awa ? CCGD_AW : 0) 3867 | (other_file ? 0 : CCGD_MULTWIN) 3868 | ((flags & ECMD_FORCEIT) ? CCGD_FORCEIT : 0) 3869 | (eap == NULL ? 0 : CCGD_EXCMD))) 3870 { 3871 if (fnum == 0 && other_file && ffname != NULL) 3872 (void)setaltfname(ffname, sfname, newlnum < 0 ? 0 : newlnum); 3873 goto theend; 3874 } 3875 3876 /* 3877 * End Visual mode before switching to another buffer, so the text can be 3878 * copied into the GUI selection buffer. 3879 */ 3880 reset_VIsual(); 3881 3882 #if defined(FEAT_EVAL) 3883 if ((command != NULL || newlnum > (linenr_T)0) 3884 && *get_vim_var_str(VV_SWAPCOMMAND) == NUL) 3885 { 3886 int len; 3887 char_u *p; 3888 3889 /* Set v:swapcommand for the SwapExists autocommands. */ 3890 if (command != NULL) 3891 len = (int)STRLEN(command) + 3; 3892 else 3893 len = 30; 3894 p = alloc((unsigned)len); 3895 if (p != NULL) 3896 { 3897 if (command != NULL) 3898 vim_snprintf((char *)p, len, ":%s\r", command); 3899 else 3900 vim_snprintf((char *)p, len, "%ldG", (long)newlnum); 3901 set_vim_var_string(VV_SWAPCOMMAND, p, -1); 3902 did_set_swapcommand = TRUE; 3903 vim_free(p); 3904 } 3905 } 3906 #endif 3907 3908 /* 3909 * If we are starting to edit another file, open a (new) buffer. 3910 * Otherwise we re-use the current buffer. 3911 */ 3912 if (other_file) 3913 { 3914 if (!(flags & ECMD_ADDBUF)) 3915 { 3916 if (!cmdmod.keepalt) 3917 curwin->w_alt_fnum = curbuf->b_fnum; 3918 if (oldwin != NULL) 3919 buflist_altfpos(oldwin); 3920 } 3921 3922 if (fnum) 3923 buf = buflist_findnr(fnum); 3924 else 3925 { 3926 if (flags & ECMD_ADDBUF) 3927 { 3928 linenr_T tlnum = 1L; 3929 3930 if (command != NULL) 3931 { 3932 tlnum = atol((char *)command); 3933 if (tlnum <= 0) 3934 tlnum = 1L; 3935 } 3936 (void)buflist_new(ffname, sfname, tlnum, BLN_LISTED); 3937 goto theend; 3938 } 3939 buf = buflist_new(ffname, sfname, 0L, 3940 BLN_CURBUF | ((flags & ECMD_SET_HELP) ? 0 : BLN_LISTED)); 3941 3942 /* autocommands may change curwin and curbuf */ 3943 if (oldwin != NULL) 3944 oldwin = curwin; 3945 set_bufref(&old_curbuf, curbuf); 3946 } 3947 if (buf == NULL) 3948 goto theend; 3949 if (buf->b_ml.ml_mfp == NULL) /* no memfile yet */ 3950 { 3951 oldbuf = FALSE; 3952 } 3953 else /* existing memfile */ 3954 { 3955 oldbuf = TRUE; 3956 set_bufref(&bufref, buf); 3957 (void)buf_check_timestamp(buf, FALSE); 3958 /* Check if autocommands made the buffer invalid or changed the 3959 * current buffer. */ 3960 if (!bufref_valid(&bufref) || curbuf != old_curbuf.br_buf) 3961 goto theend; 3962 #ifdef FEAT_EVAL 3963 if (aborting()) /* autocmds may abort script processing */ 3964 goto theend; 3965 #endif 3966 } 3967 3968 /* May jump to last used line number for a loaded buffer or when asked 3969 * for explicitly */ 3970 if ((oldbuf && newlnum == ECMD_LASTL) || newlnum == ECMD_LAST) 3971 { 3972 pos = buflist_findfpos(buf); 3973 newlnum = pos->lnum; 3974 solcol = pos->col; 3975 } 3976 3977 /* 3978 * Make the (new) buffer the one used by the current window. 3979 * If the old buffer becomes unused, free it if ECMD_HIDE is FALSE. 3980 * If the current buffer was empty and has no file name, curbuf 3981 * is returned by buflist_new(), nothing to do here. 3982 */ 3983 if (buf != curbuf) 3984 { 3985 /* 3986 * Be careful: The autocommands may delete any buffer and change 3987 * the current buffer. 3988 * - If the buffer we are going to edit is deleted, give up. 3989 * - If the current buffer is deleted, prefer to load the new 3990 * buffer when loading a buffer is required. This avoids 3991 * loading another buffer which then must be closed again. 3992 * - If we ended up in the new buffer already, need to skip a few 3993 * things, set auto_buf. 3994 */ 3995 if (buf->b_fname != NULL) 3996 new_name = vim_strsave(buf->b_fname); 3997 set_bufref(&au_new_curbuf, buf); 3998 apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE, curbuf); 3999 if (!bufref_valid(&au_new_curbuf)) 4000 { 4001 /* new buffer has been deleted */ 4002 delbuf_msg(new_name); /* frees new_name */ 4003 goto theend; 4004 } 4005 #ifdef FEAT_EVAL 4006 if (aborting()) /* autocmds may abort script processing */ 4007 { 4008 vim_free(new_name); 4009 goto theend; 4010 } 4011 #endif 4012 if (buf == curbuf) /* already in new buffer */ 4013 auto_buf = TRUE; 4014 else 4015 { 4016 win_T *the_curwin = curwin; 4017 4018 /* Set the w_closing flag to avoid that autocommands close the 4019 * window. And set b_locked for the same reason. */ 4020 the_curwin->w_closing = TRUE; 4021 ++buf->b_locked; 4022 4023 if (curbuf == old_curbuf.br_buf) 4024 buf_copy_options(buf, BCO_ENTER); 4025 4026 /* Close the link to the current buffer. This will set 4027 * oldwin->w_buffer to NULL. */ 4028 u_sync(FALSE); 4029 close_buffer(oldwin, curbuf, 4030 (flags & ECMD_HIDE) ? 0 : DOBUF_UNLOAD, FALSE); 4031 4032 the_curwin->w_closing = FALSE; 4033 --buf->b_locked; 4034 4035 #ifdef FEAT_EVAL 4036 /* autocmds may abort script processing */ 4037 if (aborting() && curwin->w_buffer != NULL) 4038 { 4039 vim_free(new_name); 4040 goto theend; 4041 } 4042 #endif 4043 /* Be careful again, like above. */ 4044 if (!bufref_valid(&au_new_curbuf)) 4045 { 4046 /* new buffer has been deleted */ 4047 delbuf_msg(new_name); /* frees new_name */ 4048 goto theend; 4049 } 4050 if (buf == curbuf) /* already in new buffer */ 4051 auto_buf = TRUE; 4052 else 4053 { 4054 #ifdef FEAT_SYN_HL 4055 /* 4056 * <VN> We could instead free the synblock 4057 * and re-attach to buffer, perhaps. 4058 */ 4059 if (curwin->w_buffer == NULL 4060 || curwin->w_s == &(curwin->w_buffer->b_s)) 4061 curwin->w_s = &(buf->b_s); 4062 #endif 4063 curwin->w_buffer = buf; 4064 curbuf = buf; 4065 ++curbuf->b_nwindows; 4066 4067 /* Set 'fileformat', 'binary' and 'fenc' when forced. */ 4068 if (!oldbuf && eap != NULL) 4069 { 4070 set_file_options(TRUE, eap); 4071 set_forced_fenc(eap); 4072 } 4073 } 4074 4075 /* May get the window options from the last time this buffer 4076 * was in this window (or another window). If not used 4077 * before, reset the local window options to the global 4078 * values. Also restores old folding stuff. */ 4079 get_winopts(curbuf); 4080 #ifdef FEAT_SPELL 4081 did_get_winopts = TRUE; 4082 #endif 4083 } 4084 vim_free(new_name); 4085 au_new_curbuf.br_buf = NULL; 4086 au_new_curbuf.br_buf_free_count = 0; 4087 } 4088 4089 curwin->w_pcmark.lnum = 1; 4090 curwin->w_pcmark.col = 0; 4091 } 4092 else /* !other_file */ 4093 { 4094 if ((flags & ECMD_ADDBUF) || check_fname() == FAIL) 4095 goto theend; 4096 4097 oldbuf = (flags & ECMD_OLDBUF); 4098 } 4099 4100 /* Don't redraw until the cursor is in the right line, otherwise 4101 * autocommands may cause ml_get errors. */ 4102 ++RedrawingDisabled; 4103 did_inc_redrawing_disabled = TRUE; 4104 4105 buf = curbuf; 4106 if ((flags & ECMD_SET_HELP) || keep_help_flag) 4107 { 4108 prepare_help_buffer(); 4109 } 4110 else 4111 { 4112 /* Don't make a buffer listed if it's a help buffer. Useful when 4113 * using CTRL-O to go back to a help file. */ 4114 if (!curbuf->b_help) 4115 set_buflisted(TRUE); 4116 } 4117 4118 /* If autocommands change buffers under our fingers, forget about 4119 * editing the file. */ 4120 if (buf != curbuf) 4121 goto theend; 4122 #ifdef FEAT_EVAL 4123 if (aborting()) /* autocmds may abort script processing */ 4124 goto theend; 4125 #endif 4126 4127 /* Since we are starting to edit a file, consider the filetype to be 4128 * unset. Helps for when an autocommand changes files and expects syntax 4129 * highlighting to work in the other file. */ 4130 did_filetype = FALSE; 4131 4132 /* 4133 * other_file oldbuf 4134 * FALSE FALSE re-edit same file, buffer is re-used 4135 * FALSE TRUE re-edit same file, nothing changes 4136 * TRUE FALSE start editing new file, new buffer 4137 * TRUE TRUE start editing in existing buffer (nothing to do) 4138 */ 4139 if (!other_file && !oldbuf) /* re-use the buffer */ 4140 { 4141 set_last_cursor(curwin); /* may set b_last_cursor */ 4142 if (newlnum == ECMD_LAST || newlnum == ECMD_LASTL) 4143 { 4144 newlnum = curwin->w_cursor.lnum; 4145 solcol = curwin->w_cursor.col; 4146 } 4147 buf = curbuf; 4148 if (buf->b_fname != NULL) 4149 new_name = vim_strsave(buf->b_fname); 4150 else 4151 new_name = NULL; 4152 set_bufref(&bufref, buf); 4153 4154 if (p_ur < 0 || curbuf->b_ml.ml_line_count <= p_ur) 4155 { 4156 /* Save all the text, so that the reload can be undone. 4157 * Sync first so that this is a separate undo-able action. */ 4158 u_sync(FALSE); 4159 if (u_savecommon(0, curbuf->b_ml.ml_line_count + 1, 0, TRUE) 4160 == FAIL) 4161 { 4162 vim_free(new_name); 4163 goto theend; 4164 } 4165 u_unchanged(curbuf); 4166 buf_freeall(curbuf, BFA_KEEP_UNDO); 4167 4168 /* tell readfile() not to clear or reload undo info */ 4169 readfile_flags = READ_KEEP_UNDO; 4170 } 4171 else 4172 buf_freeall(curbuf, 0); /* free all things for buffer */ 4173 4174 /* If autocommands deleted the buffer we were going to re-edit, give 4175 * up and jump to the end. */ 4176 if (!bufref_valid(&bufref)) 4177 { 4178 delbuf_msg(new_name); /* frees new_name */ 4179 goto theend; 4180 } 4181 vim_free(new_name); 4182 4183 /* If autocommands change buffers under our fingers, forget about 4184 * re-editing the file. Should do the buf_clear_file(), but perhaps 4185 * the autocommands changed the buffer... */ 4186 if (buf != curbuf) 4187 goto theend; 4188 #ifdef FEAT_EVAL 4189 if (aborting()) /* autocmds may abort script processing */ 4190 goto theend; 4191 #endif 4192 buf_clear_file(curbuf); 4193 curbuf->b_op_start.lnum = 0; /* clear '[ and '] marks */ 4194 curbuf->b_op_end.lnum = 0; 4195 } 4196 4197 /* 4198 * If we get here we are sure to start editing 4199 */ 4200 /* Assume success now */ 4201 retval = OK; 4202 4203 /* 4204 * Check if we are editing the w_arg_idx file in the argument list. 4205 */ 4206 check_arg_idx(curwin); 4207 4208 if (!auto_buf) 4209 { 4210 /* 4211 * Set cursor and init window before reading the file and executing 4212 * autocommands. This allows for the autocommands to position the 4213 * cursor. 4214 */ 4215 curwin_init(); 4216 4217 #ifdef FEAT_FOLDING 4218 /* It's possible that all lines in the buffer changed. Need to update 4219 * automatic folding for all windows where it's used. */ 4220 { 4221 win_T *win; 4222 tabpage_T *tp; 4223 4224 FOR_ALL_TAB_WINDOWS(tp, win) 4225 if (win->w_buffer == curbuf) 4226 foldUpdateAll(win); 4227 } 4228 #endif 4229 4230 /* Change directories when the 'acd' option is set. */ 4231 DO_AUTOCHDIR; 4232 4233 /* 4234 * Careful: open_buffer() and apply_autocmds() may change the current 4235 * buffer and window. 4236 */ 4237 orig_pos = curwin->w_cursor; 4238 topline = curwin->w_topline; 4239 if (!oldbuf) /* need to read the file */ 4240 { 4241 #if defined(HAS_SWAP_EXISTS_ACTION) 4242 swap_exists_action = SEA_DIALOG; 4243 #endif 4244 curbuf->b_flags |= BF_CHECK_RO; /* set/reset 'ro' flag */ 4245 4246 /* 4247 * Open the buffer and read the file. 4248 */ 4249 #if defined(FEAT_EVAL) 4250 if (should_abort(open_buffer(FALSE, eap, readfile_flags))) 4251 retval = FAIL; 4252 #else 4253 (void)open_buffer(FALSE, eap, readfile_flags); 4254 #endif 4255 4256 #if defined(HAS_SWAP_EXISTS_ACTION) 4257 if (swap_exists_action == SEA_QUIT) 4258 retval = FAIL; 4259 handle_swap_exists(&old_curbuf); 4260 #endif 4261 } 4262 else 4263 { 4264 /* Read the modelines, but only to set window-local options. Any 4265 * buffer-local options have already been set and may have been 4266 * changed by the user. */ 4267 do_modelines(OPT_WINONLY); 4268 4269 apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf, 4270 &retval); 4271 apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, FALSE, curbuf, 4272 &retval); 4273 } 4274 check_arg_idx(curwin); 4275 4276 /* If autocommands change the cursor position or topline, we should 4277 * keep it. Also when it moves within a line. But not when it moves 4278 * to the first non-blank. */ 4279 if (!EQUAL_POS(curwin->w_cursor, orig_pos)) 4280 { 4281 char_u *text = ml_get_curline(); 4282 4283 if (curwin->w_cursor.lnum != orig_pos.lnum 4284 || curwin->w_cursor.col != (int)(skipwhite(text) - text)) 4285 { 4286 newlnum = curwin->w_cursor.lnum; 4287 newcol = curwin->w_cursor.col; 4288 } 4289 } 4290 if (curwin->w_topline == topline) 4291 topline = 0; 4292 4293 /* Even when cursor didn't move we need to recompute topline. */ 4294 changed_line_abv_curs(); 4295 4296 #ifdef FEAT_TITLE 4297 maketitle(); 4298 #endif 4299 } 4300 4301 #ifdef FEAT_DIFF 4302 /* Tell the diff stuff that this buffer is new and/or needs updating. 4303 * Also needed when re-editing the same buffer, because unloading will 4304 * have removed it as a diff buffer. */ 4305 if (curwin->w_p_diff) 4306 { 4307 diff_buf_add(curbuf); 4308 diff_invalidate(curbuf); 4309 } 4310 #endif 4311 4312 #ifdef FEAT_SPELL 4313 /* If the window options were changed may need to set the spell language. 4314 * Can only do this after the buffer has been properly setup. */ 4315 if (did_get_winopts && curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL) 4316 (void)did_set_spelllang(curwin); 4317 #endif 4318 4319 if (command == NULL) 4320 { 4321 if (newcol >= 0) /* position set by autocommands */ 4322 { 4323 curwin->w_cursor.lnum = newlnum; 4324 curwin->w_cursor.col = newcol; 4325 check_cursor(); 4326 } 4327 else if (newlnum > 0) /* line number from caller or old position */ 4328 { 4329 curwin->w_cursor.lnum = newlnum; 4330 check_cursor_lnum(); 4331 if (solcol >= 0 && !p_sol) 4332 { 4333 /* 'sol' is off: Use last known column. */ 4334 curwin->w_cursor.col = solcol; 4335 check_cursor_col(); 4336 curwin->w_cursor.coladd = 0; 4337 curwin->w_set_curswant = TRUE; 4338 } 4339 else 4340 beginline(BL_SOL | BL_FIX); 4341 } 4342 else /* no line number, go to last line in Ex mode */ 4343 { 4344 if (exmode_active) 4345 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; 4346 beginline(BL_WHITE | BL_FIX); 4347 } 4348 } 4349 4350 /* Check if cursors in other windows on the same buffer are still valid */ 4351 check_lnums(FALSE); 4352 4353 /* 4354 * Did not read the file, need to show some info about the file. 4355 * Do this after setting the cursor. 4356 */ 4357 if (oldbuf && !auto_buf) 4358 { 4359 int msg_scroll_save = msg_scroll; 4360 4361 /* Obey the 'O' flag in 'cpoptions': overwrite any previous file 4362 * message. */ 4363 if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0) 4364 msg_scroll = FALSE; 4365 if (!msg_scroll) /* wait a bit when overwriting an error msg */ 4366 check_for_delay(FALSE); 4367 msg_start(); 4368 msg_scroll = msg_scroll_save; 4369 msg_scrolled_ign = TRUE; 4370 4371 if (!shortmess(SHM_FILEINFO)) 4372 fileinfo(FALSE, TRUE, FALSE); 4373 4374 msg_scrolled_ign = FALSE; 4375 } 4376 4377 #ifdef FEAT_VIMINFO 4378 curbuf->b_last_used = vim_time(); 4379 #endif 4380 4381 if (command != NULL) 4382 do_cmdline(command, NULL, NULL, DOCMD_VERBOSE); 4383 4384 #ifdef FEAT_KEYMAP 4385 if (curbuf->b_kmap_state & KEYMAP_INIT) 4386 (void)keymap_init(); 4387 #endif 4388 4389 --RedrawingDisabled; 4390 did_inc_redrawing_disabled = FALSE; 4391 if (!skip_redraw) 4392 { 4393 n = *so_ptr; 4394 if (topline == 0 && command == NULL) 4395 *so_ptr = 9999; // force cursor halfway the window 4396 update_topline(); 4397 curwin->w_scbind_pos = curwin->w_topline; 4398 *so_ptr = n; 4399 redraw_curbuf_later(NOT_VALID); /* redraw this buffer later */ 4400 } 4401 4402 if (p_im) 4403 need_start_insertmode = TRUE; 4404 4405 #ifdef FEAT_AUTOCHDIR 4406 /* Change directories when the 'acd' option is set and we aren't already in 4407 * that directory (should already be done above). Expect getcwd() to be 4408 * faster than calling shorten_fnames() unnecessarily. */ 4409 if (p_acd && curbuf->b_ffname != NULL) 4410 { 4411 char_u curdir[MAXPATHL]; 4412 char_u filedir[MAXPATHL]; 4413 4414 vim_strncpy(filedir, curbuf->b_ffname, MAXPATHL - 1); 4415 *gettail_sep(filedir) = NUL; 4416 if (mch_dirname(curdir, MAXPATHL) != FAIL 4417 && vim_fnamecmp(curdir, filedir) != 0) 4418 do_autochdir(); 4419 } 4420 #endif 4421 4422 #if defined(FEAT_NETBEANS_INTG) 4423 if (curbuf->b_ffname != NULL) 4424 { 4425 # ifdef FEAT_NETBEANS_INTG 4426 if ((flags & ECMD_SET_HELP) != ECMD_SET_HELP) 4427 netbeans_file_opened(curbuf); 4428 # endif 4429 } 4430 #endif 4431 4432 theend: 4433 if (did_inc_redrawing_disabled) 4434 --RedrawingDisabled; 4435 #if defined(FEAT_EVAL) 4436 if (did_set_swapcommand) 4437 set_vim_var_string(VV_SWAPCOMMAND, NULL, -1); 4438 #endif 4439 #ifdef FEAT_BROWSE 4440 vim_free(browse_file); 4441 #endif 4442 vim_free(free_fname); 4443 return retval; 4444 } 4445 4446 static void 4447 delbuf_msg(char_u *name) 4448 { 4449 semsg(_("E143: Autocommands unexpectedly deleted new buffer %s"), 4450 name == NULL ? (char_u *)"" : name); 4451 vim_free(name); 4452 au_new_curbuf.br_buf = NULL; 4453 au_new_curbuf.br_buf_free_count = 0; 4454 } 4455 4456 static int append_indent = 0; /* autoindent for first line */ 4457 4458 /* 4459 * ":insert" and ":append", also used by ":change" 4460 */ 4461 void 4462 ex_append(exarg_T *eap) 4463 { 4464 char_u *theline; 4465 int did_undo = FALSE; 4466 linenr_T lnum = eap->line2; 4467 int indent = 0; 4468 char_u *p; 4469 int vcol; 4470 int empty = (curbuf->b_ml.ml_flags & ML_EMPTY); 4471 4472 /* the ! flag toggles autoindent */ 4473 if (eap->forceit) 4474 curbuf->b_p_ai = !curbuf->b_p_ai; 4475 4476 /* First autoindent comes from the line we start on */ 4477 if (eap->cmdidx != CMD_change && curbuf->b_p_ai && lnum > 0) 4478 append_indent = get_indent_lnum(lnum); 4479 4480 if (eap->cmdidx != CMD_append) 4481 --lnum; 4482 4483 /* when the buffer is empty need to delete the dummy line */ 4484 if (empty && lnum == 1) 4485 lnum = 0; 4486 4487 State = INSERT; /* behave like in Insert mode */ 4488 if (curbuf->b_p_iminsert == B_IMODE_LMAP) 4489 State |= LANGMAP; 4490 4491 for (;;) 4492 { 4493 msg_scroll = TRUE; 4494 need_wait_return = FALSE; 4495 if (curbuf->b_p_ai) 4496 { 4497 if (append_indent >= 0) 4498 { 4499 indent = append_indent; 4500 append_indent = -1; 4501 } 4502 else if (lnum > 0) 4503 indent = get_indent_lnum(lnum); 4504 } 4505 ex_keep_indent = FALSE; 4506 if (eap->getline == NULL) 4507 { 4508 /* No getline() function, use the lines that follow. This ends 4509 * when there is no more. */ 4510 if (eap->nextcmd == NULL || *eap->nextcmd == NUL) 4511 break; 4512 p = vim_strchr(eap->nextcmd, NL); 4513 if (p == NULL) 4514 p = eap->nextcmd + STRLEN(eap->nextcmd); 4515 theline = vim_strnsave(eap->nextcmd, (int)(p - eap->nextcmd)); 4516 if (*p != NUL) 4517 ++p; 4518 eap->nextcmd = p; 4519 } 4520 else 4521 { 4522 int save_State = State; 4523 4524 /* Set State to avoid the cursor shape to be set to INSERT mode 4525 * when getline() returns. */ 4526 State = CMDLINE; 4527 theline = eap->getline( 4528 #ifdef FEAT_EVAL 4529 eap->cstack->cs_looplevel > 0 ? -1 : 4530 #endif 4531 NUL, eap->cookie, indent); 4532 State = save_State; 4533 } 4534 lines_left = Rows - 1; 4535 if (theline == NULL) 4536 break; 4537 4538 /* Using ^ CTRL-D in getexmodeline() makes us repeat the indent. */ 4539 if (ex_keep_indent) 4540 append_indent = indent; 4541 4542 /* Look for the "." after automatic indent. */ 4543 vcol = 0; 4544 for (p = theline; indent > vcol; ++p) 4545 { 4546 if (*p == ' ') 4547 ++vcol; 4548 else if (*p == TAB) 4549 vcol += 8 - vcol % 8; 4550 else 4551 break; 4552 } 4553 if ((p[0] == '.' && p[1] == NUL) 4554 || (!did_undo && u_save(lnum, lnum + 1 + (empty ? 1 : 0)) 4555 == FAIL)) 4556 { 4557 vim_free(theline); 4558 break; 4559 } 4560 4561 /* don't use autoindent if nothing was typed. */ 4562 if (p[0] == NUL) 4563 theline[0] = NUL; 4564 4565 did_undo = TRUE; 4566 ml_append(lnum, theline, (colnr_T)0, FALSE); 4567 appended_lines_mark(lnum + (empty ? 1 : 0), 1L); 4568 4569 vim_free(theline); 4570 ++lnum; 4571 4572 if (empty) 4573 { 4574 ml_delete(2L, FALSE); 4575 empty = FALSE; 4576 } 4577 } 4578 State = NORMAL; 4579 4580 if (eap->forceit) 4581 curbuf->b_p_ai = !curbuf->b_p_ai; 4582 4583 /* "start" is set to eap->line2+1 unless that position is invalid (when 4584 * eap->line2 pointed to the end of the buffer and nothing was appended) 4585 * "end" is set to lnum when something has been appended, otherwise 4586 * it is the same than "start" -- Acevedo */ 4587 curbuf->b_op_start.lnum = (eap->line2 < curbuf->b_ml.ml_line_count) ? 4588 eap->line2 + 1 : curbuf->b_ml.ml_line_count; 4589 if (eap->cmdidx != CMD_append) 4590 --curbuf->b_op_start.lnum; 4591 curbuf->b_op_end.lnum = (eap->line2 < lnum) 4592 ? lnum : curbuf->b_op_start.lnum; 4593 curbuf->b_op_start.col = curbuf->b_op_end.col = 0; 4594 curwin->w_cursor.lnum = lnum; 4595 check_cursor_lnum(); 4596 beginline(BL_SOL | BL_FIX); 4597 4598 need_wait_return = FALSE; /* don't use wait_return() now */ 4599 ex_no_reprint = TRUE; 4600 } 4601 4602 /* 4603 * ":change" 4604 */ 4605 void 4606 ex_change(exarg_T *eap) 4607 { 4608 linenr_T lnum; 4609 4610 if (eap->line2 >= eap->line1 4611 && u_save(eap->line1 - 1, eap->line2 + 1) == FAIL) 4612 return; 4613 4614 /* the ! flag toggles autoindent */ 4615 if (eap->forceit ? !curbuf->b_p_ai : curbuf->b_p_ai) 4616 append_indent = get_indent_lnum(eap->line1); 4617 4618 for (lnum = eap->line2; lnum >= eap->line1; --lnum) 4619 { 4620 if (curbuf->b_ml.ml_flags & ML_EMPTY) /* nothing to delete */ 4621 break; 4622 ml_delete(eap->line1, FALSE); 4623 } 4624 4625 /* make sure the cursor is not beyond the end of the file now */ 4626 check_cursor_lnum(); 4627 deleted_lines_mark(eap->line1, (long)(eap->line2 - lnum)); 4628 4629 /* ":append" on the line above the deleted lines. */ 4630 eap->line2 = eap->line1; 4631 ex_append(eap); 4632 } 4633 4634 void 4635 ex_z(exarg_T *eap) 4636 { 4637 char_u *x; 4638 long bigness; 4639 char_u *kind; 4640 int minus = 0; 4641 linenr_T start, end, curs, i; 4642 int j; 4643 linenr_T lnum = eap->line2; 4644 4645 /* Vi compatible: ":z!" uses display height, without a count uses 4646 * 'scroll' */ 4647 if (eap->forceit) 4648 bigness = curwin->w_height; 4649 else if (!ONE_WINDOW) 4650 bigness = curwin->w_height - 3; 4651 else 4652 bigness = curwin->w_p_scr * 2; 4653 if (bigness < 1) 4654 bigness = 1; 4655 4656 x = eap->arg; 4657 kind = x; 4658 if (*kind == '-' || *kind == '+' || *kind == '=' 4659 || *kind == '^' || *kind == '.') 4660 ++x; 4661 while (*x == '-' || *x == '+') 4662 ++x; 4663 4664 if (*x != 0) 4665 { 4666 if (!VIM_ISDIGIT(*x)) 4667 { 4668 emsg(_("E144: non-numeric argument to :z")); 4669 return; 4670 } 4671 else 4672 { 4673 bigness = atol((char *)x); 4674 4675 /* bigness could be < 0 if atol(x) overflows. */ 4676 if (bigness > 2 * curbuf->b_ml.ml_line_count || bigness < 0) 4677 bigness = 2 * curbuf->b_ml.ml_line_count; 4678 4679 p_window = bigness; 4680 if (*kind == '=') 4681 bigness += 2; 4682 } 4683 } 4684 4685 /* the number of '-' and '+' multiplies the distance */ 4686 if (*kind == '-' || *kind == '+') 4687 for (x = kind + 1; *x == *kind; ++x) 4688 ; 4689 4690 switch (*kind) 4691 { 4692 case '-': 4693 start = lnum - bigness * (linenr_T)(x - kind) + 1; 4694 end = start + bigness - 1; 4695 curs = end; 4696 break; 4697 4698 case '=': 4699 start = lnum - (bigness + 1) / 2 + 1; 4700 end = lnum + (bigness + 1) / 2 - 1; 4701 curs = lnum; 4702 minus = 1; 4703 break; 4704 4705 case '^': 4706 start = lnum - bigness * 2; 4707 end = lnum - bigness; 4708 curs = lnum - bigness; 4709 break; 4710 4711 case '.': 4712 start = lnum - (bigness + 1) / 2 + 1; 4713 end = lnum + (bigness + 1) / 2 - 1; 4714 curs = end; 4715 break; 4716 4717 default: /* '+' */ 4718 start = lnum; 4719 if (*kind == '+') 4720 start += bigness * (linenr_T)(x - kind - 1) + 1; 4721 else if (eap->addr_count == 0) 4722 ++start; 4723 end = start + bigness - 1; 4724 curs = end; 4725 break; 4726 } 4727 4728 if (start < 1) 4729 start = 1; 4730 4731 if (end > curbuf->b_ml.ml_line_count) 4732 end = curbuf->b_ml.ml_line_count; 4733 4734 if (curs > curbuf->b_ml.ml_line_count) 4735 curs = curbuf->b_ml.ml_line_count; 4736 else if (curs < 1) 4737 curs = 1; 4738 4739 for (i = start; i <= end; i++) 4740 { 4741 if (minus && i == lnum) 4742 { 4743 msg_putchar('\n'); 4744 4745 for (j = 1; j < Columns; j++) 4746 msg_putchar('-'); 4747 } 4748 4749 print_line(i, eap->flags & EXFLAG_NR, eap->flags & EXFLAG_LIST); 4750 4751 if (minus && i == lnum) 4752 { 4753 msg_putchar('\n'); 4754 4755 for (j = 1; j < Columns; j++) 4756 msg_putchar('-'); 4757 } 4758 } 4759 4760 if (curwin->w_cursor.lnum != curs) 4761 { 4762 curwin->w_cursor.lnum = curs; 4763 curwin->w_cursor.col = 0; 4764 } 4765 ex_no_reprint = TRUE; 4766 } 4767 4768 /* 4769 * Check if the restricted flag is set. 4770 * If so, give an error message and return TRUE. 4771 * Otherwise, return FALSE. 4772 */ 4773 int 4774 check_restricted(void) 4775 { 4776 if (restricted) 4777 { 4778 emsg(_("E145: Shell commands not allowed in rvim")); 4779 return TRUE; 4780 } 4781 return FALSE; 4782 } 4783 4784 /* 4785 * Check if the secure flag is set (.exrc or .vimrc in current directory). 4786 * If so, give an error message and return TRUE. 4787 * Otherwise, return FALSE. 4788 */ 4789 int 4790 check_secure(void) 4791 { 4792 if (secure) 4793 { 4794 secure = 2; 4795 emsg(_(e_curdir)); 4796 return TRUE; 4797 } 4798 #ifdef HAVE_SANDBOX 4799 /* 4800 * In the sandbox more things are not allowed, including the things 4801 * disallowed in secure mode. 4802 */ 4803 if (sandbox != 0) 4804 { 4805 emsg(_(e_sandbox)); 4806 return TRUE; 4807 } 4808 #endif 4809 return FALSE; 4810 } 4811 4812 static char_u *old_sub = NULL; /* previous substitute pattern */ 4813 static int global_need_beginline; /* call beginline() after ":g" */ 4814 4815 /* 4816 * Flags that are kept between calls to :substitute. 4817 */ 4818 typedef struct { 4819 int do_all; /* do multiple substitutions per line */ 4820 int do_ask; /* ask for confirmation */ 4821 int do_count; /* count only */ 4822 int do_error; /* if false, ignore errors */ 4823 int do_print; /* print last line with subs. */ 4824 int do_list; /* list last line with subs. */ 4825 int do_number; /* list last line with line nr*/ 4826 int do_ic; /* ignore case flag */ 4827 } subflags_T; 4828 4829 /* do_sub() 4830 * 4831 * Perform a substitution from line eap->line1 to line eap->line2 using the 4832 * command pointed to by eap->arg which should be of the form: 4833 * 4834 * /pattern/substitution/{flags} 4835 * 4836 * The usual escapes are supported as described in the regexp docs. 4837 */ 4838 void 4839 do_sub(exarg_T *eap) 4840 { 4841 linenr_T lnum; 4842 long i = 0; 4843 regmmatch_T regmatch; 4844 static subflags_T subflags = {FALSE, FALSE, FALSE, TRUE, FALSE, 4845 FALSE, FALSE, 0}; 4846 #ifdef FEAT_EVAL 4847 subflags_T subflags_save; 4848 #endif 4849 int save_do_all; /* remember user specified 'g' flag */ 4850 int save_do_ask; /* remember user specified 'c' flag */ 4851 char_u *pat = NULL, *sub = NULL; /* init for GCC */ 4852 int delimiter; 4853 int sublen; 4854 int got_quit = FALSE; 4855 int got_match = FALSE; 4856 int temp; 4857 int which_pat; 4858 char_u *cmd; 4859 int save_State; 4860 linenr_T first_line = 0; /* first changed line */ 4861 linenr_T last_line= 0; /* below last changed line AFTER the 4862 * change */ 4863 linenr_T old_line_count = curbuf->b_ml.ml_line_count; 4864 linenr_T line2; 4865 long nmatch; /* number of lines in match */ 4866 char_u *sub_firstline; /* allocated copy of first sub line */ 4867 int endcolumn = FALSE; /* cursor in last column when done */ 4868 pos_T old_cursor = curwin->w_cursor; 4869 int start_nsubs; 4870 #ifdef FEAT_EVAL 4871 int save_ma = 0; 4872 #endif 4873 4874 cmd = eap->arg; 4875 if (!global_busy) 4876 { 4877 sub_nsubs = 0; 4878 sub_nlines = 0; 4879 } 4880 start_nsubs = sub_nsubs; 4881 4882 if (eap->cmdidx == CMD_tilde) 4883 which_pat = RE_LAST; /* use last used regexp */ 4884 else 4885 which_pat = RE_SUBST; /* use last substitute regexp */ 4886 4887 /* new pattern and substitution */ 4888 if (eap->cmd[0] == 's' && *cmd != NUL && !VIM_ISWHITE(*cmd) 4889 && vim_strchr((char_u *)"0123456789cegriIp|\"", *cmd) == NULL) 4890 { 4891 /* don't accept alphanumeric for separator */ 4892 if (isalpha(*cmd)) 4893 { 4894 emsg(_("E146: Regular expressions can't be delimited by letters")); 4895 return; 4896 } 4897 /* 4898 * undocumented vi feature: 4899 * "\/sub/" and "\?sub?" use last used search pattern (almost like 4900 * //sub/r). "\&sub&" use last substitute pattern (like //sub/). 4901 */ 4902 if (*cmd == '\\') 4903 { 4904 ++cmd; 4905 if (vim_strchr((char_u *)"/?&", *cmd) == NULL) 4906 { 4907 emsg(_(e_backslash)); 4908 return; 4909 } 4910 if (*cmd != '&') 4911 which_pat = RE_SEARCH; /* use last '/' pattern */ 4912 pat = (char_u *)""; /* empty search pattern */ 4913 delimiter = *cmd++; /* remember delimiter character */ 4914 } 4915 else /* find the end of the regexp */ 4916 { 4917 #ifdef FEAT_FKMAP /* reverse the flow of the Farsi characters */ 4918 if (p_altkeymap && curwin->w_p_rl) 4919 lrF_sub(cmd); 4920 #endif 4921 which_pat = RE_LAST; /* use last used regexp */ 4922 delimiter = *cmd++; /* remember delimiter character */ 4923 pat = cmd; /* remember start of search pat */ 4924 cmd = skip_regexp(cmd, delimiter, p_magic, &eap->arg); 4925 if (cmd[0] == delimiter) /* end delimiter found */ 4926 *cmd++ = NUL; /* replace it with a NUL */ 4927 } 4928 4929 /* 4930 * Small incompatibility: vi sees '\n' as end of the command, but in 4931 * Vim we want to use '\n' to find/substitute a NUL. 4932 */ 4933 sub = cmd; /* remember the start of the substitution */ 4934 4935 while (cmd[0]) 4936 { 4937 if (cmd[0] == delimiter) /* end delimiter found */ 4938 { 4939 *cmd++ = NUL; /* replace it with a NUL */ 4940 break; 4941 } 4942 if (cmd[0] == '\\' && cmd[1] != 0) /* skip escaped characters */ 4943 ++cmd; 4944 MB_PTR_ADV(cmd); 4945 } 4946 4947 if (!eap->skip) 4948 { 4949 /* In POSIX vi ":s/pat/%/" uses the previous subst. string. */ 4950 if (STRCMP(sub, "%") == 0 4951 && vim_strchr(p_cpo, CPO_SUBPERCENT) != NULL) 4952 { 4953 if (old_sub == NULL) /* there is no previous command */ 4954 { 4955 emsg(_(e_nopresub)); 4956 return; 4957 } 4958 sub = old_sub; 4959 } 4960 else 4961 { 4962 vim_free(old_sub); 4963 old_sub = vim_strsave(sub); 4964 } 4965 } 4966 } 4967 else if (!eap->skip) /* use previous pattern and substitution */ 4968 { 4969 if (old_sub == NULL) /* there is no previous command */ 4970 { 4971 emsg(_(e_nopresub)); 4972 return; 4973 } 4974 pat = NULL; /* search_regcomp() will use previous pattern */ 4975 sub = old_sub; 4976 4977 /* Vi compatibility quirk: repeating with ":s" keeps the cursor in the 4978 * last column after using "$". */ 4979 endcolumn = (curwin->w_curswant == MAXCOL); 4980 } 4981 4982 /* Recognize ":%s/\n//" and turn it into a join command, which is much 4983 * more efficient. 4984 * TODO: find a generic solution to make line-joining operations more 4985 * efficient, avoid allocating a string that grows in size. 4986 */ 4987 if (pat != NULL && STRCMP(pat, "\\n") == 0 4988 && *sub == NUL 4989 && (*cmd == NUL || (cmd[1] == NUL && (*cmd == 'g' || *cmd == 'l' 4990 || *cmd == 'p' || *cmd == '#')))) 4991 { 4992 linenr_T joined_lines_count; 4993 4994 curwin->w_cursor.lnum = eap->line1; 4995 if (*cmd == 'l') 4996 eap->flags = EXFLAG_LIST; 4997 else if (*cmd == '#') 4998 eap->flags = EXFLAG_NR; 4999 else if (*cmd == 'p') 5000 eap->flags = EXFLAG_PRINT; 5001 5002 /* The number of lines joined is the number of lines in the range plus 5003 * one. One less when the last line is included. */ 5004 joined_lines_count = eap->line2 - eap->line1 + 1; 5005 if (eap->line2 < curbuf->b_ml.ml_line_count) 5006 ++joined_lines_count; 5007 if (joined_lines_count > 1) 5008 { 5009 (void)do_join(joined_lines_count, FALSE, TRUE, FALSE, TRUE); 5010 sub_nsubs = joined_lines_count - 1; 5011 sub_nlines = 1; 5012 (void)do_sub_msg(FALSE); 5013 ex_may_print(eap); 5014 } 5015 5016 if (!cmdmod.keeppatterns) 5017 save_re_pat(RE_SUBST, pat, p_magic); 5018 #ifdef FEAT_CMDHIST 5019 /* put pattern in history */ 5020 add_to_history(HIST_SEARCH, pat, TRUE, NUL); 5021 #endif 5022 5023 return; 5024 } 5025 5026 /* 5027 * Find trailing options. When '&' is used, keep old options. 5028 */ 5029 if (*cmd == '&') 5030 ++cmd; 5031 else 5032 { 5033 if (!p_ed) 5034 { 5035 if (p_gd) /* default is global on */ 5036 subflags.do_all = TRUE; 5037 else 5038 subflags.do_all = FALSE; 5039 subflags.do_ask = FALSE; 5040 } 5041 subflags.do_error = TRUE; 5042 subflags.do_print = FALSE; 5043 subflags.do_count = FALSE; 5044 subflags.do_number = FALSE; 5045 subflags.do_ic = 0; 5046 } 5047 while (*cmd) 5048 { 5049 /* 5050 * Note that 'g' and 'c' are always inverted, also when p_ed is off. 5051 * 'r' is never inverted. 5052 */ 5053 if (*cmd == 'g') 5054 subflags.do_all = !subflags.do_all; 5055 else if (*cmd == 'c') 5056 subflags.do_ask = !subflags.do_ask; 5057 else if (*cmd == 'n') 5058 subflags.do_count = TRUE; 5059 else if (*cmd == 'e') 5060 subflags.do_error = !subflags.do_error; 5061 else if (*cmd == 'r') /* use last used regexp */ 5062 which_pat = RE_LAST; 5063 else if (*cmd == 'p') 5064 subflags.do_print = TRUE; 5065 else if (*cmd == '#') 5066 { 5067 subflags.do_print = TRUE; 5068 subflags.do_number = TRUE; 5069 } 5070 else if (*cmd == 'l') 5071 { 5072 subflags.do_print = TRUE; 5073 subflags.do_list = TRUE; 5074 } 5075 else if (*cmd == 'i') /* ignore case */ 5076 subflags.do_ic = 'i'; 5077 else if (*cmd == 'I') /* don't ignore case */ 5078 subflags.do_ic = 'I'; 5079 else 5080 break; 5081 ++cmd; 5082 } 5083 if (subflags.do_count) 5084 subflags.do_ask = FALSE; 5085 5086 save_do_all = subflags.do_all; 5087 save_do_ask = subflags.do_ask; 5088 5089 /* 5090 * check for a trailing count 5091 */ 5092 cmd = skipwhite(cmd); 5093 if (VIM_ISDIGIT(*cmd)) 5094 { 5095 i = getdigits(&cmd); 5096 if (i <= 0 && !eap->skip && subflags.do_error) 5097 { 5098 emsg(_(e_zerocount)); 5099 return; 5100 } 5101 eap->line1 = eap->line2; 5102 eap->line2 += i - 1; 5103 if (eap->line2 > curbuf->b_ml.ml_line_count) 5104 eap->line2 = curbuf->b_ml.ml_line_count; 5105 } 5106 5107 /* 5108 * check for trailing command or garbage 5109 */ 5110 cmd = skipwhite(cmd); 5111 if (*cmd && *cmd != '"') /* if not end-of-line or comment */ 5112 { 5113 eap->nextcmd = check_nextcmd(cmd); 5114 if (eap->nextcmd == NULL) 5115 { 5116 emsg(_(e_trailing)); 5117 return; 5118 } 5119 } 5120 5121 if (eap->skip) /* not executing commands, only parsing */ 5122 return; 5123 5124 if (!subflags.do_count && !curbuf->b_p_ma) 5125 { 5126 /* Substitution is not allowed in non-'modifiable' buffer */ 5127 emsg(_(e_modifiable)); 5128 return; 5129 } 5130 5131 if (search_regcomp(pat, RE_SUBST, which_pat, SEARCH_HIS, ®match) == FAIL) 5132 { 5133 if (subflags.do_error) 5134 emsg(_(e_invcmd)); 5135 return; 5136 } 5137 5138 /* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */ 5139 if (subflags.do_ic == 'i') 5140 regmatch.rmm_ic = TRUE; 5141 else if (subflags.do_ic == 'I') 5142 regmatch.rmm_ic = FALSE; 5143 5144 sub_firstline = NULL; 5145 5146 /* 5147 * ~ in the substitute pattern is replaced with the old pattern. 5148 * We do it here once to avoid it to be replaced over and over again. 5149 * But don't do it when it starts with "\=", then it's an expression. 5150 */ 5151 if (!(sub[0] == '\\' && sub[1] == '=')) 5152 sub = regtilde(sub, p_magic); 5153 5154 /* 5155 * Check for a match on each line. 5156 */ 5157 line2 = eap->line2; 5158 for (lnum = eap->line1; lnum <= line2 && !(got_quit 5159 #if defined(FEAT_EVAL) 5160 || aborting() 5161 #endif 5162 ); ++lnum) 5163 { 5164 nmatch = vim_regexec_multi(®match, curwin, curbuf, lnum, 5165 (colnr_T)0, NULL, NULL); 5166 if (nmatch) 5167 { 5168 colnr_T copycol; 5169 colnr_T matchcol; 5170 colnr_T prev_matchcol = MAXCOL; 5171 char_u *new_end, *new_start = NULL; 5172 unsigned new_start_len = 0; 5173 char_u *p1; 5174 int did_sub = FALSE; 5175 int lastone; 5176 int len, copy_len, needed_len; 5177 long nmatch_tl = 0; /* nr of lines matched below lnum */ 5178 int do_again; /* do it again after joining lines */ 5179 int skip_match = FALSE; 5180 linenr_T sub_firstlnum; /* nr of first sub line */ 5181 5182 /* 5183 * The new text is build up step by step, to avoid too much 5184 * copying. There are these pieces: 5185 * sub_firstline The old text, unmodified. 5186 * copycol Column in the old text where we started 5187 * looking for a match; from here old text still 5188 * needs to be copied to the new text. 5189 * matchcol Column number of the old text where to look 5190 * for the next match. It's just after the 5191 * previous match or one further. 5192 * prev_matchcol Column just after the previous match (if any). 5193 * Mostly equal to matchcol, except for the first 5194 * match and after skipping an empty match. 5195 * regmatch.*pos Where the pattern matched in the old text. 5196 * new_start The new text, all that has been produced so 5197 * far. 5198 * new_end The new text, where to append new text. 5199 * 5200 * lnum The line number where we found the start of 5201 * the match. Can be below the line we searched 5202 * when there is a \n before a \zs in the 5203 * pattern. 5204 * sub_firstlnum The line number in the buffer where to look 5205 * for a match. Can be different from "lnum" 5206 * when the pattern or substitute string contains 5207 * line breaks. 5208 * 5209 * Special situations: 5210 * - When the substitute string contains a line break, the part up 5211 * to the line break is inserted in the text, but the copy of 5212 * the original line is kept. "sub_firstlnum" is adjusted for 5213 * the inserted lines. 5214 * - When the matched pattern contains a line break, the old line 5215 * is taken from the line at the end of the pattern. The lines 5216 * in the match are deleted later, "sub_firstlnum" is adjusted 5217 * accordingly. 5218 * 5219 * The new text is built up in new_start[]. It has some extra 5220 * room to avoid using alloc()/free() too often. new_start_len is 5221 * the length of the allocated memory at new_start. 5222 * 5223 * Make a copy of the old line, so it won't be taken away when 5224 * updating the screen or handling a multi-line match. The "old_" 5225 * pointers point into this copy. 5226 */ 5227 sub_firstlnum = lnum; 5228 copycol = 0; 5229 matchcol = 0; 5230 5231 /* At first match, remember current cursor position. */ 5232 if (!got_match) 5233 { 5234 setpcmark(); 5235 got_match = TRUE; 5236 } 5237 5238 /* 5239 * Loop until nothing more to replace in this line. 5240 * 1. Handle match with empty string. 5241 * 2. If do_ask is set, ask for confirmation. 5242 * 3. substitute the string. 5243 * 4. if do_all is set, find next match 5244 * 5. break if there isn't another match in this line 5245 */ 5246 for (;;) 5247 { 5248 /* Advance "lnum" to the line where the match starts. The 5249 * match does not start in the first line when there is a line 5250 * break before \zs. */ 5251 if (regmatch.startpos[0].lnum > 0) 5252 { 5253 lnum += regmatch.startpos[0].lnum; 5254 sub_firstlnum += regmatch.startpos[0].lnum; 5255 nmatch -= regmatch.startpos[0].lnum; 5256 VIM_CLEAR(sub_firstline); 5257 } 5258 5259 if (sub_firstline == NULL) 5260 { 5261 sub_firstline = vim_strsave(ml_get(sub_firstlnum)); 5262 if (sub_firstline == NULL) 5263 { 5264 vim_free(new_start); 5265 goto outofmem; 5266 } 5267 } 5268 5269 /* Save the line number of the last change for the final 5270 * cursor position (just like Vi). */ 5271 curwin->w_cursor.lnum = lnum; 5272 do_again = FALSE; 5273 5274 /* 5275 * 1. Match empty string does not count, except for first 5276 * match. This reproduces the strange vi behaviour. 5277 * This also catches endless loops. 5278 */ 5279 if (matchcol == prev_matchcol 5280 && regmatch.endpos[0].lnum == 0 5281 && matchcol == regmatch.endpos[0].col) 5282 { 5283 if (sub_firstline[matchcol] == NUL) 5284 /* We already were at the end of the line. Don't look 5285 * for a match in this line again. */ 5286 skip_match = TRUE; 5287 else 5288 { 5289 /* search for a match at next column */ 5290 if (has_mbyte) 5291 matchcol += mb_ptr2len(sub_firstline + matchcol); 5292 else 5293 ++matchcol; 5294 } 5295 goto skip; 5296 } 5297 5298 /* Normally we continue searching for a match just after the 5299 * previous match. */ 5300 matchcol = regmatch.endpos[0].col; 5301 prev_matchcol = matchcol; 5302 5303 /* 5304 * 2. If do_count is set only increase the counter. 5305 * If do_ask is set, ask for confirmation. 5306 */ 5307 if (subflags.do_count) 5308 { 5309 /* For a multi-line match, put matchcol at the NUL at 5310 * the end of the line and set nmatch to one, so that 5311 * we continue looking for a match on the next line. 5312 * Avoids that ":s/\nB\@=//gc" get stuck. */ 5313 if (nmatch > 1) 5314 { 5315 matchcol = (colnr_T)STRLEN(sub_firstline); 5316 nmatch = 1; 5317 skip_match = TRUE; 5318 } 5319 sub_nsubs++; 5320 did_sub = TRUE; 5321 #ifdef FEAT_EVAL 5322 /* Skip the substitution, unless an expression is used, 5323 * then it is evaluated in the sandbox. */ 5324 if (!(sub[0] == '\\' && sub[1] == '=')) 5325 #endif 5326 goto skip; 5327 } 5328 5329 if (subflags.do_ask) 5330 { 5331 int typed = 0; 5332 5333 /* change State to CONFIRM, so that the mouse works 5334 * properly */ 5335 save_State = State; 5336 State = CONFIRM; 5337 #ifdef FEAT_MOUSE 5338 setmouse(); /* disable mouse in xterm */ 5339 #endif 5340 curwin->w_cursor.col = regmatch.startpos[0].col; 5341 if (curwin->w_p_crb) 5342 do_check_cursorbind(); 5343 5344 /* When 'cpoptions' contains "u" don't sync undo when 5345 * asking for confirmation. */ 5346 if (vim_strchr(p_cpo, CPO_UNDO) != NULL) 5347 ++no_u_sync; 5348 5349 /* 5350 * Loop until 'y', 'n', 'q', CTRL-E or CTRL-Y typed. 5351 */ 5352 while (subflags.do_ask) 5353 { 5354 if (exmode_active) 5355 { 5356 char_u *resp; 5357 colnr_T sc, ec; 5358 5359 print_line_no_prefix(lnum, 5360 subflags.do_number, subflags.do_list); 5361 5362 getvcol(curwin, &curwin->w_cursor, &sc, NULL, NULL); 5363 curwin->w_cursor.col = regmatch.endpos[0].col - 1; 5364 if (curwin->w_cursor.col < 0) 5365 curwin->w_cursor.col = 0; 5366 getvcol(curwin, &curwin->w_cursor, NULL, NULL, &ec); 5367 if (subflags.do_number || curwin->w_p_nu) 5368 { 5369 int numw = number_width(curwin) + 1; 5370 sc += numw; 5371 ec += numw; 5372 } 5373 msg_start(); 5374 for (i = 0; i < (long)sc; ++i) 5375 msg_putchar(' '); 5376 for ( ; i <= (long)ec; ++i) 5377 msg_putchar('^'); 5378 5379 resp = getexmodeline('?', NULL, 0); 5380 if (resp != NULL) 5381 { 5382 typed = *resp; 5383 vim_free(resp); 5384 } 5385 } 5386 else 5387 { 5388 char_u *orig_line = NULL; 5389 int len_change = 0; 5390 #ifdef FEAT_FOLDING 5391 int save_p_fen = curwin->w_p_fen; 5392 5393 curwin->w_p_fen = FALSE; 5394 #endif 5395 /* Invert the matched string. 5396 * Remove the inversion afterwards. */ 5397 temp = RedrawingDisabled; 5398 RedrawingDisabled = 0; 5399 5400 if (new_start != NULL) 5401 { 5402 /* There already was a substitution, we would 5403 * like to show this to the user. We cannot 5404 * really update the line, it would change 5405 * what matches. Temporarily replace the line 5406 * and change it back afterwards. */ 5407 orig_line = vim_strsave(ml_get(lnum)); 5408 if (orig_line != NULL) 5409 { 5410 char_u *new_line = concat_str(new_start, 5411 sub_firstline + copycol); 5412 5413 if (new_line == NULL) 5414 VIM_CLEAR(orig_line); 5415 else 5416 { 5417 /* Position the cursor relative to the 5418 * end of the line, the previous 5419 * substitute may have inserted or 5420 * deleted characters before the 5421 * cursor. */ 5422 len_change = (int)STRLEN(new_line) 5423 - (int)STRLEN(orig_line); 5424 curwin->w_cursor.col += len_change; 5425 ml_replace(lnum, new_line, FALSE); 5426 } 5427 } 5428 } 5429 5430 search_match_lines = regmatch.endpos[0].lnum 5431 - regmatch.startpos[0].lnum; 5432 search_match_endcol = regmatch.endpos[0].col 5433 + len_change; 5434 highlight_match = TRUE; 5435 5436 update_topline(); 5437 validate_cursor(); 5438 update_screen(SOME_VALID); 5439 highlight_match = FALSE; 5440 redraw_later(SOME_VALID); 5441 5442 #ifdef FEAT_FOLDING 5443 curwin->w_p_fen = save_p_fen; 5444 #endif 5445 if (msg_row == Rows - 1) 5446 msg_didout = FALSE; /* avoid a scroll-up */ 5447 msg_starthere(); 5448 i = msg_scroll; 5449 msg_scroll = 0; /* truncate msg when 5450 needed */ 5451 msg_no_more = TRUE; 5452 /* write message same highlighting as for 5453 * wait_return */ 5454 smsg_attr(HL_ATTR(HLF_R), 5455 _("replace with %s (y/n/a/q/l/^E/^Y)?"), sub); 5456 msg_no_more = FALSE; 5457 msg_scroll = i; 5458 showruler(TRUE); 5459 windgoto(msg_row, msg_col); 5460 RedrawingDisabled = temp; 5461 5462 #ifdef USE_ON_FLY_SCROLL 5463 dont_scroll = FALSE; /* allow scrolling here */ 5464 #endif 5465 ++no_mapping; /* don't map this key */ 5466 ++allow_keys; /* allow special keys */ 5467 typed = plain_vgetc(); 5468 --allow_keys; 5469 --no_mapping; 5470 5471 /* clear the question */ 5472 msg_didout = FALSE; /* don't scroll up */ 5473 msg_col = 0; 5474 gotocmdline(TRUE); 5475 5476 /* restore the line */ 5477 if (orig_line != NULL) 5478 ml_replace(lnum, orig_line, FALSE); 5479 } 5480 5481 need_wait_return = FALSE; /* no hit-return prompt */ 5482 if (typed == 'q' || typed == ESC || typed == Ctrl_C 5483 #ifdef UNIX 5484 || typed == intr_char 5485 #endif 5486 ) 5487 { 5488 got_quit = TRUE; 5489 break; 5490 } 5491 if (typed == 'n') 5492 break; 5493 if (typed == 'y') 5494 break; 5495 if (typed == 'l') 5496 { 5497 /* last: replace and then stop */ 5498 subflags.do_all = FALSE; 5499 line2 = lnum; 5500 break; 5501 } 5502 if (typed == 'a') 5503 { 5504 subflags.do_ask = FALSE; 5505 break; 5506 } 5507 #ifdef FEAT_INS_EXPAND 5508 if (typed == Ctrl_E) 5509 scrollup_clamp(); 5510 else if (typed == Ctrl_Y) 5511 scrolldown_clamp(); 5512 #endif 5513 } 5514 State = save_State; 5515 #ifdef FEAT_MOUSE 5516 setmouse(); 5517 #endif 5518 if (vim_strchr(p_cpo, CPO_UNDO) != NULL) 5519 --no_u_sync; 5520 5521 if (typed == 'n') 5522 { 5523 /* For a multi-line match, put matchcol at the NUL at 5524 * the end of the line and set nmatch to one, so that 5525 * we continue looking for a match on the next line. 5526 * Avoids that ":%s/\nB\@=//gc" and ":%s/\n/,\r/gc" 5527 * get stuck when pressing 'n'. */ 5528 if (nmatch > 1) 5529 { 5530 matchcol = (colnr_T)STRLEN(sub_firstline); 5531 skip_match = TRUE; 5532 } 5533 goto skip; 5534 } 5535 if (got_quit) 5536 goto skip; 5537 } 5538 5539 /* Move the cursor to the start of the match, so that we can 5540 * use "\=col("."). */ 5541 curwin->w_cursor.col = regmatch.startpos[0].col; 5542 5543 /* 5544 * 3. substitute the string. 5545 */ 5546 #ifdef FEAT_EVAL 5547 if (subflags.do_count) 5548 { 5549 /* prevent accidentally changing the buffer by a function */ 5550 save_ma = curbuf->b_p_ma; 5551 curbuf->b_p_ma = FALSE; 5552 sandbox++; 5553 } 5554 /* Save flags for recursion. They can change for e.g. 5555 * :s/^/\=execute("s#^##gn") */ 5556 subflags_save = subflags; 5557 #endif 5558 /* get length of substitution part */ 5559 sublen = vim_regsub_multi(®match, 5560 sub_firstlnum - regmatch.startpos[0].lnum, 5561 sub, sub_firstline, FALSE, p_magic, TRUE); 5562 #ifdef FEAT_EVAL 5563 /* Don't keep flags set by a recursive call. */ 5564 subflags = subflags_save; 5565 if (subflags.do_count) 5566 { 5567 curbuf->b_p_ma = save_ma; 5568 if (sandbox > 0) 5569 sandbox--; 5570 goto skip; 5571 } 5572 #endif 5573 5574 /* When the match included the "$" of the last line it may 5575 * go beyond the last line of the buffer. */ 5576 if (nmatch > curbuf->b_ml.ml_line_count - sub_firstlnum + 1) 5577 { 5578 nmatch = curbuf->b_ml.ml_line_count - sub_firstlnum + 1; 5579 skip_match = TRUE; 5580 } 5581 5582 /* Need room for: 5583 * - result so far in new_start (not for first sub in line) 5584 * - original text up to match 5585 * - length of substituted part 5586 * - original text after match 5587 * Adjust text properties here, since we have all information 5588 * needed. 5589 */ 5590 if (nmatch == 1) 5591 { 5592 p1 = sub_firstline; 5593 #ifdef FEAT_TEXT_PROP 5594 if (curbuf->b_has_textprop) 5595 adjust_prop_columns(lnum, regmatch.startpos[0].col, 5596 sublen - 1 - (regmatch.endpos[0].col 5597 - regmatch.startpos[0].col)); 5598 #endif 5599 } 5600 else 5601 { 5602 p1 = ml_get(sub_firstlnum + nmatch - 1); 5603 nmatch_tl += nmatch - 1; 5604 } 5605 copy_len = regmatch.startpos[0].col - copycol; 5606 needed_len = copy_len + ((unsigned)STRLEN(p1) 5607 - regmatch.endpos[0].col) + sublen + 1; 5608 if (new_start == NULL) 5609 { 5610 /* 5611 * Get some space for a temporary buffer to do the 5612 * substitution into (and some extra space to avoid 5613 * too many calls to alloc()/free()). 5614 */ 5615 new_start_len = needed_len + 50; 5616 if ((new_start = alloc_check(new_start_len)) == NULL) 5617 goto outofmem; 5618 *new_start = NUL; 5619 new_end = new_start; 5620 } 5621 else 5622 { 5623 /* 5624 * Check if the temporary buffer is long enough to do the 5625 * substitution into. If not, make it larger (with a bit 5626 * extra to avoid too many calls to alloc()/free()). 5627 */ 5628 len = (unsigned)STRLEN(new_start); 5629 needed_len += len; 5630 if (needed_len > (int)new_start_len) 5631 { 5632 new_start_len = needed_len + 50; 5633 if ((p1 = alloc_check(new_start_len)) == NULL) 5634 { 5635 vim_free(new_start); 5636 goto outofmem; 5637 } 5638 mch_memmove(p1, new_start, (size_t)(len + 1)); 5639 vim_free(new_start); 5640 new_start = p1; 5641 } 5642 new_end = new_start + len; 5643 } 5644 5645 /* 5646 * copy the text up to the part that matched 5647 */ 5648 mch_memmove(new_end, sub_firstline + copycol, (size_t)copy_len); 5649 new_end += copy_len; 5650 5651 (void)vim_regsub_multi(®match, 5652 sub_firstlnum - regmatch.startpos[0].lnum, 5653 sub, new_end, TRUE, p_magic, TRUE); 5654 sub_nsubs++; 5655 did_sub = TRUE; 5656 5657 /* Move the cursor to the start of the line, to avoid that it 5658 * is beyond the end of the line after the substitution. */ 5659 curwin->w_cursor.col = 0; 5660 5661 /* For a multi-line match, make a copy of the last matched 5662 * line and continue in that one. */ 5663 if (nmatch > 1) 5664 { 5665 sub_firstlnum += nmatch - 1; 5666 vim_free(sub_firstline); 5667 sub_firstline = vim_strsave(ml_get(sub_firstlnum)); 5668 /* When going beyond the last line, stop substituting. */ 5669 if (sub_firstlnum <= line2) 5670 do_again = TRUE; 5671 else 5672 subflags.do_all = FALSE; 5673 } 5674 5675 /* Remember next character to be copied. */ 5676 copycol = regmatch.endpos[0].col; 5677 5678 if (skip_match) 5679 { 5680 /* Already hit end of the buffer, sub_firstlnum is one 5681 * less than what it ought to be. */ 5682 vim_free(sub_firstline); 5683 sub_firstline = vim_strsave((char_u *)""); 5684 copycol = 0; 5685 } 5686 5687 /* 5688 * Now the trick is to replace CTRL-M chars with a real line 5689 * break. This would make it impossible to insert a CTRL-M in 5690 * the text. The line break can be avoided by preceding the 5691 * CTRL-M with a backslash. To be able to insert a backslash, 5692 * they must be doubled in the string and are halved here. 5693 * That is Vi compatible. 5694 */ 5695 for (p1 = new_end; *p1; ++p1) 5696 { 5697 if (p1[0] == '\\' && p1[1] != NUL) /* remove backslash */ 5698 STRMOVE(p1, p1 + 1); 5699 else if (*p1 == CAR) 5700 { 5701 if (u_inssub(lnum) == OK) // prepare for undo 5702 { 5703 colnr_T plen = (colnr_T)(p1 - new_start + 1); 5704 5705 *p1 = NUL; // truncate up to the CR 5706 ml_append(lnum - 1, new_start, plen, FALSE); 5707 mark_adjust(lnum + 1, (linenr_T)MAXLNUM, 1L, 0L); 5708 if (subflags.do_ask) 5709 appended_lines(lnum - 1, 1L); 5710 else 5711 { 5712 if (first_line == 0) 5713 first_line = lnum; 5714 last_line = lnum + 1; 5715 } 5716 #ifdef FEAT_TEXT_PROP 5717 adjust_props_for_split(lnum, plen, 1); 5718 #endif 5719 // all line numbers increase 5720 ++sub_firstlnum; 5721 ++lnum; 5722 ++line2; 5723 // move the cursor to the new line, like Vi 5724 ++curwin->w_cursor.lnum; 5725 // copy the rest 5726 STRMOVE(new_start, p1 + 1); 5727 p1 = new_start - 1; 5728 } 5729 } 5730 else if (has_mbyte) 5731 p1 += (*mb_ptr2len)(p1) - 1; 5732 } 5733 5734 /* 5735 * 4. If do_all is set, find next match. 5736 * Prevent endless loop with patterns that match empty 5737 * strings, e.g. :s/$/pat/g or :s/[a-z]* /(&)/g. 5738 * But ":s/\n/#/" is OK. 5739 */ 5740 skip: 5741 /* We already know that we did the last subst when we are at 5742 * the end of the line, except that a pattern like 5743 * "bar\|\nfoo" may match at the NUL. "lnum" can be below 5744 * "line2" when there is a \zs in the pattern after a line 5745 * break. */ 5746 lastone = (skip_match 5747 || got_int 5748 || got_quit 5749 || lnum > line2 5750 || !(subflags.do_all || do_again) 5751 || (sub_firstline[matchcol] == NUL && nmatch <= 1 5752 && !re_multiline(regmatch.regprog))); 5753 nmatch = -1; 5754 5755 /* 5756 * Replace the line in the buffer when needed. This is 5757 * skipped when there are more matches. 5758 * The check for nmatch_tl is needed for when multi-line 5759 * matching must replace the lines before trying to do another 5760 * match, otherwise "\@<=" won't work. 5761 * When the match starts below where we start searching also 5762 * need to replace the line first (using \zs after \n). 5763 */ 5764 if (lastone 5765 || nmatch_tl > 0 5766 || (nmatch = vim_regexec_multi(®match, curwin, 5767 curbuf, sub_firstlnum, 5768 matchcol, NULL, NULL)) == 0 5769 || regmatch.startpos[0].lnum > 0) 5770 { 5771 if (new_start != NULL) 5772 { 5773 /* 5774 * Copy the rest of the line, that didn't match. 5775 * "matchcol" has to be adjusted, we use the end of 5776 * the line as reference, because the substitute may 5777 * have changed the number of characters. Same for 5778 * "prev_matchcol". 5779 */ 5780 STRCAT(new_start, sub_firstline + copycol); 5781 matchcol = (colnr_T)STRLEN(sub_firstline) - matchcol; 5782 prev_matchcol = (colnr_T)STRLEN(sub_firstline) 5783 - prev_matchcol; 5784 5785 if (u_savesub(lnum) != OK) 5786 break; 5787 ml_replace(lnum, new_start, TRUE); 5788 5789 if (nmatch_tl > 0) 5790 { 5791 /* 5792 * Matched lines have now been substituted and are 5793 * useless, delete them. The part after the match 5794 * has been appended to new_start, we don't need 5795 * it in the buffer. 5796 */ 5797 ++lnum; 5798 if (u_savedel(lnum, nmatch_tl) != OK) 5799 break; 5800 for (i = 0; i < nmatch_tl; ++i) 5801 ml_delete(lnum, (int)FALSE); 5802 mark_adjust(lnum, lnum + nmatch_tl - 1, 5803 (long)MAXLNUM, -nmatch_tl); 5804 if (subflags.do_ask) 5805 deleted_lines(lnum, nmatch_tl); 5806 --lnum; 5807 line2 -= nmatch_tl; /* nr of lines decreases */ 5808 nmatch_tl = 0; 5809 } 5810 5811 /* When asking, undo is saved each time, must also set 5812 * changed flag each time. */ 5813 if (subflags.do_ask) 5814 changed_bytes(lnum, 0); 5815 else 5816 { 5817 if (first_line == 0) 5818 first_line = lnum; 5819 last_line = lnum + 1; 5820 } 5821 5822 sub_firstlnum = lnum; 5823 vim_free(sub_firstline); /* free the temp buffer */ 5824 sub_firstline = new_start; 5825 new_start = NULL; 5826 matchcol = (colnr_T)STRLEN(sub_firstline) - matchcol; 5827 prev_matchcol = (colnr_T)STRLEN(sub_firstline) 5828 - prev_matchcol; 5829 copycol = 0; 5830 } 5831 if (nmatch == -1 && !lastone) 5832 nmatch = vim_regexec_multi(®match, curwin, curbuf, 5833 sub_firstlnum, matchcol, NULL, NULL); 5834 5835 /* 5836 * 5. break if there isn't another match in this line 5837 */ 5838 if (nmatch <= 0) 5839 { 5840 /* If the match found didn't start where we were 5841 * searching, do the next search in the line where we 5842 * found the match. */ 5843 if (nmatch == -1) 5844 lnum -= regmatch.startpos[0].lnum; 5845 break; 5846 } 5847 } 5848 5849 line_breakcheck(); 5850 } 5851 5852 if (did_sub) 5853 ++sub_nlines; 5854 vim_free(new_start); /* for when substitute was cancelled */ 5855 VIM_CLEAR(sub_firstline); /* free the copy of the original line */ 5856 } 5857 5858 line_breakcheck(); 5859 } 5860 5861 if (first_line != 0) 5862 { 5863 /* Need to subtract the number of added lines from "last_line" to get 5864 * the line number before the change (same as adding the number of 5865 * deleted lines). */ 5866 i = curbuf->b_ml.ml_line_count - old_line_count; 5867 changed_lines(first_line, 0, last_line - i, i); 5868 } 5869 5870 outofmem: 5871 vim_free(sub_firstline); /* may have to free allocated copy of the line */ 5872 5873 /* ":s/pat//n" doesn't move the cursor */ 5874 if (subflags.do_count) 5875 curwin->w_cursor = old_cursor; 5876 5877 if (sub_nsubs > start_nsubs) 5878 { 5879 /* Set the '[ and '] marks. */ 5880 curbuf->b_op_start.lnum = eap->line1; 5881 curbuf->b_op_end.lnum = line2; 5882 curbuf->b_op_start.col = curbuf->b_op_end.col = 0; 5883 5884 if (!global_busy) 5885 { 5886 /* when interactive leave cursor on the match */ 5887 if (!subflags.do_ask) 5888 { 5889 if (endcolumn) 5890 coladvance((colnr_T)MAXCOL); 5891 else 5892 beginline(BL_WHITE | BL_FIX); 5893 } 5894 if (!do_sub_msg(subflags.do_count) && subflags.do_ask) 5895 msg(""); 5896 } 5897 else 5898 global_need_beginline = TRUE; 5899 if (subflags.do_print) 5900 print_line(curwin->w_cursor.lnum, 5901 subflags.do_number, subflags.do_list); 5902 } 5903 else if (!global_busy) 5904 { 5905 if (got_int) /* interrupted */ 5906 emsg(_(e_interr)); 5907 else if (got_match) /* did find something but nothing substituted */ 5908 msg(""); 5909 else if (subflags.do_error) /* nothing found */ 5910 semsg(_(e_patnotf2), get_search_pat()); 5911 } 5912 5913 #ifdef FEAT_FOLDING 5914 if (subflags.do_ask && hasAnyFolding(curwin)) 5915 /* Cursor position may require updating */ 5916 changed_window_setting(); 5917 #endif 5918 5919 vim_regfree(regmatch.regprog); 5920 5921 /* Restore the flag values, they can be used for ":&&". */ 5922 subflags.do_all = save_do_all; 5923 subflags.do_ask = save_do_ask; 5924 } 5925 5926 /* 5927 * Give message for number of substitutions. 5928 * Can also be used after a ":global" command. 5929 * Return TRUE if a message was given. 5930 */ 5931 int 5932 do_sub_msg( 5933 int count_only) /* used 'n' flag for ":s" */ 5934 { 5935 /* 5936 * Only report substitutions when: 5937 * - more than 'report' substitutions 5938 * - command was typed by user, or number of changed lines > 'report' 5939 * - giving messages is not disabled by 'lazyredraw' 5940 */ 5941 if (((sub_nsubs > p_report && (KeyTyped || sub_nlines > 1 || p_report < 1)) 5942 || count_only) 5943 && messaging()) 5944 { 5945 char *msg_single; 5946 char *msg_plural; 5947 5948 if (got_int) 5949 STRCPY(msg_buf, _("(Interrupted) ")); 5950 else 5951 *msg_buf = NUL; 5952 5953 msg_single = count_only 5954 ? NGETTEXT("%ld match on %ld line", 5955 "%ld matches on %ld line", sub_nsubs) 5956 : NGETTEXT("%ld substitution on %ld line", 5957 "%ld substitutions on %ld line", sub_nsubs); 5958 msg_plural = count_only 5959 ? NGETTEXT("%ld match on %ld lines", 5960 "%ld matches on %ld lines", sub_nsubs) 5961 : NGETTEXT("%ld substitution on %ld lines", 5962 "%ld substitutions on %ld lines", sub_nsubs); 5963 5964 vim_snprintf_add(msg_buf, sizeof(msg_buf), 5965 NGETTEXT(msg_single, msg_plural, sub_nlines), 5966 sub_nsubs, (long)sub_nlines); 5967 5968 if (msg(msg_buf)) 5969 /* save message to display it after redraw */ 5970 set_keep_msg((char_u *)msg_buf, 0); 5971 return TRUE; 5972 } 5973 if (got_int) 5974 { 5975 emsg(_(e_interr)); 5976 return TRUE; 5977 } 5978 return FALSE; 5979 } 5980 5981 static void 5982 global_exe_one(char_u *cmd, linenr_T lnum) 5983 { 5984 curwin->w_cursor.lnum = lnum; 5985 curwin->w_cursor.col = 0; 5986 if (*cmd == NUL || *cmd == '\n') 5987 do_cmdline((char_u *)"p", NULL, NULL, DOCMD_NOWAIT); 5988 else 5989 do_cmdline(cmd, NULL, NULL, DOCMD_NOWAIT); 5990 } 5991 5992 /* 5993 * Execute a global command of the form: 5994 * 5995 * g/pattern/X : execute X on all lines where pattern matches 5996 * v/pattern/X : execute X on all lines where pattern does not match 5997 * 5998 * where 'X' is an EX command 5999 * 6000 * The command character (as well as the trailing slash) is optional, and 6001 * is assumed to be 'p' if missing. 6002 * 6003 * This is implemented in two passes: first we scan the file for the pattern and 6004 * set a mark for each line that (not) matches. Secondly we execute the command 6005 * for each line that has a mark. This is required because after deleting 6006 * lines we do not know where to search for the next match. 6007 */ 6008 void 6009 ex_global(exarg_T *eap) 6010 { 6011 linenr_T lnum; /* line number according to old situation */ 6012 int ndone = 0; 6013 int type; /* first char of cmd: 'v' or 'g' */ 6014 char_u *cmd; /* command argument */ 6015 6016 char_u delim; /* delimiter, normally '/' */ 6017 char_u *pat; 6018 regmmatch_T regmatch; 6019 int match; 6020 int which_pat; 6021 6022 /* When nesting the command works on one line. This allows for 6023 * ":g/found/v/notfound/command". */ 6024 if (global_busy && (eap->line1 != 1 6025 || eap->line2 != curbuf->b_ml.ml_line_count)) 6026 { 6027 /* will increment global_busy to break out of the loop */ 6028 emsg(_("E147: Cannot do :global recursive with a range")); 6029 return; 6030 } 6031 6032 if (eap->forceit) /* ":global!" is like ":vglobal" */ 6033 type = 'v'; 6034 else 6035 type = *eap->cmd; 6036 cmd = eap->arg; 6037 which_pat = RE_LAST; /* default: use last used regexp */ 6038 6039 /* 6040 * undocumented vi feature: 6041 * "\/" and "\?": use previous search pattern. 6042 * "\&": use previous substitute pattern. 6043 */ 6044 if (*cmd == '\\') 6045 { 6046 ++cmd; 6047 if (vim_strchr((char_u *)"/?&", *cmd) == NULL) 6048 { 6049 emsg(_(e_backslash)); 6050 return; 6051 } 6052 if (*cmd == '&') 6053 which_pat = RE_SUBST; /* use previous substitute pattern */ 6054 else 6055 which_pat = RE_SEARCH; /* use previous search pattern */ 6056 ++cmd; 6057 pat = (char_u *)""; 6058 } 6059 else if (*cmd == NUL) 6060 { 6061 emsg(_("E148: Regular expression missing from global")); 6062 return; 6063 } 6064 else 6065 { 6066 delim = *cmd; /* get the delimiter */ 6067 if (delim) 6068 ++cmd; /* skip delimiter if there is one */ 6069 pat = cmd; /* remember start of pattern */ 6070 cmd = skip_regexp(cmd, delim, p_magic, &eap->arg); 6071 if (cmd[0] == delim) /* end delimiter found */ 6072 *cmd++ = NUL; /* replace it with a NUL */ 6073 } 6074 6075 #ifdef FEAT_FKMAP /* when in Farsi mode, reverse the character flow */ 6076 if (p_altkeymap && curwin->w_p_rl) 6077 lrFswap(pat,0); 6078 #endif 6079 6080 if (search_regcomp(pat, RE_BOTH, which_pat, SEARCH_HIS, ®match) == FAIL) 6081 { 6082 emsg(_(e_invcmd)); 6083 return; 6084 } 6085 6086 if (global_busy) 6087 { 6088 lnum = curwin->w_cursor.lnum; 6089 match = vim_regexec_multi(®match, curwin, curbuf, lnum, 6090 (colnr_T)0, NULL, NULL); 6091 if ((type == 'g' && match) || (type == 'v' && !match)) 6092 global_exe_one(cmd, lnum); 6093 } 6094 else 6095 { 6096 /* 6097 * pass 1: set marks for each (not) matching line 6098 */ 6099 for (lnum = eap->line1; lnum <= eap->line2 && !got_int; ++lnum) 6100 { 6101 /* a match on this line? */ 6102 match = vim_regexec_multi(®match, curwin, curbuf, lnum, 6103 (colnr_T)0, NULL, NULL); 6104 if ((type == 'g' && match) || (type == 'v' && !match)) 6105 { 6106 ml_setmarked(lnum); 6107 ndone++; 6108 } 6109 line_breakcheck(); 6110 } 6111 6112 /* 6113 * pass 2: execute the command for each line that has been marked 6114 */ 6115 if (got_int) 6116 msg(_(e_interr)); 6117 else if (ndone == 0) 6118 { 6119 if (type == 'v') 6120 smsg(_("Pattern found in every line: %s"), pat); 6121 else 6122 smsg(_("Pattern not found: %s"), pat); 6123 } 6124 else 6125 { 6126 #ifdef FEAT_CLIPBOARD 6127 start_global_changes(); 6128 #endif 6129 global_exe(cmd); 6130 #ifdef FEAT_CLIPBOARD 6131 end_global_changes(); 6132 #endif 6133 } 6134 6135 ml_clearmarked(); /* clear rest of the marks */ 6136 } 6137 6138 vim_regfree(regmatch.regprog); 6139 } 6140 6141 /* 6142 * Execute "cmd" on lines marked with ml_setmarked(). 6143 */ 6144 void 6145 global_exe(char_u *cmd) 6146 { 6147 linenr_T old_lcount; /* b_ml.ml_line_count before the command */ 6148 buf_T *old_buf = curbuf; /* remember what buffer we started in */ 6149 linenr_T lnum; /* line number according to old situation */ 6150 6151 /* 6152 * Set current position only once for a global command. 6153 * If global_busy is set, setpcmark() will not do anything. 6154 * If there is an error, global_busy will be incremented. 6155 */ 6156 setpcmark(); 6157 6158 /* When the command writes a message, don't overwrite the command. */ 6159 msg_didout = TRUE; 6160 6161 sub_nsubs = 0; 6162 sub_nlines = 0; 6163 global_need_beginline = FALSE; 6164 global_busy = 1; 6165 old_lcount = curbuf->b_ml.ml_line_count; 6166 while (!got_int && (lnum = ml_firstmarked()) != 0 && global_busy == 1) 6167 { 6168 global_exe_one(cmd, lnum); 6169 ui_breakcheck(); 6170 } 6171 6172 global_busy = 0; 6173 if (global_need_beginline) 6174 beginline(BL_WHITE | BL_FIX); 6175 else 6176 check_cursor(); /* cursor may be beyond the end of the line */ 6177 6178 /* the cursor may not have moved in the text but a change in a previous 6179 * line may move it on the screen */ 6180 changed_line_abv_curs(); 6181 6182 /* If it looks like no message was written, allow overwriting the 6183 * command with the report for number of changes. */ 6184 if (msg_col == 0 && msg_scrolled == 0) 6185 msg_didout = FALSE; 6186 6187 /* If substitutes done, report number of substitutes, otherwise report 6188 * number of extra or deleted lines. 6189 * Don't report extra or deleted lines in the edge case where the buffer 6190 * we are in after execution is different from the buffer we started in. */ 6191 if (!do_sub_msg(FALSE) && curbuf == old_buf) 6192 msgmore(curbuf->b_ml.ml_line_count - old_lcount); 6193 } 6194 6195 #ifdef FEAT_VIMINFO 6196 int 6197 read_viminfo_sub_string(vir_T *virp, int force) 6198 { 6199 if (force) 6200 vim_free(old_sub); 6201 if (force || old_sub == NULL) 6202 old_sub = viminfo_readstring(virp, 1, TRUE); 6203 return viminfo_readline(virp); 6204 } 6205 6206 void 6207 write_viminfo_sub_string(FILE *fp) 6208 { 6209 if (get_viminfo_parameter('/') != 0 && old_sub != NULL) 6210 { 6211 fputs(_("\n# Last Substitute String:\n$"), fp); 6212 viminfo_writestring(fp, old_sub); 6213 } 6214 } 6215 #endif /* FEAT_VIMINFO */ 6216 6217 #if defined(EXITFREE) || defined(PROTO) 6218 void 6219 free_old_sub(void) 6220 { 6221 vim_free(old_sub); 6222 } 6223 #endif 6224 6225 #if defined(FEAT_QUICKFIX) || defined(PROTO) 6226 /* 6227 * Set up for a tagpreview. 6228 * Return TRUE when it was created. 6229 */ 6230 int 6231 prepare_tagpreview( 6232 int undo_sync) /* sync undo when leaving the window */ 6233 { 6234 win_T *wp; 6235 6236 # ifdef FEAT_GUI 6237 need_mouse_correct = TRUE; 6238 # endif 6239 6240 /* 6241 * If there is already a preview window open, use that one. 6242 */ 6243 if (!curwin->w_p_pvw) 6244 { 6245 FOR_ALL_WINDOWS(wp) 6246 if (wp->w_p_pvw) 6247 break; 6248 if (wp != NULL) 6249 win_enter(wp, undo_sync); 6250 else 6251 { 6252 /* 6253 * There is no preview window open yet. Create one. 6254 */ 6255 if (win_split(g_do_tagpreview > 0 ? g_do_tagpreview : 0, 0) 6256 == FAIL) 6257 return FALSE; 6258 curwin->w_p_pvw = TRUE; 6259 curwin->w_p_wfh = TRUE; 6260 RESET_BINDING(curwin); /* don't take over 'scrollbind' 6261 and 'cursorbind' */ 6262 # ifdef FEAT_DIFF 6263 curwin->w_p_diff = FALSE; /* no 'diff' */ 6264 # endif 6265 # ifdef FEAT_FOLDING 6266 curwin->w_p_fdc = 0; /* no 'foldcolumn' */ 6267 # endif 6268 return TRUE; 6269 } 6270 } 6271 return FALSE; 6272 } 6273 6274 #endif 6275 6276 6277 /* 6278 * ":help": open a read-only window on a help file 6279 */ 6280 void 6281 ex_help(exarg_T *eap) 6282 { 6283 char_u *arg; 6284 char_u *tag; 6285 FILE *helpfd; /* file descriptor of help file */ 6286 int n; 6287 int i; 6288 win_T *wp; 6289 int num_matches; 6290 char_u **matches; 6291 char_u *p; 6292 int empty_fnum = 0; 6293 int alt_fnum = 0; 6294 buf_T *buf; 6295 #ifdef FEAT_MULTI_LANG 6296 int len; 6297 char_u *lang; 6298 #endif 6299 #ifdef FEAT_FOLDING 6300 int old_KeyTyped = KeyTyped; 6301 #endif 6302 6303 if (eap != NULL) 6304 { 6305 /* 6306 * A ":help" command ends at the first LF, or at a '|' that is 6307 * followed by some text. Set nextcmd to the following command. 6308 */ 6309 for (arg = eap->arg; *arg; ++arg) 6310 { 6311 if (*arg == '\n' || *arg == '\r' 6312 || (*arg == '|' && arg[1] != NUL && arg[1] != '|')) 6313 { 6314 *arg++ = NUL; 6315 eap->nextcmd = arg; 6316 break; 6317 } 6318 } 6319 arg = eap->arg; 6320 6321 if (eap->forceit && *arg == NUL && !curbuf->b_help) 6322 { 6323 emsg(_("E478: Don't panic!")); 6324 return; 6325 } 6326 6327 if (eap->skip) /* not executing commands */ 6328 return; 6329 } 6330 else 6331 arg = (char_u *)""; 6332 6333 /* remove trailing blanks */ 6334 p = arg + STRLEN(arg) - 1; 6335 while (p > arg && VIM_ISWHITE(*p) && p[-1] != '\\') 6336 *p-- = NUL; 6337 6338 #ifdef FEAT_MULTI_LANG 6339 /* Check for a specified language */ 6340 lang = check_help_lang(arg); 6341 #endif 6342 6343 /* When no argument given go to the index. */ 6344 if (*arg == NUL) 6345 arg = (char_u *)"help.txt"; 6346 6347 /* 6348 * Check if there is a match for the argument. 6349 */ 6350 n = find_help_tags(arg, &num_matches, &matches, 6351 eap != NULL && eap->forceit); 6352 6353 i = 0; 6354 #ifdef FEAT_MULTI_LANG 6355 if (n != FAIL && lang != NULL) 6356 /* Find first item with the requested language. */ 6357 for (i = 0; i < num_matches; ++i) 6358 { 6359 len = (int)STRLEN(matches[i]); 6360 if (len > 3 && matches[i][len - 3] == '@' 6361 && STRICMP(matches[i] + len - 2, lang) == 0) 6362 break; 6363 } 6364 #endif 6365 if (i >= num_matches || n == FAIL) 6366 { 6367 #ifdef FEAT_MULTI_LANG 6368 if (lang != NULL) 6369 semsg(_("E661: Sorry, no '%s' help for %s"), lang, arg); 6370 else 6371 #endif 6372 semsg(_("E149: Sorry, no help for %s"), arg); 6373 if (n != FAIL) 6374 FreeWild(num_matches, matches); 6375 return; 6376 } 6377 6378 /* The first match (in the requested language) is the best match. */ 6379 tag = vim_strsave(matches[i]); 6380 FreeWild(num_matches, matches); 6381 6382 #ifdef FEAT_GUI 6383 need_mouse_correct = TRUE; 6384 #endif 6385 6386 /* 6387 * Re-use an existing help window or open a new one. 6388 * Always open a new one for ":tab help". 6389 */ 6390 if (!bt_help(curwin->w_buffer) || cmdmod.tab != 0) 6391 { 6392 if (cmdmod.tab != 0) 6393 wp = NULL; 6394 else 6395 FOR_ALL_WINDOWS(wp) 6396 if (bt_help(wp->w_buffer)) 6397 break; 6398 if (wp != NULL && wp->w_buffer->b_nwindows > 0) 6399 win_enter(wp, TRUE); 6400 else 6401 { 6402 /* 6403 * There is no help window yet. 6404 * Try to open the file specified by the "helpfile" option. 6405 */ 6406 if ((helpfd = mch_fopen((char *)p_hf, READBIN)) == NULL) 6407 { 6408 smsg(_("Sorry, help file \"%s\" not found"), p_hf); 6409 goto erret; 6410 } 6411 fclose(helpfd); 6412 6413 /* Split off help window; put it at far top if no position 6414 * specified, the current window is vertically split and 6415 * narrow. */ 6416 n = WSP_HELP; 6417 if (cmdmod.split == 0 && curwin->w_width != Columns 6418 && curwin->w_width < 80) 6419 n |= WSP_TOP; 6420 if (win_split(0, n) == FAIL) 6421 goto erret; 6422 6423 if (curwin->w_height < p_hh) 6424 win_setheight((int)p_hh); 6425 6426 /* 6427 * Open help file (do_ecmd() will set b_help flag, readfile() will 6428 * set b_p_ro flag). 6429 * Set the alternate file to the previously edited file. 6430 */ 6431 alt_fnum = curbuf->b_fnum; 6432 (void)do_ecmd(0, NULL, NULL, NULL, ECMD_LASTL, 6433 ECMD_HIDE + ECMD_SET_HELP, 6434 NULL); /* buffer is still open, don't store info */ 6435 if (!cmdmod.keepalt) 6436 curwin->w_alt_fnum = alt_fnum; 6437 empty_fnum = curbuf->b_fnum; 6438 } 6439 } 6440 6441 if (!p_im) 6442 restart_edit = 0; /* don't want insert mode in help file */ 6443 6444 #ifdef FEAT_FOLDING 6445 /* Restore KeyTyped, setting 'filetype=help' may reset it. 6446 * It is needed for do_tag top open folds under the cursor. */ 6447 KeyTyped = old_KeyTyped; 6448 #endif 6449 6450 if (tag != NULL) 6451 do_tag(tag, DT_HELP, 1, FALSE, TRUE); 6452 6453 /* Delete the empty buffer if we're not using it. Careful: autocommands 6454 * may have jumped to another window, check that the buffer is not in a 6455 * window. */ 6456 if (empty_fnum != 0 && curbuf->b_fnum != empty_fnum) 6457 { 6458 buf = buflist_findnr(empty_fnum); 6459 if (buf != NULL && buf->b_nwindows == 0) 6460 wipe_buffer(buf, TRUE); 6461 } 6462 6463 /* keep the previous alternate file */ 6464 if (alt_fnum != 0 && curwin->w_alt_fnum == empty_fnum && !cmdmod.keepalt) 6465 curwin->w_alt_fnum = alt_fnum; 6466 6467 erret: 6468 vim_free(tag); 6469 } 6470 6471 /* 6472 * ":helpclose": Close one help window 6473 */ 6474 void 6475 ex_helpclose(exarg_T *eap UNUSED) 6476 { 6477 win_T *win; 6478 6479 FOR_ALL_WINDOWS(win) 6480 { 6481 if (bt_help(win->w_buffer)) 6482 { 6483 win_close(win, FALSE); 6484 return; 6485 } 6486 } 6487 } 6488 6489 #if defined(FEAT_MULTI_LANG) || defined(PROTO) 6490 /* 6491 * In an argument search for a language specifiers in the form "@xx". 6492 * Changes the "@" to NUL if found, and returns a pointer to "xx". 6493 * Returns NULL if not found. 6494 */ 6495 char_u * 6496 check_help_lang(char_u *arg) 6497 { 6498 int len = (int)STRLEN(arg); 6499 6500 if (len >= 3 && arg[len - 3] == '@' && ASCII_ISALPHA(arg[len - 2]) 6501 && ASCII_ISALPHA(arg[len - 1])) 6502 { 6503 arg[len - 3] = NUL; /* remove the '@' */ 6504 return arg + len - 2; 6505 } 6506 return NULL; 6507 } 6508 #endif 6509 6510 /* 6511 * Return a heuristic indicating how well the given string matches. The 6512 * smaller the number, the better the match. This is the order of priorities, 6513 * from best match to worst match: 6514 * - Match with least alpha-numeric characters is better. 6515 * - Match with least total characters is better. 6516 * - Match towards the start is better. 6517 * - Match starting with "+" is worse (feature instead of command) 6518 * Assumption is made that the matched_string passed has already been found to 6519 * match some string for which help is requested. webb. 6520 */ 6521 int 6522 help_heuristic( 6523 char_u *matched_string, 6524 int offset, /* offset for match */ 6525 int wrong_case) /* no matching case */ 6526 { 6527 int num_letters; 6528 char_u *p; 6529 6530 num_letters = 0; 6531 for (p = matched_string; *p; p++) 6532 if (ASCII_ISALNUM(*p)) 6533 num_letters++; 6534 6535 /* 6536 * Multiply the number of letters by 100 to give it a much bigger 6537 * weighting than the number of characters. 6538 * If there only is a match while ignoring case, add 5000. 6539 * If the match starts in the middle of a word, add 10000 to put it 6540 * somewhere in the last half. 6541 * If the match is more than 2 chars from the start, multiply by 200 to 6542 * put it after matches at the start. 6543 */ 6544 if (ASCII_ISALNUM(matched_string[offset]) && offset > 0 6545 && ASCII_ISALNUM(matched_string[offset - 1])) 6546 offset += 10000; 6547 else if (offset > 2) 6548 offset *= 200; 6549 if (wrong_case) 6550 offset += 5000; 6551 /* Features are less interesting than the subjects themselves, but "+" 6552 * alone is not a feature. */ 6553 if (matched_string[0] == '+' && matched_string[1] != NUL) 6554 offset += 100; 6555 return (int)(100 * num_letters + STRLEN(matched_string) + offset); 6556 } 6557 6558 /* 6559 * Compare functions for qsort() below, that checks the help heuristics number 6560 * that has been put after the tagname by find_tags(). 6561 */ 6562 static int 6563 #ifdef __BORLANDC__ 6564 _RTLENTRYF 6565 #endif 6566 help_compare(const void *s1, const void *s2) 6567 { 6568 char *p1; 6569 char *p2; 6570 6571 p1 = *(char **)s1 + strlen(*(char **)s1) + 1; 6572 p2 = *(char **)s2 + strlen(*(char **)s2) + 1; 6573 return strcmp(p1, p2); 6574 } 6575 6576 /* 6577 * Find all help tags matching "arg", sort them and return in matches[], with 6578 * the number of matches in num_matches. 6579 * The matches will be sorted with a "best" match algorithm. 6580 * When "keep_lang" is TRUE try keeping the language of the current buffer. 6581 */ 6582 int 6583 find_help_tags( 6584 char_u *arg, 6585 int *num_matches, 6586 char_u ***matches, 6587 int keep_lang) 6588 { 6589 char_u *s, *d; 6590 int i; 6591 static char *(mtable[]) = {"*", "g*", "[*", "]*", ":*", 6592 "/*", "/\\*", "\"*", "**", 6593 "cpo-*", "/\\(\\)", "/\\%(\\)", 6594 "?", ":?", "?<CR>", "g?", "g?g?", "g??", 6595 "-?", "q?", "v_g?", 6596 "/\\?", "/\\z(\\)", "\\=", ":s\\=", 6597 "[count]", "[quotex]", 6598 "[range]", ":[range]", 6599 "[pattern]", "\\|", "\\%$", 6600 "s/\\~", "s/\\U", "s/\\L", 6601 "s/\\1", "s/\\2", "s/\\3", "s/\\9"}; 6602 static char *(rtable[]) = {"star", "gstar", "[star", "]star", ":star", 6603 "/star", "/\\\\star", "quotestar", "starstar", 6604 "cpo-star", "/\\\\(\\\\)", "/\\\\%(\\\\)", 6605 "?", ":?", "?<CR>", "g?", "g?g?", "g??", 6606 "-?", "q?", "v_g?", 6607 "/\\\\?", "/\\\\z(\\\\)", "\\\\=", ":s\\\\=", 6608 "\\[count]", "\\[quotex]", 6609 "\\[range]", ":\\[range]", 6610 "\\[pattern]", "\\\\bar", "/\\\\%\\$", 6611 "s/\\\\\\~", "s/\\\\U", "s/\\\\L", 6612 "s/\\\\1", "s/\\\\2", "s/\\\\3", "s/\\\\9"}; 6613 static char *(expr_table[]) = {"!=?", "!~?", "<=?", "<?", "==?", "=~?", 6614 ">=?", ">?", "is?", "isnot?"}; 6615 int flags; 6616 6617 d = IObuff; /* assume IObuff is long enough! */ 6618 6619 if (STRNICMP(arg, "expr-", 5) == 0) 6620 { 6621 // When the string starting with "expr-" and containing '?' and matches 6622 // the table, it is taken literally. Otherwise '?' is recognized as a 6623 // wildcard. 6624 for (i = (int)(sizeof(expr_table) / sizeof(char *)); --i >= 0; ) 6625 if (STRCMP(arg + 5, expr_table[i]) == 0) 6626 { 6627 STRCPY(d, arg); 6628 break; 6629 } 6630 } 6631 else 6632 { 6633 // Recognize a few exceptions to the rule. Some strings that contain 6634 // '*' with "star". Otherwise '*' is recognized as a wildcard. 6635 for (i = (int)(sizeof(mtable) / sizeof(char *)); --i >= 0; ) 6636 if (STRCMP(arg, mtable[i]) == 0) 6637 { 6638 STRCPY(d, rtable[i]); 6639 break; 6640 } 6641 } 6642 6643 if (i < 0) /* no match in table */ 6644 { 6645 /* Replace "\S" with "/\\S", etc. Otherwise every tag is matched. 6646 * Also replace "\%^" and "\%(", they match every tag too. 6647 * Also "\zs", "\z1", etc. 6648 * Also "\@<", "\@=", "\@<=", etc. 6649 * And also "\_$" and "\_^". */ 6650 if (arg[0] == '\\' 6651 && ((arg[1] != NUL && arg[2] == NUL) 6652 || (vim_strchr((char_u *)"%_z@", arg[1]) != NULL 6653 && arg[2] != NUL))) 6654 { 6655 STRCPY(d, "/\\\\"); 6656 STRCPY(d + 3, arg + 1); 6657 /* Check for "/\\_$", should be "/\\_\$" */ 6658 if (d[3] == '_' && d[4] == '$') 6659 STRCPY(d + 4, "\\$"); 6660 } 6661 else 6662 { 6663 /* Replace: 6664 * "[:...:]" with "\[:...:]" 6665 * "[++...]" with "\[++...]" 6666 * "\{" with "\\{" -- matching "} \}" 6667 */ 6668 if ((arg[0] == '[' && (arg[1] == ':' 6669 || (arg[1] == '+' && arg[2] == '+'))) 6670 || (arg[0] == '\\' && arg[1] == '{')) 6671 *d++ = '\\'; 6672 6673 /* 6674 * If tag starts with "('", skip the "(". Fixes CTRL-] on ('option'. 6675 */ 6676 if (*arg == '(' && arg[1] == '\'') 6677 arg++; 6678 for (s = arg; *s; ++s) 6679 { 6680 /* 6681 * Replace "|" with "bar" and '"' with "quote" to match the name of 6682 * the tags for these commands. 6683 * Replace "*" with ".*" and "?" with "." to match command line 6684 * completion. 6685 * Insert a backslash before '~', '$' and '.' to avoid their 6686 * special meaning. 6687 */ 6688 if (d - IObuff > IOSIZE - 10) /* getting too long!? */ 6689 break; 6690 switch (*s) 6691 { 6692 case '|': STRCPY(d, "bar"); 6693 d += 3; 6694 continue; 6695 case '"': STRCPY(d, "quote"); 6696 d += 5; 6697 continue; 6698 case '*': *d++ = '.'; 6699 break; 6700 case '?': *d++ = '.'; 6701 continue; 6702 case '$': 6703 case '.': 6704 case '~': *d++ = '\\'; 6705 break; 6706 } 6707 6708 /* 6709 * Replace "^x" by "CTRL-X". Don't do this for "^_" to make 6710 * ":help i_^_CTRL-D" work. 6711 * Insert '-' before and after "CTRL-X" when applicable. 6712 */ 6713 if (*s < ' ' || (*s == '^' && s[1] && (ASCII_ISALPHA(s[1]) 6714 || vim_strchr((char_u *)"?@[\\]^", s[1]) != NULL))) 6715 { 6716 if (d > IObuff && d[-1] != '_' && d[-1] != '\\') 6717 *d++ = '_'; /* prepend a '_' to make x_CTRL-x */ 6718 STRCPY(d, "CTRL-"); 6719 d += 5; 6720 if (*s < ' ') 6721 { 6722 #ifdef EBCDIC 6723 *d++ = CtrlChar(*s); 6724 #else 6725 *d++ = *s + '@'; 6726 #endif 6727 if (d[-1] == '\\') 6728 *d++ = '\\'; /* double a backslash */ 6729 } 6730 else 6731 *d++ = *++s; 6732 if (s[1] != NUL && s[1] != '_') 6733 *d++ = '_'; /* append a '_' */ 6734 continue; 6735 } 6736 else if (*s == '^') /* "^" or "CTRL-^" or "^_" */ 6737 *d++ = '\\'; 6738 6739 /* 6740 * Insert a backslash before a backslash after a slash, for search 6741 * pattern tags: "/\|" --> "/\\|". 6742 */ 6743 else if (s[0] == '\\' && s[1] != '\\' 6744 && *arg == '/' && s == arg + 1) 6745 *d++ = '\\'; 6746 6747 /* "CTRL-\_" -> "CTRL-\\_" to avoid the special meaning of "\_" in 6748 * "CTRL-\_CTRL-N" */ 6749 if (STRNICMP(s, "CTRL-\\_", 7) == 0) 6750 { 6751 STRCPY(d, "CTRL-\\\\"); 6752 d += 7; 6753 s += 6; 6754 } 6755 6756 *d++ = *s; 6757 6758 /* 6759 * If tag contains "({" or "([", tag terminates at the "(". 6760 * This is for help on functions, e.g.: abs({expr}). 6761 */ 6762 if (*s == '(' && (s[1] == '{' || s[1] =='[')) 6763 break; 6764 6765 /* 6766 * If tag starts with ', toss everything after a second '. Fixes 6767 * CTRL-] on 'option'. (would include the trailing '.'). 6768 */ 6769 if (*s == '\'' && s > arg && *arg == '\'') 6770 break; 6771 /* Also '{' and '}'. */ 6772 if (*s == '}' && s > arg && *arg == '{') 6773 break; 6774 } 6775 *d = NUL; 6776 6777 if (*IObuff == '`') 6778 { 6779 if (d > IObuff + 2 && d[-1] == '`') 6780 { 6781 /* remove the backticks from `command` */ 6782 mch_memmove(IObuff, IObuff + 1, STRLEN(IObuff)); 6783 d[-2] = NUL; 6784 } 6785 else if (d > IObuff + 3 && d[-2] == '`' && d[-1] == ',') 6786 { 6787 /* remove the backticks and comma from `command`, */ 6788 mch_memmove(IObuff, IObuff + 1, STRLEN(IObuff)); 6789 d[-3] = NUL; 6790 } 6791 else if (d > IObuff + 4 && d[-3] == '`' 6792 && d[-2] == '\\' && d[-1] == '.') 6793 { 6794 /* remove the backticks and dot from `command`\. */ 6795 mch_memmove(IObuff, IObuff + 1, STRLEN(IObuff)); 6796 d[-4] = NUL; 6797 } 6798 } 6799 } 6800 } 6801 6802 *matches = (char_u **)""; 6803 *num_matches = 0; 6804 flags = TAG_HELP | TAG_REGEXP | TAG_NAMES | TAG_VERBOSE; 6805 if (keep_lang) 6806 flags |= TAG_KEEP_LANG; 6807 if (find_tags(IObuff, num_matches, matches, flags, (int)MAXCOL, NULL) == OK 6808 && *num_matches > 0) 6809 { 6810 /* Sort the matches found on the heuristic number that is after the 6811 * tag name. */ 6812 qsort((void *)*matches, (size_t)*num_matches, 6813 sizeof(char_u *), help_compare); 6814 /* Delete more than TAG_MANY to reduce the size of the listing. */ 6815 while (*num_matches > TAG_MANY) 6816 vim_free((*matches)[--*num_matches]); 6817 } 6818 return OK; 6819 } 6820 6821 /* 6822 * Called when starting to edit a buffer for a help file. 6823 */ 6824 static void 6825 prepare_help_buffer(void) 6826 { 6827 char_u *p; 6828 6829 curbuf->b_help = TRUE; 6830 #ifdef FEAT_QUICKFIX 6831 set_string_option_direct((char_u *)"buftype", -1, 6832 (char_u *)"help", OPT_FREE|OPT_LOCAL, 0); 6833 #endif 6834 6835 /* 6836 * Always set these options after jumping to a help tag, because the 6837 * user may have an autocommand that gets in the way. 6838 * Accept all ASCII chars for keywords, except ' ', '*', '"', '|', and 6839 * latin1 word characters (for translated help files). 6840 * Only set it when needed, buf_init_chartab() is some work. 6841 */ 6842 p = 6843 #ifdef EBCDIC 6844 (char_u *)"65-255,^*,^|,^\""; 6845 #else 6846 (char_u *)"!-~,^*,^|,^\",192-255"; 6847 #endif 6848 if (STRCMP(curbuf->b_p_isk, p) != 0) 6849 { 6850 set_string_option_direct((char_u *)"isk", -1, p, OPT_FREE|OPT_LOCAL, 0); 6851 check_buf_options(curbuf); 6852 (void)buf_init_chartab(curbuf, FALSE); 6853 } 6854 6855 #ifdef FEAT_FOLDING 6856 /* Don't use the global foldmethod.*/ 6857 set_string_option_direct((char_u *)"fdm", -1, (char_u *)"manual", 6858 OPT_FREE|OPT_LOCAL, 0); 6859 #endif 6860 6861 curbuf->b_p_ts = 8; /* 'tabstop' is 8 */ 6862 curwin->w_p_list = FALSE; /* no list mode */ 6863 6864 curbuf->b_p_ma = FALSE; /* not modifiable */ 6865 curbuf->b_p_bin = FALSE; /* reset 'bin' before reading file */ 6866 curwin->w_p_nu = 0; /* no line numbers */ 6867 curwin->w_p_rnu = 0; /* no relative line numbers */ 6868 RESET_BINDING(curwin); /* no scroll or cursor binding */ 6869 #ifdef FEAT_ARABIC 6870 curwin->w_p_arab = FALSE; /* no arabic mode */ 6871 #endif 6872 #ifdef FEAT_RIGHTLEFT 6873 curwin->w_p_rl = FALSE; /* help window is left-to-right */ 6874 #endif 6875 #ifdef FEAT_FOLDING 6876 curwin->w_p_fen = FALSE; /* No folding in the help window */ 6877 #endif 6878 #ifdef FEAT_DIFF 6879 curwin->w_p_diff = FALSE; /* No 'diff' */ 6880 #endif 6881 #ifdef FEAT_SPELL 6882 curwin->w_p_spell = FALSE; /* No spell checking */ 6883 #endif 6884 6885 set_buflisted(FALSE); 6886 } 6887 6888 /* 6889 * After reading a help file: May cleanup a help buffer when syntax 6890 * highlighting is not used. 6891 */ 6892 void 6893 fix_help_buffer(void) 6894 { 6895 linenr_T lnum; 6896 char_u *line; 6897 int in_example = FALSE; 6898 int len; 6899 char_u *fname; 6900 char_u *p; 6901 char_u *rt; 6902 int mustfree; 6903 6904 /* Set filetype to "help" if still needed. */ 6905 if (STRCMP(curbuf->b_p_ft, "help") != 0) 6906 { 6907 ++curbuf_lock; 6908 set_option_value((char_u *)"ft", 0L, (char_u *)"help", OPT_LOCAL); 6909 --curbuf_lock; 6910 } 6911 6912 #ifdef FEAT_SYN_HL 6913 if (!syntax_present(curwin)) 6914 #endif 6915 { 6916 for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) 6917 { 6918 line = ml_get_buf(curbuf, lnum, FALSE); 6919 len = (int)STRLEN(line); 6920 if (in_example && len > 0 && !VIM_ISWHITE(line[0])) 6921 { 6922 /* End of example: non-white or '<' in first column. */ 6923 if (line[0] == '<') 6924 { 6925 /* blank-out a '<' in the first column */ 6926 line = ml_get_buf(curbuf, lnum, TRUE); 6927 line[0] = ' '; 6928 } 6929 in_example = FALSE; 6930 } 6931 if (!in_example && len > 0) 6932 { 6933 if (line[len - 1] == '>' && (len == 1 || line[len - 2] == ' ')) 6934 { 6935 /* blank-out a '>' in the last column (start of example) */ 6936 line = ml_get_buf(curbuf, lnum, TRUE); 6937 line[len - 1] = ' '; 6938 in_example = TRUE; 6939 } 6940 else if (line[len - 1] == '~') 6941 { 6942 /* blank-out a '~' at the end of line (header marker) */ 6943 line = ml_get_buf(curbuf, lnum, TRUE); 6944 line[len - 1] = ' '; 6945 } 6946 } 6947 } 6948 } 6949 6950 /* 6951 * In the "help.txt" and "help.abx" file, add the locally added help 6952 * files. This uses the very first line in the help file. 6953 */ 6954 fname = gettail(curbuf->b_fname); 6955 if (fnamecmp(fname, "help.txt") == 0 6956 #ifdef FEAT_MULTI_LANG 6957 || (fnamencmp(fname, "help.", 5) == 0 6958 && ASCII_ISALPHA(fname[5]) 6959 && ASCII_ISALPHA(fname[6]) 6960 && TOLOWER_ASC(fname[7]) == 'x' 6961 && fname[8] == NUL) 6962 #endif 6963 ) 6964 { 6965 for (lnum = 1; lnum < curbuf->b_ml.ml_line_count; ++lnum) 6966 { 6967 line = ml_get_buf(curbuf, lnum, FALSE); 6968 if (strstr((char *)line, "*local-additions*") == NULL) 6969 continue; 6970 6971 /* Go through all directories in 'runtimepath', skipping 6972 * $VIMRUNTIME. */ 6973 p = p_rtp; 6974 while (*p != NUL) 6975 { 6976 copy_option_part(&p, NameBuff, MAXPATHL, ","); 6977 mustfree = FALSE; 6978 rt = vim_getenv((char_u *)"VIMRUNTIME", &mustfree); 6979 if (rt != NULL && fullpathcmp(rt, NameBuff, FALSE) != FPC_SAME) 6980 { 6981 int fcount; 6982 char_u **fnames; 6983 FILE *fd; 6984 char_u *s; 6985 int fi; 6986 vimconv_T vc; 6987 char_u *cp; 6988 6989 /* Find all "doc/ *.txt" files in this directory. */ 6990 add_pathsep(NameBuff); 6991 #ifdef FEAT_MULTI_LANG 6992 STRCAT(NameBuff, "doc/*.??[tx]"); 6993 #else 6994 STRCAT(NameBuff, "doc/*.txt"); 6995 #endif 6996 if (gen_expand_wildcards(1, &NameBuff, &fcount, 6997 &fnames, EW_FILE|EW_SILENT) == OK 6998 && fcount > 0) 6999 { 7000 #ifdef FEAT_MULTI_LANG 7001 int i1, i2; 7002 char_u *f1, *f2; 7003 char_u *t1, *t2; 7004 char_u *e1, *e2; 7005 7006 /* If foo.abx is found use it instead of foo.txt in 7007 * the same directory. */ 7008 for (i1 = 0; i1 < fcount; ++i1) 7009 { 7010 for (i2 = 0; i2 < fcount; ++i2) 7011 { 7012 if (i1 == i2) 7013 continue; 7014 if (fnames[i1] == NULL || fnames[i2] == NULL) 7015 continue; 7016 f1 = fnames[i1]; 7017 f2 = fnames[i2]; 7018 t1 = gettail(f1); 7019 t2 = gettail(f2); 7020 e1 = vim_strrchr(t1, '.'); 7021 e2 = vim_strrchr(t2, '.'); 7022 if (e1 == NULL || e2 == NULL) 7023 continue; 7024 if (fnamecmp(e1, ".txt") != 0 7025 && fnamecmp(e1, fname + 4) != 0) 7026 { 7027 /* Not .txt and not .abx, remove it. */ 7028 VIM_CLEAR(fnames[i1]); 7029 continue; 7030 } 7031 if (e1 - f1 != e2 - f2 7032 || fnamencmp(f1, f2, e1 - f1) != 0) 7033 continue; 7034 if (fnamecmp(e1, ".txt") == 0 7035 && fnamecmp(e2, fname + 4) == 0) 7036 /* use .abx instead of .txt */ 7037 VIM_CLEAR(fnames[i1]); 7038 } 7039 } 7040 #endif 7041 for (fi = 0; fi < fcount; ++fi) 7042 { 7043 if (fnames[fi] == NULL) 7044 continue; 7045 fd = mch_fopen((char *)fnames[fi], "r"); 7046 if (fd != NULL) 7047 { 7048 vim_fgets(IObuff, IOSIZE, fd); 7049 if (IObuff[0] == '*' 7050 && (s = vim_strchr(IObuff + 1, '*')) 7051 != NULL) 7052 { 7053 int this_utf = MAYBE; 7054 7055 /* Change tag definition to a 7056 * reference and remove <CR>/<NL>. */ 7057 IObuff[0] = '|'; 7058 *s = '|'; 7059 while (*s != NUL) 7060 { 7061 if (*s == '\r' || *s == '\n') 7062 *s = NUL; 7063 /* The text is utf-8 when a byte 7064 * above 127 is found and no 7065 * illegal byte sequence is found. 7066 */ 7067 if (*s >= 0x80 && this_utf != FALSE) 7068 { 7069 int l; 7070 7071 this_utf = TRUE; 7072 l = utf_ptr2len(s); 7073 if (l == 1) 7074 this_utf = FALSE; 7075 s += l - 1; 7076 } 7077 ++s; 7078 } 7079 7080 /* The help file is latin1 or utf-8; 7081 * conversion to the current 7082 * 'encoding' may be required. */ 7083 vc.vc_type = CONV_NONE; 7084 convert_setup(&vc, (char_u *)( 7085 this_utf == TRUE ? "utf-8" 7086 : "latin1"), p_enc); 7087 if (vc.vc_type == CONV_NONE) 7088 /* No conversion needed. */ 7089 cp = IObuff; 7090 else 7091 { 7092 /* Do the conversion. If it fails 7093 * use the unconverted text. */ 7094 cp = string_convert(&vc, IObuff, 7095 NULL); 7096 if (cp == NULL) 7097 cp = IObuff; 7098 } 7099 convert_setup(&vc, NULL, NULL); 7100 7101 ml_append(lnum, cp, (colnr_T)0, FALSE); 7102 if (cp != IObuff) 7103 vim_free(cp); 7104 ++lnum; 7105 } 7106 fclose(fd); 7107 } 7108 } 7109 FreeWild(fcount, fnames); 7110 } 7111 } 7112 if (mustfree) 7113 vim_free(rt); 7114 } 7115 break; 7116 } 7117 } 7118 } 7119 7120 /* 7121 * ":exusage" 7122 */ 7123 void 7124 ex_exusage(exarg_T *eap UNUSED) 7125 { 7126 do_cmdline_cmd((char_u *)"help ex-cmd-index"); 7127 } 7128 7129 /* 7130 * ":viusage" 7131 */ 7132 void 7133 ex_viusage(exarg_T *eap UNUSED) 7134 { 7135 do_cmdline_cmd((char_u *)"help normal-index"); 7136 } 7137 7138 /* 7139 * Generate tags in one help directory. 7140 */ 7141 static void 7142 helptags_one( 7143 char_u *dir, /* doc directory */ 7144 char_u *ext, /* suffix, ".txt", ".itx", ".frx", etc. */ 7145 char_u *tagfname, /* "tags" for English, "tags-fr" for French. */ 7146 int add_help_tags) /* add "help-tags" tag */ 7147 { 7148 FILE *fd_tags; 7149 FILE *fd; 7150 garray_T ga; 7151 int filecount; 7152 char_u **files; 7153 char_u *p1, *p2; 7154 int fi; 7155 char_u *s; 7156 int i; 7157 char_u *fname; 7158 int dirlen; 7159 int utf8 = MAYBE; 7160 int this_utf8; 7161 int firstline; 7162 int mix = FALSE; /* detected mixed encodings */ 7163 7164 /* 7165 * Find all *.txt files. 7166 */ 7167 dirlen = (int)STRLEN(dir); 7168 STRCPY(NameBuff, dir); 7169 STRCAT(NameBuff, "/**/*"); 7170 STRCAT(NameBuff, ext); 7171 if (gen_expand_wildcards(1, &NameBuff, &filecount, &files, 7172 EW_FILE|EW_SILENT) == FAIL 7173 || filecount == 0) 7174 { 7175 if (!got_int) 7176 semsg(_("E151: No match: %s"), NameBuff); 7177 return; 7178 } 7179 7180 /* 7181 * Open the tags file for writing. 7182 * Do this before scanning through all the files. 7183 */ 7184 STRCPY(NameBuff, dir); 7185 add_pathsep(NameBuff); 7186 STRCAT(NameBuff, tagfname); 7187 fd_tags = mch_fopen((char *)NameBuff, "w"); 7188 if (fd_tags == NULL) 7189 { 7190 semsg(_("E152: Cannot open %s for writing"), NameBuff); 7191 FreeWild(filecount, files); 7192 return; 7193 } 7194 7195 /* 7196 * If using the "++t" argument or generating tags for "$VIMRUNTIME/doc" 7197 * add the "help-tags" tag. 7198 */ 7199 ga_init2(&ga, (int)sizeof(char_u *), 100); 7200 if (add_help_tags || fullpathcmp((char_u *)"$VIMRUNTIME/doc", 7201 dir, FALSE) == FPC_SAME) 7202 { 7203 if (ga_grow(&ga, 1) == FAIL) 7204 got_int = TRUE; 7205 else 7206 { 7207 s = alloc(18 + (unsigned)STRLEN(tagfname)); 7208 if (s == NULL) 7209 got_int = TRUE; 7210 else 7211 { 7212 sprintf((char *)s, "help-tags\t%s\t1\n", tagfname); 7213 ((char_u **)ga.ga_data)[ga.ga_len] = s; 7214 ++ga.ga_len; 7215 } 7216 } 7217 } 7218 7219 /* 7220 * Go over all the files and extract the tags. 7221 */ 7222 for (fi = 0; fi < filecount && !got_int; ++fi) 7223 { 7224 fd = mch_fopen((char *)files[fi], "r"); 7225 if (fd == NULL) 7226 { 7227 semsg(_("E153: Unable to open %s for reading"), files[fi]); 7228 continue; 7229 } 7230 fname = files[fi] + dirlen + 1; 7231 7232 firstline = TRUE; 7233 while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int) 7234 { 7235 if (firstline) 7236 { 7237 /* Detect utf-8 file by a non-ASCII char in the first line. */ 7238 this_utf8 = MAYBE; 7239 for (s = IObuff; *s != NUL; ++s) 7240 if (*s >= 0x80) 7241 { 7242 int l; 7243 7244 this_utf8 = TRUE; 7245 l = utf_ptr2len(s); 7246 if (l == 1) 7247 { 7248 /* Illegal UTF-8 byte sequence. */ 7249 this_utf8 = FALSE; 7250 break; 7251 } 7252 s += l - 1; 7253 } 7254 if (this_utf8 == MAYBE) /* only ASCII characters found */ 7255 this_utf8 = FALSE; 7256 if (utf8 == MAYBE) /* first file */ 7257 utf8 = this_utf8; 7258 else if (utf8 != this_utf8) 7259 { 7260 semsg(_("E670: Mix of help file encodings within a language: %s"), files[fi]); 7261 mix = !got_int; 7262 got_int = TRUE; 7263 } 7264 firstline = FALSE; 7265 } 7266 p1 = vim_strchr(IObuff, '*'); /* find first '*' */ 7267 while (p1 != NULL) 7268 { 7269 /* Use vim_strbyte() instead of vim_strchr() so that when 7270 * 'encoding' is dbcs it still works, don't find '*' in the 7271 * second byte. */ 7272 p2 = vim_strbyte(p1 + 1, '*'); /* find second '*' */ 7273 if (p2 != NULL && p2 > p1 + 1) /* skip "*" and "**" */ 7274 { 7275 for (s = p1 + 1; s < p2; ++s) 7276 if (*s == ' ' || *s == '\t' || *s == '|') 7277 break; 7278 7279 /* 7280 * Only accept a *tag* when it consists of valid 7281 * characters, there is white space before it and is 7282 * followed by a white character or end-of-line. 7283 */ 7284 if (s == p2 7285 && (p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t') 7286 && (vim_strchr((char_u *)" \t\n\r", s[1]) != NULL 7287 || s[1] == '\0')) 7288 { 7289 *p2 = '\0'; 7290 ++p1; 7291 if (ga_grow(&ga, 1) == FAIL) 7292 { 7293 got_int = TRUE; 7294 break; 7295 } 7296 s = alloc((unsigned)(p2 - p1 + STRLEN(fname) + 2)); 7297 if (s == NULL) 7298 { 7299 got_int = TRUE; 7300 break; 7301 } 7302 ((char_u **)ga.ga_data)[ga.ga_len] = s; 7303 ++ga.ga_len; 7304 sprintf((char *)s, "%s\t%s", p1, fname); 7305 7306 /* find next '*' */ 7307 p2 = vim_strchr(p2 + 1, '*'); 7308 } 7309 } 7310 p1 = p2; 7311 } 7312 line_breakcheck(); 7313 } 7314 7315 fclose(fd); 7316 } 7317 7318 FreeWild(filecount, files); 7319 7320 if (!got_int) 7321 { 7322 /* 7323 * Sort the tags. 7324 */ 7325 if (ga.ga_data != NULL) 7326 sort_strings((char_u **)ga.ga_data, ga.ga_len); 7327 7328 /* 7329 * Check for duplicates. 7330 */ 7331 for (i = 1; i < ga.ga_len; ++i) 7332 { 7333 p1 = ((char_u **)ga.ga_data)[i - 1]; 7334 p2 = ((char_u **)ga.ga_data)[i]; 7335 while (*p1 == *p2) 7336 { 7337 if (*p2 == '\t') 7338 { 7339 *p2 = NUL; 7340 vim_snprintf((char *)NameBuff, MAXPATHL, 7341 _("E154: Duplicate tag \"%s\" in file %s/%s"), 7342 ((char_u **)ga.ga_data)[i], dir, p2 + 1); 7343 emsg((char *)NameBuff); 7344 *p2 = '\t'; 7345 break; 7346 } 7347 ++p1; 7348 ++p2; 7349 } 7350 } 7351 7352 if (utf8 == TRUE) 7353 fprintf(fd_tags, "!_TAG_FILE_ENCODING\tutf-8\t//\n"); 7354 7355 /* 7356 * Write the tags into the file. 7357 */ 7358 for (i = 0; i < ga.ga_len; ++i) 7359 { 7360 s = ((char_u **)ga.ga_data)[i]; 7361 if (STRNCMP(s, "help-tags\t", 10) == 0) 7362 /* help-tags entry was added in formatted form */ 7363 fputs((char *)s, fd_tags); 7364 else 7365 { 7366 fprintf(fd_tags, "%s\t/*", s); 7367 for (p1 = s; *p1 != '\t'; ++p1) 7368 { 7369 /* insert backslash before '\\' and '/' */ 7370 if (*p1 == '\\' || *p1 == '/') 7371 putc('\\', fd_tags); 7372 putc(*p1, fd_tags); 7373 } 7374 fprintf(fd_tags, "*\n"); 7375 } 7376 } 7377 } 7378 if (mix) 7379 got_int = FALSE; /* continue with other languages */ 7380 7381 for (i = 0; i < ga.ga_len; ++i) 7382 vim_free(((char_u **)ga.ga_data)[i]); 7383 ga_clear(&ga); 7384 fclose(fd_tags); /* there is no check for an error... */ 7385 } 7386 7387 /* 7388 * Generate tags in one help directory, taking care of translations. 7389 */ 7390 static void 7391 do_helptags(char_u *dirname, int add_help_tags) 7392 { 7393 #ifdef FEAT_MULTI_LANG 7394 int len; 7395 int i, j; 7396 garray_T ga; 7397 char_u lang[2]; 7398 char_u ext[5]; 7399 char_u fname[8]; 7400 int filecount; 7401 char_u **files; 7402 7403 /* Get a list of all files in the help directory and in subdirectories. */ 7404 STRCPY(NameBuff, dirname); 7405 add_pathsep(NameBuff); 7406 STRCAT(NameBuff, "**"); 7407 if (gen_expand_wildcards(1, &NameBuff, &filecount, &files, 7408 EW_FILE|EW_SILENT) == FAIL 7409 || filecount == 0) 7410 { 7411 semsg(_("E151: No match: %s"), NameBuff); 7412 return; 7413 } 7414 7415 /* Go over all files in the directory to find out what languages are 7416 * present. */ 7417 ga_init2(&ga, 1, 10); 7418 for (i = 0; i < filecount; ++i) 7419 { 7420 len = (int)STRLEN(files[i]); 7421 if (len > 4) 7422 { 7423 if (STRICMP(files[i] + len - 4, ".txt") == 0) 7424 { 7425 /* ".txt" -> language "en" */ 7426 lang[0] = 'e'; 7427 lang[1] = 'n'; 7428 } 7429 else if (files[i][len - 4] == '.' 7430 && ASCII_ISALPHA(files[i][len - 3]) 7431 && ASCII_ISALPHA(files[i][len - 2]) 7432 && TOLOWER_ASC(files[i][len - 1]) == 'x') 7433 { 7434 /* ".abx" -> language "ab" */ 7435 lang[0] = TOLOWER_ASC(files[i][len - 3]); 7436 lang[1] = TOLOWER_ASC(files[i][len - 2]); 7437 } 7438 else 7439 continue; 7440 7441 /* Did we find this language already? */ 7442 for (j = 0; j < ga.ga_len; j += 2) 7443 if (STRNCMP(lang, ((char_u *)ga.ga_data) + j, 2) == 0) 7444 break; 7445 if (j == ga.ga_len) 7446 { 7447 /* New language, add it. */ 7448 if (ga_grow(&ga, 2) == FAIL) 7449 break; 7450 ((char_u *)ga.ga_data)[ga.ga_len++] = lang[0]; 7451 ((char_u *)ga.ga_data)[ga.ga_len++] = lang[1]; 7452 } 7453 } 7454 } 7455 7456 /* 7457 * Loop over the found languages to generate a tags file for each one. 7458 */ 7459 for (j = 0; j < ga.ga_len; j += 2) 7460 { 7461 STRCPY(fname, "tags-xx"); 7462 fname[5] = ((char_u *)ga.ga_data)[j]; 7463 fname[6] = ((char_u *)ga.ga_data)[j + 1]; 7464 if (fname[5] == 'e' && fname[6] == 'n') 7465 { 7466 /* English is an exception: use ".txt" and "tags". */ 7467 fname[4] = NUL; 7468 STRCPY(ext, ".txt"); 7469 } 7470 else 7471 { 7472 /* Language "ab" uses ".abx" and "tags-ab". */ 7473 STRCPY(ext, ".xxx"); 7474 ext[1] = fname[5]; 7475 ext[2] = fname[6]; 7476 } 7477 helptags_one(dirname, ext, fname, add_help_tags); 7478 } 7479 7480 ga_clear(&ga); 7481 FreeWild(filecount, files); 7482 7483 #else 7484 /* No language support, just use "*.txt" and "tags". */ 7485 helptags_one(dirname, (char_u *)".txt", (char_u *)"tags", add_help_tags); 7486 #endif 7487 } 7488 7489 static void 7490 helptags_cb(char_u *fname, void *cookie) 7491 { 7492 do_helptags(fname, *(int *)cookie); 7493 } 7494 7495 /* 7496 * ":helptags" 7497 */ 7498 void 7499 ex_helptags(exarg_T *eap) 7500 { 7501 expand_T xpc; 7502 char_u *dirname; 7503 int add_help_tags = FALSE; 7504 7505 /* Check for ":helptags ++t {dir}". */ 7506 if (STRNCMP(eap->arg, "++t", 3) == 0 && VIM_ISWHITE(eap->arg[3])) 7507 { 7508 add_help_tags = TRUE; 7509 eap->arg = skipwhite(eap->arg + 3); 7510 } 7511 7512 if (STRCMP(eap->arg, "ALL") == 0) 7513 { 7514 do_in_path(p_rtp, (char_u *)"doc", DIP_ALL + DIP_DIR, 7515 helptags_cb, &add_help_tags); 7516 } 7517 else 7518 { 7519 ExpandInit(&xpc); 7520 xpc.xp_context = EXPAND_DIRECTORIES; 7521 dirname = ExpandOne(&xpc, eap->arg, NULL, 7522 WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE); 7523 if (dirname == NULL || !mch_isdir(dirname)) 7524 semsg(_("E150: Not a directory: %s"), eap->arg); 7525 else 7526 do_helptags(dirname, add_help_tags); 7527 vim_free(dirname); 7528 } 7529 } 7530 7531 /* 7532 * Make the user happy. 7533 */ 7534 void 7535 ex_smile(exarg_T *eap UNUSED) 7536 { 7537 static char *code[] = { 7538 "\34 \4o\14$\4ox\30 \2o\30$\1ox\25 \2o\36$\1o\11 \1o\1$\3 \2$\1 \1o\1$x\5 \1o\1 \1$\1 \2o\10 \1o\44$\1o\7 \2$\1 \2$\1 \2$\1o\1$x\2 \2o\1 \1$\1 \1$\1 \1\"\1$\6 \1o\11$\4 \15$\4 \11$\1o\7 \3$\1o\2$\1o\1$x\2 \1\"\6$\1o\1$\5 \1o\11$\6 \13$\6 \12$\1o\4 \10$x\4 \7$\4 \13$\6 \13$\6 \27$x\4 \27$\4 \15$\4 \16$\2 \3\"\3$x\5 \1\"\3$\4\"\61$\5 \1\"\3$x\6 \3$\3 \1o\62$\5 \1\"\3$\1ox\5 \1o\2$\1\"\3 \63$\7 \3$\1ox\5 \3$\4 \55$\1\"\1 \1\"\6$", 7539 "\5o\4$\1ox\4 \1o\3$\4o\5$\2 \45$\3 \1o\21$x\4 \10$\1\"\4$\3 \42$\5 \4$\10\"x\3 \4\"\7 \4$\4 \1\"\34$\1\"\6 \1o\3$x\16 \1\"\3$\1o\5 \3\"\22$\1\"\2$\1\"\11 \3$x\20 \3$\1o\12 \1\"\2$\2\"\6$\4\"\13 \1o\3$x\21 \4$\1o\40 \1o\3$\1\"x\22 \1\"\4$\1o\6 \1o\6$\1o\1\"\4$\1o\10 \1o\4$x\24 \1\"\5$\2o\5 \2\"\4$\1o\5$\1o\3 \1o\4$\2\"x\27 \2\"\5$\4o\2 \1\"\3$\1o\11$\3\"x\32 \2\"\7$\2o\1 \12$x\42 \4\"\13$x\46 \14$x\47 \12$\1\"x\50 \1\"\3$\4\"x" 7540 }; 7541 char *p; 7542 int n; 7543 int i; 7544 7545 msg_start(); 7546 msg_putchar('\n'); 7547 for (i = 0; i < 2; ++i) 7548 for (p = code[i]; *p != NUL; ++p) 7549 if (*p == 'x') 7550 msg_putchar('\n'); 7551 else 7552 for (n = *p++; n > 0; --n) 7553 if (*p == 'o' || *p == '$') 7554 msg_putchar_attr(*p, HL_ATTR(HLF_L)); 7555 else 7556 msg_putchar(*p); 7557 msg_clr_eos(); 7558 } 7559 7560 /* 7561 * ":drop" 7562 * Opens the first argument in a window. When there are two or more arguments 7563 * the argument list is redefined. 7564 */ 7565 void 7566 ex_drop(exarg_T *eap) 7567 { 7568 int split = FALSE; 7569 win_T *wp; 7570 buf_T *buf; 7571 tabpage_T *tp; 7572 7573 /* 7574 * Check if the first argument is already being edited in a window. If 7575 * so, jump to that window. 7576 * We would actually need to check all arguments, but that's complicated 7577 * and mostly only one file is dropped. 7578 * This also ignores wildcards, since it is very unlikely the user is 7579 * editing a file name with a wildcard character. 7580 */ 7581 set_arglist(eap->arg); 7582 7583 /* 7584 * Expanding wildcards may result in an empty argument list. E.g. when 7585 * editing "foo.pyc" and ".pyc" is in 'wildignore'. Assume that we 7586 * already did an error message for this. 7587 */ 7588 if (ARGCOUNT == 0) 7589 return; 7590 7591 if (cmdmod.tab) 7592 { 7593 /* ":tab drop file ...": open a tab for each argument that isn't 7594 * edited in a window yet. It's like ":tab all" but without closing 7595 * windows or tabs. */ 7596 ex_all(eap); 7597 } 7598 else 7599 { 7600 /* ":drop file ...": Edit the first argument. Jump to an existing 7601 * window if possible, edit in current window if the current buffer 7602 * can be abandoned, otherwise open a new window. */ 7603 buf = buflist_findnr(ARGLIST[0].ae_fnum); 7604 7605 FOR_ALL_TAB_WINDOWS(tp, wp) 7606 { 7607 if (wp->w_buffer == buf) 7608 { 7609 goto_tabpage_win(tp, wp); 7610 curwin->w_arg_idx = 0; 7611 return; 7612 } 7613 } 7614 7615 /* 7616 * Check whether the current buffer is changed. If so, we will need 7617 * to split the current window or data could be lost. 7618 * Skip the check if the 'hidden' option is set, as in this case the 7619 * buffer won't be lost. 7620 */ 7621 if (!buf_hide(curbuf)) 7622 { 7623 ++emsg_off; 7624 split = check_changed(curbuf, CCGD_AW | CCGD_EXCMD); 7625 --emsg_off; 7626 } 7627 7628 /* Fake a ":sfirst" or ":first" command edit the first argument. */ 7629 if (split) 7630 { 7631 eap->cmdidx = CMD_sfirst; 7632 eap->cmd[0] = 's'; 7633 } 7634 else 7635 eap->cmdidx = CMD_first; 7636 ex_rewind(eap); 7637 } 7638 } 7639 7640 /* 7641 * Skip over the pattern argument of ":vimgrep /pat/[g][j]". 7642 * Put the start of the pattern in "*s", unless "s" is NULL. 7643 * If "flags" is not NULL put the flags in it: VGR_GLOBAL, VGR_NOJUMP. 7644 * If "s" is not NULL terminate the pattern with a NUL. 7645 * Return a pointer to the char just past the pattern plus flags. 7646 */ 7647 char_u * 7648 skip_vimgrep_pat(char_u *p, char_u **s, int *flags) 7649 { 7650 int c; 7651 7652 if (vim_isIDc(*p)) 7653 { 7654 /* ":vimgrep pattern fname" */ 7655 if (s != NULL) 7656 *s = p; 7657 p = skiptowhite(p); 7658 if (s != NULL && *p != NUL) 7659 *p++ = NUL; 7660 } 7661 else 7662 { 7663 /* ":vimgrep /pattern/[g][j] fname" */ 7664 if (s != NULL) 7665 *s = p + 1; 7666 c = *p; 7667 p = skip_regexp(p + 1, c, TRUE, NULL); 7668 if (*p != c) 7669 return NULL; 7670 7671 /* Truncate the pattern. */ 7672 if (s != NULL) 7673 *p = NUL; 7674 ++p; 7675 7676 /* Find the flags */ 7677 while (*p == 'g' || *p == 'j') 7678 { 7679 if (flags != NULL) 7680 { 7681 if (*p == 'g') 7682 *flags |= VGR_GLOBAL; 7683 else 7684 *flags |= VGR_NOJUMP; 7685 } 7686 ++p; 7687 } 7688 } 7689 return p; 7690 } 7691 7692 #if defined(FEAT_EVAL) || defined(PROTO) 7693 /* 7694 * List v:oldfiles in a nice way. 7695 */ 7696 void 7697 ex_oldfiles(exarg_T *eap UNUSED) 7698 { 7699 list_T *l = get_vim_var_list(VV_OLDFILES); 7700 listitem_T *li; 7701 int nr = 0; 7702 char_u *fname; 7703 7704 if (l == NULL) 7705 msg(_("No old files")); 7706 else 7707 { 7708 msg_start(); 7709 msg_scroll = TRUE; 7710 for (li = l->lv_first; li != NULL && !got_int; li = li->li_next) 7711 { 7712 ++nr; 7713 fname = tv_get_string(&li->li_tv); 7714 if (!message_filtered(fname)) 7715 { 7716 msg_outnum((long)nr); 7717 msg_puts(": "); 7718 msg_outtrans(fname); 7719 msg_clr_eos(); 7720 msg_putchar('\n'); 7721 out_flush(); /* output one line at a time */ 7722 ui_breakcheck(); 7723 } 7724 } 7725 7726 /* Assume "got_int" was set to truncate the listing. */ 7727 got_int = FALSE; 7728 7729 # ifdef FEAT_BROWSE_CMD 7730 if (cmdmod.browse) 7731 { 7732 quit_more = FALSE; 7733 nr = prompt_for_number(FALSE); 7734 msg_starthere(); 7735 if (nr > 0) 7736 { 7737 char_u *p = list_find_str(get_vim_var_list(VV_OLDFILES), 7738 (long)nr); 7739 7740 if (p != NULL) 7741 { 7742 p = expand_env_save(p); 7743 eap->arg = p; 7744 eap->cmdidx = CMD_edit; 7745 cmdmod.browse = FALSE; 7746 do_exedit(eap, NULL); 7747 vim_free(p); 7748 } 7749 } 7750 } 7751 # endif 7752 } 7753 } 7754 #endif 7755