#include "vim.h"

#include "xdiff/xdiff.h"

#if defined(FEAT_DIFF) || defined(PROTO)

static int diff_busy = FALSE; // using diff structs, don't change them

static int diff_need_update = FALSE; // ex_diffupdate needs to be called

#define DIFF_FILLER 0x001 // display filler lines

#define DIFF_IBLANK 0x002 // ignore empty lines

#define DIFF_ICASE 0x004 // ignore case

#define DIFF_IWHITE 0x008 // ignore change in white space

#define DIFF_IWHITEALL 0x010 // ignore all white space changes

#define DIFF_IWHITEEOL 0x020 // ignore change in white space at EOL

#define DIFF_HORIZONTAL 0x040 // horizontal splits

#define DIFF_VERTICAL 0x080 // vertical splits

#define DIFF_HIDDEN_OFF 0x100 // diffoff when hidden

#define DIFF_INTERNAL 0x200 // use internal xdiff algorithm

#define DIFF_CLOSE_OFF 0x400 // diffoff when closing window

#define DIFF_FOLLOWWRAP 0x800 // follow the wrap option

#define DIFF_LINEMATCH 0x1000 // match most similar lines within diff

#define DIFF_INLINE_NONE 0x2000 // no inline highlight

#define DIFF_INLINE_SIMPLE 0x4000 // inline highlight with simple algorithm

#define DIFF_INLINE_CHAR 0x8000 // inline highlight with character diff

#define DIFF_INLINE_WORD 0x10000 // inline highlight with word diff

#define DIFF_ANCHOR 0x20000 // use 'diffanchors' to anchor the diff

#define ALL_WHITE_DIFF (DIFF_IWHITE | DIFF_IWHITEALL | DIFF_IWHITEEOL)

#define ALL_INLINE (DIFF_INLINE_NONE | DIFF_INLINE_SIMPLE | DIFF_INLINE_CHAR | DIFF_INLINE_WORD)

#define ALL_INLINE_DIFF (DIFF_INLINE_CHAR | DIFF_INLINE_WORD)

static int diff_flags = DIFF_INTERNAL | DIFF_FILLER | DIFF_CLOSE_OFF;

static long diff_algorithm = 0;

#define LBUFLEN 50 // length of line in diff file

static int diff_a_works = MAYBE; // TRUE when "diff -a" works, FALSE when it

// doesn't work, MAYBE when not checked yet

#if defined(MSWIN)

static int diff_bin_works = MAYBE; // TRUE when "diff --binary" works, FALSE

// when it doesn't work, MAYBE when not

// checked yet

#define MAX_DIFF_ANCHORS 20

typedef struct {

char_u *din_fname; // used for external diff

mmfile_t din_mmfile; // used for internal diff

} diffin_T;

typedef struct {

char_u *dout_fname; // used for external diff

garray_T dout_ga; // used for internal diff

} diffout_T;

typedef struct {

linenr_T lnum_orig;

long count_orig;

linenr_T lnum_new;

long count_new;

} diffhunk_T;

typedef enum {

DIO_OUTPUT_INDICES = 0, // default

DIO_OUTPUT_UNIFIED = 1 // unified diff format

} dio_outfmt_T;

typedef struct {

diffin_T dio_orig; // original file input

diffin_T dio_new; // new file input

diffout_T dio_diff; // diff result

int dio_internal; // using internal diff

dio_outfmt_T dio_outfmt; // internal diff output format

int dio_ctxlen; // unified diff context length

} diffio_T;

static int diff_buf_idx(buf_T *buf);

static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp);

static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after);

static void diff_check_unchanged(tabpage_T *tp, diff_T *dp);

static int diff_check_sanity(tabpage_T *tp, diff_T *dp);

static int check_external_diff(diffio_T *diffio);

static int diff_file(diffio_T *diffio);

static int diff_equal_entry(diff_T *dp, int idx1, int idx2);

static int diff_cmp(char_u *s1, char_u *s2);

#ifdef FEAT_FOLDING

static void diff_fold_update(diff_T *dp, int skip_idx);

static void diff_read(int idx_orig, int idx_new, diffio_T *dio);

static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new);

static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp);

static int parse_diff_ed(char_u *line, diffhunk_T *hunk);

static int parse_diff_unified(char_u *line, diffhunk_T *hunk);

static int xdiff_out_indices(long start_a, long count_a, long start_b, long count_b, void *priv);

static int xdiff_out_unified(void *priv, mmbuffer_t *mb, int nbuf);

static int parse_diffanchors(int check_only, buf_T *buf, linenr_T *anchors, int *num_anchors);

#define FOR_ALL_DIFFBLOCKS_IN_TAB(tp, dp) \

for ((dp) = (tp)->tp_first_diff; (dp) != NULL; (dp) = (dp)->df_next)

static void

clear_diffblock(diff_T *dp)

{

ga_clear(&dp->df_changes);

vim_free(dp);

}

void

diff_buf_delete(buf_T *buf)

{

int i;

tabpage_T *tp;

FOR_ALL_TABPAGES(tp)

{

i = diff_buf_idx_tp(buf, tp);

if (i != DB_COUNT)

{

tp->tp_diffbuf[i] = NULL;

tp->tp_diff_invalid = TRUE;

if (tp == curtab)

{

// don't redraw right away, more might change or buffer state

// is invalid right now

need_diff_redraw = TRUE;

redraw_later(UPD_VALID);

}

}

}

}

void

diff_buf_adjust(win_T *win)

{

win_T *wp;

int i;

if (!win->w_p_diff)

{

// When there is no window showing a diff for this buffer, remove

// it from the diffs.

FOR_ALL_WINDOWS(wp)

if (wp->w_buffer == win->w_buffer && wp->w_p_diff)

break;

if (wp == NULL)

{

i = diff_buf_idx(win->w_buffer);

if (i != DB_COUNT)

{

curtab->tp_diffbuf[i] = NULL;

curtab->tp_diff_invalid = TRUE;

diff_redraw(TRUE);

}

}

}

else

diff_buf_add(win->w_buffer);

}

void

diff_buf_add(buf_T *buf)

{

int i;

if (diff_buf_idx(buf) != DB_COUNT)

return; // It's already there.

for (i = 0; i < DB_COUNT; ++i)

if (curtab->tp_diffbuf[i] == NULL)

{

curtab->tp_diffbuf[i] = buf;

curtab->tp_diff_invalid = TRUE;

diff_redraw(TRUE);

return;

}

semsg(_(e_cannot_diff_more_than_nr_buffers), DB_COUNT);

}

static void

diff_buf_clear(void)

{

int i;

for (i = 0; i < DB_COUNT; ++i)

if (curtab->tp_diffbuf[i] != NULL)

{

curtab->tp_diffbuf[i] = NULL;

curtab->tp_diff_invalid = TRUE;

diff_redraw(TRUE);

}

}

static int

diff_buf_idx(buf_T *buf)

{

int idx;

for (idx = 0; idx < DB_COUNT; ++idx)

if (curtab->tp_diffbuf[idx] == buf)

break;

return idx;

}

static int

diff_buf_idx_tp(buf_T *buf, tabpage_T *tp)

{

int idx;

for (idx = 0; idx < DB_COUNT; ++idx)

if (tp->tp_diffbuf[idx] == buf)

break;

return idx;

}

void

diff_invalidate(buf_T *buf)

{

tabpage_T *tp;

int i;

FOR_ALL_TABPAGES(tp)

{

i = diff_buf_idx_tp(buf, tp);

if (i != DB_COUNT)

{

tp->tp_diff_invalid = TRUE;

if (tp == curtab)

diff_redraw(TRUE);

}

}

}

void

diff_mark_adjust(

long amount_after)

{

int idx;

tabpage_T *tp;

// Handle all tab pages that use the current buffer in a diff.

FOR_ALL_TABPAGES(tp)

{

idx = diff_buf_idx_tp(curbuf, tp);

if (idx != DB_COUNT)

diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after);

}

}

static void

diff_mark_adjust_tp(

long amount_after)

{

diff_T *dp;

diff_T *dprev;

diff_T *dnext;

int i;

int inserted, deleted;

int n, off;

linenr_T last;

linenr_T lnum_deleted = line1; // lnum of remaining deletion

int check_unchanged;

if (diff_internal())

{

// Will update diffs before redrawing. Set _invalid to update the

// diffs themselves, set _update to also update folds properly just

// before redrawing.

// Do update marks here, it is needed for :%diffput.

tp->tp_diff_invalid = TRUE;

tp->tp_diff_update = TRUE;

}

if (line2 == MAXLNUM)

{

// mark_adjust(99, MAXLNUM, 9, 0): insert lines

inserted = amount;

deleted = 0;

}

else if (amount_after > 0)

{

// mark_adjust(99, 98, MAXLNUM, 9): a change that inserts lines

inserted = amount_after;

deleted = 0;

}

else

{

// mark_adjust(98, 99, MAXLNUM, -2): delete lines

inserted = 0;

deleted = -amount_after;

}

dprev = NULL;

dp = tp->tp_first_diff;

for (;;)

{

// If the change is after the previous diff block and before the next

// diff block, thus not touching an existing change, create a new diff

// block. Don't do this when ex_diffgetput() is busy.

if ((dp == NULL || dp->df_lnum[idx] - 1 > line2

|| (line2 == MAXLNUM && dp->df_lnum[idx] > line1))

&& (dprev == NULL

|| dprev->df_lnum[idx] + dprev->df_count[idx] < line1)

&& !diff_busy)

{

dnext = diff_alloc_new(tp, dprev, dp);

if (dnext == NULL)

return;

dnext->df_lnum[idx] = line1;

dnext->df_count[idx] = inserted;

for (i = 0; i < DB_COUNT; ++i)

if (tp->tp_diffbuf[i] != NULL && i != idx)

{

if (dprev == NULL)

dnext->df_lnum[i] = line1;

else

dnext->df_lnum[i] = line1

+ (dprev->df_lnum[i] + dprev->df_count[i])

- (dprev->df_lnum[idx] + dprev->df_count[idx]);

dnext->df_count[i] = deleted;

}

}

// if at end of the list, quit

if (dp == NULL)

break;

/*

// compute last line of this change

last = dp->df_lnum[idx] + dp->df_count[idx] - 1;

// 1. change completely above line1: nothing to do

if (last >= line1 - 1)

{

if (diff_busy)

{

// Currently in the middle of updating diff blocks. All we want

// is to adjust the line numbers and nothing else.

if (dp->df_lnum[idx] > line2)

dp->df_lnum[idx] += amount_after;

// Advance to next entry.

dprev = dp;

dp = dp->df_next;

continue;

}

// 6. change below line2: only adjust for amount_after; also when

// "deleted" became zero when deleted all lines between two diffs

if (dp->df_lnum[idx] - (deleted + inserted != 0) > line2)

{

if (amount_after == 0)

break; // nothing left to change

dp->df_lnum[idx] += amount_after;

}

else

{

check_unchanged = FALSE;

// 2. 3. 4. 5.: inserted/deleted lines touching this diff.

if (deleted > 0)

{

off = 0;

if (dp->df_lnum[idx] >= line1)

{

if (last <= line2)

{

// 4. delete all lines of diff

if (dp->df_next != NULL

&& dp->df_next->df_lnum[idx] - 1 <= line2)

{

// delete continues in next diff, only do

// lines until that one

n = dp->df_next->df_lnum[idx] - lnum_deleted;

deleted -= n;

n -= dp->df_count[idx];

lnum_deleted = dp->df_next->df_lnum[idx];

}

else

n = deleted - dp->df_count[idx];

dp->df_count[idx] = 0;

}

else

{

// 5. delete lines at or just before top of diff

off = dp->df_lnum[idx] - lnum_deleted;

n = off;

dp->df_count[idx] -= line2 - dp->df_lnum[idx] + 1;

check_unchanged = TRUE;

}

dp->df_lnum[idx] = line1;

}

else

{

if (last < line2)

{

// 2. delete at end of diff

dp->df_count[idx] -= last - lnum_deleted + 1;

if (dp->df_next != NULL

&& dp->df_next->df_lnum[idx] - 1 <= line2)

{

// delete continues in next diff, only do

// lines until that one

n = dp->df_next->df_lnum[idx] - 1 - last;

deleted -= dp->df_next->df_lnum[idx]

- lnum_deleted;

lnum_deleted = dp->df_next->df_lnum[idx];

}

else

n = line2 - last;

check_unchanged = TRUE;

}

else

{

// 3. delete lines inside the diff

n = 0;

dp->df_count[idx] -= deleted;

}

}

for (i = 0; i < DB_COUNT; ++i)

if (tp->tp_diffbuf[i] != NULL && i != idx)

{

if (dp->df_lnum[i] > off)

dp->df_lnum[i] -= off;

else

dp->df_lnum[i] = 1;

dp->df_count[i] += n;

}

}

else

{

if (dp->df_lnum[idx] <= line1)

{

// inserted lines somewhere in this diff

dp->df_count[idx] += inserted;

check_unchanged = TRUE;

}

else

// inserted lines somewhere above this diff

dp->df_lnum[idx] += inserted;

}

if (check_unchanged)

// Check if inserted lines are equal, may reduce the

// size of the diff. TODO: also check for equal lines

// in the middle and perhaps split the block.

diff_check_unchanged(tp, dp);

}

}

// check if this block touches the previous one, may merge them.

if (dprev != NULL && !dp->is_linematched && !diff_busy

&& dprev->df_lnum[idx] + dprev->df_count[idx]

== dp->df_lnum[idx])

{

for (i = 0; i < DB_COUNT; ++i)

if (tp->tp_diffbuf[i] != NULL)

dprev->df_count[i] += dp->df_count[i];

dprev->df_next = dp->df_next;

clear_diffblock(dp);

dp = dprev->df_next;

}

else

{

// Advance to next entry.

dprev = dp;

dp = dp->df_next;

}

}

dprev = NULL;

dp = tp->tp_first_diff;

while (dp != NULL)

{

// All counts are zero, remove this entry.

for (i = 0; i < DB_COUNT; ++i)

if (tp->tp_diffbuf[i] != NULL && dp->df_count[i] != 0)

break;

if (i == DB_COUNT)

{

dnext = dp->df_next;

clear_diffblock(dp);

dp = dnext;

if (dprev == NULL)

tp->tp_first_diff = dnext;

else

dprev->df_next = dnext;

}

else

{

// Advance to next entry.

dprev = dp;

dp = dp->df_next;

}

}

if (tp == curtab)

{

// Don't redraw right away, this updates the diffs, which can be slow.

need_diff_redraw = TRUE;

// Need to recompute the scroll binding, may remove or add filler

// lines (e.g., when adding lines above w_topline). But it's slow when

// making many changes, postpone until redrawing.

diff_need_scrollbind = TRUE;

}

}

static diff_T *

diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)

{

diff_T *dnew;

dnew = ALLOC_CLEAR_ONE(diff_T);

if (dnew == NULL)

return NULL;

dnew->is_linematched = FALSE;

dnew->df_next = dp;

if (dprev == NULL)

tp->tp_first_diff = dnew;

else

dprev->df_next = dnew;

dnew->has_changes = FALSE;

ga_init2(&dnew->df_changes, sizeof(diffline_change_T), 20);

return dnew;

}

static void

diff_check_unchanged(tabpage_T *tp, diff_T *dp)

{

int i_org;

int i_new;

int off_org, off_new;

char_u *line_org;

int dir = FORWARD;

// Find the first buffers, use it as the original, compare the other

// buffer lines against this one.

for (i_org = 0; i_org < DB_COUNT; ++i_org)

if (tp->tp_diffbuf[i_org] != NULL)

break;

if (i_org == DB_COUNT) // safety check

return;

if (diff_check_sanity(tp, dp) == FAIL)

return;

// First check lines at the top, then at the bottom.

off_org = 0;

off_new = 0;

for (;;)

{

// Repeat until a line is found which is different or the number of

// lines has become zero.

while (dp->df_count[i_org] > 0)

{

// Copy the line, the next ml_get() will invalidate it.

if (dir == BACKWARD)

off_org = dp->df_count[i_org] - 1;

line_org = vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org],

dp->df_lnum[i_org] + off_org, FALSE));

if (line_org == NULL)

return;

for (i_new = i_org + 1; i_new < DB_COUNT; ++i_new)

{

if (tp->tp_diffbuf[i_new] == NULL)

continue;

if (dir == BACKWARD)

off_new = dp->df_count[i_new] - 1;

// if other buffer doesn't have this line, it was inserted

if (off_new < 0 || off_new >= dp->df_count[i_new])

break;

if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new],

dp->df_lnum[i_new] + off_new, FALSE)) != 0)

break;

}

vim_free(line_org);

// Stop when a line isn't equal in all diff buffers.

if (i_new != DB_COUNT)

break;

// Line matched in all buffers, remove it from the diff.

for (i_new = i_org; i_new < DB_COUNT; ++i_new)

if (tp->tp_diffbuf[i_new] != NULL)

{

if (dir == FORWARD)

++dp->df_lnum[i_new];

--dp->df_count[i_new];

}

}

if (dir == BACKWARD)

break;

dir = BACKWARD;

}

}

static int

diff_check_sanity(tabpage_T *tp, diff_T *dp)

{

int i;

for (i = 0; i < DB_COUNT; ++i)

if (tp->tp_diffbuf[i] != NULL)

if (dp->df_lnum[i] + dp->df_count[i] - 1

> tp->tp_diffbuf[i]->b_ml.ml_line_count)

return FAIL;

return OK;

}

void

diff_redraw(

int dofold) // also recompute the folds

{

win_T *wp;

win_T *wp_other = NULL;

int used_max_fill_other = FALSE;

int used_max_fill_curwin = FALSE;

int n;

need_diff_redraw = FALSE;

FOR_ALL_WINDOWS(wp)

{

// when closing windows or wiping buffers skip invalid window

if (!wp->w_p_diff || !buf_valid(wp->w_buffer))

continue;

redraw_win_later(wp, UPD_SOME_VALID);

if (wp != curwin)

wp_other = wp;

#ifdef FEAT_FOLDING

if (dofold && foldmethodIsDiff(wp))

foldUpdateAll(wp);

// A change may have made filler lines invalid, need to take care of

// that for other windows.

n = diff_check_fill(wp, wp->w_topline);

if ((wp != curwin && wp->w_topfill > 0) || n > 0)

{

if (wp->w_topfill > n)

wp->w_topfill = (n < 0 ? 0 : n);

else if (n > 0 && n > wp->w_topfill)

{

wp->w_topfill = n;

if (wp == curwin)

used_max_fill_curwin = TRUE;

else if (wp_other != NULL)

used_max_fill_other = TRUE;

}

check_topfill(wp, FALSE);

}

}

if (wp_other != NULL && curwin->w_p_scb)

{

if (used_max_fill_curwin)

// The current window was set to use the maximum number of filler

// lines, may need to reduce them.

diff_set_topline(wp_other, curwin);

else if (used_max_fill_other)

// The other window was set to use the maximum number of filler

// lines, may need to reduce them.

diff_set_topline(curwin, wp_other);

}

}

static void

clear_diffin(diffin_T *din)

{

if (din->din_fname == NULL)

VIM_CLEAR(din->din_mmfile.ptr);

else

mch_remove(din->din_fname);

}

static void

clear_diffout(diffout_T *dout)

{

if (dout->dout_fname == NULL)

ga_clear_strings(&dout->dout_ga);

else

mch_remove(dout->dout_fname);

}

static int

diff_write_buffer(buf_T *buf, diffin_T *din, linenr_T start, linenr_T end)

{

linenr_T lnum;

char_u *s;

long len = 0;

char_u *ptr;

if (end < 0)

end = buf->b_ml.ml_line_count;

if (buf->b_ml.ml_flags & ML_EMPTY || end < start)

{

din->din_mmfile.ptr = NULL;

din->din_mmfile.size = 0;

return OK;

}

// xdiff requires one big block of memory with all the text.

for (lnum = start; lnum <= end; ++lnum)

len += ml_get_buf_len(buf, lnum) + 1;

ptr = alloc(len);

if (ptr == NULL)

{

// Allocating memory failed. This can happen, because we try to read

// the whole buffer text into memory. Set the failed flag, the diff

// will be retried with external diff. The flag is never reset.

buf->b_diff_failed = TRUE;

if (p_verbose > 0)

{

verbose_enter();

smsg(_("Not enough memory to use internal diff for buffer \"%s\""),

buf->b_fname);

verbose_leave();

}

return FAIL;

}

din->din_mmfile.ptr = (char *)ptr;

din->din_mmfile.size = len;

len = 0;

for (lnum = start; lnum <= end; ++lnum)

{

for (s = ml_get_buf(buf, lnum, FALSE); *s != NUL; )

{

if (diff_flags & DIFF_ICASE)

{

int c;

int orig_len;

int c_len = 1;

char_u cbuf[MB_MAXBYTES + 1];

if (*s == NL)

c = NUL;

else

{

// xdiff doesn't support ignoring case, fold-case the text.

c = PTR2CHAR(s);

c_len = MB_CHAR2LEN(c);

c = MB_CASEFOLD(c);

}

orig_len = mb_ptr2len(s);

if (mb_char2bytes(c, cbuf) != c_len)

// TODO: handle byte length difference.

// One example is Å (3 bytes) and å (2 bytes).

mch_memmove(ptr + len, s, orig_len);

else

{

mch_memmove(ptr + len, cbuf, c_len);

if (orig_len > c_len)

{

// Copy remaining composing characters

mch_memmove(ptr + len + c_len, s + c_len,

orig_len - c_len);

}

}

s += orig_len;

len += orig_len;

}

else

{

ptr[len++] = *s == NL ? NUL : *s;

s++;

}

}

ptr[len++] = NL;

}

return OK;

}

static int

diff_write(buf_T *buf, diffin_T *din, linenr_T start, linenr_T end)

{

int r;

int save_ml_flags;

char_u *save_ff;

int save_cmod_flags;

if (din->din_fname == NULL)

return diff_write_buffer(buf, din, start, end);

if (end < 0)

end = buf->b_ml.ml_line_count;

// Always use 'fileformat' set to "unix".

save_ml_flags = buf->b_ml.ml_flags;

save_ff = buf->b_p_ff;

buf->b_p_ff = vim_strsave((char_u *)FF_UNIX);

save_cmod_flags = cmdmod.cmod_flags;

// Writing the buffer is an implementation detail of performing the diff,

// so it shouldn't update the '[ and '] marks.

cmdmod.cmod_flags |= CMOD_LOCKMARKS;

if (end < start)

{

// The line range specifies a completely empty file.

end = start;

buf->b_ml.ml_flags |= ML_EMPTY;

}

r = buf_write(buf, din->din_fname, NULL,

start, end,

NULL, FALSE, FALSE, FALSE, TRUE);

cmdmod.cmod_flags = save_cmod_flags;

free_string_option(buf->b_p_ff);

buf->b_p_ff = save_ff;

buf->b_ml.ml_flags = save_ml_flags;

return r;

}

static int

lnum_compare(const void *s1, const void *s2)

{

linenr_T lnum1 = *(linenr_T*)s1;

linenr_T lnum2 = *(linenr_T*)s2;

if (lnum1 < lnum2)

return -1;

if (lnum1 > lnum2)

return 1;

return 0;

}

static void

diff_try_update(

diffio_T *dio,

int idx_orig,

exarg_T *eap) // "eap" can be NULL

{

buf_T *buf;

int idx_new;

if (dio->dio_internal)

{

ga_init2(&dio->dio_diff.dout_ga, sizeof(char *), 1000);

}

else

{

// We need three temp file names.

dio->dio_orig.din_fname = vim_tempname('o', TRUE);

dio->dio_new.din_fname = vim_tempname('n', TRUE);

dio->dio_diff.dout_fname = vim_tempname('d', TRUE);

if (dio->dio_orig.din_fname == NULL

|| dio->dio_new.din_fname == NULL

|| dio->dio_diff.dout_fname == NULL)

goto theend;

}

// Check external diff is actually working.

if (!dio->dio_internal && check_external_diff(dio) == FAIL)

goto theend;

// :diffupdate!

if (eap != NULL && eap->forceit)

for (idx_new = idx_orig; idx_new < DB_COUNT; ++idx_new)

{

buf = curtab->tp_diffbuf[idx_new];

if (buf_valid(buf))

buf_check_timestamp(buf, FALSE);

}

// Parse and sort diff anchors if enabled

int num_anchors = INT_MAX;

linenr_T anchors[DB_COUNT][MAX_DIFF_ANCHORS];

CLEAR_FIELD(anchors);

if (diff_flags & DIFF_ANCHOR)

{

for (int idx = 0; idx < DB_COUNT; idx++)

{

if (curtab->tp_diffbuf[idx] == NULL)

continue;

int buf_num_anchors = 0;

if (parse_diffanchors(FALSE,

curtab->tp_diffbuf[idx],

anchors[idx],

&buf_num_anchors) != OK)

{

emsg(_(e_failed_to_find_all_diff_anchors));

num_anchors = 0;

CLEAR_FIELD(anchors);

break;

}

if (buf_num_anchors < num_anchors)

num_anchors = buf_num_anchors;