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 /*ARGSUSED*/ 656 void 657 ex_diffupdate(eap) 658 exarg_T *eap; /* can be NULL, it's not used */ 659 { 660 buf_T *buf; 661 int idx_orig; 662 int idx_new; 663 char_u *tmp_orig; 664 char_u *tmp_new; 665 char_u *tmp_diff; 666 FILE *fd; 667 int ok; 668 int io_error = FALSE; 669 670 /* Delete all diffblocks. */ 671 diff_clear(curtab); 672 curtab->tp_diff_invalid = FALSE; 673 674 /* Use the first buffer as the original text. */ 675 for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) 676 if (curtab->tp_diffbuf[idx_orig] != NULL) 677 break; 678 if (idx_orig == DB_COUNT) 679 return; 680 681 /* Only need to do something when there is another buffer. */ 682 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) 683 if (curtab->tp_diffbuf[idx_new] != NULL) 684 break; 685 if (idx_new == DB_COUNT) 686 return; 687 688 /* We need three temp file names. */ 689 tmp_orig = vim_tempname('o'); 690 tmp_new = vim_tempname('n'); 691 tmp_diff = vim_tempname('d'); 692 if (tmp_orig == NULL || tmp_new == NULL || tmp_diff == NULL) 693 goto theend; 694 695 /* 696 * Do a quick test if "diff" really works. Otherwise it looks like there 697 * are no differences. Can't use the return value, it's non-zero when 698 * there are differences. 699 * May try twice, first with "-a" and then without. 700 */ 701 for (;;) 702 { 703 ok = FALSE; 704 fd = mch_fopen((char *)tmp_orig, "w"); 705 if (fd == NULL) 706 io_error = TRUE; 707 else 708 { 709 if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) 710 io_error = TRUE; 711 fclose(fd); 712 fd = mch_fopen((char *)tmp_new, "w"); 713 if (fd == NULL) 714 io_error = TRUE; 715 else 716 { 717 if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) 718 io_error = TRUE; 719 fclose(fd); 720 diff_file(tmp_orig, tmp_new, tmp_diff); 721 fd = mch_fopen((char *)tmp_diff, "r"); 722 if (fd == NULL) 723 io_error = TRUE; 724 else 725 { 726 char_u linebuf[LBUFLEN]; 727 728 for (;;) 729 { 730 /* There must be a line that contains "1c1". */ 731 if (tag_fgets(linebuf, LBUFLEN, fd)) 732 break; 733 if (STRNCMP(linebuf, "1c1", 3) == 0) 734 ok = TRUE; 735 } 736 fclose(fd); 737 } 738 mch_remove(tmp_diff); 739 mch_remove(tmp_new); 740 } 741 mch_remove(tmp_orig); 742 } 743 744 #ifdef FEAT_EVAL 745 /* When using 'diffexpr' break here. */ 746 if (*p_dex != NUL) 747 break; 748 #endif 749 750 #if defined(MSWIN) || defined(MSDOS) 751 /* If the "-a" argument works, also check if "--binary" works. */ 752 if (ok && diff_a_works == MAYBE && diff_bin_works == MAYBE) 753 { 754 diff_a_works = TRUE; 755 diff_bin_works = TRUE; 756 continue; 757 } 758 if (!ok && diff_a_works == TRUE && diff_bin_works == TRUE) 759 { 760 /* Tried --binary, but it failed. "-a" works though. */ 761 diff_bin_works = FALSE; 762 ok = TRUE; 763 } 764 #endif 765 766 /* If we checked if "-a" works already, break here. */ 767 if (diff_a_works != MAYBE) 768 break; 769 diff_a_works = ok; 770 771 /* If "-a" works break here, otherwise retry without "-a". */ 772 if (ok) 773 break; 774 } 775 if (!ok) 776 { 777 if (io_error) 778 EMSG(_("E810: Cannot read or write temp files")); 779 EMSG(_("E97: Cannot create diffs")); 780 diff_a_works = MAYBE; 781 #if defined(MSWIN) || defined(MSDOS) 782 diff_bin_works = MAYBE; 783 #endif 784 goto theend; 785 } 786 787 /* Write the first buffer to a tempfile. */ 788 buf = curtab->tp_diffbuf[idx_orig]; 789 if (diff_write(buf, tmp_orig) == FAIL) 790 goto theend; 791 792 /* Make a difference between the first buffer and every other. */ 793 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) 794 { 795 buf = curtab->tp_diffbuf[idx_new]; 796 if (buf == NULL) 797 continue; 798 if (diff_write(buf, tmp_new) == FAIL) 799 continue; 800 diff_file(tmp_orig, tmp_new, tmp_diff); 801 802 /* Read the diff output and add each entry to the diff list. */ 803 diff_read(idx_orig, idx_new, tmp_diff); 804 mch_remove(tmp_diff); 805 mch_remove(tmp_new); 806 } 807 mch_remove(tmp_orig); 808 809 /* force updating cursor position on screen */ 810 curwin->w_valid_cursor.lnum = 0; 811 812 diff_redraw(TRUE); 813 814 theend: 815 vim_free(tmp_orig); 816 vim_free(tmp_new); 817 vim_free(tmp_diff); 818 } 819 820 /* 821 * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". 822 */ 823 static void 824 diff_file(tmp_orig, tmp_new, tmp_diff) 825 char_u *tmp_orig; 826 char_u *tmp_new; 827 char_u *tmp_diff; 828 { 829 char_u *cmd; 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 cmd = alloc((unsigned)(STRLEN(tmp_orig) + STRLEN(tmp_new) 839 + STRLEN(tmp_diff) + STRLEN(p_srr) + 27)); 840 if (cmd != NULL) 841 { 842 /* We don't want $DIFF_OPTIONS to get in the way. */ 843 if (getenv("DIFF_OPTIONS")) 844 vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); 845 846 /* Build the diff command and execute it. Always use -a, binary 847 * differences are of no use. Ignore errors, diff returns 848 * non-zero when differences have been found. */ 849 sprintf((char *)cmd, "diff %s%s%s%s%s %s", 850 diff_a_works == FALSE ? "" : "-a ", 851 #if defined(MSWIN) || defined(MSDOS) 852 diff_bin_works == TRUE ? "--binary " : "", 853 #else 854 "", 855 #endif 856 (diff_flags & DIFF_IWHITE) ? "-b " : "", 857 (diff_flags & DIFF_ICASE) ? "-i " : "", 858 tmp_orig, tmp_new); 859 append_redir(cmd, p_srr, tmp_diff); 860 #ifdef FEAT_AUTOCMD 861 block_autocmds(); /* Avoid ShellCmdPost stuff */ 862 #endif 863 (void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT); 864 #ifdef FEAT_AUTOCMD 865 unblock_autocmds(); 866 #endif 867 vim_free(cmd); 868 } 869 } 870 } 871 872 /* 873 * Create a new version of a file from the current buffer and a diff file. 874 * The buffer is written to a file, also for unmodified buffers (the file 875 * could have been produced by autocommands, e.g. the netrw plugin). 876 */ 877 void 878 ex_diffpatch(eap) 879 exarg_T *eap; 880 { 881 char_u *tmp_orig; /* name of original temp file */ 882 char_u *tmp_new; /* name of patched temp file */ 883 char_u *buf = NULL; 884 win_T *old_curwin = curwin; 885 char_u *newname = NULL; /* name of patched file buffer */ 886 #ifdef UNIX 887 char_u dirbuf[MAXPATHL]; 888 char_u *fullname = NULL; 889 #endif 890 #ifdef FEAT_BROWSE 891 char_u *browseFile = NULL; 892 int browse_flag = cmdmod.browse; 893 #endif 894 895 #ifdef FEAT_BROWSE 896 if (cmdmod.browse) 897 { 898 browseFile = do_browse(0, (char_u *)_("Patch file"), 899 eap->arg, NULL, NULL, BROWSE_FILTER_ALL_FILES, NULL); 900 if (browseFile == NULL) 901 return; /* operation cancelled */ 902 eap->arg = browseFile; 903 cmdmod.browse = FALSE; /* don't let do_ecmd() browse again */ 904 } 905 #endif 906 907 /* We need two temp file names. */ 908 tmp_orig = vim_tempname('o'); 909 tmp_new = vim_tempname('n'); 910 if (tmp_orig == NULL || tmp_new == NULL) 911 goto theend; 912 913 /* Write the current buffer to "tmp_orig". */ 914 if (buf_write(curbuf, tmp_orig, NULL, 915 (linenr_T)1, curbuf->b_ml.ml_line_count, 916 NULL, FALSE, FALSE, FALSE, TRUE) == FAIL) 917 goto theend; 918 919 #ifdef UNIX 920 /* Get the absolute path of the patchfile, changing directory below. */ 921 fullname = FullName_save(eap->arg, FALSE); 922 #endif 923 buf = alloc((unsigned)(STRLEN(tmp_orig) + ( 924 # ifdef UNIX 925 fullname != NULL ? STRLEN(fullname) : 926 # endif 927 STRLEN(eap->arg)) + STRLEN(tmp_new) + 16)); 928 if (buf == NULL) 929 goto theend; 930 931 #ifdef UNIX 932 /* Temporarily chdir to /tmp, to avoid patching files in the current 933 * directory when the patch file contains more than one patch. When we 934 * have our own temp dir use that instead, it will be cleaned up when we 935 * exit (any .rej files created). Don't change directory if we can't 936 * return to the current. */ 937 if (mch_dirname(dirbuf, MAXPATHL) != OK || mch_chdir((char *)dirbuf) != 0) 938 dirbuf[0] = NUL; 939 else 940 { 941 # ifdef TEMPDIRNAMES 942 if (vim_tempdir != NULL) 943 ignored = mch_chdir((char *)vim_tempdir); 944 else 945 # endif 946 ignored = mch_chdir("/tmp"); 947 shorten_fnames(TRUE); 948 } 949 #endif 950 951 #ifdef FEAT_EVAL 952 if (*p_pex != NUL) 953 /* Use 'patchexpr' to generate the new file. */ 954 eval_patch(tmp_orig, 955 # ifdef UNIX 956 fullname != NULL ? fullname : 957 # endif 958 eap->arg, tmp_new); 959 else 960 #endif 961 { 962 /* Build the patch command and execute it. Ignore errors. Switch to 963 * cooked mode to allow the user to respond to prompts. */ 964 sprintf((char *)buf, "patch -o %s %s < \"%s\"", tmp_new, tmp_orig, 965 # ifdef UNIX 966 fullname != NULL ? fullname : 967 # endif 968 eap->arg); 969 #ifdef FEAT_AUTOCMD 970 block_autocmds(); /* Avoid ShellCmdPost stuff */ 971 #endif 972 (void)call_shell(buf, SHELL_FILTER | SHELL_COOKED); 973 #ifdef FEAT_AUTOCMD 974 unblock_autocmds(); 975 #endif 976 } 977 978 #ifdef UNIX 979 if (dirbuf[0] != NUL) 980 { 981 if (mch_chdir((char *)dirbuf) != 0) 982 EMSG(_(e_prev_dir)); 983 shorten_fnames(TRUE); 984 } 985 #endif 986 987 /* patch probably has written over the screen */ 988 redraw_later(CLEAR); 989 990 /* Delete any .orig or .rej file created. */ 991 STRCPY(buf, tmp_new); 992 STRCAT(buf, ".orig"); 993 mch_remove(buf); 994 STRCPY(buf, tmp_new); 995 STRCAT(buf, ".rej"); 996 mch_remove(buf); 997 998 if (curbuf->b_fname != NULL) 999 { 1000 newname = vim_strnsave(curbuf->b_fname, 1001 (int)(STRLEN(curbuf->b_fname) + 4)); 1002 if (newname != NULL) 1003 STRCAT(newname, ".new"); 1004 } 1005 1006 #ifdef FEAT_GUI 1007 need_mouse_correct = TRUE; 1008 #endif 1009 /* don't use a new tab page, each tab page has its own diffs */ 1010 cmdmod.tab = 0; 1011 1012 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) 1013 { 1014 /* Pretend it was a ":split fname" command */ 1015 eap->cmdidx = CMD_split; 1016 eap->arg = tmp_new; 1017 do_exedit(eap, old_curwin); 1018 1019 if (curwin != old_curwin) /* split must have worked */ 1020 { 1021 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1022 diff_win_options(curwin, TRUE); 1023 diff_win_options(old_curwin, TRUE); 1024 1025 if (newname != NULL) 1026 { 1027 /* do a ":file filename.new" on the patched buffer */ 1028 eap->arg = newname; 1029 ex_file(eap); 1030 1031 #ifdef FEAT_AUTOCMD 1032 /* Do filetype detection with the new name. */ 1033 if (au_has_group((char_u *)"filetypedetect")) 1034 do_cmdline_cmd((char_u *)":doau filetypedetect BufRead"); 1035 #endif 1036 } 1037 } 1038 } 1039 1040 theend: 1041 if (tmp_orig != NULL) 1042 mch_remove(tmp_orig); 1043 vim_free(tmp_orig); 1044 if (tmp_new != NULL) 1045 mch_remove(tmp_new); 1046 vim_free(tmp_new); 1047 vim_free(newname); 1048 vim_free(buf); 1049 #ifdef UNIX 1050 vim_free(fullname); 1051 #endif 1052 #ifdef FEAT_BROWSE 1053 vim_free(browseFile); 1054 cmdmod.browse = browse_flag; 1055 #endif 1056 } 1057 1058 /* 1059 * Split the window and edit another file, setting options to show the diffs. 1060 */ 1061 void 1062 ex_diffsplit(eap) 1063 exarg_T *eap; 1064 { 1065 win_T *old_curwin = curwin; 1066 1067 #ifdef FEAT_GUI 1068 need_mouse_correct = TRUE; 1069 #endif 1070 /* don't use a new tab page, each tab page has its own diffs */ 1071 cmdmod.tab = 0; 1072 1073 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) 1074 { 1075 /* Pretend it was a ":split fname" command */ 1076 eap->cmdidx = CMD_split; 1077 curwin->w_p_diff = TRUE; 1078 do_exedit(eap, old_curwin); 1079 1080 if (curwin != old_curwin) /* split must have worked */ 1081 { 1082 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1083 diff_win_options(curwin, TRUE); 1084 diff_win_options(old_curwin, TRUE); 1085 } 1086 } 1087 } 1088 1089 /* 1090 * Set options to show difs for the current window. 1091 */ 1092 /*ARGSUSED*/ 1093 void 1094 ex_diffthis(eap) 1095 exarg_T *eap; 1096 { 1097 /* Set 'diff', 'scrollbind' on and 'wrap' off. */ 1098 diff_win_options(curwin, TRUE); 1099 } 1100 1101 /* 1102 * Set options in window "wp" for diff mode. 1103 */ 1104 void 1105 diff_win_options(wp, addbuf) 1106 win_T *wp; 1107 int addbuf; /* Add buffer to diff. */ 1108 { 1109 wp->w_p_diff = TRUE; 1110 wp->w_p_scb = TRUE; 1111 wp->w_p_wrap = FALSE; 1112 # ifdef FEAT_FOLDING 1113 { 1114 win_T *old_curwin = curwin; 1115 1116 curwin = wp; 1117 curbuf = curwin->w_buffer; 1118 set_string_option_direct((char_u *)"fdm", -1, (char_u *)"diff", 1119 OPT_LOCAL|OPT_FREE, 0); 1120 curwin = old_curwin; 1121 curbuf = curwin->w_buffer; 1122 wp->w_p_fdc = diff_foldcolumn; 1123 wp->w_p_fen = TRUE; 1124 wp->w_p_fdl = 0; 1125 foldUpdateAll(wp); 1126 /* make sure topline is not halfway a fold */ 1127 changed_window_setting_win(wp); 1128 } 1129 # endif 1130 #ifdef FEAT_SCROLLBIND 1131 if (vim_strchr(p_sbo, 'h') == NULL) 1132 do_cmdline_cmd((char_u *)"set sbo+=hor"); 1133 #endif 1134 1135 if (addbuf) 1136 diff_buf_add(wp->w_buffer); 1137 redraw_win_later(wp, NOT_VALID); 1138 } 1139 1140 /* 1141 * Set options not to show diffs. For the current window or all windows. 1142 * Only in the current tab page. 1143 */ 1144 void 1145 ex_diffoff(eap) 1146 exarg_T *eap; 1147 { 1148 win_T *wp; 1149 win_T *old_curwin = curwin; 1150 #ifdef FEAT_SCROLLBIND 1151 int diffwin = FALSE; 1152 #endif 1153 1154 for (wp = firstwin; wp != NULL; wp = wp->w_next) 1155 { 1156 if (wp == curwin || (eap->forceit && wp->w_p_diff)) 1157 { 1158 /* Set 'diff', 'scrollbind' off and 'wrap' on. */ 1159 wp->w_p_diff = FALSE; 1160 wp->w_p_scb = FALSE; 1161 wp->w_p_wrap = TRUE; 1162 #ifdef FEAT_FOLDING 1163 curwin = wp; 1164 curbuf = curwin->w_buffer; 1165 set_string_option_direct((char_u *)"fdm", -1, 1166 (char_u *)"manual", OPT_LOCAL|OPT_FREE, 0); 1167 curwin = old_curwin; 1168 curbuf = curwin->w_buffer; 1169 wp->w_p_fdc = 0; 1170 wp->w_p_fen = FALSE; 1171 wp->w_p_fdl = 0; 1172 foldUpdateAll(wp); 1173 /* make sure topline is not halfway a fold */ 1174 changed_window_setting_win(wp); 1175 #endif 1176 diff_buf_adjust(wp); 1177 } 1178 #ifdef FEAT_SCROLLBIND 1179 diffwin |= wp->w_p_diff; 1180 #endif 1181 } 1182 1183 #ifdef FEAT_SCROLLBIND 1184 /* Remove "hor" from from 'scrollopt' if there are no diff windows left. */ 1185 if (!diffwin && vim_strchr(p_sbo, 'h') != NULL) 1186 do_cmdline_cmd((char_u *)"set sbo-=hor"); 1187 #endif 1188 } 1189 1190 /* 1191 * Read the diff output and add each entry to the diff list. 1192 */ 1193 static void 1194 diff_read(idx_orig, idx_new, fname) 1195 int idx_orig; /* idx of original file */ 1196 int idx_new; /* idx of new file */ 1197 char_u *fname; /* name of diff output file */ 1198 { 1199 FILE *fd; 1200 diff_T *dprev = NULL; 1201 diff_T *dp = curtab->tp_first_diff; 1202 diff_T *dn, *dpl; 1203 long f1, l1, f2, l2; 1204 char_u linebuf[LBUFLEN]; /* only need to hold the diff line */ 1205 int difftype; 1206 char_u *p; 1207 long off; 1208 int i; 1209 linenr_T lnum_orig, lnum_new; 1210 long count_orig, count_new; 1211 int notset = TRUE; /* block "*dp" not set yet */ 1212 1213 fd = mch_fopen((char *)fname, "r"); 1214 if (fd == NULL) 1215 { 1216 EMSG(_("E98: Cannot read diff output")); 1217 return; 1218 } 1219 1220 for (;;) 1221 { 1222 if (tag_fgets(linebuf, LBUFLEN, fd)) 1223 break; /* end of file */ 1224 if (!isdigit(*linebuf)) 1225 continue; /* not the start of a diff block */ 1226 1227 /* This line must be one of three formats: 1228 * {first}[,{last}]c{first}[,{last}] 1229 * {first}a{first}[,{last}] 1230 * {first}[,{last}]d{first} 1231 */ 1232 p = linebuf; 1233 f1 = getdigits(&p); 1234 if (*p == ',') 1235 { 1236 ++p; 1237 l1 = getdigits(&p); 1238 } 1239 else 1240 l1 = f1; 1241 if (*p != 'a' && *p != 'c' && *p != 'd') 1242 continue; /* invalid diff format */ 1243 difftype = *p++; 1244 f2 = getdigits(&p); 1245 if (*p == ',') 1246 { 1247 ++p; 1248 l2 = getdigits(&p); 1249 } 1250 else 1251 l2 = f2; 1252 if (l1 < f1 || l2 < f2) 1253 continue; /* invalid line range */ 1254 1255 if (difftype == 'a') 1256 { 1257 lnum_orig = f1 + 1; 1258 count_orig = 0; 1259 } 1260 else 1261 { 1262 lnum_orig = f1; 1263 count_orig = l1 - f1 + 1; 1264 } 1265 if (difftype == 'd') 1266 { 1267 lnum_new = f2 + 1; 1268 count_new = 0; 1269 } 1270 else 1271 { 1272 lnum_new = f2; 1273 count_new = l2 - f2 + 1; 1274 } 1275 1276 /* Go over blocks before the change, for which orig and new are equal. 1277 * Copy blocks from orig to new. */ 1278 while (dp != NULL 1279 && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) 1280 { 1281 if (notset) 1282 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1283 dprev = dp; 1284 dp = dp->df_next; 1285 notset = TRUE; 1286 } 1287 1288 if (dp != NULL 1289 && lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig] 1290 && lnum_orig + count_orig >= dp->df_lnum[idx_orig]) 1291 { 1292 /* New block overlaps with existing block(s). 1293 * First find last block that overlaps. */ 1294 for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) 1295 if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) 1296 break; 1297 1298 /* If the newly found block starts before the old one, set the 1299 * start back a number of lines. */ 1300 off = dp->df_lnum[idx_orig] - lnum_orig; 1301 if (off > 0) 1302 { 1303 for (i = idx_orig; i < idx_new; ++i) 1304 if (curtab->tp_diffbuf[i] != NULL) 1305 dp->df_lnum[i] -= off; 1306 dp->df_lnum[idx_new] = lnum_new; 1307 dp->df_count[idx_new] = count_new; 1308 } 1309 else if (notset) 1310 { 1311 /* new block inside existing one, adjust new block */ 1312 dp->df_lnum[idx_new] = lnum_new + off; 1313 dp->df_count[idx_new] = count_new - off; 1314 } 1315 else 1316 /* second overlap of new block with existing block */ 1317 dp->df_count[idx_new] += count_new - count_orig 1318 + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] 1319 - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); 1320 1321 /* Adjust the size of the block to include all the lines to the 1322 * end of the existing block or the new diff, whatever ends last. */ 1323 off = (lnum_orig + count_orig) 1324 - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); 1325 if (off < 0) 1326 { 1327 /* new change ends in existing block, adjust the end if not 1328 * done already */ 1329 if (notset) 1330 dp->df_count[idx_new] += -off; 1331 off = 0; 1332 } 1333 for (i = idx_orig; i < idx_new; ++i) 1334 if (curtab->tp_diffbuf[i] != NULL) 1335 dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] 1336 - dp->df_lnum[i] + off; 1337 1338 /* Delete the diff blocks that have been merged into one. */ 1339 dn = dp->df_next; 1340 dp->df_next = dpl->df_next; 1341 while (dn != dp->df_next) 1342 { 1343 dpl = dn->df_next; 1344 vim_free(dn); 1345 dn = dpl; 1346 } 1347 } 1348 else 1349 { 1350 /* Allocate a new diffblock. */ 1351 dp = diff_alloc_new(curtab, dprev, dp); 1352 if (dp == NULL) 1353 goto done; 1354 1355 dp->df_lnum[idx_orig] = lnum_orig; 1356 dp->df_count[idx_orig] = count_orig; 1357 dp->df_lnum[idx_new] = lnum_new; 1358 dp->df_count[idx_new] = count_new; 1359 1360 /* Set values for other buffers, these must be equal to the 1361 * original buffer, otherwise there would have been a change 1362 * already. */ 1363 for (i = idx_orig + 1; i < idx_new; ++i) 1364 if (curtab->tp_diffbuf[i] != NULL) 1365 diff_copy_entry(dprev, dp, idx_orig, i); 1366 } 1367 notset = FALSE; /* "*dp" has been set */ 1368 } 1369 1370 /* for remaining diff blocks orig and new are equal */ 1371 while (dp != NULL) 1372 { 1373 if (notset) 1374 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1375 dprev = dp; 1376 dp = dp->df_next; 1377 notset = TRUE; 1378 } 1379 1380 done: 1381 fclose(fd); 1382 } 1383 1384 /* 1385 * Copy an entry at "dp" from "idx_orig" to "idx_new". 1386 */ 1387 static void 1388 diff_copy_entry(dprev, dp, idx_orig, idx_new) 1389 diff_T *dprev; 1390 diff_T *dp; 1391 int idx_orig; 1392 int idx_new; 1393 { 1394 long off; 1395 1396 if (dprev == NULL) 1397 off = 0; 1398 else 1399 off = (dprev->df_lnum[idx_orig] + dprev->df_count[idx_orig]) 1400 - (dprev->df_lnum[idx_new] + dprev->df_count[idx_new]); 1401 dp->df_lnum[idx_new] = dp->df_lnum[idx_orig] - off; 1402 dp->df_count[idx_new] = dp->df_count[idx_orig]; 1403 } 1404 1405 /* 1406 * Clear the list of diffblocks for tab page "tp". 1407 */ 1408 void 1409 diff_clear(tp) 1410 tabpage_T *tp; 1411 { 1412 diff_T *p, *next_p; 1413 1414 for (p = tp->tp_first_diff; p != NULL; p = next_p) 1415 { 1416 next_p = p->df_next; 1417 vim_free(p); 1418 } 1419 tp->tp_first_diff = NULL; 1420 } 1421 1422 /* 1423 * Check diff status for line "lnum" in buffer "buf": 1424 * Returns 0 for nothing special 1425 * Returns -1 for a line that should be highlighted as changed. 1426 * Returns -2 for a line that should be highlighted as added/deleted. 1427 * Returns > 0 for inserting that many filler lines above it (never happens 1428 * when 'diffopt' doesn't contain "filler"). 1429 * This should only be used for windows where 'diff' is set. 1430 */ 1431 int 1432 diff_check(wp, lnum) 1433 win_T *wp; 1434 linenr_T lnum; 1435 { 1436 int idx; /* index in tp_diffbuf[] for this buffer */ 1437 diff_T *dp; 1438 int maxcount; 1439 int i; 1440 buf_T *buf = wp->w_buffer; 1441 int cmp; 1442 1443 if (curtab->tp_diff_invalid) 1444 ex_diffupdate(NULL); /* update after a big change */ 1445 1446 if (curtab->tp_first_diff == NULL || !wp->w_p_diff) /* no diffs at all */ 1447 return 0; 1448 1449 /* safety check: "lnum" must be a buffer line */ 1450 if (lnum < 1 || lnum > buf->b_ml.ml_line_count + 1) 1451 return 0; 1452 1453 idx = diff_buf_idx(buf); 1454 if (idx == DB_COUNT) 1455 return 0; /* no diffs for buffer "buf" */ 1456 1457 #ifdef FEAT_FOLDING 1458 /* A closed fold never has filler lines. */ 1459 if (hasFoldingWin(wp, lnum, NULL, NULL, TRUE, NULL)) 1460 return 0; 1461 #endif 1462 1463 /* search for a change that includes "lnum" in the list of diffblocks. */ 1464 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1465 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1466 break; 1467 if (dp == NULL || lnum < dp->df_lnum[idx]) 1468 return 0; 1469 1470 if (lnum < dp->df_lnum[idx] + dp->df_count[idx]) 1471 { 1472 int zero = FALSE; 1473 1474 /* Changed or inserted line. If the other buffers have a count of 1475 * zero, the lines were inserted. If the other buffers have the same 1476 * count, check if the lines are identical. */ 1477 cmp = FALSE; 1478 for (i = 0; i < DB_COUNT; ++i) 1479 if (i != idx && curtab->tp_diffbuf[i] != NULL) 1480 { 1481 if (dp->df_count[i] == 0) 1482 zero = TRUE; 1483 else 1484 { 1485 if (dp->df_count[i] != dp->df_count[idx]) 1486 return -1; /* nr of lines changed. */ 1487 cmp = TRUE; 1488 } 1489 } 1490 if (cmp) 1491 { 1492 /* Compare all lines. If they are equal the lines were inserted 1493 * in some buffers, deleted in others, but not changed. */ 1494 for (i = 0; i < DB_COUNT; ++i) 1495 if (i != idx && curtab->tp_diffbuf[i] != NULL && dp->df_count[i] != 0) 1496 if (!diff_equal_entry(dp, idx, i)) 1497 return -1; 1498 } 1499 /* If there is no buffer with zero lines then there is no difference 1500 * any longer. Happens when making a change (or undo) that removes 1501 * the difference. Can't remove the entry here, we might be halfway 1502 * updating the window. Just report the text as unchanged. Other 1503 * windows might still show the change though. */ 1504 if (zero == FALSE) 1505 return 0; 1506 return -2; 1507 } 1508 1509 /* If 'diffopt' doesn't contain "filler", return 0. */ 1510 if (!(diff_flags & DIFF_FILLER)) 1511 return 0; 1512 1513 /* Insert filler lines above the line just below the change. Will return 1514 * 0 when this buf had the max count. */ 1515 maxcount = 0; 1516 for (i = 0; i < DB_COUNT; ++i) 1517 if (curtab->tp_diffbuf[i] != NULL && dp->df_count[i] > maxcount) 1518 maxcount = dp->df_count[i]; 1519 return maxcount - dp->df_count[idx]; 1520 } 1521 1522 /* 1523 * Compare two entries in diff "*dp" and return TRUE if they are equal. 1524 */ 1525 static int 1526 diff_equal_entry(dp, idx1, idx2) 1527 diff_T *dp; 1528 int idx1; 1529 int idx2; 1530 { 1531 int i; 1532 char_u *line; 1533 int cmp; 1534 1535 if (dp->df_count[idx1] != dp->df_count[idx2]) 1536 return FALSE; 1537 if (diff_check_sanity(curtab, dp) == FAIL) 1538 return FALSE; 1539 for (i = 0; i < dp->df_count[idx1]; ++i) 1540 { 1541 line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1], 1542 dp->df_lnum[idx1] + i, FALSE)); 1543 if (line == NULL) 1544 return FALSE; 1545 cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2], 1546 dp->df_lnum[idx2] + i, FALSE)); 1547 vim_free(line); 1548 if (cmp != 0) 1549 return FALSE; 1550 } 1551 return TRUE; 1552 } 1553 1554 /* 1555 * Compare strings "s1" and "s2" according to 'diffopt'. 1556 * Return non-zero when they are different. 1557 */ 1558 static int 1559 diff_cmp(s1, s2) 1560 char_u *s1; 1561 char_u *s2; 1562 { 1563 char_u *p1, *p2; 1564 #ifdef FEAT_MBYTE 1565 int l; 1566 #endif 1567 1568 if ((diff_flags & (DIFF_ICASE | DIFF_IWHITE)) == 0) 1569 return STRCMP(s1, s2); 1570 if ((diff_flags & DIFF_ICASE) && !(diff_flags & DIFF_IWHITE)) 1571 return MB_STRICMP(s1, s2); 1572 1573 /* Ignore white space changes and possibly ignore case. */ 1574 p1 = s1; 1575 p2 = s2; 1576 while (*p1 != NUL && *p2 != NUL) 1577 { 1578 if (vim_iswhite(*p1) && vim_iswhite(*p2)) 1579 { 1580 p1 = skipwhite(p1); 1581 p2 = skipwhite(p2); 1582 } 1583 else 1584 { 1585 #ifdef FEAT_MBYTE 1586 l = (*mb_ptr2len)(p1); 1587 if (l != (*mb_ptr2len)(p2)) 1588 break; 1589 if (l > 1) 1590 { 1591 if (STRNCMP(p1, p2, l) != 0 1592 && (!enc_utf8 1593 || !(diff_flags & DIFF_ICASE) 1594 || utf_fold(utf_ptr2char(p1)) 1595 != utf_fold(utf_ptr2char(p2)))) 1596 break; 1597 p1 += l; 1598 p2 += l; 1599 } 1600 else 1601 #endif 1602 { 1603 if (*p1 != *p2 && (!(diff_flags & DIFF_ICASE) 1604 || TOLOWER_LOC(*p1) != TOLOWER_LOC(*p2))) 1605 break; 1606 ++p1; 1607 ++p2; 1608 } 1609 } 1610 } 1611 1612 /* Ignore trailing white space. */ 1613 p1 = skipwhite(p1); 1614 p2 = skipwhite(p2); 1615 if (*p1 != NUL || *p2 != NUL) 1616 return 1; 1617 return 0; 1618 } 1619 1620 /* 1621 * Return the number of filler lines above "lnum". 1622 */ 1623 int 1624 diff_check_fill(wp, lnum) 1625 win_T *wp; 1626 linenr_T lnum; 1627 { 1628 int n; 1629 1630 /* be quick when there are no filler lines */ 1631 if (!(diff_flags & DIFF_FILLER)) 1632 return 0; 1633 n = diff_check(wp, lnum); 1634 if (n <= 0) 1635 return 0; 1636 return n; 1637 } 1638 1639 /* 1640 * Set the topline of "towin" to match the position in "fromwin", so that they 1641 * show the same diff'ed lines. 1642 */ 1643 void 1644 diff_set_topline(fromwin, towin) 1645 win_T *fromwin; 1646 win_T *towin; 1647 { 1648 buf_T *frombuf = fromwin->w_buffer; 1649 linenr_T lnum = fromwin->w_topline; 1650 int fromidx; 1651 int toidx; 1652 diff_T *dp; 1653 int max_count; 1654 int i; 1655 1656 fromidx = diff_buf_idx(frombuf); 1657 if (fromidx == DB_COUNT) 1658 return; /* safety check */ 1659 1660 if (curtab->tp_diff_invalid) 1661 ex_diffupdate(NULL); /* update after a big change */ 1662 1663 towin->w_topfill = 0; 1664 1665 /* search for a change that includes "lnum" in the list of diffblocks. */ 1666 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1667 if (lnum <= dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1668 break; 1669 if (dp == NULL) 1670 { 1671 /* After last change, compute topline relative to end of file; no 1672 * filler lines. */ 1673 towin->w_topline = towin->w_buffer->b_ml.ml_line_count 1674 - (frombuf->b_ml.ml_line_count - lnum); 1675 } 1676 else 1677 { 1678 /* Find index for "towin". */ 1679 toidx = diff_buf_idx(towin->w_buffer); 1680 if (toidx == DB_COUNT) 1681 return; /* safety check */ 1682 1683 towin->w_topline = lnum + (dp->df_lnum[toidx] - dp->df_lnum[fromidx]); 1684 if (lnum >= dp->df_lnum[fromidx]) 1685 { 1686 /* Inside a change: compute filler lines. With three or more 1687 * buffers we need to know the largest count. */ 1688 max_count = 0; 1689 for (i = 0; i < DB_COUNT; ++i) 1690 if (curtab->tp_diffbuf[i] != NULL 1691 && max_count < dp->df_count[i]) 1692 max_count = dp->df_count[i]; 1693 1694 if (dp->df_count[toidx] == dp->df_count[fromidx]) 1695 { 1696 /* same number of lines: use same filler count */ 1697 towin->w_topfill = fromwin->w_topfill; 1698 } 1699 else if (dp->df_count[toidx] > dp->df_count[fromidx]) 1700 { 1701 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1702 { 1703 /* more lines in towin and fromwin doesn't show diff 1704 * lines, only filler lines */ 1705 if (max_count - fromwin->w_topfill >= dp->df_count[toidx]) 1706 { 1707 /* towin also only shows filler lines */ 1708 towin->w_topline = dp->df_lnum[toidx] 1709 + dp->df_count[toidx]; 1710 towin->w_topfill = fromwin->w_topfill; 1711 } 1712 else 1713 /* towin still has some diff lines to show */ 1714 towin->w_topline = dp->df_lnum[toidx] 1715 + max_count - fromwin->w_topfill; 1716 } 1717 } 1718 else if (towin->w_topline >= dp->df_lnum[toidx] 1719 + dp->df_count[toidx]) 1720 { 1721 /* less lines in towin and no diff lines to show: compute 1722 * filler lines */ 1723 towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; 1724 if (diff_flags & DIFF_FILLER) 1725 { 1726 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1727 /* fromwin is also out of diff lines */ 1728 towin->w_topfill = fromwin->w_topfill; 1729 else 1730 /* fromwin has some diff lines */ 1731 towin->w_topfill = dp->df_lnum[fromidx] 1732 + max_count - lnum; 1733 } 1734 } 1735 } 1736 } 1737 1738 /* safety check (if diff info gets outdated strange things may happen) */ 1739 towin->w_botfill = FALSE; 1740 if (towin->w_topline > towin->w_buffer->b_ml.ml_line_count) 1741 { 1742 towin->w_topline = towin->w_buffer->b_ml.ml_line_count; 1743 towin->w_botfill = TRUE; 1744 } 1745 if (towin->w_topline < 1) 1746 { 1747 towin->w_topline = 1; 1748 towin->w_topfill = 0; 1749 } 1750 1751 /* When w_topline changes need to recompute w_botline and cursor position */ 1752 invalidate_botline_win(towin); 1753 changed_line_abv_curs_win(towin); 1754 1755 check_topfill(towin, FALSE); 1756 #ifdef FEAT_FOLDING 1757 (void)hasFoldingWin(towin, towin->w_topline, &towin->w_topline, 1758 NULL, TRUE, NULL); 1759 #endif 1760 } 1761 1762 /* 1763 * This is called when 'diffopt' is changed. 1764 */ 1765 int 1766 diffopt_changed() 1767 { 1768 char_u *p; 1769 int diff_context_new = 6; 1770 int diff_flags_new = 0; 1771 int diff_foldcolumn_new = 2; 1772 tabpage_T *tp; 1773 1774 p = p_dip; 1775 while (*p != NUL) 1776 { 1777 if (STRNCMP(p, "filler", 6) == 0) 1778 { 1779 p += 6; 1780 diff_flags_new |= DIFF_FILLER; 1781 } 1782 else if (STRNCMP(p, "context:", 8) == 0 && VIM_ISDIGIT(p[8])) 1783 { 1784 p += 8; 1785 diff_context_new = getdigits(&p); 1786 } 1787 else if (STRNCMP(p, "icase", 5) == 0) 1788 { 1789 p += 5; 1790 diff_flags_new |= DIFF_ICASE; 1791 } 1792 else if (STRNCMP(p, "iwhite", 6) == 0) 1793 { 1794 p += 6; 1795 diff_flags_new |= DIFF_IWHITE; 1796 } 1797 else if (STRNCMP(p, "horizontal", 10) == 0) 1798 { 1799 p += 10; 1800 diff_flags_new |= DIFF_HORIZONTAL; 1801 } 1802 else if (STRNCMP(p, "vertical", 8) == 0) 1803 { 1804 p += 8; 1805 diff_flags_new |= DIFF_VERTICAL; 1806 } 1807 else if (STRNCMP(p, "foldcolumn:", 11) == 0 && VIM_ISDIGIT(p[11])) 1808 { 1809 p += 11; 1810 diff_foldcolumn_new = getdigits(&p); 1811 } 1812 if (*p != ',' && *p != NUL) 1813 return FAIL; 1814 if (*p == ',') 1815 ++p; 1816 } 1817 1818 /* Can't have both "horizontal" and "vertical". */ 1819 if ((diff_flags_new & DIFF_HORIZONTAL) && (diff_flags_new & DIFF_VERTICAL)) 1820 return FAIL; 1821 1822 /* If "icase" or "iwhite" was added or removed, need to update the diff. */ 1823 if (diff_flags != diff_flags_new) 1824 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 1825 tp->tp_diff_invalid = TRUE; 1826 1827 diff_flags = diff_flags_new; 1828 diff_context = diff_context_new; 1829 diff_foldcolumn = diff_foldcolumn_new; 1830 1831 diff_redraw(TRUE); 1832 1833 /* recompute the scroll binding with the new option value, may 1834 * remove or add filler lines */ 1835 check_scrollbind((linenr_T)0, 0L); 1836 1837 return OK; 1838 } 1839 1840 /* 1841 * Return TRUE if 'diffopt' contains "horizontal". 1842 */ 1843 int 1844 diffopt_horizontal() 1845 { 1846 return (diff_flags & DIFF_HORIZONTAL) != 0; 1847 } 1848 1849 /* 1850 * Find the difference within a changed line. 1851 * Returns TRUE if the line was added, no other buffer has it. 1852 */ 1853 int 1854 diff_find_change(wp, lnum, startp, endp) 1855 win_T *wp; 1856 linenr_T lnum; 1857 int *startp; /* first char of the change */ 1858 int *endp; /* last char of the change */ 1859 { 1860 char_u *line_org; 1861 char_u *line_new; 1862 int i; 1863 int si_org, si_new; 1864 int ei_org, ei_new; 1865 diff_T *dp; 1866 int idx; 1867 int off; 1868 int added = TRUE; 1869 1870 /* Make a copy of the line, the next ml_get() will invalidate it. */ 1871 line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE)); 1872 if (line_org == NULL) 1873 return FALSE; 1874 1875 idx = diff_buf_idx(wp->w_buffer); 1876 if (idx == DB_COUNT) /* cannot happen */ 1877 { 1878 vim_free(line_org); 1879 return FALSE; 1880 } 1881 1882 /* search for a change that includes "lnum" in the list of diffblocks. */ 1883 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1884 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1885 break; 1886 if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL) 1887 { 1888 vim_free(line_org); 1889 return FALSE; 1890 } 1891 1892 off = lnum - dp->df_lnum[idx]; 1893 1894 for (i = 0; i < DB_COUNT; ++i) 1895 if (curtab->tp_diffbuf[i] != NULL && i != idx) 1896 { 1897 /* Skip lines that are not in the other change (filler lines). */ 1898 if (off >= dp->df_count[i]) 1899 continue; 1900 added = FALSE; 1901 line_new = ml_get_buf(curtab->tp_diffbuf[i], 1902 dp->df_lnum[i] + off, FALSE); 1903 1904 /* Search for start of difference */ 1905 si_org = si_new = 0; 1906 while (line_org[si_org] != NUL) 1907 { 1908 if ((diff_flags & DIFF_IWHITE) 1909 && vim_iswhite(line_org[si_org]) 1910 && vim_iswhite(line_new[si_new])) 1911 { 1912 si_org = (int)(skipwhite(line_org + si_org) - line_org); 1913 si_new = (int)(skipwhite(line_new + si_new) - line_new); 1914 } 1915 else 1916 { 1917 if (line_org[si_org] != line_new[si_new]) 1918 break; 1919 ++si_org; 1920 ++si_new; 1921 } 1922 } 1923 #ifdef FEAT_MBYTE 1924 if (has_mbyte) 1925 { 1926 /* Move back to first byte of character in both lines (may 1927 * have "nn^" in line_org and "n^ in line_new). */ 1928 si_org -= (*mb_head_off)(line_org, line_org + si_org); 1929 si_new -= (*mb_head_off)(line_new, line_new + si_new); 1930 } 1931 #endif 1932 if (*startp > si_org) 1933 *startp = si_org; 1934 1935 /* Search for end of difference, if any. */ 1936 if (line_org[si_org] != NUL || line_new[si_new] != NUL) 1937 { 1938 ei_org = (int)STRLEN(line_org); 1939 ei_new = (int)STRLEN(line_new); 1940 while (ei_org >= *startp && ei_new >= si_new 1941 && ei_org >= 0 && ei_new >= 0) 1942 { 1943 if ((diff_flags & DIFF_IWHITE) 1944 && vim_iswhite(line_org[ei_org]) 1945 && vim_iswhite(line_new[ei_new])) 1946 { 1947 while (ei_org >= *startp 1948 && vim_iswhite(line_org[ei_org])) 1949 --ei_org; 1950 while (ei_new >= si_new 1951 && vim_iswhite(line_new[ei_new])) 1952 --ei_new; 1953 } 1954 else 1955 { 1956 if (line_org[ei_org] != line_new[ei_new]) 1957 break; 1958 --ei_org; 1959 --ei_new; 1960 } 1961 } 1962 if (*endp < ei_org) 1963 *endp = ei_org; 1964 } 1965 } 1966 1967 vim_free(line_org); 1968 return added; 1969 } 1970 1971 #if defined(FEAT_FOLDING) || defined(PROTO) 1972 /* 1973 * Return TRUE if line "lnum" is not close to a diff block, this line should 1974 * be in a fold. 1975 * Return FALSE if there are no diff blocks at all in this window. 1976 */ 1977 int 1978 diff_infold(wp, lnum) 1979 win_T *wp; 1980 linenr_T lnum; 1981 { 1982 int i; 1983 int idx = -1; 1984 int other = FALSE; 1985 diff_T *dp; 1986 1987 /* Return if 'diff' isn't set. */ 1988 if (!wp->w_p_diff) 1989 return FALSE; 1990 1991 for (i = 0; i < DB_COUNT; ++i) 1992 { 1993 if (curtab->tp_diffbuf[i] == wp->w_buffer) 1994 idx = i; 1995 else if (curtab->tp_diffbuf[i] != NULL) 1996 other = TRUE; 1997 } 1998 1999 /* return here if there are no diffs in the window */ 2000 if (idx == -1 || !other) 2001 return FALSE; 2002 2003 if (curtab->tp_diff_invalid) 2004 ex_diffupdate(NULL); /* update after a big change */ 2005 2006 /* Return if there are no diff blocks. All lines will be folded. */ 2007 if (curtab->tp_first_diff == NULL) 2008 return TRUE; 2009 2010 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2011 { 2012 /* If this change is below the line there can't be any further match. */ 2013 if (dp->df_lnum[idx] - diff_context > lnum) 2014 break; 2015 /* If this change ends before the line we have a match. */ 2016 if (dp->df_lnum[idx] + dp->df_count[idx] + diff_context > lnum) 2017 return FALSE; 2018 } 2019 return TRUE; 2020 } 2021 #endif 2022 2023 /* 2024 * "dp" and "do" commands. 2025 */ 2026 void 2027 nv_diffgetput(put) 2028 int put; 2029 { 2030 exarg_T ea; 2031 2032 ea.arg = (char_u *)""; 2033 if (put) 2034 ea.cmdidx = CMD_diffput; 2035 else 2036 ea.cmdidx = CMD_diffget; 2037 ea.addr_count = 0; 2038 ea.line1 = curwin->w_cursor.lnum; 2039 ea.line2 = curwin->w_cursor.lnum; 2040 ex_diffgetput(&ea); 2041 } 2042 2043 /* 2044 * ":diffget" 2045 * ":diffput" 2046 */ 2047 void 2048 ex_diffgetput(eap) 2049 exarg_T *eap; 2050 { 2051 linenr_T lnum; 2052 int count; 2053 linenr_T off = 0; 2054 diff_T *dp; 2055 diff_T *dprev; 2056 diff_T *dfree; 2057 int idx_cur; 2058 int idx_other; 2059 int idx_from; 2060 int idx_to; 2061 int i; 2062 int added; 2063 char_u *p; 2064 aco_save_T aco; 2065 buf_T *buf; 2066 int start_skip, end_skip; 2067 int new_count; 2068 int buf_empty; 2069 int found_not_ma = FALSE; 2070 2071 /* Find the current buffer in the list of diff buffers. */ 2072 idx_cur = diff_buf_idx(curbuf); 2073 if (idx_cur == DB_COUNT) 2074 { 2075 EMSG(_("E99: Current buffer is not in diff mode")); 2076 return; 2077 } 2078 2079 if (*eap->arg == NUL) 2080 { 2081 /* No argument: Find the other buffer in the list of diff buffers. */ 2082 for (idx_other = 0; idx_other < DB_COUNT; ++idx_other) 2083 if (curtab->tp_diffbuf[idx_other] != curbuf 2084 && curtab->tp_diffbuf[idx_other] != NULL) 2085 { 2086 if (eap->cmdidx != CMD_diffput 2087 || curtab->tp_diffbuf[idx_other]->b_p_ma) 2088 break; 2089 found_not_ma = TRUE; 2090 } 2091 if (idx_other == DB_COUNT) 2092 { 2093 if (found_not_ma) 2094 EMSG(_("E793: No other buffer in diff mode is modifiable")); 2095 else 2096 EMSG(_("E100: No other buffer in diff mode")); 2097 return; 2098 } 2099 2100 /* Check that there isn't a third buffer in the list */ 2101 for (i = idx_other + 1; i < DB_COUNT; ++i) 2102 if (curtab->tp_diffbuf[i] != curbuf 2103 && curtab->tp_diffbuf[i] != NULL 2104 && (eap->cmdidx != CMD_diffput || curtab->tp_diffbuf[i]->b_p_ma)) 2105 { 2106 EMSG(_("E101: More than two buffers in diff mode, don't know which one to use")); 2107 return; 2108 } 2109 } 2110 else 2111 { 2112 /* Buffer number or pattern given. Ignore trailing white space. */ 2113 p = eap->arg + STRLEN(eap->arg); 2114 while (p > eap->arg && vim_iswhite(p[-1])) 2115 --p; 2116 for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i) 2117 ; 2118 if (eap->arg + i == p) /* digits only */ 2119 i = atol((char *)eap->arg); 2120 else 2121 { 2122 i = buflist_findpat(eap->arg, p, FALSE, TRUE); 2123 if (i < 0) 2124 return; /* error message already given */ 2125 } 2126 buf = buflist_findnr(i); 2127 if (buf == NULL) 2128 { 2129 EMSG2(_("E102: Can't find buffer \"%s\""), eap->arg); 2130 return; 2131 } 2132 if (buf == curbuf) 2133 return; /* nothing to do */ 2134 idx_other = diff_buf_idx(buf); 2135 if (idx_other == DB_COUNT) 2136 { 2137 EMSG2(_("E103: Buffer \"%s\" is not in diff mode"), eap->arg); 2138 return; 2139 } 2140 } 2141 2142 diff_busy = TRUE; 2143 2144 /* When no range given include the line above or below the cursor. */ 2145 if (eap->addr_count == 0) 2146 { 2147 /* Make it possible that ":diffget" on the last line gets line below 2148 * the cursor line when there is no difference above the cursor. */ 2149 if (eap->cmdidx == CMD_diffget 2150 && eap->line1 == curbuf->b_ml.ml_line_count 2151 && diff_check(curwin, eap->line1) == 0 2152 && (eap->line1 == 1 || diff_check(curwin, eap->line1 - 1) == 0)) 2153 ++eap->line2; 2154 else if (eap->line1 > 0) 2155 --eap->line1; 2156 } 2157 2158 if (eap->cmdidx == CMD_diffget) 2159 { 2160 idx_from = idx_other; 2161 idx_to = idx_cur; 2162 } 2163 else 2164 { 2165 idx_from = idx_cur; 2166 idx_to = idx_other; 2167 /* Need to make the other buffer the current buffer to be able to make 2168 * changes in it. */ 2169 /* set curwin/curbuf to buf and save a few things */ 2170 aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]); 2171 } 2172 2173 /* May give the warning for a changed buffer here, which can trigger the 2174 * FileChangedRO autocommand, which may do nasty things and mess 2175 * everything up. */ 2176 if (!curbuf->b_changed) 2177 { 2178 change_warning(0); 2179 if (diff_buf_idx(curbuf) != idx_to) 2180 { 2181 EMSG(_("E787: Buffer changed unexpectedly")); 2182 return; 2183 } 2184 } 2185 2186 dprev = NULL; 2187 for (dp = curtab->tp_first_diff; dp != NULL; ) 2188 { 2189 if (dp->df_lnum[idx_cur] > eap->line2 + off) 2190 break; /* past the range that was specified */ 2191 2192 dfree = NULL; 2193 lnum = dp->df_lnum[idx_to]; 2194 count = dp->df_count[idx_to]; 2195 if (dp->df_lnum[idx_cur] + dp->df_count[idx_cur] > eap->line1 + off 2196 && u_save(lnum - 1, lnum + count) != FAIL) 2197 { 2198 /* Inside the specified range and saving for undo worked. */ 2199 start_skip = 0; 2200 end_skip = 0; 2201 if (eap->addr_count > 0) 2202 { 2203 /* A range was specified: check if lines need to be skipped. */ 2204 start_skip = eap->line1 + off - dp->df_lnum[idx_cur]; 2205 if (start_skip > 0) 2206 { 2207 /* range starts below start of current diff block */ 2208 if (start_skip > count) 2209 { 2210 lnum += count; 2211 count = 0; 2212 } 2213 else 2214 { 2215 count -= start_skip; 2216 lnum += start_skip; 2217 } 2218 } 2219 else 2220 start_skip = 0; 2221 2222 end_skip = dp->df_lnum[idx_cur] + dp->df_count[idx_cur] - 1 2223 - (eap->line2 + off); 2224 if (end_skip > 0) 2225 { 2226 /* range ends above end of current/from diff block */ 2227 if (idx_cur == idx_from) /* :diffput */ 2228 { 2229 i = dp->df_count[idx_cur] - start_skip - end_skip; 2230 if (count > i) 2231 count = i; 2232 } 2233 else /* :diffget */ 2234 { 2235 count -= end_skip; 2236 end_skip = dp->df_count[idx_from] - start_skip - count; 2237 if (end_skip < 0) 2238 end_skip = 0; 2239 } 2240 } 2241 else 2242 end_skip = 0; 2243 } 2244 2245 buf_empty = FALSE; 2246 added = 0; 2247 for (i = 0; i < count; ++i) 2248 { 2249 /* remember deleting the last line of the buffer */ 2250 buf_empty = curbuf->b_ml.ml_line_count == 1; 2251 ml_delete(lnum, FALSE); 2252 --added; 2253 } 2254 for (i = 0; i < dp->df_count[idx_from] - start_skip - end_skip; ++i) 2255 { 2256 linenr_T nr; 2257 2258 nr = dp->df_lnum[idx_from] + start_skip + i; 2259 if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) 2260 break; 2261 p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], 2262 nr, FALSE)); 2263 if (p != NULL) 2264 { 2265 ml_append(lnum + i - 1, p, 0, FALSE); 2266 vim_free(p); 2267 ++added; 2268 if (buf_empty && curbuf->b_ml.ml_line_count == 2) 2269 { 2270 /* Added the first line into an empty buffer, need to 2271 * delete the dummy empty line. */ 2272 buf_empty = FALSE; 2273 ml_delete((linenr_T)2, FALSE); 2274 } 2275 } 2276 } 2277 new_count = dp->df_count[idx_to] + added; 2278 dp->df_count[idx_to] = new_count; 2279 2280 if (start_skip == 0 && end_skip == 0) 2281 { 2282 /* Check if there are any other buffers and if the diff is 2283 * equal in them. */ 2284 for (i = 0; i < DB_COUNT; ++i) 2285 if (curtab->tp_diffbuf[i] != NULL && i != idx_from 2286 && i != idx_to 2287 && !diff_equal_entry(dp, idx_from, i)) 2288 break; 2289 if (i == DB_COUNT) 2290 { 2291 /* delete the diff entry, the buffers are now equal here */ 2292 dfree = dp; 2293 dp = dp->df_next; 2294 if (dprev == NULL) 2295 curtab->tp_first_diff = dp; 2296 else 2297 dprev->df_next = dp; 2298 } 2299 } 2300 2301 /* Adjust marks. This will change the following entries! */ 2302 if (added != 0) 2303 { 2304 mark_adjust(lnum, lnum + count - 1, (long)MAXLNUM, (long)added); 2305 if (curwin->w_cursor.lnum >= lnum) 2306 { 2307 /* Adjust the cursor position if it's in/after the changed 2308 * lines. */ 2309 if (curwin->w_cursor.lnum >= lnum + count) 2310 curwin->w_cursor.lnum += added; 2311 else if (added < 0) 2312 curwin->w_cursor.lnum = lnum; 2313 } 2314 } 2315 changed_lines(lnum, 0, lnum + count, (long)added); 2316 2317 if (dfree != NULL) 2318 { 2319 /* Diff is deleted, update folds in other windows. */ 2320 #ifdef FEAT_FOLDING 2321 diff_fold_update(dfree, idx_to); 2322 #endif 2323 vim_free(dfree); 2324 } 2325 else 2326 /* mark_adjust() may have changed the count in a wrong way */ 2327 dp->df_count[idx_to] = new_count; 2328 2329 /* When changing the current buffer, keep track of line numbers */ 2330 if (idx_cur == idx_to) 2331 off += added; 2332 } 2333 2334 /* If before the range or not deleted, go to next diff. */ 2335 if (dfree == NULL) 2336 { 2337 dprev = dp; 2338 dp = dp->df_next; 2339 } 2340 } 2341 2342 /* restore curwin/curbuf and a few other things */ 2343 if (idx_other == idx_to) 2344 { 2345 /* Syncing undo only works for the current buffer, but we change 2346 * another buffer. Sync undo if the command was typed. This isn't 2347 * 100% right when ":diffput" is used in a function or mapping. */ 2348 if (KeyTyped) 2349 u_sync(FALSE); 2350 aucmd_restbuf(&aco); 2351 } 2352 2353 diff_busy = FALSE; 2354 2355 /* Check that the cursor is on a valid character and update it's position. 2356 * When there were filler lines the topline has become invalid. */ 2357 check_cursor(); 2358 changed_line_abv_curs(); 2359 2360 /* Also need to redraw the other buffers. */ 2361 diff_redraw(FALSE); 2362 } 2363 2364 #ifdef FEAT_FOLDING 2365 /* 2366 * Update folds for all diff buffers for entry "dp". 2367 * Skip buffer with index "skip_idx". 2368 * When there are no diffs, all folds are removed. 2369 */ 2370 static void 2371 diff_fold_update(dp, skip_idx) 2372 diff_T *dp; 2373 int skip_idx; 2374 { 2375 int i; 2376 win_T *wp; 2377 2378 for (wp = firstwin; wp != NULL; wp = wp->w_next) 2379 for (i = 0; i < DB_COUNT; ++i) 2380 if (curtab->tp_diffbuf[i] == wp->w_buffer && i != skip_idx) 2381 foldUpdate(wp, dp->df_lnum[i], 2382 dp->df_lnum[i] + dp->df_count[i]); 2383 } 2384 #endif 2385 2386 /* 2387 * Return TRUE if buffer "buf" is in diff-mode. 2388 */ 2389 int 2390 diff_mode_buf(buf) 2391 buf_T *buf; 2392 { 2393 tabpage_T *tp; 2394 2395 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 2396 if (diff_buf_idx_tp(buf, tp) != DB_COUNT) 2397 return TRUE; 2398 return FALSE; 2399 } 2400 2401 /* 2402 * Move "count" times in direction "dir" to the next diff block. 2403 * Return FAIL if there isn't such a diff block. 2404 */ 2405 int 2406 diff_move_to(dir, count) 2407 int dir; 2408 long count; 2409 { 2410 int idx; 2411 linenr_T lnum = curwin->w_cursor.lnum; 2412 diff_T *dp; 2413 2414 idx = diff_buf_idx(curbuf); 2415 if (idx == DB_COUNT || curtab->tp_first_diff == NULL) 2416 return FAIL; 2417 2418 if (curtab->tp_diff_invalid) 2419 ex_diffupdate(NULL); /* update after a big change */ 2420 2421 if (curtab->tp_first_diff == NULL) /* no diffs today */ 2422 return FAIL; 2423 2424 while (--count >= 0) 2425 { 2426 /* Check if already before first diff. */ 2427 if (dir == BACKWARD && lnum <= curtab->tp_first_diff->df_lnum[idx]) 2428 break; 2429 2430 for (dp = curtab->tp_first_diff; ; dp = dp->df_next) 2431 { 2432 if (dp == NULL) 2433 break; 2434 if ((dir == FORWARD && lnum < dp->df_lnum[idx]) 2435 || (dir == BACKWARD 2436 && (dp->df_next == NULL 2437 || lnum <= dp->df_next->df_lnum[idx]))) 2438 { 2439 lnum = dp->df_lnum[idx]; 2440 break; 2441 } 2442 } 2443 } 2444 2445 /* don't end up past the end of the file */ 2446 if (lnum > curbuf->b_ml.ml_line_count) 2447 lnum = curbuf->b_ml.ml_line_count; 2448 2449 /* When the cursor didn't move at all we fail. */ 2450 if (lnum == curwin->w_cursor.lnum) 2451 return FAIL; 2452 2453 setpcmark(); 2454 curwin->w_cursor.lnum = lnum; 2455 curwin->w_cursor.col = 0; 2456 2457 return OK; 2458 } 2459 2460 #if defined(FEAT_FOLDING) || defined(PROTO) 2461 /* 2462 * For line "lnum" in the current window find the equivalent lnum in window 2463 * "wp", compensating for inserted/deleted lines. 2464 */ 2465 linenr_T 2466 diff_lnum_win(lnum, wp) 2467 linenr_T lnum; 2468 win_T *wp; 2469 { 2470 diff_T *dp; 2471 int idx; 2472 int i; 2473 linenr_T n; 2474 2475 idx = diff_buf_idx(curbuf); 2476 if (idx == DB_COUNT) /* safety check */ 2477 return (linenr_T)0; 2478 2479 if (curtab->tp_diff_invalid) 2480 ex_diffupdate(NULL); /* update after a big change */ 2481 2482 /* search for a change that includes "lnum" in the list of diffblocks. */ 2483 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2484 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 2485 break; 2486 2487 /* When after the last change, compute relative to the last line number. */ 2488 if (dp == NULL) 2489 return wp->w_buffer->b_ml.ml_line_count 2490 - (curbuf->b_ml.ml_line_count - lnum); 2491 2492 /* Find index for "wp". */ 2493 i = diff_buf_idx(wp->w_buffer); 2494 if (i == DB_COUNT) /* safety check */ 2495 return (linenr_T)0; 2496 2497 n = lnum + (dp->df_lnum[i] - dp->df_lnum[idx]); 2498 if (n > dp->df_lnum[i] + dp->df_count[i]) 2499 n = dp->df_lnum[i] + dp->df_count[i]; 2500 return n; 2501 } 2502 #endif 2503 2504 #endif /* FEAT_DIFF */ 2505