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 wp->w_p_diff = TRUE; 1121 wp->w_p_scb = TRUE; 1122 wp->w_p_wrap = FALSE; 1123 # ifdef FEAT_FOLDING 1124 { 1125 win_T *old_curwin = curwin; 1126 1127 curwin = wp; 1128 curbuf = curwin->w_buffer; 1129 set_string_option_direct((char_u *)"fdm", -1, (char_u *)"diff", 1130 OPT_LOCAL|OPT_FREE, 0); 1131 curwin = old_curwin; 1132 curbuf = curwin->w_buffer; 1133 wp->w_p_fdc = diff_foldcolumn; 1134 wp->w_p_fen = TRUE; 1135 wp->w_p_fdl = 0; 1136 foldUpdateAll(wp); 1137 /* make sure topline is not halfway a fold */ 1138 changed_window_setting_win(wp); 1139 } 1140 # endif 1141 #ifdef FEAT_SCROLLBIND 1142 if (vim_strchr(p_sbo, 'h') == NULL) 1143 do_cmdline_cmd((char_u *)"set sbo+=hor"); 1144 #endif 1145 1146 if (addbuf) 1147 diff_buf_add(wp->w_buffer); 1148 redraw_win_later(wp, NOT_VALID); 1149 } 1150 1151 /* 1152 * Set options not to show diffs. For the current window or all windows. 1153 * Only in the current tab page. 1154 */ 1155 void 1156 ex_diffoff(eap) 1157 exarg_T *eap; 1158 { 1159 win_T *wp; 1160 win_T *old_curwin = curwin; 1161 #ifdef FEAT_SCROLLBIND 1162 int diffwin = FALSE; 1163 #endif 1164 1165 for (wp = firstwin; wp != NULL; wp = wp->w_next) 1166 { 1167 if (wp == curwin || (eap->forceit && wp->w_p_diff)) 1168 { 1169 /* Set 'diff', 'scrollbind' off and 'wrap' on. */ 1170 wp->w_p_diff = FALSE; 1171 wp->w_p_scb = FALSE; 1172 wp->w_p_wrap = TRUE; 1173 #ifdef FEAT_FOLDING 1174 curwin = wp; 1175 curbuf = curwin->w_buffer; 1176 set_string_option_direct((char_u *)"fdm", -1, 1177 (char_u *)"manual", OPT_LOCAL|OPT_FREE, 0); 1178 curwin = old_curwin; 1179 curbuf = curwin->w_buffer; 1180 wp->w_p_fdc = 0; 1181 wp->w_p_fen = FALSE; 1182 wp->w_p_fdl = 0; 1183 foldUpdateAll(wp); 1184 /* make sure topline is not halfway a fold */ 1185 changed_window_setting_win(wp); 1186 #endif 1187 diff_buf_adjust(wp); 1188 } 1189 #ifdef FEAT_SCROLLBIND 1190 diffwin |= wp->w_p_diff; 1191 #endif 1192 } 1193 1194 #ifdef FEAT_SCROLLBIND 1195 /* Remove "hor" from from 'scrollopt' if there are no diff windows left. */ 1196 if (!diffwin && vim_strchr(p_sbo, 'h') != NULL) 1197 do_cmdline_cmd((char_u *)"set sbo-=hor"); 1198 #endif 1199 } 1200 1201 /* 1202 * Read the diff output and add each entry to the diff list. 1203 */ 1204 static void 1205 diff_read(idx_orig, idx_new, fname) 1206 int idx_orig; /* idx of original file */ 1207 int idx_new; /* idx of new file */ 1208 char_u *fname; /* name of diff output file */ 1209 { 1210 FILE *fd; 1211 diff_T *dprev = NULL; 1212 diff_T *dp = curtab->tp_first_diff; 1213 diff_T *dn, *dpl; 1214 long f1, l1, f2, l2; 1215 char_u linebuf[LBUFLEN]; /* only need to hold the diff line */ 1216 int difftype; 1217 char_u *p; 1218 long off; 1219 int i; 1220 linenr_T lnum_orig, lnum_new; 1221 long count_orig, count_new; 1222 int notset = TRUE; /* block "*dp" not set yet */ 1223 1224 fd = mch_fopen((char *)fname, "r"); 1225 if (fd == NULL) 1226 { 1227 EMSG(_("E98: Cannot read diff output")); 1228 return; 1229 } 1230 1231 for (;;) 1232 { 1233 if (tag_fgets(linebuf, LBUFLEN, fd)) 1234 break; /* end of file */ 1235 if (!isdigit(*linebuf)) 1236 continue; /* not the start of a diff block */ 1237 1238 /* This line must be one of three formats: 1239 * {first}[,{last}]c{first}[,{last}] 1240 * {first}a{first}[,{last}] 1241 * {first}[,{last}]d{first} 1242 */ 1243 p = linebuf; 1244 f1 = getdigits(&p); 1245 if (*p == ',') 1246 { 1247 ++p; 1248 l1 = getdigits(&p); 1249 } 1250 else 1251 l1 = f1; 1252 if (*p != 'a' && *p != 'c' && *p != 'd') 1253 continue; /* invalid diff format */ 1254 difftype = *p++; 1255 f2 = getdigits(&p); 1256 if (*p == ',') 1257 { 1258 ++p; 1259 l2 = getdigits(&p); 1260 } 1261 else 1262 l2 = f2; 1263 if (l1 < f1 || l2 < f2) 1264 continue; /* invalid line range */ 1265 1266 if (difftype == 'a') 1267 { 1268 lnum_orig = f1 + 1; 1269 count_orig = 0; 1270 } 1271 else 1272 { 1273 lnum_orig = f1; 1274 count_orig = l1 - f1 + 1; 1275 } 1276 if (difftype == 'd') 1277 { 1278 lnum_new = f2 + 1; 1279 count_new = 0; 1280 } 1281 else 1282 { 1283 lnum_new = f2; 1284 count_new = l2 - f2 + 1; 1285 } 1286 1287 /* Go over blocks before the change, for which orig and new are equal. 1288 * Copy blocks from orig to new. */ 1289 while (dp != NULL 1290 && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) 1291 { 1292 if (notset) 1293 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1294 dprev = dp; 1295 dp = dp->df_next; 1296 notset = TRUE; 1297 } 1298 1299 if (dp != NULL 1300 && lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig] 1301 && lnum_orig + count_orig >= dp->df_lnum[idx_orig]) 1302 { 1303 /* New block overlaps with existing block(s). 1304 * First find last block that overlaps. */ 1305 for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) 1306 if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) 1307 break; 1308 1309 /* If the newly found block starts before the old one, set the 1310 * start back a number of lines. */ 1311 off = dp->df_lnum[idx_orig] - lnum_orig; 1312 if (off > 0) 1313 { 1314 for (i = idx_orig; i < idx_new; ++i) 1315 if (curtab->tp_diffbuf[i] != NULL) 1316 dp->df_lnum[i] -= off; 1317 dp->df_lnum[idx_new] = lnum_new; 1318 dp->df_count[idx_new] = count_new; 1319 } 1320 else if (notset) 1321 { 1322 /* new block inside existing one, adjust new block */ 1323 dp->df_lnum[idx_new] = lnum_new + off; 1324 dp->df_count[idx_new] = count_new - off; 1325 } 1326 else 1327 /* second overlap of new block with existing block */ 1328 dp->df_count[idx_new] += count_new - count_orig 1329 + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] 1330 - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); 1331 1332 /* Adjust the size of the block to include all the lines to the 1333 * end of the existing block or the new diff, whatever ends last. */ 1334 off = (lnum_orig + count_orig) 1335 - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); 1336 if (off < 0) 1337 { 1338 /* new change ends in existing block, adjust the end if not 1339 * done already */ 1340 if (notset) 1341 dp->df_count[idx_new] += -off; 1342 off = 0; 1343 } 1344 for (i = idx_orig; i < idx_new; ++i) 1345 if (curtab->tp_diffbuf[i] != NULL) 1346 dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] 1347 - dp->df_lnum[i] + off; 1348 1349 /* Delete the diff blocks that have been merged into one. */ 1350 dn = dp->df_next; 1351 dp->df_next = dpl->df_next; 1352 while (dn != dp->df_next) 1353 { 1354 dpl = dn->df_next; 1355 vim_free(dn); 1356 dn = dpl; 1357 } 1358 } 1359 else 1360 { 1361 /* Allocate a new diffblock. */ 1362 dp = diff_alloc_new(curtab, dprev, dp); 1363 if (dp == NULL) 1364 goto done; 1365 1366 dp->df_lnum[idx_orig] = lnum_orig; 1367 dp->df_count[idx_orig] = count_orig; 1368 dp->df_lnum[idx_new] = lnum_new; 1369 dp->df_count[idx_new] = count_new; 1370 1371 /* Set values for other buffers, these must be equal to the 1372 * original buffer, otherwise there would have been a change 1373 * already. */ 1374 for (i = idx_orig + 1; i < idx_new; ++i) 1375 if (curtab->tp_diffbuf[i] != NULL) 1376 diff_copy_entry(dprev, dp, idx_orig, i); 1377 } 1378 notset = FALSE; /* "*dp" has been set */ 1379 } 1380 1381 /* for remaining diff blocks orig and new are equal */ 1382 while (dp != NULL) 1383 { 1384 if (notset) 1385 diff_copy_entry(dprev, dp, idx_orig, idx_new); 1386 dprev = dp; 1387 dp = dp->df_next; 1388 notset = TRUE; 1389 } 1390 1391 done: 1392 fclose(fd); 1393 } 1394 1395 /* 1396 * Copy an entry at "dp" from "idx_orig" to "idx_new". 1397 */ 1398 static void 1399 diff_copy_entry(dprev, dp, idx_orig, idx_new) 1400 diff_T *dprev; 1401 diff_T *dp; 1402 int idx_orig; 1403 int idx_new; 1404 { 1405 long off; 1406 1407 if (dprev == NULL) 1408 off = 0; 1409 else 1410 off = (dprev->df_lnum[idx_orig] + dprev->df_count[idx_orig]) 1411 - (dprev->df_lnum[idx_new] + dprev->df_count[idx_new]); 1412 dp->df_lnum[idx_new] = dp->df_lnum[idx_orig] - off; 1413 dp->df_count[idx_new] = dp->df_count[idx_orig]; 1414 } 1415 1416 /* 1417 * Clear the list of diffblocks for tab page "tp". 1418 */ 1419 void 1420 diff_clear(tp) 1421 tabpage_T *tp; 1422 { 1423 diff_T *p, *next_p; 1424 1425 for (p = tp->tp_first_diff; p != NULL; p = next_p) 1426 { 1427 next_p = p->df_next; 1428 vim_free(p); 1429 } 1430 tp->tp_first_diff = NULL; 1431 } 1432 1433 /* 1434 * Check diff status for line "lnum" in buffer "buf": 1435 * Returns 0 for nothing special 1436 * Returns -1 for a line that should be highlighted as changed. 1437 * Returns -2 for a line that should be highlighted as added/deleted. 1438 * Returns > 0 for inserting that many filler lines above it (never happens 1439 * when 'diffopt' doesn't contain "filler"). 1440 * This should only be used for windows where 'diff' is set. 1441 */ 1442 int 1443 diff_check(wp, lnum) 1444 win_T *wp; 1445 linenr_T lnum; 1446 { 1447 int idx; /* index in tp_diffbuf[] for this buffer */ 1448 diff_T *dp; 1449 int maxcount; 1450 int i; 1451 buf_T *buf = wp->w_buffer; 1452 int cmp; 1453 1454 if (curtab->tp_diff_invalid) 1455 ex_diffupdate(NULL); /* update after a big change */ 1456 1457 if (curtab->tp_first_diff == NULL || !wp->w_p_diff) /* no diffs at all */ 1458 return 0; 1459 1460 /* safety check: "lnum" must be a buffer line */ 1461 if (lnum < 1 || lnum > buf->b_ml.ml_line_count + 1) 1462 return 0; 1463 1464 idx = diff_buf_idx(buf); 1465 if (idx == DB_COUNT) 1466 return 0; /* no diffs for buffer "buf" */ 1467 1468 #ifdef FEAT_FOLDING 1469 /* A closed fold never has filler lines. */ 1470 if (hasFoldingWin(wp, lnum, NULL, NULL, TRUE, NULL)) 1471 return 0; 1472 #endif 1473 1474 /* search for a change that includes "lnum" in the list of diffblocks. */ 1475 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1476 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1477 break; 1478 if (dp == NULL || lnum < dp->df_lnum[idx]) 1479 return 0; 1480 1481 if (lnum < dp->df_lnum[idx] + dp->df_count[idx]) 1482 { 1483 int zero = FALSE; 1484 1485 /* Changed or inserted line. If the other buffers have a count of 1486 * zero, the lines were inserted. If the other buffers have the same 1487 * count, check if the lines are identical. */ 1488 cmp = FALSE; 1489 for (i = 0; i < DB_COUNT; ++i) 1490 if (i != idx && curtab->tp_diffbuf[i] != NULL) 1491 { 1492 if (dp->df_count[i] == 0) 1493 zero = TRUE; 1494 else 1495 { 1496 if (dp->df_count[i] != dp->df_count[idx]) 1497 return -1; /* nr of lines changed. */ 1498 cmp = TRUE; 1499 } 1500 } 1501 if (cmp) 1502 { 1503 /* Compare all lines. If they are equal the lines were inserted 1504 * in some buffers, deleted in others, but not changed. */ 1505 for (i = 0; i < DB_COUNT; ++i) 1506 if (i != idx && curtab->tp_diffbuf[i] != NULL && dp->df_count[i] != 0) 1507 if (!diff_equal_entry(dp, idx, i)) 1508 return -1; 1509 } 1510 /* If there is no buffer with zero lines then there is no difference 1511 * any longer. Happens when making a change (or undo) that removes 1512 * the difference. Can't remove the entry here, we might be halfway 1513 * updating the window. Just report the text as unchanged. Other 1514 * windows might still show the change though. */ 1515 if (zero == FALSE) 1516 return 0; 1517 return -2; 1518 } 1519 1520 /* If 'diffopt' doesn't contain "filler", return 0. */ 1521 if (!(diff_flags & DIFF_FILLER)) 1522 return 0; 1523 1524 /* Insert filler lines above the line just below the change. Will return 1525 * 0 when this buf had the max count. */ 1526 maxcount = 0; 1527 for (i = 0; i < DB_COUNT; ++i) 1528 if (curtab->tp_diffbuf[i] != NULL && dp->df_count[i] > maxcount) 1529 maxcount = dp->df_count[i]; 1530 return maxcount - dp->df_count[idx]; 1531 } 1532 1533 /* 1534 * Compare two entries in diff "*dp" and return TRUE if they are equal. 1535 */ 1536 static int 1537 diff_equal_entry(dp, idx1, idx2) 1538 diff_T *dp; 1539 int idx1; 1540 int idx2; 1541 { 1542 int i; 1543 char_u *line; 1544 int cmp; 1545 1546 if (dp->df_count[idx1] != dp->df_count[idx2]) 1547 return FALSE; 1548 if (diff_check_sanity(curtab, dp) == FAIL) 1549 return FALSE; 1550 for (i = 0; i < dp->df_count[idx1]; ++i) 1551 { 1552 line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1], 1553 dp->df_lnum[idx1] + i, FALSE)); 1554 if (line == NULL) 1555 return FALSE; 1556 cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2], 1557 dp->df_lnum[idx2] + i, FALSE)); 1558 vim_free(line); 1559 if (cmp != 0) 1560 return FALSE; 1561 } 1562 return TRUE; 1563 } 1564 1565 /* 1566 * Compare strings "s1" and "s2" according to 'diffopt'. 1567 * Return non-zero when they are different. 1568 */ 1569 static int 1570 diff_cmp(s1, s2) 1571 char_u *s1; 1572 char_u *s2; 1573 { 1574 char_u *p1, *p2; 1575 #ifdef FEAT_MBYTE 1576 int l; 1577 #endif 1578 1579 if ((diff_flags & (DIFF_ICASE | DIFF_IWHITE)) == 0) 1580 return STRCMP(s1, s2); 1581 if ((diff_flags & DIFF_ICASE) && !(diff_flags & DIFF_IWHITE)) 1582 return MB_STRICMP(s1, s2); 1583 1584 /* Ignore white space changes and possibly ignore case. */ 1585 p1 = s1; 1586 p2 = s2; 1587 while (*p1 != NUL && *p2 != NUL) 1588 { 1589 if (vim_iswhite(*p1) && vim_iswhite(*p2)) 1590 { 1591 p1 = skipwhite(p1); 1592 p2 = skipwhite(p2); 1593 } 1594 else 1595 { 1596 #ifdef FEAT_MBYTE 1597 l = (*mb_ptr2len)(p1); 1598 if (l != (*mb_ptr2len)(p2)) 1599 break; 1600 if (l > 1) 1601 { 1602 if (STRNCMP(p1, p2, l) != 0 1603 && (!enc_utf8 1604 || !(diff_flags & DIFF_ICASE) 1605 || utf_fold(utf_ptr2char(p1)) 1606 != utf_fold(utf_ptr2char(p2)))) 1607 break; 1608 p1 += l; 1609 p2 += l; 1610 } 1611 else 1612 #endif 1613 { 1614 if (*p1 != *p2 && (!(diff_flags & DIFF_ICASE) 1615 || TOLOWER_LOC(*p1) != TOLOWER_LOC(*p2))) 1616 break; 1617 ++p1; 1618 ++p2; 1619 } 1620 } 1621 } 1622 1623 /* Ignore trailing white space. */ 1624 p1 = skipwhite(p1); 1625 p2 = skipwhite(p2); 1626 if (*p1 != NUL || *p2 != NUL) 1627 return 1; 1628 return 0; 1629 } 1630 1631 /* 1632 * Return the number of filler lines above "lnum". 1633 */ 1634 int 1635 diff_check_fill(wp, lnum) 1636 win_T *wp; 1637 linenr_T lnum; 1638 { 1639 int n; 1640 1641 /* be quick when there are no filler lines */ 1642 if (!(diff_flags & DIFF_FILLER)) 1643 return 0; 1644 n = diff_check(wp, lnum); 1645 if (n <= 0) 1646 return 0; 1647 return n; 1648 } 1649 1650 /* 1651 * Set the topline of "towin" to match the position in "fromwin", so that they 1652 * show the same diff'ed lines. 1653 */ 1654 void 1655 diff_set_topline(fromwin, towin) 1656 win_T *fromwin; 1657 win_T *towin; 1658 { 1659 buf_T *frombuf = fromwin->w_buffer; 1660 linenr_T lnum = fromwin->w_topline; 1661 int fromidx; 1662 int toidx; 1663 diff_T *dp; 1664 int max_count; 1665 int i; 1666 1667 fromidx = diff_buf_idx(frombuf); 1668 if (fromidx == DB_COUNT) 1669 return; /* safety check */ 1670 1671 if (curtab->tp_diff_invalid) 1672 ex_diffupdate(NULL); /* update after a big change */ 1673 1674 towin->w_topfill = 0; 1675 1676 /* search for a change that includes "lnum" in the list of diffblocks. */ 1677 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1678 if (lnum <= dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1679 break; 1680 if (dp == NULL) 1681 { 1682 /* After last change, compute topline relative to end of file; no 1683 * filler lines. */ 1684 towin->w_topline = towin->w_buffer->b_ml.ml_line_count 1685 - (frombuf->b_ml.ml_line_count - lnum); 1686 } 1687 else 1688 { 1689 /* Find index for "towin". */ 1690 toidx = diff_buf_idx(towin->w_buffer); 1691 if (toidx == DB_COUNT) 1692 return; /* safety check */ 1693 1694 towin->w_topline = lnum + (dp->df_lnum[toidx] - dp->df_lnum[fromidx]); 1695 if (lnum >= dp->df_lnum[fromidx]) 1696 { 1697 /* Inside a change: compute filler lines. With three or more 1698 * buffers we need to know the largest count. */ 1699 max_count = 0; 1700 for (i = 0; i < DB_COUNT; ++i) 1701 if (curtab->tp_diffbuf[i] != NULL 1702 && max_count < dp->df_count[i]) 1703 max_count = dp->df_count[i]; 1704 1705 if (dp->df_count[toidx] == dp->df_count[fromidx]) 1706 { 1707 /* same number of lines: use same filler count */ 1708 towin->w_topfill = fromwin->w_topfill; 1709 } 1710 else if (dp->df_count[toidx] > dp->df_count[fromidx]) 1711 { 1712 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1713 { 1714 /* more lines in towin and fromwin doesn't show diff 1715 * lines, only filler lines */ 1716 if (max_count - fromwin->w_topfill >= dp->df_count[toidx]) 1717 { 1718 /* towin also only shows filler lines */ 1719 towin->w_topline = dp->df_lnum[toidx] 1720 + dp->df_count[toidx]; 1721 towin->w_topfill = fromwin->w_topfill; 1722 } 1723 else 1724 /* towin still has some diff lines to show */ 1725 towin->w_topline = dp->df_lnum[toidx] 1726 + max_count - fromwin->w_topfill; 1727 } 1728 } 1729 else if (towin->w_topline >= dp->df_lnum[toidx] 1730 + dp->df_count[toidx]) 1731 { 1732 /* less lines in towin and no diff lines to show: compute 1733 * filler lines */ 1734 towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; 1735 if (diff_flags & DIFF_FILLER) 1736 { 1737 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) 1738 /* fromwin is also out of diff lines */ 1739 towin->w_topfill = fromwin->w_topfill; 1740 else 1741 /* fromwin has some diff lines */ 1742 towin->w_topfill = dp->df_lnum[fromidx] 1743 + max_count - lnum; 1744 } 1745 } 1746 } 1747 } 1748 1749 /* safety check (if diff info gets outdated strange things may happen) */ 1750 towin->w_botfill = FALSE; 1751 if (towin->w_topline > towin->w_buffer->b_ml.ml_line_count) 1752 { 1753 towin->w_topline = towin->w_buffer->b_ml.ml_line_count; 1754 towin->w_botfill = TRUE; 1755 } 1756 if (towin->w_topline < 1) 1757 { 1758 towin->w_topline = 1; 1759 towin->w_topfill = 0; 1760 } 1761 1762 /* When w_topline changes need to recompute w_botline and cursor position */ 1763 invalidate_botline_win(towin); 1764 changed_line_abv_curs_win(towin); 1765 1766 check_topfill(towin, FALSE); 1767 #ifdef FEAT_FOLDING 1768 (void)hasFoldingWin(towin, towin->w_topline, &towin->w_topline, 1769 NULL, TRUE, NULL); 1770 #endif 1771 } 1772 1773 /* 1774 * This is called when 'diffopt' is changed. 1775 */ 1776 int 1777 diffopt_changed() 1778 { 1779 char_u *p; 1780 int diff_context_new = 6; 1781 int diff_flags_new = 0; 1782 int diff_foldcolumn_new = 2; 1783 tabpage_T *tp; 1784 1785 p = p_dip; 1786 while (*p != NUL) 1787 { 1788 if (STRNCMP(p, "filler", 6) == 0) 1789 { 1790 p += 6; 1791 diff_flags_new |= DIFF_FILLER; 1792 } 1793 else if (STRNCMP(p, "context:", 8) == 0 && VIM_ISDIGIT(p[8])) 1794 { 1795 p += 8; 1796 diff_context_new = getdigits(&p); 1797 } 1798 else if (STRNCMP(p, "icase", 5) == 0) 1799 { 1800 p += 5; 1801 diff_flags_new |= DIFF_ICASE; 1802 } 1803 else if (STRNCMP(p, "iwhite", 6) == 0) 1804 { 1805 p += 6; 1806 diff_flags_new |= DIFF_IWHITE; 1807 } 1808 else if (STRNCMP(p, "horizontal", 10) == 0) 1809 { 1810 p += 10; 1811 diff_flags_new |= DIFF_HORIZONTAL; 1812 } 1813 else if (STRNCMP(p, "vertical", 8) == 0) 1814 { 1815 p += 8; 1816 diff_flags_new |= DIFF_VERTICAL; 1817 } 1818 else if (STRNCMP(p, "foldcolumn:", 11) == 0 && VIM_ISDIGIT(p[11])) 1819 { 1820 p += 11; 1821 diff_foldcolumn_new = getdigits(&p); 1822 } 1823 if (*p != ',' && *p != NUL) 1824 return FAIL; 1825 if (*p == ',') 1826 ++p; 1827 } 1828 1829 /* Can't have both "horizontal" and "vertical". */ 1830 if ((diff_flags_new & DIFF_HORIZONTAL) && (diff_flags_new & DIFF_VERTICAL)) 1831 return FAIL; 1832 1833 /* If "icase" or "iwhite" was added or removed, need to update the diff. */ 1834 if (diff_flags != diff_flags_new) 1835 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 1836 tp->tp_diff_invalid = TRUE; 1837 1838 diff_flags = diff_flags_new; 1839 diff_context = diff_context_new; 1840 diff_foldcolumn = diff_foldcolumn_new; 1841 1842 diff_redraw(TRUE); 1843 1844 /* recompute the scroll binding with the new option value, may 1845 * remove or add filler lines */ 1846 check_scrollbind((linenr_T)0, 0L); 1847 1848 return OK; 1849 } 1850 1851 /* 1852 * Return TRUE if 'diffopt' contains "horizontal". 1853 */ 1854 int 1855 diffopt_horizontal() 1856 { 1857 return (diff_flags & DIFF_HORIZONTAL) != 0; 1858 } 1859 1860 /* 1861 * Find the difference within a changed line. 1862 * Returns TRUE if the line was added, no other buffer has it. 1863 */ 1864 int 1865 diff_find_change(wp, lnum, startp, endp) 1866 win_T *wp; 1867 linenr_T lnum; 1868 int *startp; /* first char of the change */ 1869 int *endp; /* last char of the change */ 1870 { 1871 char_u *line_org; 1872 char_u *line_new; 1873 int i; 1874 int si_org, si_new; 1875 int ei_org, ei_new; 1876 diff_T *dp; 1877 int idx; 1878 int off; 1879 int added = TRUE; 1880 1881 /* Make a copy of the line, the next ml_get() will invalidate it. */ 1882 line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE)); 1883 if (line_org == NULL) 1884 return FALSE; 1885 1886 idx = diff_buf_idx(wp->w_buffer); 1887 if (idx == DB_COUNT) /* cannot happen */ 1888 { 1889 vim_free(line_org); 1890 return FALSE; 1891 } 1892 1893 /* search for a change that includes "lnum" in the list of diffblocks. */ 1894 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 1895 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 1896 break; 1897 if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL) 1898 { 1899 vim_free(line_org); 1900 return FALSE; 1901 } 1902 1903 off = lnum - dp->df_lnum[idx]; 1904 1905 for (i = 0; i < DB_COUNT; ++i) 1906 if (curtab->tp_diffbuf[i] != NULL && i != idx) 1907 { 1908 /* Skip lines that are not in the other change (filler lines). */ 1909 if (off >= dp->df_count[i]) 1910 continue; 1911 added = FALSE; 1912 line_new = ml_get_buf(curtab->tp_diffbuf[i], 1913 dp->df_lnum[i] + off, FALSE); 1914 1915 /* Search for start of difference */ 1916 si_org = si_new = 0; 1917 while (line_org[si_org] != NUL) 1918 { 1919 if ((diff_flags & DIFF_IWHITE) 1920 && vim_iswhite(line_org[si_org]) 1921 && vim_iswhite(line_new[si_new])) 1922 { 1923 si_org = (int)(skipwhite(line_org + si_org) - line_org); 1924 si_new = (int)(skipwhite(line_new + si_new) - line_new); 1925 } 1926 else 1927 { 1928 if (line_org[si_org] != line_new[si_new]) 1929 break; 1930 ++si_org; 1931 ++si_new; 1932 } 1933 } 1934 #ifdef FEAT_MBYTE 1935 if (has_mbyte) 1936 { 1937 /* Move back to first byte of character in both lines (may 1938 * have "nn^" in line_org and "n^ in line_new). */ 1939 si_org -= (*mb_head_off)(line_org, line_org + si_org); 1940 si_new -= (*mb_head_off)(line_new, line_new + si_new); 1941 } 1942 #endif 1943 if (*startp > si_org) 1944 *startp = si_org; 1945 1946 /* Search for end of difference, if any. */ 1947 if (line_org[si_org] != NUL || line_new[si_new] != NUL) 1948 { 1949 ei_org = (int)STRLEN(line_org); 1950 ei_new = (int)STRLEN(line_new); 1951 while (ei_org >= *startp && ei_new >= si_new 1952 && ei_org >= 0 && ei_new >= 0) 1953 { 1954 if ((diff_flags & DIFF_IWHITE) 1955 && vim_iswhite(line_org[ei_org]) 1956 && vim_iswhite(line_new[ei_new])) 1957 { 1958 while (ei_org >= *startp 1959 && vim_iswhite(line_org[ei_org])) 1960 --ei_org; 1961 while (ei_new >= si_new 1962 && vim_iswhite(line_new[ei_new])) 1963 --ei_new; 1964 } 1965 else 1966 { 1967 if (line_org[ei_org] != line_new[ei_new]) 1968 break; 1969 --ei_org; 1970 --ei_new; 1971 } 1972 } 1973 if (*endp < ei_org) 1974 *endp = ei_org; 1975 } 1976 } 1977 1978 vim_free(line_org); 1979 return added; 1980 } 1981 1982 #if defined(FEAT_FOLDING) || defined(PROTO) 1983 /* 1984 * Return TRUE if line "lnum" is not close to a diff block, this line should 1985 * be in a fold. 1986 * Return FALSE if there are no diff blocks at all in this window. 1987 */ 1988 int 1989 diff_infold(wp, lnum) 1990 win_T *wp; 1991 linenr_T lnum; 1992 { 1993 int i; 1994 int idx = -1; 1995 int other = FALSE; 1996 diff_T *dp; 1997 1998 /* Return if 'diff' isn't set. */ 1999 if (!wp->w_p_diff) 2000 return FALSE; 2001 2002 for (i = 0; i < DB_COUNT; ++i) 2003 { 2004 if (curtab->tp_diffbuf[i] == wp->w_buffer) 2005 idx = i; 2006 else if (curtab->tp_diffbuf[i] != NULL) 2007 other = TRUE; 2008 } 2009 2010 /* return here if there are no diffs in the window */ 2011 if (idx == -1 || !other) 2012 return FALSE; 2013 2014 if (curtab->tp_diff_invalid) 2015 ex_diffupdate(NULL); /* update after a big change */ 2016 2017 /* Return if there are no diff blocks. All lines will be folded. */ 2018 if (curtab->tp_first_diff == NULL) 2019 return TRUE; 2020 2021 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2022 { 2023 /* If this change is below the line there can't be any further match. */ 2024 if (dp->df_lnum[idx] - diff_context > lnum) 2025 break; 2026 /* If this change ends before the line we have a match. */ 2027 if (dp->df_lnum[idx] + dp->df_count[idx] + diff_context > lnum) 2028 return FALSE; 2029 } 2030 return TRUE; 2031 } 2032 #endif 2033 2034 /* 2035 * "dp" and "do" commands. 2036 */ 2037 void 2038 nv_diffgetput(put) 2039 int put; 2040 { 2041 exarg_T ea; 2042 2043 ea.arg = (char_u *)""; 2044 if (put) 2045 ea.cmdidx = CMD_diffput; 2046 else 2047 ea.cmdidx = CMD_diffget; 2048 ea.addr_count = 0; 2049 ea.line1 = curwin->w_cursor.lnum; 2050 ea.line2 = curwin->w_cursor.lnum; 2051 ex_diffgetput(&ea); 2052 } 2053 2054 /* 2055 * ":diffget" 2056 * ":diffput" 2057 */ 2058 void 2059 ex_diffgetput(eap) 2060 exarg_T *eap; 2061 { 2062 linenr_T lnum; 2063 int count; 2064 linenr_T off = 0; 2065 diff_T *dp; 2066 diff_T *dprev; 2067 diff_T *dfree; 2068 int idx_cur; 2069 int idx_other; 2070 int idx_from; 2071 int idx_to; 2072 int i; 2073 int added; 2074 char_u *p; 2075 aco_save_T aco; 2076 buf_T *buf; 2077 int start_skip, end_skip; 2078 int new_count; 2079 int buf_empty; 2080 int found_not_ma = FALSE; 2081 2082 /* Find the current buffer in the list of diff buffers. */ 2083 idx_cur = diff_buf_idx(curbuf); 2084 if (idx_cur == DB_COUNT) 2085 { 2086 EMSG(_("E99: Current buffer is not in diff mode")); 2087 return; 2088 } 2089 2090 if (*eap->arg == NUL) 2091 { 2092 /* No argument: Find the other buffer in the list of diff buffers. */ 2093 for (idx_other = 0; idx_other < DB_COUNT; ++idx_other) 2094 if (curtab->tp_diffbuf[idx_other] != curbuf 2095 && curtab->tp_diffbuf[idx_other] != NULL) 2096 { 2097 if (eap->cmdidx != CMD_diffput 2098 || curtab->tp_diffbuf[idx_other]->b_p_ma) 2099 break; 2100 found_not_ma = TRUE; 2101 } 2102 if (idx_other == DB_COUNT) 2103 { 2104 if (found_not_ma) 2105 EMSG(_("E793: No other buffer in diff mode is modifiable")); 2106 else 2107 EMSG(_("E100: No other buffer in diff mode")); 2108 return; 2109 } 2110 2111 /* Check that there isn't a third buffer in the list */ 2112 for (i = idx_other + 1; i < DB_COUNT; ++i) 2113 if (curtab->tp_diffbuf[i] != curbuf 2114 && curtab->tp_diffbuf[i] != NULL 2115 && (eap->cmdidx != CMD_diffput || curtab->tp_diffbuf[i]->b_p_ma)) 2116 { 2117 EMSG(_("E101: More than two buffers in diff mode, don't know which one to use")); 2118 return; 2119 } 2120 } 2121 else 2122 { 2123 /* Buffer number or pattern given. Ignore trailing white space. */ 2124 p = eap->arg + STRLEN(eap->arg); 2125 while (p > eap->arg && vim_iswhite(p[-1])) 2126 --p; 2127 for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i) 2128 ; 2129 if (eap->arg + i == p) /* digits only */ 2130 i = atol((char *)eap->arg); 2131 else 2132 { 2133 i = buflist_findpat(eap->arg, p, FALSE, TRUE); 2134 if (i < 0) 2135 return; /* error message already given */ 2136 } 2137 buf = buflist_findnr(i); 2138 if (buf == NULL) 2139 { 2140 EMSG2(_("E102: Can't find buffer \"%s\""), eap->arg); 2141 return; 2142 } 2143 if (buf == curbuf) 2144 return; /* nothing to do */ 2145 idx_other = diff_buf_idx(buf); 2146 if (idx_other == DB_COUNT) 2147 { 2148 EMSG2(_("E103: Buffer \"%s\" is not in diff mode"), eap->arg); 2149 return; 2150 } 2151 } 2152 2153 diff_busy = TRUE; 2154 2155 /* When no range given include the line above or below the cursor. */ 2156 if (eap->addr_count == 0) 2157 { 2158 /* Make it possible that ":diffget" on the last line gets line below 2159 * the cursor line when there is no difference above the cursor. */ 2160 if (eap->cmdidx == CMD_diffget 2161 && eap->line1 == curbuf->b_ml.ml_line_count 2162 && diff_check(curwin, eap->line1) == 0 2163 && (eap->line1 == 1 || diff_check(curwin, eap->line1 - 1) == 0)) 2164 ++eap->line2; 2165 else if (eap->line1 > 0) 2166 --eap->line1; 2167 } 2168 2169 if (eap->cmdidx == CMD_diffget) 2170 { 2171 idx_from = idx_other; 2172 idx_to = idx_cur; 2173 } 2174 else 2175 { 2176 idx_from = idx_cur; 2177 idx_to = idx_other; 2178 /* Need to make the other buffer the current buffer to be able to make 2179 * changes in it. */ 2180 /* set curwin/curbuf to buf and save a few things */ 2181 aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]); 2182 } 2183 2184 /* May give the warning for a changed buffer here, which can trigger the 2185 * FileChangedRO autocommand, which may do nasty things and mess 2186 * everything up. */ 2187 if (!curbuf->b_changed) 2188 { 2189 change_warning(0); 2190 if (diff_buf_idx(curbuf) != idx_to) 2191 { 2192 EMSG(_("E787: Buffer changed unexpectedly")); 2193 return; 2194 } 2195 } 2196 2197 dprev = NULL; 2198 for (dp = curtab->tp_first_diff; dp != NULL; ) 2199 { 2200 if (dp->df_lnum[idx_cur] > eap->line2 + off) 2201 break; /* past the range that was specified */ 2202 2203 dfree = NULL; 2204 lnum = dp->df_lnum[idx_to]; 2205 count = dp->df_count[idx_to]; 2206 if (dp->df_lnum[idx_cur] + dp->df_count[idx_cur] > eap->line1 + off 2207 && u_save(lnum - 1, lnum + count) != FAIL) 2208 { 2209 /* Inside the specified range and saving for undo worked. */ 2210 start_skip = 0; 2211 end_skip = 0; 2212 if (eap->addr_count > 0) 2213 { 2214 /* A range was specified: check if lines need to be skipped. */ 2215 start_skip = eap->line1 + off - dp->df_lnum[idx_cur]; 2216 if (start_skip > 0) 2217 { 2218 /* range starts below start of current diff block */ 2219 if (start_skip > count) 2220 { 2221 lnum += count; 2222 count = 0; 2223 } 2224 else 2225 { 2226 count -= start_skip; 2227 lnum += start_skip; 2228 } 2229 } 2230 else 2231 start_skip = 0; 2232 2233 end_skip = dp->df_lnum[idx_cur] + dp->df_count[idx_cur] - 1 2234 - (eap->line2 + off); 2235 if (end_skip > 0) 2236 { 2237 /* range ends above end of current/from diff block */ 2238 if (idx_cur == idx_from) /* :diffput */ 2239 { 2240 i = dp->df_count[idx_cur] - start_skip - end_skip; 2241 if (count > i) 2242 count = i; 2243 } 2244 else /* :diffget */ 2245 { 2246 count -= end_skip; 2247 end_skip = dp->df_count[idx_from] - start_skip - count; 2248 if (end_skip < 0) 2249 end_skip = 0; 2250 } 2251 } 2252 else 2253 end_skip = 0; 2254 } 2255 2256 buf_empty = FALSE; 2257 added = 0; 2258 for (i = 0; i < count; ++i) 2259 { 2260 /* remember deleting the last line of the buffer */ 2261 buf_empty = curbuf->b_ml.ml_line_count == 1; 2262 ml_delete(lnum, FALSE); 2263 --added; 2264 } 2265 for (i = 0; i < dp->df_count[idx_from] - start_skip - end_skip; ++i) 2266 { 2267 linenr_T nr; 2268 2269 nr = dp->df_lnum[idx_from] + start_skip + i; 2270 if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) 2271 break; 2272 p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], 2273 nr, FALSE)); 2274 if (p != NULL) 2275 { 2276 ml_append(lnum + i - 1, p, 0, FALSE); 2277 vim_free(p); 2278 ++added; 2279 if (buf_empty && curbuf->b_ml.ml_line_count == 2) 2280 { 2281 /* Added the first line into an empty buffer, need to 2282 * delete the dummy empty line. */ 2283 buf_empty = FALSE; 2284 ml_delete((linenr_T)2, FALSE); 2285 } 2286 } 2287 } 2288 new_count = dp->df_count[idx_to] + added; 2289 dp->df_count[idx_to] = new_count; 2290 2291 if (start_skip == 0 && end_skip == 0) 2292 { 2293 /* Check if there are any other buffers and if the diff is 2294 * equal in them. */ 2295 for (i = 0; i < DB_COUNT; ++i) 2296 if (curtab->tp_diffbuf[i] != NULL && i != idx_from 2297 && i != idx_to 2298 && !diff_equal_entry(dp, idx_from, i)) 2299 break; 2300 if (i == DB_COUNT) 2301 { 2302 /* delete the diff entry, the buffers are now equal here */ 2303 dfree = dp; 2304 dp = dp->df_next; 2305 if (dprev == NULL) 2306 curtab->tp_first_diff = dp; 2307 else 2308 dprev->df_next = dp; 2309 } 2310 } 2311 2312 /* Adjust marks. This will change the following entries! */ 2313 if (added != 0) 2314 { 2315 mark_adjust(lnum, lnum + count - 1, (long)MAXLNUM, (long)added); 2316 if (curwin->w_cursor.lnum >= lnum) 2317 { 2318 /* Adjust the cursor position if it's in/after the changed 2319 * lines. */ 2320 if (curwin->w_cursor.lnum >= lnum + count) 2321 curwin->w_cursor.lnum += added; 2322 else if (added < 0) 2323 curwin->w_cursor.lnum = lnum; 2324 } 2325 } 2326 changed_lines(lnum, 0, lnum + count, (long)added); 2327 2328 if (dfree != NULL) 2329 { 2330 /* Diff is deleted, update folds in other windows. */ 2331 #ifdef FEAT_FOLDING 2332 diff_fold_update(dfree, idx_to); 2333 #endif 2334 vim_free(dfree); 2335 } 2336 else 2337 /* mark_adjust() may have changed the count in a wrong way */ 2338 dp->df_count[idx_to] = new_count; 2339 2340 /* When changing the current buffer, keep track of line numbers */ 2341 if (idx_cur == idx_to) 2342 off += added; 2343 } 2344 2345 /* If before the range or not deleted, go to next diff. */ 2346 if (dfree == NULL) 2347 { 2348 dprev = dp; 2349 dp = dp->df_next; 2350 } 2351 } 2352 2353 /* restore curwin/curbuf and a few other things */ 2354 if (idx_other == idx_to) 2355 { 2356 /* Syncing undo only works for the current buffer, but we change 2357 * another buffer. Sync undo if the command was typed. This isn't 2358 * 100% right when ":diffput" is used in a function or mapping. */ 2359 if (KeyTyped) 2360 u_sync(FALSE); 2361 aucmd_restbuf(&aco); 2362 } 2363 2364 diff_busy = FALSE; 2365 2366 /* Check that the cursor is on a valid character and update it's position. 2367 * When there were filler lines the topline has become invalid. */ 2368 check_cursor(); 2369 changed_line_abv_curs(); 2370 2371 /* Also need to redraw the other buffers. */ 2372 diff_redraw(FALSE); 2373 } 2374 2375 #ifdef FEAT_FOLDING 2376 /* 2377 * Update folds for all diff buffers for entry "dp". 2378 * Skip buffer with index "skip_idx". 2379 * When there are no diffs, all folds are removed. 2380 */ 2381 static void 2382 diff_fold_update(dp, skip_idx) 2383 diff_T *dp; 2384 int skip_idx; 2385 { 2386 int i; 2387 win_T *wp; 2388 2389 for (wp = firstwin; wp != NULL; wp = wp->w_next) 2390 for (i = 0; i < DB_COUNT; ++i) 2391 if (curtab->tp_diffbuf[i] == wp->w_buffer && i != skip_idx) 2392 foldUpdate(wp, dp->df_lnum[i], 2393 dp->df_lnum[i] + dp->df_count[i]); 2394 } 2395 #endif 2396 2397 /* 2398 * Return TRUE if buffer "buf" is in diff-mode. 2399 */ 2400 int 2401 diff_mode_buf(buf) 2402 buf_T *buf; 2403 { 2404 tabpage_T *tp; 2405 2406 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 2407 if (diff_buf_idx_tp(buf, tp) != DB_COUNT) 2408 return TRUE; 2409 return FALSE; 2410 } 2411 2412 /* 2413 * Move "count" times in direction "dir" to the next diff block. 2414 * Return FAIL if there isn't such a diff block. 2415 */ 2416 int 2417 diff_move_to(dir, count) 2418 int dir; 2419 long count; 2420 { 2421 int idx; 2422 linenr_T lnum = curwin->w_cursor.lnum; 2423 diff_T *dp; 2424 2425 idx = diff_buf_idx(curbuf); 2426 if (idx == DB_COUNT || curtab->tp_first_diff == NULL) 2427 return FAIL; 2428 2429 if (curtab->tp_diff_invalid) 2430 ex_diffupdate(NULL); /* update after a big change */ 2431 2432 if (curtab->tp_first_diff == NULL) /* no diffs today */ 2433 return FAIL; 2434 2435 while (--count >= 0) 2436 { 2437 /* Check if already before first diff. */ 2438 if (dir == BACKWARD && lnum <= curtab->tp_first_diff->df_lnum[idx]) 2439 break; 2440 2441 for (dp = curtab->tp_first_diff; ; dp = dp->df_next) 2442 { 2443 if (dp == NULL) 2444 break; 2445 if ((dir == FORWARD && lnum < dp->df_lnum[idx]) 2446 || (dir == BACKWARD 2447 && (dp->df_next == NULL 2448 || lnum <= dp->df_next->df_lnum[idx]))) 2449 { 2450 lnum = dp->df_lnum[idx]; 2451 break; 2452 } 2453 } 2454 } 2455 2456 /* don't end up past the end of the file */ 2457 if (lnum > curbuf->b_ml.ml_line_count) 2458 lnum = curbuf->b_ml.ml_line_count; 2459 2460 /* When the cursor didn't move at all we fail. */ 2461 if (lnum == curwin->w_cursor.lnum) 2462 return FAIL; 2463 2464 setpcmark(); 2465 curwin->w_cursor.lnum = lnum; 2466 curwin->w_cursor.col = 0; 2467 2468 return OK; 2469 } 2470 2471 #if defined(FEAT_FOLDING) || defined(PROTO) 2472 /* 2473 * For line "lnum" in the current window find the equivalent lnum in window 2474 * "wp", compensating for inserted/deleted lines. 2475 */ 2476 linenr_T 2477 diff_lnum_win(lnum, wp) 2478 linenr_T lnum; 2479 win_T *wp; 2480 { 2481 diff_T *dp; 2482 int idx; 2483 int i; 2484 linenr_T n; 2485 2486 idx = diff_buf_idx(curbuf); 2487 if (idx == DB_COUNT) /* safety check */ 2488 return (linenr_T)0; 2489 2490 if (curtab->tp_diff_invalid) 2491 ex_diffupdate(NULL); /* update after a big change */ 2492 2493 /* search for a change that includes "lnum" in the list of diffblocks. */ 2494 for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) 2495 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) 2496 break; 2497 2498 /* When after the last change, compute relative to the last line number. */ 2499 if (dp == NULL) 2500 return wp->w_buffer->b_ml.ml_line_count 2501 - (curbuf->b_ml.ml_line_count - lnum); 2502 2503 /* Find index for "wp". */ 2504 i = diff_buf_idx(wp->w_buffer); 2505 if (i == DB_COUNT) /* safety check */ 2506 return (linenr_T)0; 2507 2508 n = lnum + (dp->df_lnum[i] - dp->df_lnum[idx]); 2509 if (n > dp->df_lnum[i] + dp->df_count[i]) 2510 n = dp->df_lnum[i] + dp->df_count[i]; 2511 return n; 2512 } 2513 #endif 2514 2515 #endif /* FEAT_DIFF */ 2516