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