1 /* vim:set ts=8 sts=4 sw=4: 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 * diff.c: code for diff'ing two, three or four buffers. 12 */ 13 14 #include "vim.h" 15 16 #if defined(FEAT_DIFF) || defined(PROTO) 17 18 static int diff_busy = FALSE; /* ex_diffgetput() is busy */ 19 20 /* flags obtained from the 'diffopt' option */ 21 #define DIFF_FILLER 1 /* display filler lines */ 22 #define DIFF_ICASE 2 /* ignore case */ 23 #define DIFF_IWHITE 4 /* ignore change in white space */ 24 #define DIFF_HORIZONTAL 8 /* horizontal splits */ 25 #define DIFF_VERTICAL 16 /* vertical splits */ 26 static int diff_flags = DIFF_FILLER; 27 28 #define LBUFLEN 50 /* length of line in diff file */ 29 30 static int diff_a_works = MAYBE; /* TRUE when "diff -a" works, FALSE when it 31 doesn't work, MAYBE when not checked yet */ 32 #if defined(MSWIN) || defined(MSDOS) 33 static int diff_bin_works = MAYBE; /* TRUE when "diff --binary" works, FALSE 34 when it doesn't work, MAYBE when not 35 checked yet */ 36 #endif 37 38 static int diff_buf_idx __ARGS((buf_T *buf)); 39 static int diff_buf_idx_tp __ARGS((buf_T *buf, tabpage_T *tp)); 40 static void diff_mark_adjust_tp __ARGS((tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after)); 41 static void diff_check_unchanged __ARGS((tabpage_T *tp, diff_T *dp)); 42 static int diff_check_sanity __ARGS((tabpage_T *tp, diff_T *dp)); 43 static void diff_redraw __ARGS((int dofold)); 44 static int diff_write __ARGS((buf_T *buf, char_u *fname)); 45 static void diff_file __ARGS((char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff)); 46 static int diff_equal_entry __ARGS((diff_T *dp, int idx1, int idx2)); 47 static int diff_cmp __ARGS((char_u *s1, char_u *s2)); 48 #ifdef FEAT_FOLDING 49 static void diff_fold_update __ARGS((diff_T *dp, int skip_idx)); 50 #endif 51 static void diff_read __ARGS((int idx_orig, int idx_new, char_u *fname)); 52 static void diff_copy_entry __ARGS((diff_T *dprev, diff_T *dp, int idx_orig, int idx_new)); 53 static diff_T *diff_alloc_new __ARGS((tabpage_T *tp, diff_T *dprev, diff_T *dp)); 54 55 #ifndef USE_CR 56 # define tag_fgets vim_fgets 57 #endif 58 59 /* 60 * Called when deleting or unloading a buffer: No longer make a diff with it. 61 */ 62 void 63 diff_buf_delete(buf) 64 buf_T *buf; 65 { 66 int i; 67 tabpage_T *tp; 68 69 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 70 { 71 i = diff_buf_idx_tp(buf, tp); 72 if (i != DB_COUNT) 73 { 74 tp->tp_diffbuf[i] = NULL; 75 tp->tp_diff_invalid = TRUE; 76 if (tp == curtab) 77 diff_redraw(TRUE); 78 } 79 } 80 } 81 82 /* 83 * Check if the current buffer should be added to or removed from the list of 84 * diff buffers. 85 */ 86 void 87 diff_buf_adjust(win) 88 win_T *win; 89 { 90 win_T *wp; 91 int i; 92 93 if (!win->w_p_diff) 94 { 95 /* When there is no window showing a diff for this buffer, remove 96 * it from the diffs. */ 97 for (wp = firstwin; wp != NULL; wp = wp->w_next) 98 if (wp->w_buffer == win->w_buffer && wp->w_p_diff) 99 break; 100 if (wp == NULL) 101 { 102 i = diff_buf_idx(win->w_buffer); 103 if (i != DB_COUNT) 104 { 105 curtab->tp_diffbuf[i] = NULL; 106 curtab->tp_diff_invalid = TRUE; 107 diff_redraw(TRUE); 108 } 109 } 110 } 111 else 112 diff_buf_add(win->w_buffer); 113 } 114 115 /* 116 * Add a buffer to make diffs for. 117 * Call this when a new buffer is being edited in the current window where 118 * 'diff' is set. 119 * Marks the current buffer as being part of the diff and requiring updating. 120 * This must be done before any autocmd, because a command may use info 121 * about the screen contents. 122 */ 123 void 124 diff_buf_add(buf) 125 buf_T *buf; 126 { 127 int i; 128 129 if (diff_buf_idx(buf) != DB_COUNT) 130 return; /* It's already there. */ 131 132 for (i = 0; i < DB_COUNT; ++i) 133 if (curtab->tp_diffbuf[i] == NULL) 134 { 135 curtab->tp_diffbuf[i] = buf; 136 curtab->tp_diff_invalid = TRUE; 137 diff_redraw(TRUE); 138 return; 139 } 140 141 EMSGN(_("E96: Can not diff more than %ld buffers"), DB_COUNT); 142 } 143 144 /* 145 * Find buffer "buf" in the list of diff buffers for the current tab page. 146 * Return its index or DB_COUNT if not found. 147 */ 148 static int 149 diff_buf_idx(buf) 150 buf_T *buf; 151 { 152 int idx; 153 154 for (idx = 0; idx < DB_COUNT; ++idx) 155 if (curtab->tp_diffbuf[idx] == buf) 156 break; 157 return idx; 158 } 159 160 /* 161 * Find buffer "buf" in the list of diff buffers for tab page "tp". 162 * Return its index or DB_COUNT if not found. 163 */ 164 static int 165 diff_buf_idx_tp(buf, tp) 166 buf_T *buf; 167 tabpage_T *tp; 168 { 169 int idx; 170 171 for (idx = 0; idx < DB_COUNT; ++idx) 172 if (tp->tp_diffbuf[idx] == buf) 173 break; 174 return idx; 175 } 176 177 /* 178 * Mark the diff info involving buffer "buf" as invalid, it will be updated 179 * when info is requested. 180 */ 181 void 182 diff_invalidate(buf) 183 buf_T *buf; 184 { 185 tabpage_T *tp; 186 int i; 187 188 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 189 { 190 i = diff_buf_idx_tp(buf, tp); 191 if (i != DB_COUNT) 192 { 193 tp->tp_diff_invalid = TRUE; 194 if (tp == curtab) 195 diff_redraw(TRUE); 196 } 197 } 198 } 199 200 /* 201 * Called by mark_adjust(): update line numbers in "curbuf". 202 */ 203 void 204 diff_mark_adjust(line1, line2, amount, amount_after) 205 linenr_T line1; 206 linenr_T line2; 207 long amount; 208 long amount_after; 209 { 210 int idx; 211 tabpage_T *tp; 212 213 /* Handle all tab pages that use the current buffer in a diff. */ 214 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 215 { 216 idx = diff_buf_idx_tp(curbuf, tp); 217 if (idx != DB_COUNT) 218 diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after); 219 } 220 } 221 222 /* 223 * Update line numbers in tab page "tp" for "curbuf" with index "idx". 224 * This attempts to update the changes as much as possible: 225 * When inserting/deleting lines outside of existing change blocks, create a 226 * new change block and update the line numbers in following blocks. 227 * When inserting/deleting lines in existing change blocks, update them. 228 */ 229 static void 230 diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after) 231 tabpage_T *tp; 232 int idx; 233 linenr_T line1; 234 linenr_T line2; 235 long amount; 236 long amount_after; 237 { 238 diff_T *dp; 239 diff_T *dprev; 240 diff_T *dnext; 241 int i; 242 int inserted, deleted; 243 int n, off; 244 linenr_T last; 245 linenr_T lnum_deleted = line1; /* lnum of remaining deletion */ 246 int check_unchanged; 247 248 if (line2 == MAXLNUM) 249 { 250 /* mark_adjust(99, MAXLNUM, 9, 0): insert lines */ 251 inserted = amount; 252 deleted = 0; 253 } 254 else if (amount_after > 0) 255 { 256 /* mark_adjust(99, 98, MAXLNUM, 9): a change that inserts lines*/ 257 inserted = amount_after; 258 deleted = 0; 259 } 260 else 261 { 262 /* mark_adjust(98, 99, MAXLNUM, -2): delete lines */ 263 inserted = 0; 264 deleted = -amount_after; 265 } 266 267 dprev = NULL; 268 dp = tp->tp_first_diff; 269 for (;;) 270 { 271 /* If the change is after the previous diff block and before the next 272 * diff block, thus not touching an existing change, create a new diff 273 * block. Don't do this when ex_diffgetput() is busy. */ 274 if ((dp == NULL || dp->df_lnum[idx] - 1 > line2 275 || (line2 == MAXLNUM && dp->df_lnum[idx] > line1)) 276 && (dprev == NULL 277 || dprev->df_lnum[idx] + dprev->df_count[idx] < line1) 278 && !diff_busy) 279 { 280 dnext = diff_alloc_new(tp, dprev, dp); 281 if (dnext == NULL) 282 return; 283 284 dnext->df_lnum[idx] = line1; 285 dnext->df_count[idx] = inserted; 286 for (i = 0; i < DB_COUNT; ++i) 287 if (tp->tp_diffbuf[i] != NULL && i != idx) 288 { 289 if (dprev == NULL) 290 dnext->df_lnum[i] = line1; 291 else 292 dnext->df_lnum[i] = line1 293 + (dprev->df_lnum[i] + dprev->df_count[i]) 294 - (dprev->df_lnum[idx] + dprev->df_count[idx]); 295 dnext->df_count[i] = deleted; 296 } 297 } 298 299 /* if at end of the list, quit */ 300 if (dp == NULL) 301 break; 302 303 /* 304 * Check for these situations: 305 * 1 2 3 306 * 1 2 3 307 * line1 2 3 4 5 308 * 2 3 4 5 309 * 2 3 4 5 310 * line2 2 3 4 5 311 * 3 5 6 312 * 3 5 6 313 */ 314 /* compute last line of this change */ 315 last = dp->df_lnum[idx] + dp->df_count[idx] - 1; 316 317 /* 1. change completely above line1: nothing to do */ 318 if (last >= line1 - 1) 319 { 320 /* 6. change below line2: only adjust for amount_after; also when 321 * "deleted" became zero when deleted all lines between two diffs */ 322 if (dp->df_lnum[idx] - (deleted + inserted != 0) > line2) 323 { 324 if (amount_after == 0) 325 break; /* nothing left to change */ 326 dp->df_lnum[idx] += amount_after; 327 } 328 else 329 { 330 check_unchanged = FALSE; 331 332 /* 2. 3. 4. 5.: inserted/deleted lines touching this diff. */ 333 if (deleted > 0) 334 { 335 if (dp->df_lnum[idx] >= line1) 336 { 337 off = dp->df_lnum[idx] - lnum_deleted; 338 if (last <= line2) 339 { 340 /* 4. delete all lines of diff */ 341 if (dp->df_next != NULL 342 && dp->df_next->df_lnum[idx] - 1 <= line2) 343 { 344 /* delete continues in next diff, only do 345 * lines until that one */ 346 n = dp->df_next->df_lnum[idx] - lnum_deleted; 347 deleted -= n; 348 n -= dp->df_count[idx]; 349 lnum_deleted = dp->df_next->df_lnum[idx]; 350 } 351 else 352 n = deleted - dp->df_count[idx]; 353 dp->df_count[idx] = 0; 354 } 355 else 356 { 357 /* 5. delete lines at or just before top of diff */ 358 n = off; 359 dp->df_count[idx] -= line2 - dp->df_lnum[idx] + 1; 360 check_unchanged = TRUE; 361 } 362 dp->df_lnum[idx] = line1; 363 } 364 else 365 { 366 off = 0; 367 if (last < line2) 368 { 369 /* 2. delete at end of of diff */ 370 dp->df_count[idx] -= last - lnum_deleted + 1; 371 if (dp->df_next != NULL 372 && dp->df_next->df_lnum[idx] - 1 <= line2) 373 { 374 /* delete continues in next diff, only do 375 * lines until that one */ 376 n = dp->df_next->df_lnum[idx] - 1 - last; 377 deleted -= dp->df_next->df_lnum[idx] 378 - lnum_deleted; 379 lnum_deleted = dp->df_next->df_lnum[idx]; 380 } 381 else 382 n = line2 - last; 383 check_unchanged = TRUE; 384 } 385 else 386 { 387 /* 3. delete lines inside the diff */ 388 n = 0; 389 dp->df_count[idx] -= deleted; 390 } 391 } 392 393 for (i = 0; i < DB_COUNT; ++i) 394 if (tp->tp_diffbuf[i] != NULL && i != idx) 395 { 396 dp->df_lnum[i] -= off; 397 dp->df_count[i] += n; 398 } 399 } 400 else 401 { 402 if (dp->df_lnum[idx] <= line1) 403 { 404 /* inserted lines somewhere in this diff */ 405 dp->df_count[idx] += inserted; 406 check_unchanged = TRUE; 407 } 408 else 409 /* inserted lines somewhere above this diff */ 410 dp->df_lnum[idx] += inserted; 411 } 412 413 if (check_unchanged) 414 /* Check if inserted lines are equal, may reduce the 415 * size of the diff. TODO: also check for equal lines 416 * in the middle and perhaps split the block. */ 417 diff_check_unchanged(tp, dp); 418 } 419 } 420 421 /* check if this block touches the previous one, may merge them. */ 422 if (dprev != NULL && dprev->df_lnum[idx] + dprev->df_count[idx] 423 == dp->df_lnum[idx]) 424 { 425 for (i = 0; i < DB_COUNT; ++i) 426 if (tp->tp_diffbuf[i] != NULL) 427 dprev->df_count[i] += dp->df_count[i]; 428 dprev->df_next = dp->df_next; 429 vim_free(dp); 430 dp = dprev->df_next; 431 } 432 else 433 { 434 /* Advance to next entry. */ 435 dprev = dp; 436 dp = dp->df_next; 437 } 438 } 439 440 dprev = NULL; 441 dp = tp->tp_first_diff; 442 while (dp != NULL) 443 { 444 /* All counts are zero, remove this entry. */ 445 for (i = 0; i < DB_COUNT; ++i) 446 if (tp->tp_diffbuf[i] != NULL && dp->df_count[i] != 0) 447 break; 448 if (i == DB_COUNT) 449 { 450 dnext = dp->df_next; 451 vim_free(dp); 452 dp = dnext; 453 if (dprev == NULL) 454 tp->tp_first_diff = dnext; 455 else 456 dprev->df_next = dnext; 457 } 458 else 459 { 460 /* Advance to next entry. */ 461 dprev = dp; 462 dp = dp->df_next; 463 } 464 465 } 466 467 if (tp == curtab) 468 { 469 diff_redraw(TRUE); 470 471 /* Need to recompute the scroll binding, may remove or add filler 472 * lines (e.g., when adding lines above w_topline). But it's slow when 473 * making many changes, postpone until redrawing. */ 474 diff_need_scrollbind = TRUE; 475 } 476 } 477 478 /* 479 * Allocate a new diff block and link it between "dprev" and "dp". 480 */ 481 static diff_T * 482 diff_alloc_new(tp, dprev, dp) 483 tabpage_T *tp; 484 diff_T *dprev; 485 diff_T *dp; 486 { 487 diff_T *dnew; 488 489 dnew = (diff_T *)alloc((unsigned)sizeof(diff_T)); 490 if (dnew != NULL) 491 { 492 dnew->df_next = dp; 493 if (dprev == NULL) 494 tp->tp_first_diff = dnew; 495 else 496 dprev->df_next = dnew; 497 } 498 return dnew; 499 } 500 501 /* 502 * Check if the diff block "dp" can be made smaller for lines at the start and 503 * end that are equal. Called after inserting lines. 504 * This may result in a change where all buffers have zero lines, the caller 505 * must take care of removing it. 506 */ 507 static void 508 diff_check_unchanged(tp, dp) 509 tabpage_T *tp; 510 diff_T *dp; 511 { 512 int i_org; 513 int i_new; 514 int off_org, off_new; 515 char_u *line_org; 516 int dir = FORWARD; 517 518 /* Find the first buffers, use it as the original, compare the other 519 * buffer lines against this one. */ 520 for (i_org = 0; i_org < DB_COUNT; ++i_org) 521 if (tp->tp_diffbuf[i_org] != NULL) 522 break; 523 if (i_org == DB_COUNT) /* safety check */ 524 return; 525 526 if (diff_check_sanity(tp, dp) == FAIL) 527 return; 528 529 /* First check lines at the top, then at the bottom. */ 530 off_org = 0; 531 off_new = 0; 532 for (;;) 533 { 534 /* Repeat until a line is found which is different or the number of 535 * lines has become zero. */ 536 while (dp->df_count[i_org] > 0) 537 { 538 /* Copy the line, the next ml_get() will invalidate it. */ 539 if (dir == BACKWARD) 540 off_org = dp->df_count[i_org] - 1; 541 line_org = vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org], 542 dp->df_lnum[i_org] + off_org, FALSE)); 543 if (line_org == NULL) 544 return; 545 for (i_new = i_org + 1; i_new < DB_COUNT; ++i_new) 546 { 547 if (tp->tp_diffbuf[i_new] == NULL) 548 continue; 549 if (dir == BACKWARD) 550 off_new = dp->df_count[i_new] - 1; 551 /* if other buffer doesn't have this line, it was inserted */ 552 if (off_new < 0 || off_new >= dp->df_count[i_new]) 553 break; 554 if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new], 555 dp->df_lnum[i_new] + off_new, FALSE)) != 0) 556 break; 557 } 558 vim_free(line_org); 559 560 /* Stop when a line isn't equal in all diff buffers. */ 561 if (i_new != DB_COUNT) 562 break; 563 564 /* Line matched in all buffers, remove it from the diff. */ 565 for (i_new = i_org; i_new < DB_COUNT; ++i_new) 566 if (tp->tp_diffbuf[i_new] != NULL) 567 { 568 if (dir == FORWARD) 569 ++dp->df_lnum[i_new]; 570 --dp->df_count[i_new]; 571 } 572 } 573 if (dir == BACKWARD) 574 break; 575 dir = BACKWARD; 576 } 577 } 578 579 /* 580 * Check if a diff block doesn't contain invalid line numbers. 581 * This can happen when the diff program returns invalid results. 582 */ 583 static int 584 diff_check_sanity(tp, dp) 585 tabpage_T *tp; 586 diff_T *dp; 587 { 588 int i; 589 590 for (i = 0; i < DB_COUNT; ++i) 591 if (tp->tp_diffbuf[i] != NULL) 592 if (dp->df_lnum[i] + dp->df_count[i] - 1 593 > tp->tp_diffbuf[i]->b_ml.ml_line_count) 594 return FAIL; 595 return OK; 596 } 597 598 /* 599 * Mark all diff buffers in the current tab page for redraw. 600 */ 601 static void 602 diff_redraw(dofold) 603 int dofold; /* also recompute the folds */ 604 { 605 win_T *wp; 606 int n; 607 608 for (wp = firstwin; wp != NULL; wp = wp->w_next) 609 if (wp->w_p_diff) 610 { 611 redraw_win_later(wp, SOME_VALID); 612 #ifdef FEAT_FOLDING 613 if (dofold && foldmethodIsDiff(wp)) 614 foldUpdateAll(wp); 615 #endif 616 /* A change may have made filler lines invalid, need to take care 617 * of that for other windows. */ 618 if (wp != curwin && wp->w_topfill > 0) 619 { 620 n = diff_check(wp, wp->w_topline); 621 if (wp->w_topfill > n) 622 wp->w_topfill = (n < 0 ? 0 : n); 623 } 624 } 625 } 626 627 /* 628 * Write buffer "buf" to file "name". 629 * Always use 'fileformat' set to "unix". 630 * Return FAIL for failure 631 */ 632 static int 633 diff_write(buf, fname) 634 buf_T *buf; 635 char_u *fname; 636 { 637 int r; 638 char_u *save_ff; 639 640 save_ff = buf->b_p_ff; 641 buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); 642 r = buf_write(buf, fname, NULL, (linenr_T)1, buf->b_ml.ml_line_count, 643 NULL, FALSE, FALSE, FALSE, TRUE); 644 free_string_option(buf->b_p_ff); 645 buf->b_p_ff = save_ff; 646 return r; 647 } 648 649 /* 650 * Completely update the diffs for the buffers involved. 651 * This uses the ordinary "diff" command. 652 * The buffers are written to a file, also for unmodified buffers (the file 653 * could have been produced by autocommands, e.g. the netrw plugin). 654 */ 655 void 656 ex_diffupdate(eap) 657 exarg_T *eap UNUSED; /* can be NULL */ 658 { 659 buf_T *buf; 660 int idx_orig; 661 int idx_new; 662 char_u *tmp_orig; 663 char_u *tmp_new; 664 char_u *tmp_diff; 665 FILE *fd; 666 int ok; 667 int io_error = FALSE; 668 669 /* Delete all diffblocks. */ 670 diff_clear(curtab); 671 curtab->tp_diff_invalid = FALSE; 672 673 /* Use the first buffer as the original text. */ 674 for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) 675 if (curtab->tp_diffbuf[idx_orig] != NULL) 676 break; 677 if (idx_orig == DB_COUNT) 678 return; 679 680 /* Only need to do something when there is another buffer. */ 681 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) 682 if (curtab->tp_diffbuf[idx_new] != NULL) 683 break; 684 if (idx_new == DB_COUNT) 685 return; 686 687 /* We need three temp file names. */ 688 tmp_orig = vim_tempname('o'); 689 tmp_new = vim_tempname('n'); 690 tmp_diff = vim_tempname('d'); 691 if (tmp_orig == NULL || tmp_new == NULL || tmp_diff == NULL) 692 goto theend; 693 694 /* 695 * Do a quick test if "diff" really works. Otherwise it looks like there 696 * are no differences. Can't use the return value, it's non-zero when 697 * there are differences. 698 * May try twice, first with "-a" and then without. 699 */ 700 for (;;) 701 { 702 ok = FALSE; 703 fd = mch_fopen((char *)tmp_orig, "w"); 704 if (fd == NULL) 705 io_error = TRUE; 706 else 707 { 708 if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) 709 io_error = TRUE; 710 fclose(fd); 711 fd = mch_fopen((char *)tmp_new, "w"); 712 if (fd == NULL) 713 io_error = TRUE; 714 else 715 { 716 if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) 717 io_error = TRUE; 718 fclose(fd); 719 diff_file(tmp_orig, tmp_new, tmp_diff); 720 fd = mch_fopen((char *)tmp_diff, "r"); 721 if (fd == NULL) 722 io_error = TRUE; 723 else 724 { 725 char_u linebuf[LBUFLEN]; 726 727 for (;;) 728 { 729 /* There must be a line that contains "1c1". */ 730 if (tag_fgets(linebuf, LBUFLEN, fd)) 731 break; 732 if (STRNCMP(linebuf, "1c1", 3) == 0) 733 ok = TRUE; 734 } 735 fclose(fd); 736 } 737 mch_remove(tmp_diff); 738 mch_remove(tmp_new); 739 } 740 mch_remove(tmp_orig); 741 } 742 743 #ifdef FEAT_EVAL 744 /* When using 'diffexpr' break here. */ 745 if (*p_dex != NUL) 746 break; 747 #endif 748 749 #if defined(MSWIN) || defined(MSDOS) 750 /* If the "-a" argument works, also check if "--binary" works. */ 751 if (ok && diff_a_works == MAYBE && diff_bin_works == MAYBE) 752 { 753 diff_a_works = TRUE; 754 diff_bin_works = TRUE; 755 continue; 756 } 757 if (!ok && diff_a_works == TRUE && diff_bin_works == TRUE) 758 { 759 /* Tried --binary, but it failed. "-a" works though. */ 760 diff_bin_works = FALSE; 761 ok = TRUE; 762 } 763 #endif 764 765 /* If we checked if "-a" works already, break here. */ 766 if (diff_a_works != MAYBE) 767 break; 768 diff_a_works = ok; 769 770 /* If "-a" works break here, otherwise retry without "-a". */ 771 if (ok) 772 break; 773 } 774 if (!ok) 775 { 776 if (io_error) 777 EMSG(_("E810: Cannot read or write temp files")); 778 EMSG(_("E97: Cannot create diffs")); 779 diff_a_works = MAYBE; 780 #if defined(MSWIN) || defined(MSDOS) 781 diff_bin_works = MAYBE; 782 #endif 783 goto theend; 784 } 785 786 /* Write the first buffer to a tempfile. */ 787 buf = curtab->tp_diffbuf[idx_orig]; 788 if (diff_write(buf, tmp_orig) == FAIL) 789 goto theend; 790 791 /* Make a difference between the first buffer and every other. */ 792 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) 793 { 794 buf = curtab->tp_diffbuf[idx_new]; 795 if (buf == NULL) 796 continue; 797 if (diff_write(buf, tmp_new) == FAIL) 798 continue; 799 diff_file(tmp_orig, tmp_new, tmp_diff); 800 801 /* Read the diff output and add each entry to the diff list. */ 802 diff_read(idx_orig, idx_new, tmp_diff); 803 mch_remove(tmp_diff); 804 mch_remove(tmp_new); 805 } 806 mch_remove(tmp_orig); 807 808 /* force updating cursor position on screen */ 809 curwin->w_valid_cursor.lnum = 0; 810 811 diff_redraw(TRUE); 812 813 theend: 814 vim_free(tmp_orig); 815 vim_free(tmp_new); 816 vim_free(tmp_diff); 817 } 818 819 /* 820 * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". 821 */ 822 static void 823 diff_file(tmp_orig, tmp_new, tmp_diff) 824 char_u *tmp_orig; 825 char_u *tmp_new; 826 char_u *tmp_diff; 827 { 828 char_u *cmd; 829 size_t len; 830 831 #ifdef FEAT_EVAL 832 if (*p_dex != NUL) 833 /* Use 'diffexpr' to generate the diff file. */ 834 eval_diff(tmp_orig, tmp_new, tmp_diff); 835 else 836 #endif 837 { 838 len = STRLEN(tmp_orig) + STRLEN(tmp_new) 839 + STRLEN(tmp_diff) + STRLEN(p_srr) + 27; 840 cmd = alloc((unsigned)len); 841 if (cmd != NULL) 842 { 843 /* We don't want $DIFF_OPTIONS to get in the way. */ 844 if (getenv("DIFF_OPTIONS")) 845 vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); 846 847 /* Build the diff command and execute it. Always use -a, binary 848 * differences are of no use. Ignore errors, diff returns 849 * non-zero when differences have been found. */ 850 vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s", 851 diff_a_works == FALSE ? "" : "-a ", 852 #if defined(MSWIN) || defined(MSDOS) 853 diff_bin_works == TRUE ? "--binary " : "", 854 #else 855 "", 856 #endif 857 (diff_flags & DIFF_IWHITE) ? "-b " : "", 858 (diff_flags & DIFF_ICASE) ? "-i " : "", 859 tmp_orig, tmp_new); 860 append_redir(cmd, (int)len, p_srr, tmp_diff); 861 #ifdef FEAT_AUTOCMD 862 block_autocmds(); /* Avoid ShellCmdPost stuff */ 863 #endif 864 (void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT); 865 #ifdef FEAT_AUTOCMD 866 unblock_autocmds(); 867 #endif 868 vim_free(cmd); 869 } 870 } 871 } 872 873 /* 874 * Create a new version of a file from the current buffer and a diff file. 875 * The buffer is written to a file, also for unmodified buffers (the file 876 * could have been produced by autocommands, e.g. the netrw plugin). 877 */ 878 void 879 ex_diffpatch(eap) 880 exarg_T *eap; 881 { 882 char_u *tmp_orig; /* name of original temp file */ 883 char_u *tmp_new; /* name of patched temp file */ 884 char_u *buf = NULL; 885 size_t buflen; 886 win_T *old_curwin = curwin; 887 char_u *newname = NULL; /* name of patched file buffer */ 888 #ifdef UNIX 889 char_u dirbuf[MAXPATHL]; 890 char_u *fullname = NULL; 891 #endif 892 #ifdef FEAT_BROWSE 893 char_u *browseFile = NULL; 894 int browse_flag = cmdmod.browse; 895 #endif 896 struct stat st; 897 898 #ifdef FEAT_BROWSE 899 if (cmdmod.browse) 900 { 901 browseFile = do_browse(0, (char_u *)_("Patch file"), 902 eap->arg, NULL, NULL, BROWSE_FILTER_ALL_FILES, NULL); 903 if (browseFile == NULL) 904 return; /* operation cancelled */ 905 eap->arg = browseFile; 906 cmdmod.browse = FALSE; /* don't let do_ecmd() browse again */ 907 } 908 #endif 909 910 /* We need two temp file names. */ 911 tmp_orig = vim_tempname('o'); 912 tmp_new = vim_tempname('n'); 913 if (tmp_orig == NULL || tmp_new == NULL) 914 goto theend; 915 916 /* Write the current buffer to "tmp_orig". */ 917 if (buf_write(curbuf, tmp_orig, NULL, 918 (linenr_T)1, curbuf->b_ml.ml_line_count, 919 NULL, FALSE, FALSE, FALSE, TRUE) == FAIL) 920 goto theend; 921 922 #ifdef UNIX 923 /* Get the absolute path of the patchfile, changing directory below. */ 924 fullname = FullName_save(eap->arg, FALSE); 925 #endif 926 buflen = STRLEN(tmp_orig) + ( 927 # ifdef UNIX 928 fullname != NULL ? STRLEN(fullname) : 929 # endif 930 STRLEN(eap->arg)) + STRLEN(tmp_new) + 16; 931 buf = alloc((unsigned)buflen); 932 if (buf == NULL) 933 goto theend; 934 935 #ifdef UNIX 936 /* Temporarily chdir to /tmp, to avoid patching files in the current 937 * directory when the patch file contains more than one patch. When we 938 * have our own temp dir use that instead, it will be cleaned up when we 939 * exit (any .rej files created). Don't change directory if we can't 940 * return to the current. */ 941 if (mch_dirname(dirbuf, MAXPATHL) != OK || mch_chdir((char *)dirbuf) != 0) 942 dirbuf[0] = NUL; 943 else 944 { 945 # ifdef TEMPDIRNAMES 946 if (vim_tempdir != NULL) 947 ignored = mch_chdir((char *)vim_tempdir); 948 else 949 # endif 950 ignored = mch_chdir("/tmp"); 951 shorten_fnames(TRUE); 952 } 953 #endif 954 955 #ifdef FEAT_EVAL 956 if (*p_pex != NUL) 957 /* Use 'patchexpr' to generate the new file. */ 958 eval_patch(tmp_orig, 959 # ifdef UNIX 960 fullname != NULL ? fullname : 961 # endif 962 eap->arg, tmp_new); 963 else 964 #endif 965 { 966 /* Build the patch command and execute it. Ignore errors. Switch to 967 * cooked mode to allow the user to respond to prompts. */ 968 vim_snprintf((char *)buf, buflen, "patch -o %s %s < \"%s\"", 969 tmp_new, tmp_orig, 970 # ifdef UNIX 971 fullname != NULL ? fullname : 972 # endif 973 eap->arg); 974 #ifdef FEAT_AUTOCMD 975 block_autocmds(); /* Avoid ShellCmdPost stuff */ 976 #endif 977 (void)call_shell(buf, SHELL_FILTER | SHELL_COOKED); 978 #ifdef FEAT_AUTOCMD 979 unblock_autocmds(); 980 #endif 981 } 982 983 #ifdef UNIX 984 if (dirbuf[0] != NUL) 985 { 986 if (mch_chdir((char *)dirbuf) != 0) 987 EMSG(_(e_prev_dir)); 988 shorten_fnames(TRUE); 989 } 990 #endif 991 992 /* patch probably has written over the screen */ 993 redraw_later(CLEAR); 994 995 /* Delete any .orig or .rej file created. */ 996 STRCPY(buf, tmp_new); 997 STRCAT(buf, ".orig"); 998 mch_remove(buf); 999 STRCPY(buf, tmp_new); 1000 STRCAT(buf, ".rej"); 1001 mch_remove(buf); 1002 1003 /* Only continue if the output file was created. */ 1004 if (mch_stat((char *)tmp_new, &st) < 0 || st.st_size == 0) 1005 EMSG(_("E816: Cannot read patch output")); 1006 else 1007 { 1008 if (curbuf->b_fname != NULL) 1009 { 1010 newname = vim_strnsave(curbuf->b_fname, 1011 (int)(STRLEN(curbuf->b_fname) + 4)); 1012 if (newname != NULL) 1013 STRCAT(newname, ".new"); 1014 } 1015 1016 #ifdef FEAT_GUI 1017 need_mouse_correct = TRUE; 1018 #endif 1019 /* don't use a new tab page, each tab page has its own diffs */ 1020 cmdmod.tab = 0; 1021 1022 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) 1023 { 1024 /* Pretend it was a ":split fname" command */ 1025 eap->cmdidx = CMD_split; 1026 eap->arg = tmp_new; 1027 do_exedit(eap, old_curwin); 1028 1029 /* check that split worked and editing tmp_new */ 1030 if (curwin != old_curwin && win_valid(old_curwin)) 1031 { 1032 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1033 diff_win_options(curwin, TRUE); 1034 diff_win_options(old_curwin, TRUE); 1035 1036 if (newname != NULL) 1037 { 1038 /* do a ":file filename.new" on the patched buffer */ 1039 eap->arg = newname; 1040 ex_file(eap); 1041 1042 #ifdef FEAT_AUTOCMD 1043 /* Do filetype detection with the new name. */ 1044 if (au_has_group((char_u *)"filetypedetect")) 1045 do_cmdline_cmd((char_u *)":doau filetypedetect BufRead"); 1046 #endif 1047 } 1048 } 1049 } 1050 } 1051 1052 theend: 1053 if (tmp_orig != NULL) 1054 mch_remove(tmp_orig); 1055 vim_free(tmp_orig); 1056 if (tmp_new != NULL) 1057 mch_remove(tmp_new); 1058 vim_free(tmp_new); 1059 vim_free(newname); 1060 vim_free(buf); 1061 #ifdef UNIX 1062 vim_free(fullname); 1063 #endif 1064 #ifdef FEAT_BROWSE 1065 vim_free(browseFile); 1066 cmdmod.browse = browse_flag; 1067 #endif 1068 } 1069 1070 /* 1071 * Split the window and edit another file, setting options to show the diffs. 1072 */ 1073 void 1074 ex_diffsplit(eap) 1075 exarg_T *eap; 1076 { 1077 win_T *old_curwin = curwin; 1078 1079 #ifdef FEAT_GUI 1080 need_mouse_correct = TRUE; 1081 #endif 1082 /* don't use a new tab page, each tab page has its own diffs */ 1083 cmdmod.tab = 0; 1084 1085 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) 1086 { 1087 /* Pretend it was a ":split fname" command */ 1088 eap->cmdidx = CMD_split; 1089 curwin->w_p_diff = TRUE; 1090 do_exedit(eap, old_curwin); 1091 1092 if (curwin != old_curwin) /* split must have worked */ 1093 { 1094 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1095 diff_win_options(curwin, TRUE); 1096 diff_win_options(old_curwin, TRUE); 1097 } 1098 } 1099 } 1100 1101 /* 1102 * Set options to show difs for the current window. 1103 */ 1104 void 1105 ex_diffthis(eap) 1106 exarg_T *eap UNUSED; 1107 { 1108 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1109 diff_win_options(curwin, TRUE); 1110 } 1111 1112 /* 1113 * Set options in window "wp" for diff mode. 1114 */ 1115 void 1116 diff_win_options(wp, addbuf) 1117 win_T *wp; 1118 int addbuf; /* Add buffer to diff. */ 1119 { 1120 # ifdef FEAT_FOLDING 1121 win_T *old_curwin = curwin; 1122 1123 /* close the manually opened folds */ 1124 curwin = wp; 1125 newFoldLevel(); 1126 curwin = old_curwin; 1127 # endif 1128 1129 wp->w_p_diff = TRUE; 1130 wp->w_p_scb = TRUE; 1131 wp->w_p_wrap = FALSE; 1132 # ifdef FEAT_FOLDING 1133 curwin = wp; 1134 curbuf = curwin->w_buffer; 1135 set_string_option_direct((char_u *)"fdm", -1, (char_u *)"diff", 1136 OPT_LOCAL|OPT_FREE, 0); 1137 curwin = old_curwin; 1138 curbuf = curwin->w_buffer; 1139 wp->w_p_fdc = diff_foldcolumn; 1140 wp->w_p_fen = TRUE; 1141 wp->w_p_fdl = 0; 1142 foldUpdateAll(wp); 1143 /* make sure topline is not halfway a fold */ 1144 changed_window_setting_win(wp); 1145 # endif 1146 #ifdef FEAT_SCROLLBIND 1147 if (vim_strchr(p_sbo, 'h') == NULL) 1148 do_cmdline_cmd((char_u *)"set sbo+=hor"); 1149 #endif 1150 1151 if (addbuf) 1152 diff_buf_add(wp->w_buffer); 1153 redraw_win_later(wp, NOT_VALID); 1154 } 1155 1156 /* 1157 * Set options not to show diffs. For the current window or all windows. 1158 * Only in the current tab page. 1159 */ 1160 void 1161 ex_diffoff(eap) 1162 exarg_T *eap; 1163 { 1164 win_T *wp; 1165 win_T *old_curwin = curwin; 1166 #ifdef FEAT_SCROLLBIND 1167 int diffwin = FALSE; 1168 #endif 1169 1170 for (wp = firstwin; wp != NULL; wp = wp->w_next) 1171 { 1172 if (wp == curwin || (eap->forceit && wp->w_p_diff)) 1173 { 1174 /* Set 'diff', 'scrollbind' off and 'wrap' on. */ 1175 wp->w_p_diff = FALSE; 1176 wp->w_p_scb = FALSE; 1177 wp->w_p_wrap = TRUE; 1178 #ifdef FEAT_FOLDING 1179 curwin = wp; 1180 curbuf = curwin->w_buffer; 1181 set_string_option_direct((char_u *)"fdm", -1, 1182 (char_u *)"manual", OPT_LOCAL|OPT_FREE, 0); 1183 curwin = old_curwin; 1184 curbuf = curwin->w_buffer; 1185 wp->w_p_fdc = 0; 1186 wp->w_p_fen = FALSE; 1187 wp->w_p_fdl = 0; 1188 foldUpdateAll(wp); 1189 /* make sure topline is not halfway a fold */ 1190 changed_window_setting_win(wp); 1191 #endif 1192 diff_buf_adjust(wp); 1193 } 1194 #ifdef FEAT_SCROLLBIND 1195 diffwin |= wp->w_p_diff; 1196 #endif 1197 } 1198 1199 #ifdef FEAT_SCROLLBIND 1200 /* Remove "hor" from from 'scrollopt' if there are no diff windows left. */ 1201 if (!diffwin && vim_strchr(p_sbo, 'h') != NULL) 1202 do_cmdline_cmd((char_u *)"set sbo-=hor"); 1203 #endif 1204 } 1205 1206 /* 1207 * Read the diff output and add each entry to the diff list. 1208 */ 1209 static void 1210 diff_read(idx_orig, idx_new, fname) 1211 int idx_orig; /* idx of original file */ 1212 int idx_new; /* idx of new file */ 1213 char_u *fname; /* name of diff output file */ 1214 { 1215 FILE *fd; 1216 diff_T *dprev = NULL; 1217 diff_T *dp = curtab->tp_first_diff; 1218 diff_T *dn, *dpl; 1219 long f1, l1, f2, l2; 1220 char_u linebuf[LBUFLEN]; /* only need to hold the diff line */ 1221 int difftype; 1222 char_u *p; 1223 long off; 1224 int i; 1225 linenr_T lnum_orig, lnum_new; 1226 long count_orig, count_new; 1227 int notset = TRUE; /* block "*dp" not set yet */ 1228 1229 fd = mch_fopen((char *)fname, "r"); 1230 if (fd == NULL) 1231 { 1232 EMSG(_("E98: Cannot read diff output")); 1233 return; 1234 } 1235 1236 for (;;) 1237 { 1238 if (tag_fgets(linebuf, LBUFLEN, fd)) 1239 break; /* end of file */ 1240 if (!isdigit(*linebuf)) 1241 continue; /* not the start of a diff block */ 1242 1243 /* This line must be one of three formats: 1244 * {first}[,{last}]c{first}[,{last}] 1245 * {first}a{first}[,{last}] 1246 * {first}[,{last}]d{first} 1247 */ 1248 p = linebuf; 1249 f1 = getdigits(&p); 1250 if (*p == ',') 1251 { 1252 ++p; 1253 l1 = getdigits(&p); 1254 } 1255 else 1256 l1 = f1; 1257 if (*p != 'a' && *p != 'c' && *p != 'd') 1258 continue; /* invalid diff format */ 1259 difftype = *p++; 1260 f2 = getdigits(&p); 1261 if (*p == ',') 1262 { 1263 ++p; 1264 l2 = getdigits(&p); 1265 } 1266 else 1267 l2 = f2; 1268 if (l1 < f1 || l2 < f2) 1269 continue; /* invalid line range */ 1270 1271 if (difftype == 'a') 1272 { 1273 lnum_orig = f1 + 1; 1274 count_orig = 0; 1275 } 1276 else 1277 { 1278 lnum_orig = f1; 1279 count_orig = l1 - f1 + 1; 1280 } 1281 if (difftype == 'd') 1282 { 1283 lnum_new = f2 + 1; 1284 count_new = 0; 1285 } 1286 else 1287 { 1288 lnum_new = f2; 1289 count_new = l2 - f2 + 1; 1290 } 1291 1292 /* Go over blocks before the change, for which orig and new are equal. 1293 * Copy blocks from orig to new. */ 1294 while (dp != NULL 1295 && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) 1296 { 1297 if (notset) 1298 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1299 dprev = dp; 1300 dp = dp->df_next; 1301 notset = TRUE; 1302 } 1303 1304 if (dp != NULL 1305 && lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig] 1306 && lnum_orig + count_orig >= dp->df_lnum[idx_orig]) 1307 { 1308 /* New block overlaps with existing block(s). 1309 * First find last block that overlaps. */ 1310 for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) 1311 if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) 1312 break; 1313 1314 /* If the newly found block starts before the old one, set the 1315 * start back a number of lines. */ 1316 off = dp->df_lnum[idx_orig] - lnum_orig; 1317 if (off > 0) 1318 { 1319 for (i = idx_orig; i < idx_new; ++i) 1320 if (curtab->tp_diffbuf[i] != NULL) 1321 dp->df_lnum[i] -= off; 1322 dp->df_lnum[idx_new] = lnum_new; 1323 dp->df_count[idx_new] = count_new; 1324 } 1325 else if (notset) 1326 { 1327 /* new block inside existing one, adjust new block */ 1328 dp->df_lnum[idx_new] = lnum_new + off; 1329 dp->df_count[idx_new] = count_new - off; 1330 } 1331 else 1332 /* second overlap of new block with existing block */ 1333 dp->df_count[idx_new] += count_new - count_orig 1334 + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] 1335 - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); 1336 1337 /* Adjust the size of the block to include all the lines to the 1338 * end of the existing block or the new diff, whatever ends last. */ 1339 off = (lnum_orig + count_orig) 1340 - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); 1341 if (off < 0) 1342 { 1343 /* new change ends in existing block, adjust the end if not 1344 * done already */ 1345 if (notset) 1346 dp->df_count[idx_new] += -off; 1347 off = 0; 1348 } 1349 for (i = idx_orig; i < idx_new; ++i) 1350 if (curtab->tp_diffbuf[i] != NULL) 1351 dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] 1352 - dp->df_lnum[i] + off; 1353 1354 /* Delete the diff blocks that have been merged into one. */ 1355 dn = dp->df_next; 1356 dp->df_next = dpl->df_next; 1357 while (dn != dp->df_next) 1358 { 1359 dpl = dn->df_next; 1360 vim_free(dn); 1361 dn = dpl; 1362 } 1363 } 1364 else 1365 { 1366 /* Allocate a new diffblock. */ 1367 dp = diff_alloc_new(curtab, dprev, dp); 1368 if (dp == NULL) 1369 goto done; 1370 1371 dp->df_lnum[idx_orig] = lnum_orig; 1372 dp->df_count[idx_orig] = count_orig; 1373 dp->df_lnum[idx_new] = lnum_new; 1374 dp->df_count[idx_new] = count_new; 1375 1376 /* Set values for other buffers, these must be equal to the 1377 * original buffer, otherwise there would have been a change 1378 * already. */ 1379 for (i = idx_orig + 1; i < idx_new; ++i) 1380 if (curtab->tp_diffbuf[i] != NULL) 1381 diff_copy_entry(dprev, dp, idx_orig, i); 1382 } 1383 notset = FALSE; /* "*dp" has been set */ 1384 } 1385 1386 /* for remaining diff blocks orig and new are equal */ 1387 while (dp != NULL) 1388 { 1389 if (notset) 1390 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1391 dprev = dp; 1392 dp = dp->df_next; 1393 notset = TRUE; 1394 } 1395 1396 done: 1397 fclose(fd); 1398 } 1399 1400 /* 1401 * Copy an entry at "dp" from "idx_orig" to "idx_new". 1402 */ 1403 static void 1404 diff_copy_entry(dprev, dp, idx_orig, idx_new) 1405 diff_T *dprev; 1406 diff_T *dp; 1407 int idx_orig; 1408 int idx_new; 1409 { 1410 long off; 1411 1412 if (dprev == NULL) 1413 off = 0; 1414 else 1415 off = (dprev->df_lnum[idx_orig] + dprev->df_count[idx_orig]) 1416 - (dprev->df_lnum[idx_new] + dprev->df_count[idx_new]); 1417 dp->df_lnum[idx_new] = dp->df_lnum[idx_orig] - off; 1418 dp->df_count[idx_new] = dp->df_count[idx_orig]; 1419 } 1420 1421 /* 1422 * Clear the list of diffblocks for tab page "tp". 1423 */ 1424 void 1425 diff_clear(tp) 1426 tabpage_T *tp; 1427 { 1428 diff_T *p, *next_p; 1429 1430 for (p = tp->tp_first_diff; p != NULL; p = next_p) 1431 { 1432 next_p = p->df_next; 1433 vim_free(p); 1434 } 1435 tp->tp_first_diff = NULL; 1436 } 1437 1438 /* 1439 * Check diff status for line "lnum" in buffer "buf": 1440 * Returns 0 for nothing special 1441 * Returns -1 for a line that should be highlighted as changed. 1442 * Returns -2 for a line that should be highlighted as added/deleted. 1443 * Returns > 0 for inserting that many filler lines above it (never happens 1444 * when 'diffopt' doesn't contain "filler"). 1445 * This should only be used for windows where 'diff' is set. 1446 */ 1447 int 1448 diff_check(wp, lnum) 1449 win_T *wp; 1450 linenr_T lnum; 1451 { 1452 int idx; /* index in tp_diffbuf[] for this buffer */ 1453 diff_T *dp; 1454 int maxcount; 1455 int i; 1456 buf_T *buf = wp->w_buffer; 1457 int cmp; 1458 1459 if (curtab->tp_diff_invalid) 1460 ex_diffupdate(NULL); /* update after a big change */ 1461 1462 if (curtab->tp_first_diff == NULL || !wp->w_p_diff) /* no diffs at all */ 1463 return 0; 1464 1465 /* safety check: "lnum" must be a buffer line */ 1466 if (lnum < 1 || lnum > buf->b_ml.ml_line_count + 1) 1467 return 0; 1468 1469 idx = diff_buf_idx(buf); 1470 if (idx == DB_COUNT) 1471 return 0; /* no diffs for buffer "buf" */ 1472 1473 #ifdef FEAT_FOLDING 1474 /* A closed fold never has filler lines. */ 1475 if (hasFoldingWin(wp, lnum, NULL, NULL, TRUE, NULL)) 1476 return 0; 1477 #endif 1478 1479 /* search for a change that includes "lnum" in the list of diffblocks. */ 1480 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1481 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1482 break; 1483 if (dp == NULL || lnum < dp->df_lnum[idx]) 1484 return 0; 1485 1486 if (lnum < dp->df_lnum[idx] + dp->df_count[idx]) 1487 { 1488 int zero = FALSE; 1489 1490 /* Changed or inserted line. If the other buffers have a count of 1491 * zero, the lines were inserted. If the other buffers have the same 1492 * count, check if the lines are identical. */ 1493 cmp = FALSE; 1494 for (i = 0; i < DB_COUNT; ++i) 1495 if (i != idx && curtab->tp_diffbuf[i] != NULL) 1496 { 1497 if (dp->df_count[i] == 0) 1498 zero = TRUE; 1499 else 1500 { 1501 if (dp->df_count[i] != dp->df_count[idx]) 1502 return -1; /* nr of lines changed. */ 1503 cmp = TRUE; 1504 } 1505 } 1506 if (cmp) 1507 { 1508 /* Compare all lines. If they are equal the lines were inserted 1509 * in some buffers, deleted in others, but not changed. */ 1510 for (i = 0; i < DB_COUNT; ++i) 1511 if (i != idx && curtab->tp_diffbuf[i] != NULL && dp->df_count[i] != 0) 1512 if (!diff_equal_entry(dp, idx, i)) 1513 return -1; 1514 } 1515 /* If there is no buffer with zero lines then there is no difference 1516 * any longer. Happens when making a change (or undo) that removes 1517 * the difference. Can't remove the entry here, we might be halfway 1518 * updating the window. Just report the text as unchanged. Other 1519 * windows might still show the change though. */ 1520 if (zero == FALSE) 1521 return 0; 1522 return -2; 1523 } 1524 1525 /* If 'diffopt' doesn't contain "filler", return 0. */ 1526 if (!(diff_flags & DIFF_FILLER)) 1527 return 0; 1528 1529 /* Insert filler lines above the line just below the change. Will return 1530 * 0 when this buf had the max count. */ 1531 maxcount = 0; 1532 for (i = 0; i < DB_COUNT; ++i) 1533 if (curtab->tp_diffbuf[i] != NULL && dp->df_count[i] > maxcount) 1534 maxcount = dp->df_count[i]; 1535 return maxcount - dp->df_count[idx]; 1536 } 1537 1538 /* 1539 * Compare two entries in diff "*dp" and return TRUE if they are equal. 1540 */ 1541 static int 1542 diff_equal_entry(dp, idx1, idx2) 1543 diff_T *dp; 1544 int idx1; 1545 int idx2; 1546 { 1547 int i; 1548 char_u *line; 1549 int cmp; 1550 1551 if (dp->df_count[idx1] != dp->df_count[idx2]) 1552 return FALSE; 1553 if (diff_check_sanity(curtab, dp) == FAIL) 1554 return FALSE; 1555 for (i = 0; i < dp->df_count[idx1]; ++i) 1556 { 1557 line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1], 1558 dp->df_lnum[idx1] + i, FALSE)); 1559 if (line == NULL) 1560 return FALSE; 1561 cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2], 1562 dp->df_lnum[idx2] + i, FALSE)); 1563 vim_free(line); 1564 if (cmp != 0) 1565 return FALSE; 1566 } 1567 return TRUE; 1568 } 1569 1570 /* 1571 * Compare strings "s1" and "s2" according to 'diffopt'. 1572 * Return non-zero when they are different. 1573 */ 1574 static int 1575 diff_cmp(s1, s2) 1576 char_u *s1; 1577 char_u *s2; 1578 { 1579 char_u *p1, *p2; 1580 #ifdef FEAT_MBYTE 1581 int l; 1582 #endif 1583 1584 if ((diff_flags & (DIFF_ICASE | DIFF_IWHITE)) == 0) 1585 return STRCMP(s1, s2); 1586 if ((diff_flags & DIFF_ICASE) && !(diff_flags & DIFF_IWHITE)) 1587 return MB_STRICMP(s1, s2); 1588 1589 /* Ignore white space changes and possibly ignore case. */ 1590 p1 = s1; 1591 p2 = s2; 1592 while (*p1 != NUL && *p2 != NUL) 1593 { 1594 if (vim_iswhite(*p1) && vim_iswhite(*p2)) 1595 { 1596 p1 = skipwhite(p1); 1597 p2 = skipwhite(p2); 1598 } 1599 else 1600 { 1601 #ifdef FEAT_MBYTE 1602 l = (*mb_ptr2len)(p1); 1603 if (l != (*mb_ptr2len)(p2)) 1604 break; 1605 if (l > 1) 1606 { 1607 if (STRNCMP(p1, p2, l) != 0 1608 && (!enc_utf8 1609 || !(diff_flags & DIFF_ICASE) 1610 || utf_fold(utf_ptr2char(p1)) 1611 != utf_fold(utf_ptr2char(p2)))) 1612 break; 1613 p1 += l; 1614 p2 += l; 1615 } 1616 else 1617 #endif 1618 { 1619 if (*p1 != *p2 && (!(diff_flags & DIFF_ICASE) 1620 || TOLOWER_LOC(*p1) != TOLOWER_LOC(*p2))) 1621 break; 1622 ++p1; 1623 ++p2; 1624 } 1625 } 1626 } 1627 1628 /* Ignore trailing white space. */ 1629 p1 = skipwhite(p1); 1630 p2 = skipwhite(p2); 1631 if (*p1 != NUL || *p2 != NUL) 1632 return 1; 1633 return 0; 1634 } 1635 1636 /* 1637 * Return the number of filler lines above "lnum". 1638 */ 1639 int 1640 diff_check_fill(wp, lnum) 1641 win_T *wp; 1642 linenr_T lnum; 1643 { 1644 int n; 1645 1646 /* be quick when there are no filler lines */ 1647 if (!(diff_flags & DIFF_FILLER)) 1648 return 0; 1649 n = diff_check(wp, lnum); 1650 if (n <= 0) 1651 return 0; 1652 return n; 1653 } 1654 1655 /* 1656 * Set the topline of "towin" to match the position in "fromwin", so that they 1657 * show the same diff'ed lines. 1658 */ 1659 void 1660 diff_set_topline(fromwin, towin) 1661 win_T *fromwin; 1662 win_T *towin; 1663 { 1664 buf_T *frombuf = fromwin->w_buffer; 1665 linenr_T lnum = fromwin->w_topline; 1666 int fromidx; 1667 int toidx; 1668 diff_T *dp; 1669 int max_count; 1670 int i; 1671 1672 fromidx = diff_buf_idx(frombuf); 1673 if (fromidx == DB_COUNT) 1674 return; /* safety check */ 1675 1676 if (curtab->tp_diff_invalid) 1677 ex_diffupdate(NULL); /* update after a big change */ 1678 1679 towin->w_topfill = 0; 1680 1681 /* search for a change that includes "lnum" in the list of diffblocks. */ 1682 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1683 if (lnum <= dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1684 break; 1685 if (dp == NULL) 1686 { 1687 /* After last change, compute topline relative to end of file; no 1688 * filler lines. */ 1689 towin->w_topline = towin->w_buffer->b_ml.ml_line_count 1690 - (frombuf->b_ml.ml_line_count - lnum); 1691 } 1692 else 1693 { 1694 /* Find index for "towin". */ 1695 toidx = diff_buf_idx(towin->w_buffer); 1696 if (toidx == DB_COUNT) 1697 return; /* safety check */ 1698 1699 towin->w_topline = lnum + (dp->df_lnum[toidx] - dp->df_lnum[fromidx]); 1700 if (lnum >= dp->df_lnum[fromidx]) 1701 { 1702 /* Inside a change: compute filler lines. With three or more 1703 * buffers we need to know the largest count. */ 1704 max_count = 0; 1705 for (i = 0; i < DB_COUNT; ++i) 1706 if (curtab->tp_diffbuf[i] != NULL 1707 && max_count < dp->df_count[i]) 1708 max_count = dp->df_count[i]; 1709 1710 if (dp->df_count[toidx] == dp->df_count[fromidx]) 1711 { 1712 /* same number of lines: use same filler count */ 1713 towin->w_topfill = fromwin->w_topfill; 1714 } 1715 else if (dp->df_count[toidx] > dp->df_count[fromidx]) 1716 { 1717 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1718 { 1719 /* more lines in towin and fromwin doesn't show diff 1720 * lines, only filler lines */ 1721 if (max_count - fromwin->w_topfill >= dp->df_count[toidx]) 1722 { 1723 /* towin also only shows filler lines */ 1724 towin->w_topline = dp->df_lnum[toidx] 1725 + dp->df_count[toidx]; 1726 towin->w_topfill = fromwin->w_topfill; 1727 } 1728 else 1729 /* towin still has some diff lines to show */ 1730 towin->w_topline = dp->df_lnum[toidx] 1731 + max_count - fromwin->w_topfill; 1732 } 1733 } 1734 else if (towin->w_topline >= dp->df_lnum[toidx] 1735 + dp->df_count[toidx]) 1736 { 1737 /* less lines in towin and no diff lines to show: compute 1738 * filler lines */ 1739 towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; 1740 if (diff_flags & DIFF_FILLER) 1741 { 1742 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1743 /* fromwin is also out of diff lines */ 1744 towin->w_topfill = fromwin->w_topfill; 1745 else 1746 /* fromwin has some diff lines */ 1747 towin->w_topfill = dp->df_lnum[fromidx] 1748 + max_count - lnum; 1749 } 1750 } 1751 } 1752 } 1753 1754 /* safety check (if diff info gets outdated strange things may happen) */ 1755 towin->w_botfill = FALSE; 1756 if (towin->w_topline > towin->w_buffer->b_ml.ml_line_count) 1757 { 1758 towin->w_topline = towin->w_buffer->b_ml.ml_line_count; 1759 towin->w_botfill = TRUE; 1760 } 1761 if (towin->w_topline < 1) 1762 { 1763 towin->w_topline = 1; 1764 towin->w_topfill = 0; 1765 } 1766 1767 /* When w_topline changes need to recompute w_botline and cursor position */ 1768 invalidate_botline_win(towin); 1769 changed_line_abv_curs_win(towin); 1770 1771 check_topfill(towin, FALSE); 1772 #ifdef FEAT_FOLDING 1773 (void)hasFoldingWin(towin, towin->w_topline, &towin->w_topline, 1774 NULL, TRUE, NULL); 1775 #endif 1776 } 1777 1778 /* 1779 * This is called when 'diffopt' is changed. 1780 */ 1781 int 1782 diffopt_changed() 1783 { 1784 char_u *p; 1785 int diff_context_new = 6; 1786 int diff_flags_new = 0; 1787 int diff_foldcolumn_new = 2; 1788 tabpage_T *tp; 1789 1790 p = p_dip; 1791 while (*p != NUL) 1792 { 1793 if (STRNCMP(p, "filler", 6) == 0) 1794 { 1795 p += 6; 1796 diff_flags_new |= DIFF_FILLER; 1797 } 1798 else if (STRNCMP(p, "context:", 8) == 0 && VIM_ISDIGIT(p[8])) 1799 { 1800 p += 8; 1801 diff_context_new = getdigits(&p); 1802 } 1803 else if (STRNCMP(p, "icase", 5) == 0) 1804 { 1805 p += 5; 1806 diff_flags_new |= DIFF_ICASE; 1807 } 1808 else if (STRNCMP(p, "iwhite", 6) == 0) 1809 { 1810 p += 6; 1811 diff_flags_new |= DIFF_IWHITE; 1812 } 1813 else if (STRNCMP(p, "horizontal", 10) == 0) 1814 { 1815 p += 10; 1816 diff_flags_new |= DIFF_HORIZONTAL; 1817 } 1818 else if (STRNCMP(p, "vertical", 8) == 0) 1819 { 1820 p += 8; 1821 diff_flags_new |= DIFF_VERTICAL; 1822 } 1823 else if (STRNCMP(p, "foldcolumn:", 11) == 0 && VIM_ISDIGIT(p[11])) 1824 { 1825 p += 11; 1826 diff_foldcolumn_new = getdigits(&p); 1827 } 1828 if (*p != ',' && *p != NUL) 1829 return FAIL; 1830 if (*p == ',') 1831 ++p; 1832 } 1833 1834 /* Can't have both "horizontal" and "vertical". */ 1835 if ((diff_flags_new & DIFF_HORIZONTAL) && (diff_flags_new & DIFF_VERTICAL)) 1836 return FAIL; 1837 1838 /* If "icase" or "iwhite" was added or removed, need to update the diff. */ 1839 if (diff_flags != diff_flags_new) 1840 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 1841 tp->tp_diff_invalid = TRUE; 1842 1843 diff_flags = diff_flags_new; 1844 diff_context = diff_context_new; 1845 diff_foldcolumn = diff_foldcolumn_new; 1846 1847 diff_redraw(TRUE); 1848 1849 /* recompute the scroll binding with the new option value, may 1850 * remove or add filler lines */ 1851 check_scrollbind((linenr_T)0, 0L); 1852 1853 return OK; 1854 } 1855 1856 /* 1857 * Return TRUE if 'diffopt' contains "horizontal". 1858 */ 1859 int 1860 diffopt_horizontal() 1861 { 1862 return (diff_flags & DIFF_HORIZONTAL) != 0; 1863 } 1864 1865 /* 1866 * Find the difference within a changed line. 1867 * Returns TRUE if the line was added, no other buffer has it. 1868 */ 1869 int 1870 diff_find_change(wp, lnum, startp, endp) 1871 win_T *wp; 1872 linenr_T lnum; 1873 int *startp; /* first char of the change */ 1874 int *endp; /* last char of the change */ 1875 { 1876 char_u *line_org; 1877 char_u *line_new; 1878 int i; 1879 int si_org, si_new; 1880 int ei_org, ei_new; 1881 diff_T *dp; 1882 int idx; 1883 int off; 1884 int added = TRUE; 1885 1886 /* Make a copy of the line, the next ml_get() will invalidate it. */ 1887 line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE)); 1888 if (line_org == NULL) 1889 return FALSE; 1890 1891 idx = diff_buf_idx(wp->w_buffer); 1892 if (idx == DB_COUNT) /* cannot happen */ 1893 { 1894 vim_free(line_org); 1895 return FALSE; 1896 } 1897 1898 /* search for a change that includes "lnum" in the list of diffblocks. */ 1899 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1900 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1901 break; 1902 if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL) 1903 { 1904 vim_free(line_org); 1905 return FALSE; 1906 } 1907 1908 off = lnum - dp->df_lnum[idx]; 1909 1910 for (i = 0; i < DB_COUNT; ++i) 1911 if (curtab->tp_diffbuf[i] != NULL && i != idx) 1912 { 1913 /* Skip lines that are not in the other change (filler lines). */ 1914 if (off >= dp->df_count[i]) 1915 continue; 1916 added = FALSE; 1917 line_new = ml_get_buf(curtab->tp_diffbuf[i], 1918 dp->df_lnum[i] + off, FALSE); 1919 1920 /* Search for start of difference */ 1921 si_org = si_new = 0; 1922 while (line_org[si_org] != NUL) 1923 { 1924 if ((diff_flags & DIFF_IWHITE) 1925 && vim_iswhite(line_org[si_org]) 1926 && vim_iswhite(line_new[si_new])) 1927 { 1928 si_org = (int)(skipwhite(line_org + si_org) - line_org); 1929 si_new = (int)(skipwhite(line_new + si_new) - line_new); 1930 } 1931 else 1932 { 1933 if (line_org[si_org] != line_new[si_new]) 1934 break; 1935 ++si_org; 1936 ++si_new; 1937 } 1938 } 1939 #ifdef FEAT_MBYTE 1940 if (has_mbyte) 1941 { 1942 /* Move back to first byte of character in both lines (may 1943 * have "nn^" in line_org and "n^ in line_new). */ 1944 si_org -= (*mb_head_off)(line_org, line_org + si_org); 1945 si_new -= (*mb_head_off)(line_new, line_new + si_new); 1946 } 1947 #endif 1948 if (*startp > si_org) 1949 *startp = si_org; 1950 1951 /* Search for end of difference, if any. */ 1952 if (line_org[si_org] != NUL || line_new[si_new] != NUL) 1953 { 1954 ei_org = (int)STRLEN(line_org); 1955 ei_new = (int)STRLEN(line_new); 1956 while (ei_org >= *startp && ei_new >= si_new 1957 && ei_org >= 0 && ei_new >= 0) 1958 { 1959 if ((diff_flags & DIFF_IWHITE) 1960 && vim_iswhite(line_org[ei_org]) 1961 && vim_iswhite(line_new[ei_new])) 1962 { 1963 while (ei_org >= *startp 1964 && vim_iswhite(line_org[ei_org])) 1965 --ei_org; 1966 while (ei_new >= si_new 1967 && vim_iswhite(line_new[ei_new])) 1968 --ei_new; 1969 } 1970 else 1971 { 1972 if (line_org[ei_org] != line_new[ei_new]) 1973 break; 1974 --ei_org; 1975 --ei_new; 1976 } 1977 } 1978 if (*endp < ei_org) 1979 *endp = ei_org; 1980 } 1981 } 1982 1983 vim_free(line_org); 1984 return added; 1985 } 1986 1987 #if defined(FEAT_FOLDING) || defined(PROTO) 1988 /* 1989 * Return TRUE if line "lnum" is not close to a diff block, this line should 1990 * be in a fold. 1991 * Return FALSE if there are no diff blocks at all in this window. 1992 */ 1993 int 1994 diff_infold(wp, lnum) 1995 win_T *wp; 1996 linenr_T lnum; 1997 { 1998 int i; 1999 int idx = -1; 2000 int other = FALSE; 2001 diff_T *dp; 2002 2003 /* Return if 'diff' isn't set. */ 2004 if (!wp->w_p_diff) 2005 return FALSE; 2006 2007 for (i = 0; i < DB_COUNT; ++i) 2008 { 2009 if (curtab->tp_diffbuf[i] == wp->w_buffer) 2010 idx = i; 2011 else if (curtab->tp_diffbuf[i] != NULL) 2012 other = TRUE; 2013 } 2014 2015 /* return here if there are no diffs in the window */ 2016 if (idx == -1 || !other) 2017 return FALSE; 2018 2019 if (curtab->tp_diff_invalid) 2020 ex_diffupdate(NULL); /* update after a big change */ 2021 2022 /* Return if there are no diff blocks. All lines will be folded. */ 2023 if (curtab->tp_first_diff == NULL) 2024 return TRUE; 2025 2026 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2027 { 2028 /* If this change is below the line there can't be any further match. */ 2029 if (dp->df_lnum[idx] - diff_context > lnum) 2030 break; 2031 /* If this change ends before the line we have a match. */ 2032 if (dp->df_lnum[idx] + dp->df_count[idx] + diff_context > lnum) 2033 return FALSE; 2034 } 2035 return TRUE; 2036 } 2037 #endif 2038 2039 /* 2040 * "dp" and "do" commands. 2041 */ 2042 void 2043 nv_diffgetput(put) 2044 int put; 2045 { 2046 exarg_T ea; 2047 2048 ea.arg = (char_u *)""; 2049 if (put) 2050 ea.cmdidx = CMD_diffput; 2051 else 2052 ea.cmdidx = CMD_diffget; 2053 ea.addr_count = 0; 2054 ea.line1 = curwin->w_cursor.lnum; 2055 ea.line2 = curwin->w_cursor.lnum; 2056 ex_diffgetput(&ea); 2057 } 2058 2059 /* 2060 * ":diffget" 2061 * ":diffput" 2062 */ 2063 void 2064 ex_diffgetput(eap) 2065 exarg_T *eap; 2066 { 2067 linenr_T lnum; 2068 int count; 2069 linenr_T off = 0; 2070 diff_T *dp; 2071 diff_T *dprev; 2072 diff_T *dfree; 2073 int idx_cur; 2074 int idx_other; 2075 int idx_from; 2076 int idx_to; 2077 int i; 2078 int added; 2079 char_u *p; 2080 aco_save_T aco; 2081 buf_T *buf; 2082 int start_skip, end_skip; 2083 int new_count; 2084 int buf_empty; 2085 int found_not_ma = FALSE; 2086 2087 /* Find the current buffer in the list of diff buffers. */ 2088 idx_cur = diff_buf_idx(curbuf); 2089 if (idx_cur == DB_COUNT) 2090 { 2091 EMSG(_("E99: Current buffer is not in diff mode")); 2092 return; 2093 } 2094 2095 if (*eap->arg == NUL) 2096 { 2097 /* No argument: Find the other buffer in the list of diff buffers. */ 2098 for (idx_other = 0; idx_other < DB_COUNT; ++idx_other) 2099 if (curtab->tp_diffbuf[idx_other] != curbuf 2100 && curtab->tp_diffbuf[idx_other] != NULL) 2101 { 2102 if (eap->cmdidx != CMD_diffput 2103 || curtab->tp_diffbuf[idx_other]->b_p_ma) 2104 break; 2105 found_not_ma = TRUE; 2106 } 2107 if (idx_other == DB_COUNT) 2108 { 2109 if (found_not_ma) 2110 EMSG(_("E793: No other buffer in diff mode is modifiable")); 2111 else 2112 EMSG(_("E100: No other buffer in diff mode")); 2113 return; 2114 } 2115 2116 /* Check that there isn't a third buffer in the list */ 2117 for (i = idx_other + 1; i < DB_COUNT; ++i) 2118 if (curtab->tp_diffbuf[i] != curbuf 2119 && curtab->tp_diffbuf[i] != NULL 2120 && (eap->cmdidx != CMD_diffput || curtab->tp_diffbuf[i]->b_p_ma)) 2121 { 2122 EMSG(_("E101: More than two buffers in diff mode, don't know which one to use")); 2123 return; 2124 } 2125 } 2126 else 2127 { 2128 /* Buffer number or pattern given. Ignore trailing white space. */ 2129 p = eap->arg + STRLEN(eap->arg); 2130 while (p > eap->arg && vim_iswhite(p[-1])) 2131 --p; 2132 for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i) 2133 ; 2134 if (eap->arg + i == p) /* digits only */ 2135 i = atol((char *)eap->arg); 2136 else 2137 { 2138 i = buflist_findpat(eap->arg, p, FALSE, TRUE); 2139 if (i < 0) 2140 return; /* error message already given */ 2141 } 2142 buf = buflist_findnr(i); 2143 if (buf == NULL) 2144 { 2145 EMSG2(_("E102: Can't find buffer \"%s\""), eap->arg); 2146 return; 2147 } 2148 if (buf == curbuf) 2149 return; /* nothing to do */ 2150 idx_other = diff_buf_idx(buf); 2151 if (idx_other == DB_COUNT) 2152 { 2153 EMSG2(_("E103: Buffer \"%s\" is not in diff mode"), eap->arg); 2154 return; 2155 } 2156 } 2157 2158 diff_busy = TRUE; 2159 2160 /* When no range given include the line above or below the cursor. */ 2161 if (eap->addr_count == 0) 2162 { 2163 /* Make it possible that ":diffget" on the last line gets line below 2164 * the cursor line when there is no difference above the cursor. */ 2165 if (eap->cmdidx == CMD_diffget 2166 && eap->line1 == curbuf->b_ml.ml_line_count 2167 && diff_check(curwin, eap->line1) == 0 2168 && (eap->line1 == 1 || diff_check(curwin, eap->line1 - 1) == 0)) 2169 ++eap->line2; 2170 else if (eap->line1 > 0) 2171 --eap->line1; 2172 } 2173 2174 if (eap->cmdidx == CMD_diffget) 2175 { 2176 idx_from = idx_other; 2177 idx_to = idx_cur; 2178 } 2179 else 2180 { 2181 idx_from = idx_cur; 2182 idx_to = idx_other; 2183 /* Need to make the other buffer the current buffer to be able to make 2184 * changes in it. */ 2185 /* set curwin/curbuf to buf and save a few things */ 2186 aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]); 2187 } 2188 2189 /* May give the warning for a changed buffer here, which can trigger the 2190 * FileChangedRO autocommand, which may do nasty things and mess 2191 * everything up. */ 2192 if (!curbuf->b_changed) 2193 { 2194 change_warning(0); 2195 if (diff_buf_idx(curbuf) != idx_to) 2196 { 2197 EMSG(_("E787: Buffer changed unexpectedly")); 2198 return; 2199 } 2200 } 2201 2202 dprev = NULL; 2203 for (dp = curtab->tp_first_diff; dp != NULL; ) 2204 { 2205 if (dp->df_lnum[idx_cur] > eap->line2 + off) 2206 break; /* past the range that was specified */ 2207 2208 dfree = NULL; 2209 lnum = dp->df_lnum[idx_to]; 2210 count = dp->df_count[idx_to]; 2211 if (dp->df_lnum[idx_cur] + dp->df_count[idx_cur] > eap->line1 + off 2212 && u_save(lnum - 1, lnum + count) != FAIL) 2213 { 2214 /* Inside the specified range and saving for undo worked. */ 2215 start_skip = 0; 2216 end_skip = 0; 2217 if (eap->addr_count > 0) 2218 { 2219 /* A range was specified: check if lines need to be skipped. */ 2220 start_skip = eap->line1 + off - dp->df_lnum[idx_cur]; 2221 if (start_skip > 0) 2222 { 2223 /* range starts below start of current diff block */ 2224 if (start_skip > count) 2225 { 2226 lnum += count; 2227 count = 0; 2228 } 2229 else 2230 { 2231 count -= start_skip; 2232 lnum += start_skip; 2233 } 2234 } 2235 else 2236 start_skip = 0; 2237 2238 end_skip = dp->df_lnum[idx_cur] + dp->df_count[idx_cur] - 1 2239 - (eap->line2 + off); 2240 if (end_skip > 0) 2241 { 2242 /* range ends above end of current/from diff block */ 2243 if (idx_cur == idx_from) /* :diffput */ 2244 { 2245 i = dp->df_count[idx_cur] - start_skip - end_skip; 2246 if (count > i) 2247 count = i; 2248 } 2249 else /* :diffget */ 2250 { 2251 count -= end_skip; 2252 end_skip = dp->df_count[idx_from] - start_skip - count; 2253 if (end_skip < 0) 2254 end_skip = 0; 2255 } 2256 } 2257 else 2258 end_skip = 0; 2259 } 2260 2261 buf_empty = FALSE; 2262 added = 0; 2263 for (i = 0; i < count; ++i) 2264 { 2265 /* remember deleting the last line of the buffer */ 2266 buf_empty = curbuf->b_ml.ml_line_count == 1; 2267 ml_delete(lnum, FALSE); 2268 --added; 2269 } 2270 for (i = 0; i < dp->df_count[idx_from] - start_skip - end_skip; ++i) 2271 { 2272 linenr_T nr; 2273 2274 nr = dp->df_lnum[idx_from] + start_skip + i; 2275 if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) 2276 break; 2277 p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], 2278 nr, FALSE)); 2279 if (p != NULL) 2280 { 2281 ml_append(lnum + i - 1, p, 0, FALSE); 2282 vim_free(p); 2283 ++added; 2284 if (buf_empty && curbuf->b_ml.ml_line_count == 2) 2285 { 2286 /* Added the first line into an empty buffer, need to 2287 * delete the dummy empty line. */ 2288 buf_empty = FALSE; 2289 ml_delete((linenr_T)2, FALSE); 2290 } 2291 } 2292 } 2293 new_count = dp->df_count[idx_to] + added; 2294 dp->df_count[idx_to] = new_count; 2295 2296 if (start_skip == 0 && end_skip == 0) 2297 { 2298 /* Check if there are any other buffers and if the diff is 2299 * equal in them. */ 2300 for (i = 0; i < DB_COUNT; ++i) 2301 if (curtab->tp_diffbuf[i] != NULL && i != idx_from 2302 && i != idx_to 2303 && !diff_equal_entry(dp, idx_from, i)) 2304 break; 2305 if (i == DB_COUNT) 2306 { 2307 /* delete the diff entry, the buffers are now equal here */ 2308 dfree = dp; 2309 dp = dp->df_next; 2310 if (dprev == NULL) 2311 curtab->tp_first_diff = dp; 2312 else 2313 dprev->df_next = dp; 2314 } 2315 } 2316 2317 /* Adjust marks. This will change the following entries! */ 2318 if (added != 0) 2319 { 2320 mark_adjust(lnum, lnum + count - 1, (long)MAXLNUM, (long)added); 2321 if (curwin->w_cursor.lnum >= lnum) 2322 { 2323 /* Adjust the cursor position if it's in/after the changed 2324 * lines. */ 2325 if (curwin->w_cursor.lnum >= lnum + count) 2326 curwin->w_cursor.lnum += added; 2327 else if (added < 0) 2328 curwin->w_cursor.lnum = lnum; 2329 } 2330 } 2331 changed_lines(lnum, 0, lnum + count, (long)added); 2332 2333 if (dfree != NULL) 2334 { 2335 /* Diff is deleted, update folds in other windows. */ 2336 #ifdef FEAT_FOLDING 2337 diff_fold_update(dfree, idx_to); 2338 #endif 2339 vim_free(dfree); 2340 } 2341 else 2342 /* mark_adjust() may have changed the count in a wrong way */ 2343 dp->df_count[idx_to] = new_count; 2344 2345 /* When changing the current buffer, keep track of line numbers */ 2346 if (idx_cur == idx_to) 2347 off += added; 2348 } 2349 2350 /* If before the range or not deleted, go to next diff. */ 2351 if (dfree == NULL) 2352 { 2353 dprev = dp; 2354 dp = dp->df_next; 2355 } 2356 } 2357 2358 /* restore curwin/curbuf and a few other things */ 2359 if (idx_other == idx_to) 2360 { 2361 /* Syncing undo only works for the current buffer, but we change 2362 * another buffer. Sync undo if the command was typed. This isn't 2363 * 100% right when ":diffput" is used in a function or mapping. */ 2364 if (KeyTyped) 2365 u_sync(FALSE); 2366 aucmd_restbuf(&aco); 2367 } 2368 2369 diff_busy = FALSE; 2370 2371 /* Check that the cursor is on a valid character and update it's position. 2372 * When there were filler lines the topline has become invalid. */ 2373 check_cursor(); 2374 changed_line_abv_curs(); 2375 2376 /* Also need to redraw the other buffers. */ 2377 diff_redraw(FALSE); 2378 } 2379 2380 #ifdef FEAT_FOLDING 2381 /* 2382 * Update folds for all diff buffers for entry "dp". 2383 * Skip buffer with index "skip_idx". 2384 * When there are no diffs, all folds are removed. 2385 */ 2386 static void 2387 diff_fold_update(dp, skip_idx) 2388 diff_T *dp; 2389 int skip_idx; 2390 { 2391 int i; 2392 win_T *wp; 2393 2394 for (wp = firstwin; wp != NULL; wp = wp->w_next) 2395 for (i = 0; i < DB_COUNT; ++i) 2396 if (curtab->tp_diffbuf[i] == wp->w_buffer && i != skip_idx) 2397 foldUpdate(wp, dp->df_lnum[i], 2398 dp->df_lnum[i] + dp->df_count[i]); 2399 } 2400 #endif 2401 2402 /* 2403 * Return TRUE if buffer "buf" is in diff-mode. 2404 */ 2405 int 2406 diff_mode_buf(buf) 2407 buf_T *buf; 2408 { 2409 tabpage_T *tp; 2410 2411 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 2412 if (diff_buf_idx_tp(buf, tp) != DB_COUNT) 2413 return TRUE; 2414 return FALSE; 2415 } 2416 2417 /* 2418 * Move "count" times in direction "dir" to the next diff block. 2419 * Return FAIL if there isn't such a diff block. 2420 */ 2421 int 2422 diff_move_to(dir, count) 2423 int dir; 2424 long count; 2425 { 2426 int idx; 2427 linenr_T lnum = curwin->w_cursor.lnum; 2428 diff_T *dp; 2429 2430 idx = diff_buf_idx(curbuf); 2431 if (idx == DB_COUNT || curtab->tp_first_diff == NULL) 2432 return FAIL; 2433 2434 if (curtab->tp_diff_invalid) 2435 ex_diffupdate(NULL); /* update after a big change */ 2436 2437 if (curtab->tp_first_diff == NULL) /* no diffs today */ 2438 return FAIL; 2439 2440 while (--count >= 0) 2441 { 2442 /* Check if already before first diff. */ 2443 if (dir == BACKWARD && lnum <= curtab->tp_first_diff->df_lnum[idx]) 2444 break; 2445 2446 for (dp = curtab->tp_first_diff; ; dp = dp->df_next) 2447 { 2448 if (dp == NULL) 2449 break; 2450 if ((dir == FORWARD && lnum < dp->df_lnum[idx]) 2451 || (dir == BACKWARD 2452 && (dp->df_next == NULL 2453 || lnum <= dp->df_next->df_lnum[idx]))) 2454 { 2455 lnum = dp->df_lnum[idx]; 2456 break; 2457 } 2458 } 2459 } 2460 2461 /* don't end up past the end of the file */ 2462 if (lnum > curbuf->b_ml.ml_line_count) 2463 lnum = curbuf->b_ml.ml_line_count; 2464 2465 /* When the cursor didn't move at all we fail. */ 2466 if (lnum == curwin->w_cursor.lnum) 2467 return FAIL; 2468 2469 setpcmark(); 2470 curwin->w_cursor.lnum = lnum; 2471 curwin->w_cursor.col = 0; 2472 2473 return OK; 2474 } 2475 2476 #if defined(FEAT_FOLDING) || defined(PROTO) 2477 /* 2478 * For line "lnum" in the current window find the equivalent lnum in window 2479 * "wp", compensating for inserted/deleted lines. 2480 */ 2481 linenr_T 2482 diff_lnum_win(lnum, wp) 2483 linenr_T lnum; 2484 win_T *wp; 2485 { 2486 diff_T *dp; 2487 int idx; 2488 int i; 2489 linenr_T n; 2490 2491 idx = diff_buf_idx(curbuf); 2492 if (idx == DB_COUNT) /* safety check */ 2493 return (linenr_T)0; 2494 2495 if (curtab->tp_diff_invalid) 2496 ex_diffupdate(NULL); /* update after a big change */ 2497 2498 /* search for a change that includes "lnum" in the list of diffblocks. */ 2499 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2500 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 2501 break; 2502 2503 /* When after the last change, compute relative to the last line number. */ 2504 if (dp == NULL) 2505 return wp->w_buffer->b_ml.ml_line_count 2506 - (curbuf->b_ml.ml_line_count - lnum); 2507 2508 /* Find index for "wp". */ 2509 i = diff_buf_idx(wp->w_buffer); 2510 if (i == DB_COUNT) /* safety check */ 2511 return (linenr_T)0; 2512 2513 n = lnum + (dp->df_lnum[i] - dp->df_lnum[idx]); 2514 if (n > dp->df_lnum[i] + dp->df_count[i]) 2515 n = dp->df_lnum[i] + dp->df_count[i]; 2516 return n; 2517 } 2518 #endif 2519 2520 #endif /* FEAT_DIFF */ 2521