diff options
Diffstat (limited to 'src/nvim/diff.c')
| -rw-r--r-- | src/nvim/diff.c | 2611 |
1 files changed, 2611 insertions, 0 deletions
diff --git a/src/nvim/diff.c b/src/nvim/diff.c new file mode 100644 index 0000000000..e360edc665 --- /dev/null +++ b/src/nvim/diff.c @@ -0,0 +1,2611 @@ +/// @file diff.c +/// +/// Code for diff'ing two, three or four buffers. + +#include "vim.h" +#include "diff.h" +#include "buffer.h" +#include "charset.h" +#include "eval.h" +#include "ex_cmds.h" +#include "ex_docmd.h" +#include "fileio.h" +#include "fold.h" +#include "mark.h" +#include "mbyte.h" +#include "memline.h" +#include "message.h" +#include "misc1.h" +#include "misc2.h" +#include "memory.h" +#include "move.h" +#include "normal.h" +#include "option.h" +#include "path.h" +#include "screen.h" +#include "undo.h" +#include "window.h" +#include "os/os.h" +#include "os/shell.h" + +static int diff_busy = FALSE; // ex_diffgetput() is busy + +// Flags obtained from the 'diffopt' option +#define DIFF_FILLER 1 // display filler lines +#define DIFF_ICASE 2 // ignore case +#define DIFF_IWHITE 4 // ignore change in white space +#define DIFF_HORIZONTAL 8 // horizontal splits +#define DIFF_VERTICAL 16 // vertical splits +static int diff_flags = DIFF_FILLER; + +#define LBUFLEN 50 // length of line in diff file + +// TRUE when "diff -a" works, FALSE when it doesn't work, MAYBE when not +// checked yet +static int diff_a_works = MAYBE; + +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 void diff_redraw(int dofold); +static int diff_write(buf_T *buf, char_u *fname); +static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff); +static int diff_equal_entry(diff_T *dp, int idx1, int idx2); +static int diff_cmp(char_u *s1, char_u *s2); +static void diff_fold_update(diff_T *dp, int skip_idx); +static void diff_read(int idx_orig, int idx_new, char_u *fname); +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); + +#ifndef USE_CR +# define tag_fgets vim_fgets +#endif // ifndef USE_CR + +/// Called when deleting or unloading a buffer: No longer make a diff with it. +/// +/// @param buf +void diff_buf_delete(buf_T *buf) +{ + tabpage_T *tp; + for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) { + int i = diff_buf_idx_tp(buf, tp); + + if (i != DB_COUNT) { + tp->tp_diffbuf[i] = NULL; + tp->tp_diff_invalid = TRUE; + + if (tp == curtab) { + diff_redraw(TRUE); + } + } + } +} + +/// Check if the current buffer should be added to or removed from the list of +/// diff buffers. +/// +/// @param win +void diff_buf_adjust(win_T *win) +{ + + if (!win->w_p_diff) { + // When there is no window showing a diff for this buffer, remove + // it from the diffs. + win_T *wp; + for (wp = firstwin; wp != NULL; wp = wp->w_next) { + if ((wp->w_buffer == win->w_buffer) && wp->w_p_diff) { + break; + } + } + + if (wp == NULL) { + int 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); + } +} + +/// Add a buffer to make diffs for. +/// +/// Call this when a new buffer is being edited in the current window where +/// 'diff' is set. +/// Marks the current buffer as being part of the diff and requiring updating. +/// This must be done before any autocmd, because a command may use info +/// about the screen contents. +/// +/// @param buf The buffer to add. +void diff_buf_add(buf_T *buf) +{ + if (diff_buf_idx(buf) != DB_COUNT) { + // It's already there. + return; + } + + int i; + 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; + } + } + + EMSGN(_("E96: Can not diff more than %" PRId64 " buffers"), DB_COUNT); +} + +/// Find buffer "buf" in the list of diff buffers for the current tab page. +/// +/// @param buf The buffer to find. +/// +/// @return Its index or DB_COUNT if not found. +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; +} + +/// Find buffer "buf" in the list of diff buffers for tab page "tp". +/// +/// @param buf +/// @param tp +/// +/// @return its index or DB_COUNT if not found. +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; +} + +/// Mark the diff info involving buffer "buf" as invalid, it will be updated +/// when info is requested. +/// +/// @param buf +void diff_invalidate(buf_T *buf) +{ + tabpage_T *tp; + for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) { + int i = diff_buf_idx_tp(buf, tp); + if (i != DB_COUNT) { + tp->tp_diff_invalid = TRUE; + if (tp == curtab) { + diff_redraw(TRUE); + } + } + } +} + +/// Called by mark_adjust(): update line numbers in "curbuf". +/// +/// @param line1 +/// @param line2 +/// @param amount +/// @param amount_after +void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount, + long amount_after) +{ + // Handle all tab pages that use the current buffer in a diff. + tabpage_T *tp; + for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) { + int idx = diff_buf_idx_tp(curbuf, tp); + if (idx != DB_COUNT) { + diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after); + } + } +} + +/// Update line numbers in tab page "tp" for "curbuf" with index "idx". +/// +/// This attempts to update the changes as much as possible: +/// When inserting/deleting lines outside of existing change blocks, create a +/// new change block and update the line numbers in following blocks. +/// When inserting/deleting lines in existing change blocks, update them. +/// +/// @param tp +/// @param idx +/// @param line1 +/// @param line2 +/// @param amount +/// @amount_after +static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, + linenr_T line2, long amount, long amount_after) +{ + int inserted; + int deleted; + 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; + } + + diff_T *dprev = NULL; + diff_T *dp = tp->tp_first_diff; + + linenr_T last; + linenr_T lnum_deleted = line1; // lnum of remaining deletion + int n; + int off; + 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) { + diff_T *dnext = diff_alloc_new(tp, dprev, dp); + + dnext->df_lnum[idx] = line1; + dnext->df_count[idx] = inserted; + int i; + 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; + } + + // + // Check for these situations: + // 1 2 3 + // 1 2 3 + // line1 2 3 4 5 + // 2 3 4 5 + // 2 3 4 5 + // line2 2 3 4 5 + // 3 5 6 + // 3 5 6 + + // 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) { + // 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) { + // nothing left to change + break; + } + dp->df_lnum[idx] += amount_after; + } else { + int check_unchanged = FALSE; + + // 2. 3. 4. 5.: inserted/deleted lines touching this diff. + if (deleted > 0) { + if (dp->df_lnum[idx] >= line1) { + off = dp->df_lnum[idx] - lnum_deleted; + + 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 + n = off; + dp->df_count[idx] -= line2 - dp->df_lnum[idx] + 1; + check_unchanged = TRUE; + } + dp->df_lnum[idx] = line1; + } else { + off = 0; + + if (last < line2) { + // 2. delete at end of 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; + } + } + + int i; + for (i = 0; i < DB_COUNT; ++i) { + if ((tp->tp_diffbuf[i] != NULL) && (i != idx)) { + dp->df_lnum[i] -= off; + 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) + && (dprev->df_lnum[idx] + dprev->df_count[idx] == dp->df_lnum[idx])) { + int i; + 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; + free(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. + int i; + for (i = 0; i < DB_COUNT; ++i) { + if ((tp->tp_diffbuf[i] != NULL) && (dp->df_count[i] != 0)) { + break; + } + } + + if (i == DB_COUNT) { + diff_T *dnext = dp->df_next; + free(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) { + 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; + } +} + +/// Allocate a new diff block and link it between "dprev" and "dp". +/// +/// @param tp +/// @param dprev +/// @param dp +/// +/// @return The new diff block. +static diff_T* diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp) +{ + diff_T *dnew = xmalloc(sizeof(*dnew)); + + dnew->df_next = dp; + if (dprev == NULL) { + tp->tp_first_diff = dnew; + } else { + dprev->df_next = dnew; + } + + return dnew; +} + +/// Check if the diff block "dp" can be made smaller for lines at the start and +/// end that are equal. Called after inserting lines. +/// +/// This may result in a change where all buffers have zero lines, the caller +/// must take care of removing it. +/// +/// @param tp +/// @param dp +static void diff_check_unchanged(tabpage_T *tp, diff_T *dp) +{ + // Find the first buffers, use it as the original, compare the other + // buffer lines against this one. + int i_org; + for (i_org = 0; i_org < DB_COUNT; ++i_org) { + if (tp->tp_diffbuf[i_org] != NULL) { + break; + } + } + + // safety check + if (i_org == DB_COUNT) { + return; + } + + if (diff_check_sanity(tp, dp) == FAIL) { + return; + } + + // First check lines at the top, then at the bottom. + int off_org = 0; + int off_new = 0; + int dir = FORWARD; + 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; + } + char_u *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; + } + + int i_new; + 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; + } + } + 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; + } +} + +/// Check if a diff block doesn't contain invalid line numbers. +/// This can happen when the diff program returns invalid results. +/// +/// @param tp +/// @param dp +/// +/// @return OK if the diff block doesn't contain invalid line numbers. +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; +} + +/// Mark all diff buffers in the current tab page for redraw. +/// +/// @param dofold Also recompute the folds +static void diff_redraw(int dofold) +{ + win_T *wp; + for (wp = firstwin; wp != NULL; wp = wp->w_next) { + if (wp->w_p_diff) { + redraw_win_later(wp, SOME_VALID); + if (dofold && foldmethodIsDiff(wp)) { + foldUpdateAll(wp); + } + + /* A change may have made filler lines invalid, need to take care + * of that for other windows. */ + int n = diff_check(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; + } + } + } + } +} + +/// Write buffer "buf" to file "name". +/// +/// Always use 'fileformat' set to "unix". +/// +/// @param buf +/// @param fname +/// +/// @return FAIL for failure +static int diff_write(buf_T *buf, char_u *fname) +{ + char_u *save_ff = buf->b_p_ff; + buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); + int r = buf_write(buf, fname, NULL, (linenr_T)1, buf->b_ml.ml_line_count, + NULL, FALSE, FALSE, FALSE, TRUE); + free_string_option(buf->b_p_ff); + buf->b_p_ff = save_ff; + return r; +} + +/// Completely update the diffs for the buffers involved. +/// +/// This uses the ordinary "diff" command. +/// The buffers are written to a file, also for unmodified buffers (the file +/// could have been produced by autocommands, e.g. the netrw plugin). +/// +/// @param eap can be NULL +void ex_diffupdate(exarg_T *eap) +{ + // Delete all diffblocks. + diff_clear(curtab); + curtab->tp_diff_invalid = FALSE; + + // Use the first buffer as the original text. + int idx_orig; + for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) { + if (curtab->tp_diffbuf[idx_orig] != NULL) { + break; + } + } + + if (idx_orig == DB_COUNT) { + return; + } + + // Only need to do something when there is another buffer. + int idx_new; + for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) { + if (curtab->tp_diffbuf[idx_new] != NULL) { + break; + } + } + + if (idx_new == DB_COUNT) { + return; + } + + // We need three temp file names. + char_u *tmp_orig = vim_tempname('o'); + char_u *tmp_new = vim_tempname('n'); + char_u *tmp_diff = vim_tempname('d'); + + if ((tmp_orig == NULL) || (tmp_new == NULL) || (tmp_diff == NULL)) { + goto theend; + } + + // Do a quick test if "diff" really works. Otherwise it looks like there + // are no differences. Can't use the return value, it's non-zero when + // there are differences. + // May try twice, first with "-a" and then without. + int io_error = FALSE; + int ok = FALSE; + for (;;) { + ok = FALSE; + FILE *fd = mch_fopen((char *)tmp_orig, "w"); + + if (fd == NULL) { + io_error = TRUE; + } else { + if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) { + io_error = TRUE; + } + fclose(fd); + fd = mch_fopen((char *)tmp_new, "w"); + + if (fd == NULL) { + io_error = TRUE; + } else { + if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) { + io_error = TRUE; + } + fclose(fd); + diff_file(tmp_orig, tmp_new, tmp_diff); + fd = mch_fopen((char *)tmp_diff, "r"); + + if (fd == NULL) { + io_error = TRUE; + } else { + char_u linebuf[LBUFLEN]; + + for (;;) { + // There must be a line that contains "1c1". + if (tag_fgets(linebuf, LBUFLEN, fd)) { + break; + } + + if (STRNCMP(linebuf, "1c1", 3) == 0) { + ok = TRUE; + } + } + fclose(fd); + } + os_remove((char *)tmp_diff); + os_remove((char *)tmp_new); + } + os_remove((char *)tmp_orig); + } + + // When using 'diffexpr' break here. + if (*p_dex != NUL) { + break; + } + + // If we checked if "-a" works already, break here. + if (diff_a_works != MAYBE) { + break; + } + diff_a_works = ok; + + // If "-a" works break here, otherwise retry without "-a". + if (ok) { + break; + } + } + + if (!ok) { + if (io_error) { + EMSG(_("E810: Cannot read or write temp files")); + } + EMSG(_("E97: Cannot create diffs")); + diff_a_works = MAYBE; + goto theend; + } + + // :diffupdate! + if ((eap != NULL) && eap->forceit) { + for (idx_new = idx_orig; idx_new < DB_COUNT; ++idx_new) { + buf_T *buf = curtab->tp_diffbuf[idx_new]; + if (buf_valid(buf)) { + buf_check_timestamp(buf, FALSE); + } + } + } + + // Write the first buffer to a tempfile. + buf_T *buf = curtab->tp_diffbuf[idx_orig]; + if (diff_write(buf, tmp_orig) == FAIL) { + goto theend; + } + + // Make a difference between the first buffer and every other. + for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) { + buf_T *buf = curtab->tp_diffbuf[idx_new]; + if (buf == NULL) { + continue; + } + + if (diff_write(buf, tmp_new) == FAIL) { + continue; + } + diff_file(tmp_orig, tmp_new, tmp_diff); + + // Read the diff output and add each entry to the diff list. + diff_read(idx_orig, idx_new, tmp_diff); + os_remove((char *)tmp_diff); + os_remove((char *)tmp_new); + } + os_remove((char *)tmp_orig); + + // force updating cursor position on screen + curwin->w_valid_cursor.lnum = 0; + + diff_redraw(TRUE); + +theend: + free(tmp_orig); + free(tmp_new); + free(tmp_diff); +} + +/// Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". +/// +/// @param tmp_orig +/// @param tmp_new +/// @param tmp_diff +static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff) +{ + if (*p_dex != NUL) { + // Use 'diffexpr' to generate the diff file. + eval_diff(tmp_orig, tmp_new, tmp_diff); + } else { + size_t len = STRLEN(tmp_orig) + STRLEN(tmp_new) + STRLEN(tmp_diff) + + STRLEN(p_srr) + 27; + char_u *cmd = xmalloc(len); + + /* We don't want $DIFF_OPTIONS to get in the way. */ + if (os_getenv("DIFF_OPTIONS")) { + vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); + } + + /* Build the diff command and execute it. Always use -a, binary + * differences are of no use. Ignore errors, diff returns + * non-zero when differences have been found. */ + vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s", + diff_a_works == FALSE ? "" : "-a ", + "", + (diff_flags & DIFF_IWHITE) ? "-b " : "", + (diff_flags & DIFF_ICASE) ? "-i " : "", + tmp_orig, tmp_new); + append_redir(cmd, (int)len, p_srr, tmp_diff); + block_autocmds(); /* Avoid ShellCmdPost stuff */ + (void)call_shell( + cmd, + kShellOptFilter | kShellOptSilent | kShellOptDoOut, + NULL + ); + unblock_autocmds(); + free(cmd); + } +} + +/// Create a new version of a file from the current buffer and a diff file. +/// +/// The buffer is written to a file, also for unmodified buffers (the file +/// could have been produced by autocommands, e.g. the netrw plugin). +/// +/// @param eap +void ex_diffpatch(exarg_T *eap) +{ + char_u *buf = NULL; + win_T *old_curwin = curwin; + char_u *newname = NULL; // name of patched file buffer + +#ifdef UNIX + char_u dirbuf[MAXPATHL]; + char_u *fullname = NULL; +#endif // ifdef UNIX + // We need two temp file names. + // Name of original temp file. + char_u *tmp_orig = vim_tempname('o'); + // Name of patched temp file. + char_u *tmp_new = vim_tempname('n'); + + if ((tmp_orig == NULL) || (tmp_new == NULL)) { + goto theend; + } + + // Write the current buffer to "tmp_orig". + if (buf_write(curbuf, tmp_orig, NULL, + (linenr_T)1, curbuf->b_ml.ml_line_count, + NULL, FALSE, FALSE, FALSE, TRUE) == FAIL) { + goto theend; + } + +#ifdef UNIX + // Get the absolute path of the patchfile, changing directory below. + fullname = FullName_save(eap->arg, FALSE); +#endif // ifdef UNIX + +#ifdef UNIX + size_t buflen = STRLEN(tmp_orig) + + (fullname != NULL ? STRLEN(fullname) : STRLEN(eap->arg)) + + STRLEN(tmp_new) + 16; +#else + size_t buflen = STRLEN(tmp_orig) + (STRLEN(eap->arg)) + STRLEN(tmp_new) + 16; +#endif // ifdef UNIX + + buf = xmalloc(buflen); + +#ifdef UNIX + + // Temporarily chdir to /tmp, to avoid patching files in the current + // directory when the patch file contains more than one patch. When we + // have our own temp dir use that instead, it will be cleaned up when we + // exit (any .rej files created). Don't change directory if we can't + // return to the current. + if ((os_dirname(dirbuf, MAXPATHL) != OK) + || (os_chdir((char *)dirbuf) != 0)) { + dirbuf[0] = NUL; + } else { +# ifdef TEMPDIRNAMES + if (vim_tempdir != NULL) { + ignored = os_chdir((char *)vim_tempdir); + } else { + ignored = os_chdir("/tmp"); + } +# else + ignored = os_chdir("/tmp"); +# endif // ifdef TEMPDIRNAMES + shorten_fnames(TRUE); + } +#endif // ifdef UNIX + + if (*p_pex != NUL) { + // Use 'patchexpr' to generate the new file. +#ifdef UNIX + eval_patch(tmp_orig, fullname != NULL ? fullname : eap->arg, tmp_new); +#else + eval_patch(tmp_orig, eap->arg, tmp_new); +#endif // ifdef UNIX + } else { + // Build the patch command and execute it. Ignore errors. Switch to + // cooked mode to allow the user to respond to prompts. +#ifdef UNIX + vim_snprintf((char *)buf, buflen, "patch -o %s %s < \"%s\"", + tmp_new, tmp_orig, fullname != NULL ? fullname : eap->arg); +#else + vim_snprintf((char *)buf, buflen, "patch -o %s %s < \"%s\"", + tmp_new, tmp_orig, eap->arg); +#endif // ifdef UNIX + // Avoid ShellCmdPost stuff + block_autocmds(); + (void)call_shell(buf, kShellOptFilter | kShellOptCooked, NULL); + unblock_autocmds(); + } + +#ifdef UNIX + if (dirbuf[0] != NUL) { + if (os_chdir((char *)dirbuf) != 0) { + EMSG(_(e_prev_dir)); + } + shorten_fnames(TRUE); + } +#endif // ifdef UNIX + + // patch probably has written over the screen + redraw_later(CLEAR); + + // Delete any .orig or .rej file created. + STRCPY(buf, tmp_new); + STRCAT(buf, ".orig"); + os_remove((char *)buf); + STRCPY(buf, tmp_new); + STRCAT(buf, ".rej"); + os_remove((char *)buf); + + // Only continue if the output file was created. + off_t file_size; + bool file_size_success = os_get_file_size((char *)tmp_new, &file_size); + if (!file_size_success || file_size == 0) { + EMSG(_("E816: Cannot read patch output")); + } else { + if (curbuf->b_fname != NULL) { + newname = vim_strnsave(curbuf->b_fname, + (int)(STRLEN(curbuf->b_fname) + 4)); + + if (newname != NULL) { + STRCAT(newname, ".new"); + } + } + + // don't use a new tab page, each tab page has its own diffs + cmdmod.tab = 0; + + if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) { + // Pretend it was a ":split fname" command + eap->cmdidx = CMD_split; + eap->arg = tmp_new; + do_exedit(eap, old_curwin); + + // check that split worked and editing tmp_new + if ((curwin != old_curwin) && win_valid(old_curwin)) { + // Set 'diff', 'scrollbind' on and 'wrap' off. + diff_win_options(curwin, TRUE); + diff_win_options(old_curwin, TRUE); + + if (newname != NULL) { + // do a ":file filename.new" on the patched buffer + eap->arg = newname; + ex_file(eap); + + // Do filetype detection with the new name. + if (au_has_group((char_u *)"filetypedetect")) { + do_cmdline_cmd((char_u *)":doau filetypedetect BufRead"); + } + } + } + } + } + +theend: + if (tmp_orig != NULL) { + os_remove((char *)tmp_orig); + } + free(tmp_orig); + + if (tmp_new != NULL) { + os_remove((char *)tmp_new); + } + free(tmp_new); + free(newname); + free(buf); +#ifdef UNIX + free(fullname); +#endif // ifdef UNIX +} + +/// Split the window and edit another file, setting options to show the diffs. +/// +/// @param eap +void ex_diffsplit(exarg_T *eap) +{ + win_T *old_curwin = curwin; + + // don't use a new tab page, each tab page has its own diffs + cmdmod.tab = 0; + + if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) { + // Pretend it was a ":split fname" command + eap->cmdidx = CMD_split; + curwin->w_p_diff = TRUE; + do_exedit(eap, old_curwin); + + // split must have worked + if (curwin != old_curwin) { + // Set 'diff', 'scrollbind' on and 'wrap' off. + diff_win_options(curwin, TRUE); + diff_win_options(old_curwin, TRUE); + } + } +} + +// Set options to show diffs for the current window. +void ex_diffthis(exarg_T *eap) +{ + // Set 'diff', 'scrollbind' on and 'wrap' off. + diff_win_options(curwin, TRUE); +} + +/// Set options in window "wp" for diff mode. +/// +/// @param addbuf Add buffer to diff. +void diff_win_options(win_T *wp, int addbuf) +{ + win_T *old_curwin = curwin; + + // close the manually opened folds + curwin = wp; + newFoldLevel(); + curwin = old_curwin; + + wp->w_p_diff = TRUE; + + // Use 'scrollbind' and 'cursorbind' when available + if (!wp->w_p_diff_saved) { + wp->w_p_scb_save = wp->w_p_scb; + } + wp->w_p_scb = TRUE; + + if (!wp->w_p_diff_saved) { + wp->w_p_crb_save = wp->w_p_crb; + } + wp->w_p_crb = TRUE; + + if (!wp->w_p_diff_saved) { + wp->w_p_wrap_save = wp->w_p_wrap; + } + wp->w_p_wrap = FALSE; + curwin = wp; + curbuf = curwin->w_buffer; + + if (!wp->w_p_diff_saved) { + wp->w_p_fdm_save = vim_strsave(wp->w_p_fdm); + } + set_string_option_direct((char_u *)"fdm", -1, (char_u *)"diff", + OPT_LOCAL | OPT_FREE, 0); + curwin = old_curwin; + curbuf = curwin->w_buffer; + + if (!wp->w_p_diff_saved) { + wp->w_p_fdc_save = wp->w_p_fdc; + wp->w_p_fen_save = wp->w_p_fen; + wp->w_p_fdl_save = wp->w_p_fdl; + } + wp->w_p_fdc = diff_foldcolumn; + wp->w_p_fen = TRUE; + wp->w_p_fdl = 0; + foldUpdateAll(wp); + + // make sure topline is not halfway a fold + changed_window_setting_win(wp); + if (vim_strchr(p_sbo, 'h') == NULL) { + do_cmdline_cmd((char_u *)"set sbo+=hor"); + } + + // Saved the current values, to be restored in ex_diffoff(). + wp->w_p_diff_saved = TRUE; + + if (addbuf) { + diff_buf_add(wp->w_buffer); + } + redraw_win_later(wp, NOT_VALID); +} + +/// Set options not to show diffs. For the current window or all windows. +/// Only in the current tab page. +/// +/// @param eap +void ex_diffoff(exarg_T *eap) +{ + win_T *old_curwin = curwin; + int diffwin = FALSE; + + win_T *wp; + for (wp = firstwin; wp != NULL; wp = wp->w_next) { + if (eap->forceit ? wp->w_p_diff : (wp == curwin)) { + // Set 'diff', 'scrollbind' off and 'wrap' on. If option values + // were saved in diff_win_options() restore them. + wp->w_p_diff = FALSE; + + if (wp->w_p_scb) { + wp->w_p_scb = wp->w_p_diff_saved ? wp->w_p_scb_save : FALSE; + } + + if (wp->w_p_crb) { + wp->w_p_crb = wp->w_p_diff_saved ? wp->w_p_crb_save : FALSE; + } + + if (!wp->w_p_wrap) { + wp->w_p_wrap = wp->w_p_diff_saved ? wp->w_p_wrap_save : TRUE; + } + curwin = wp; + curbuf = curwin->w_buffer; + + if (wp->w_p_diff_saved) { + free_string_option(wp->w_p_fdm); + wp->w_p_fdm = wp->w_p_fdm_save; + wp->w_p_fdm_save = empty_option; + } else { + set_string_option_direct((char_u *)"fdm", -1, + (char_u *)"manual", OPT_LOCAL | OPT_FREE, 0); + } + curwin = old_curwin; + curbuf = curwin->w_buffer; + + if (wp->w_p_fdc == diff_foldcolumn) { + wp->w_p_fdc = wp->w_p_diff_saved ? wp->w_p_fdc_save : 0; + } + + if ((wp->w_p_fdl == 0) + && wp->w_p_diff_saved) { + wp->w_p_fdl = wp->w_p_fdl_save; + } + + if (wp->w_p_fen) { + // Only restore 'foldenable' when 'foldmethod' is not + // "manual", otherwise we continue to show the diff folds. + if (foldmethodIsManual(wp) || !wp->w_p_diff_saved) { + wp->w_p_fen = FALSE; + } else { + wp->w_p_fen = wp->w_p_fen_save; + } + } + + foldUpdateAll(wp); + + // make sure topline is not halfway a fold + changed_window_setting_win(wp); + + // Note: 'sbo' is not restored, it's a global option. + diff_buf_adjust(wp); + + wp->w_p_diff_saved = FALSE; + } + diffwin |= wp->w_p_diff; + } + + // Remove "hor" from from 'scrollopt' if there are no diff windows left. + if (!diffwin && (vim_strchr(p_sbo, 'h') != NULL)) { + do_cmdline_cmd((char_u *)"set sbo-=hor"); + } +} + +/// Read the diff output and add each entry to the diff list. +/// +/// @param idx_orig idx of original file +/// @param idx_new idx of new file +/// @param fname name of diff output file +static void diff_read(int idx_orig, int idx_new, char_u *fname) +{ + FILE *fd; + diff_T *dprev = NULL; + diff_T *dp = curtab->tp_first_diff; + diff_T *dn, *dpl; + long f1, l1, f2, l2; + char_u linebuf[LBUFLEN]; // only need to hold the diff line + int difftype; + char_u *p; + long off; + int i; + linenr_T lnum_orig, lnum_new; + long count_orig, count_new; + int notset = TRUE; // block "*dp" not set yet + + fd = mch_fopen((char *)fname, "r"); + + if (fd == NULL) { + EMSG(_("E98: Cannot read diff output")); + return; + } + + for (;;) { + if (tag_fgets(linebuf, LBUFLEN, fd)) { + // end of file + break; + } + + if (!isdigit(*linebuf)) { + // not the start of a diff block + continue; + } + + // This line must be one of three formats: + // {first}[,{last}]c{first}[,{last}] + // {first}a{first}[,{last}] + // {first}[,{last}]d{first} + p = linebuf; + f1 = getdigits(&p); + + if (*p == ',') { + ++p; + l1 = getdigits(&p); + } else { + l1 = f1; + } + + if ((*p != 'a') && (*p != 'c') && (*p != 'd')) { + // invalid diff format + continue; + } + difftype = *p++; + f2 = getdigits(&p); + + if (*p == ',') { + ++p; + l2 = getdigits(&p); + } else { + l2 = f2; + } + + if ((l1 < f1) || (l2 < f2)) { + // invalid line range + continue; + } + + if (difftype == 'a') { + lnum_orig = f1 + 1; + count_orig = 0; + } else { + lnum_orig = f1; + count_orig = l1 - f1 + 1; + } + + if (difftype == 'd') { + lnum_new = f2 + 1; + count_new = 0; + } else { + lnum_new = f2; + count_new = l2 - f2 + 1; + } + + // Go over blocks before the change, for which orig and new are equal. + // Copy blocks from orig to new. + while (dp != NULL + && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) { + if (notset) { + diff_copy_entry(dprev, dp, idx_orig, idx_new); + } + dprev = dp; + dp = dp->df_next; + notset = TRUE; + } + + if ((dp != NULL) + && (lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) + && (lnum_orig + count_orig >= dp->df_lnum[idx_orig])) { + // New block overlaps with existing block(s). + // First find last block that overlaps. + for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) { + if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) { + break; + } + } + + // If the newly found block starts before the old one, set the + // start back a number of lines. + off = dp->df_lnum[idx_orig] - lnum_orig; + + if (off > 0) { + for (i = idx_orig; i < idx_new; ++i) { + if (curtab->tp_diffbuf[i] != NULL) { + dp->df_lnum[i] -= off; + } + } + dp->df_lnum[idx_new] = lnum_new; + dp->df_count[idx_new] = count_new; + } else if (notset) { + // new block inside existing one, adjust new block + dp->df_lnum[idx_new] = lnum_new + off; + dp->df_count[idx_new] = count_new - off; + } else { + // second overlap of new block with existing block + dp->df_count[idx_new] += count_new - count_orig + + dpl->df_lnum[idx_orig] + + dpl->df_count[idx_orig] + - (dp->df_lnum[idx_orig] + + dp->df_count[idx_orig]); + } + + // Adjust the size of the block to include all the lines to the + // end of the existing block or the new diff, whatever ends last. + off = (lnum_orig + count_orig) + - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); + + if (off < 0) { + // new change ends in existing block, adjust the end if not + // done already + if (notset) { + dp->df_count[idx_new] += -off; + } + off = 0; + } + + for (i = idx_orig; i < idx_new; ++i) { + if (curtab->tp_diffbuf[i] != NULL) { + dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] + - dp->df_lnum[i] + off; + } + } + + // Delete the diff blocks that have been merged into one. + dn = dp->df_next; + dp->df_next = dpl->df_next; + + while (dn != dp->df_next) { + dpl = dn->df_next; + free(dn); + dn = dpl; + } + } else { + // Allocate a new diffblock. + dp = diff_alloc_new(curtab, dprev, dp); + + dp->df_lnum[idx_orig] = lnum_orig; + dp->df_count[idx_orig] = count_orig; + dp->df_lnum[idx_new] = lnum_new; + dp->df_count[idx_new] = count_new; + + // Set values for other buffers, these must be equal to the + // original buffer, otherwise there would have been a change + // already. + for (i = idx_orig + 1; i < idx_new; ++i) { + if (curtab->tp_diffbuf[i] != NULL) { + diff_copy_entry(dprev, dp, idx_orig, i); + } + } + } + notset = FALSE; // "*dp" has been set + } + + // for remaining diff blocks orig and new are equal + while (dp != NULL) { + if (notset) { + diff_copy_entry(dprev, dp, idx_orig, idx_new); + } + dprev = dp; + dp = dp->df_next; + notset = TRUE; + } + + fclose(fd); +} + +/// Copy an entry at "dp" from "idx_orig" to "idx_new". +/// +/// @param dprev +/// @param dp +/// @param idx_orig +/// @param idx_new +static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, + int idx_new) +{ + long off; + + if (dprev == NULL) { + off = 0; + } else { + off = (dprev->df_lnum[idx_orig] + dprev->df_count[idx_orig]) + - (dprev->df_lnum[idx_new] + dprev->df_count[idx_new]); + } + dp->df_lnum[idx_new] = dp->df_lnum[idx_orig] - off; + dp->df_count[idx_new] = dp->df_count[idx_orig]; +} + +/// Clear the list of diffblocks for tab page "tp". +/// +/// @param tp +void diff_clear(tabpage_T *tp) +{ + diff_T *p; + diff_T *next_p; + for (p = tp->tp_first_diff; p != NULL; p = next_p) { + next_p = p->df_next; + free(p); + } + tp->tp_first_diff = NULL; +} + +/// Check diff status for line "lnum" in buffer "buf": +/// +/// Returns 0 for nothing special +/// Returns -1 for a line that should be highlighted as changed. +/// Returns -2 for a line that should be highlighted as added/deleted. +/// Returns > 0 for inserting that many filler lines above it (never happens +/// when 'diffopt' doesn't contain "filler"). +/// This should only be used for windows where 'diff' is set. +/// +/// @param wp +/// @param lnum +/// +/// @return diff status. +int diff_check(win_T *wp, linenr_T lnum) +{ + int idx; // index in tp_diffbuf[] for this buffer + diff_T *dp; + int maxcount; + int i; + buf_T *buf = wp->w_buffer; + int cmp; + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + + // no diffs at all + if ((curtab->tp_first_diff == NULL) || !wp->w_p_diff) { + return 0; + } + + // safety check: "lnum" must be a buffer line + if ((lnum < 1) || (lnum > buf->b_ml.ml_line_count + 1)) { + return 0; + } + + idx = diff_buf_idx(buf); + + if (idx == DB_COUNT) { + // no diffs for buffer "buf" + return 0; + } + + // A closed fold never has filler lines. + if (hasFoldingWin(wp, lnum, NULL, NULL, TRUE, NULL)) { + return 0; + } + + // search for a change that includes "lnum" in the list of diffblocks. + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) { + break; + } + } + + if ((dp == NULL) || (lnum < dp->df_lnum[idx])) { + return 0; + } + + if (lnum < dp->df_lnum[idx] + dp->df_count[idx]) { + int zero = FALSE; + + // Changed or inserted line. If the other buffers have a count of + // zero, the lines were inserted. If the other buffers have the same + // count, check if the lines are identical. + cmp = FALSE; + + for (i = 0; i < DB_COUNT; ++i) { + if ((i != idx) && (curtab->tp_diffbuf[i] != NULL)) { + if (dp->df_count[i] == 0) { + zero = TRUE; + } else { + if (dp->df_count[i] != dp->df_count[idx]) { + // nr of lines changed. + return -1; + } + cmp = TRUE; + } + } + } + + if (cmp) { + // Compare all lines. If they are equal the lines were inserted + // in some buffers, deleted in others, but not changed. + for (i = 0; i < DB_COUNT; ++i) { + if ((i != idx) + && (curtab->tp_diffbuf[i] != NULL) + && (dp->df_count[i] != 0)) { + if (!diff_equal_entry(dp, idx, i)) { + return -1; + } + } + } + } + + // If there is no buffer with zero lines then there is no difference + // any longer. Happens when making a change (or undo) that removes + // the difference. Can't remove the entry here, we might be halfway + // updating the window. Just report the text as unchanged. Other + // windows might still show the change though. + if (zero == FALSE) { + return 0; + } + return -2; + } + + // If 'diffopt' doesn't contain "filler", return 0. + if (!(diff_flags & DIFF_FILLER)) { + return 0; + } + + // Insert filler lines above the line just below the change. Will return + // 0 when this buf had the max count. + maxcount = 0; + for (i = 0; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] != NULL) && (dp->df_count[i] > maxcount)) { + maxcount = dp->df_count[i]; + } + } + return maxcount - dp->df_count[idx]; +} + +/// Compare two entries in diff "*dp" and return TRUE if they are equal. +/// +/// @param dp +/// @param idx1 First entry in diff "*dp" +/// @param idx2 Second entry in diff "*dp" +/// +/// @return return TRUE if two entires are equal. +static int diff_equal_entry(diff_T *dp, int idx1, int idx2) +{ + if (dp->df_count[idx1] != dp->df_count[idx2]) { + return FALSE; + } + + if (diff_check_sanity(curtab, dp) == FAIL) { + return FALSE; + } + + int i; + for (i = 0; i < dp->df_count[idx1]; ++i) { + char_u *line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1], + dp->df_lnum[idx1] + i, FALSE)); + + if (line == NULL) { + return FALSE; + } + int cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2], + dp->df_lnum[idx2] + i, FALSE)); + free(line); + + if (cmp != 0) { + return FALSE; + } + } + return TRUE; +} + +/// Compare strings "s1" and "s2" according to 'diffopt'. +/// Return non-zero when they are different. +/// +/// @param s1 The first string +/// @param s2 The second string +/// +/// @return on-zero if the two strings are different. +static int diff_cmp(char_u *s1, char_u *s2) +{ + if ((diff_flags & (DIFF_ICASE | DIFF_IWHITE)) == 0) { + return STRCMP(s1, s2); + } + + if ((diff_flags & DIFF_ICASE) && !(diff_flags & DIFF_IWHITE)) { + return MB_STRICMP(s1, s2); + } + + // Ignore white space changes and possibly ignore case. + char_u *p1 = s1; + char_u *p2 = s2; + + while (*p1 != NUL && *p2 != NUL) { + if (vim_iswhite(*p1) && vim_iswhite(*p2)) { + p1 = skipwhite(p1); + p2 = skipwhite(p2); + } else { + int l = (*mb_ptr2len)(p1); + if (l != (*mb_ptr2len)(p2)) { + break; + } + + if (l > 1) { + if ((STRNCMP(p1, p2, l) != 0) + && (!enc_utf8 + || !(diff_flags & DIFF_ICASE) + || (utf_fold(utf_ptr2char(p1)) + != utf_fold(utf_ptr2char(p2))))) { + break; + } + p1 += l; + p2 += l; + } else { + if ((*p1 != *p2) + && (!(diff_flags & DIFF_ICASE) + || (TOLOWER_LOC(*p1) != TOLOWER_LOC(*p2)))) { + break; + } + ++p1; + ++p2; + } + } + } + + // Ignore trailing white space. + p1 = skipwhite(p1); + p2 = skipwhite(p2); + + if ((*p1 != NUL) || (*p2 != NUL)) { + return 1; + } + return 0; +} + +/// Return the number of filler lines above "lnum". +/// +/// @param wp +/// @param lnum +/// +/// @return Number of filler lines above lnum +int diff_check_fill(win_T *wp, linenr_T lnum) +{ + // be quick when there are no filler lines + if (!(diff_flags & DIFF_FILLER)) { + return 0; + } + int n = diff_check(wp, lnum); + + if (n <= 0) { + return 0; + } + return n; +} + +/// Set the topline of "towin" to match the position in "fromwin", so that they +/// show the same diff'ed lines. +/// +/// @param fromwin +/// @param towin +void diff_set_topline(win_T *fromwin, win_T *towin) +{ + buf_T *frombuf = fromwin->w_buffer; + linenr_T lnum = fromwin->w_topline; + diff_T *dp; + int max_count; + int i; + + int fromidx = diff_buf_idx(frombuf); + if (fromidx == DB_COUNT) { + // safety check + return; + } + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + towin->w_topfill = 0; + + // search for a change that includes "lnum" in the list of diffblocks. + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + if (lnum <= dp->df_lnum[fromidx] + dp->df_count[fromidx]) { + break; + } + } + + if (dp == NULL) { + // After last change, compute topline relative to end of file; no + // filler lines. + towin->w_topline = towin->w_buffer->b_ml.ml_line_count + - (frombuf->b_ml.ml_line_count - lnum); + } else { + // Find index for "towin". + int toidx = diff_buf_idx(towin->w_buffer); + + if (toidx == DB_COUNT) { + // safety check + return; + } + towin->w_topline = lnum + (dp->df_lnum[toidx] - dp->df_lnum[fromidx]); + + if (lnum >= dp->df_lnum[fromidx]) { + // Inside a change: compute filler lines. With three or more + // buffers we need to know the largest count. + max_count = 0; + + for (i = 0; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] != NULL) && (max_count < dp->df_count[i])) { + max_count = dp->df_count[i]; + } + } + + if (dp->df_count[toidx] == dp->df_count[fromidx]) { + // same number of lines: use same filler count + towin->w_topfill = fromwin->w_topfill; + } else if (dp->df_count[toidx] > dp->df_count[fromidx]) { + if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) { + // more lines in towin and fromwin doesn't show diff + // lines, only filler lines + if (max_count - fromwin->w_topfill >= dp->df_count[toidx]) { + // towin also only shows filler lines + towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; + towin->w_topfill = fromwin->w_topfill; + } else { + // towin still has some diff lines to show + towin->w_topline = dp->df_lnum[toidx] + + max_count - fromwin->w_topfill; + } + } + } else if (towin->w_topline >= dp->df_lnum[toidx] + + dp->df_count[toidx]) { + // less lines in towin and no diff lines to show: compute + // filler lines + towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; + + if (diff_flags & DIFF_FILLER) { + if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) { + // fromwin is also out of diff lines + towin->w_topfill = fromwin->w_topfill; + } else { + // fromwin has some diff lines + towin->w_topfill = dp->df_lnum[fromidx] + max_count - lnum; + } + } + } + } + } + + // safety check (if diff info gets outdated strange things may happen) + towin->w_botfill = FALSE; + + if (towin->w_topline > towin->w_buffer->b_ml.ml_line_count) { + towin->w_topline = towin->w_buffer->b_ml.ml_line_count; + towin->w_botfill = TRUE; + } + + if (towin->w_topline < 1) { + towin->w_topline = 1; + towin->w_topfill = 0; + } + + // When w_topline changes need to recompute w_botline and cursor position + invalidate_botline_win(towin); + changed_line_abv_curs_win(towin); + + check_topfill(towin, FALSE); + (void)hasFoldingWin(towin, towin->w_topline, &towin->w_topline, + NULL, TRUE, NULL); +} + +/// This is called when 'diffopt' is changed. +/// +/// @return +int diffopt_changed(void) +{ + int diff_context_new = 6; + int diff_flags_new = 0; + int diff_foldcolumn_new = 2; + + char_u *p = p_dip; + while (*p != NUL) { + if (STRNCMP(p, "filler", 6) == 0) { + p += 6; + diff_flags_new |= DIFF_FILLER; + } else if ((STRNCMP(p, "context:", 8) == 0) && VIM_ISDIGIT(p[8])) { + p += 8; + diff_context_new = getdigits(&p); + } else if (STRNCMP(p, "icase", 5) == 0) { + p += 5; + diff_flags_new |= DIFF_ICASE; + } else if (STRNCMP(p, "iwhite", 6) == 0) { + p += 6; + diff_flags_new |= DIFF_IWHITE; + } else if (STRNCMP(p, "horizontal", 10) == 0) { + p += 10; + diff_flags_new |= DIFF_HORIZONTAL; + } else if (STRNCMP(p, "vertical", 8) == 0) { + p += 8; + diff_flags_new |= DIFF_VERTICAL; + } else if ((STRNCMP(p, "foldcolumn:", 11) == 0) && VIM_ISDIGIT(p[11])) { + p += 11; + diff_foldcolumn_new = getdigits(&p); + } + + if ((*p != ',') && (*p != NUL)) { + return FAIL; + } + + if (*p == ',') { + ++p; + } + } + + // Can't have both "horizontal" and "vertical". + if ((diff_flags_new & DIFF_HORIZONTAL) && (diff_flags_new & DIFF_VERTICAL)) { + return FAIL; + } + + // If "icase" or "iwhite" was added or removed, need to update the diff. + if (diff_flags != diff_flags_new) { + tabpage_T *tp; + for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) { + tp->tp_diff_invalid = TRUE; + } + } + + diff_flags = diff_flags_new; + diff_context = diff_context_new; + diff_foldcolumn = diff_foldcolumn_new; + + diff_redraw(TRUE); + + // recompute the scroll binding with the new option value, may + // remove or add filler lines + check_scrollbind((linenr_T)0, 0L); + return OK; +} + +/// Return TRUE if 'diffopt' contains "horizontal". +/// +/// @return TRUE if 'diffopt' contains "horizontal" +int diffopt_horizontal(void) +{ + return (diff_flags & DIFF_HORIZONTAL) != 0; +} + +/// Find the difference within a changed line. +/// +/// @param startp first char of the change +/// @param endp last char of the change +/// +/// @returns TRUE if the line was added, no other buffer has it. +int diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp) +{ + char_u *line_new; + int si_org; + int si_new; + int ei_org; + int ei_new; + int added = TRUE; + + // Make a copy of the line, the next ml_get() will invalidate it. + char_u *line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE)); + if (line_org == NULL) { + return FALSE; + } + + int idx = diff_buf_idx(wp->w_buffer); + if (idx == DB_COUNT) { + // cannot happen + free(line_org); + return FALSE; + } + + // search for a change that includes "lnum" in the list of diffblocks. + diff_T *dp; + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) { + break; + } + } + + if ((dp == NULL) || (diff_check_sanity(curtab, dp) == FAIL)) { + free(line_org); + return FALSE; + } + + int off = lnum - dp->df_lnum[idx]; + int i; + for (i = 0; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] != NULL) && (i != idx)) { + // Skip lines that are not in the other change (filler lines). + if (off >= dp->df_count[i]) { + continue; + } + added = FALSE; + line_new = ml_get_buf(curtab->tp_diffbuf[i], + dp->df_lnum[i] + off, FALSE); + + // Search for start of difference + si_org = si_new = 0; + + while (line_org[si_org] != NUL) { + if ((diff_flags & DIFF_IWHITE) + && vim_iswhite(line_org[si_org]) + && vim_iswhite(line_new[si_new])) { + si_org = (int)(skipwhite(line_org + si_org) - line_org); + si_new = (int)(skipwhite(line_new + si_new) - line_new); + } else { + if (line_org[si_org] != line_new[si_new]) { + break; + } + ++si_org; + ++si_new; + } + } + + if (has_mbyte) { + // Move back to first byte of character in both lines (may + // have "nn^" in line_org and "n^ in line_new). + si_org -= (*mb_head_off)(line_org, line_org + si_org); + si_new -= (*mb_head_off)(line_new, line_new + si_new); + } + + if (*startp > si_org) { + *startp = si_org; + } + + // Search for end of difference, if any. + if ((line_org[si_org] != NUL) || (line_new[si_new] != NUL)) { + ei_org = (int)STRLEN(line_org); + ei_new = (int)STRLEN(line_new); + + while (ei_org >= *startp + && ei_new >= si_new + && ei_org >= 0 + && ei_new >= 0) { + if ((diff_flags & DIFF_IWHITE) + && vim_iswhite(line_org[ei_org]) + && vim_iswhite(line_new[ei_new])) { + while (ei_org >= *startp && vim_iswhite(line_org[ei_org])) { + ei_org--; + } + + while (ei_new >= si_new && vim_iswhite(line_new[ei_new])) { + ei_new--; + } + } else { + if (line_org[ei_org] != line_new[ei_new]) { + break; + } + ei_org--; + ei_new--; + } + } + + if (*endp < ei_org) { + *endp = ei_org; + } + } + } + } + + free(line_org); + return added; +} + +/// Return TRUE if line "lnum" is not close to a diff block, this line should +/// be in a fold. +/// +/// @param wp +/// @param lnum +/// +/// @return FALSE if there are no diff blocks at all in this window. +int diff_infold(win_T *wp, linenr_T lnum) +{ + int other = FALSE; + diff_T *dp; + + // Return if 'diff' isn't set. + if (!wp->w_p_diff) { + return FALSE; + } + + int idx = -1; + int i; + for (i = 0; i < DB_COUNT; ++i) { + if (curtab->tp_diffbuf[i] == wp->w_buffer) { + idx = i; + } else if (curtab->tp_diffbuf[i] != NULL) { + other = TRUE; + } + } + + // return here if there are no diffs in the window + if ((idx == -1) || !other) { + return FALSE; + } + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + + // Return if there are no diff blocks. All lines will be folded. + if (curtab->tp_first_diff == NULL) { + return TRUE; + } + + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + // If this change is below the line there can't be any further match. + if (dp->df_lnum[idx] - diff_context > lnum) { + break; + } + + // If this change ends before the line we have a match. + if (dp->df_lnum[idx] + dp->df_count[idx] + diff_context > lnum) { + return FALSE; + } + } + return TRUE; +} + +/// "dp" and "do" commands. +/// +/// @param put +void nv_diffgetput(int put) +{ + exarg_T ea; + ea.arg = (char_u *)""; + if (put) { + ea.cmdidx = CMD_diffput; + } else { + ea.cmdidx = CMD_diffget; + } + ea.addr_count = 0; + ea.line1 = curwin->w_cursor.lnum; + ea.line2 = curwin->w_cursor.lnum; + ex_diffgetput(&ea); +} + +/// ":diffget" and ":diffput" +/// +/// @param eap +void ex_diffgetput(exarg_T *eap) +{ + linenr_T lnum; + int count; + linenr_T off = 0; + diff_T *dp; + diff_T *dprev; + diff_T *dfree; + int i; + int added; + char_u *p; + aco_save_T aco; + buf_T *buf; + int start_skip, end_skip; + int new_count; + int buf_empty; + int found_not_ma = FALSE; + int idx_other; + int idx_from; + int idx_to; + + // Find the current buffer in the list of diff buffers. + int idx_cur = diff_buf_idx(curbuf); + if (idx_cur == DB_COUNT) { + EMSG(_("E99: Current buffer is not in diff mode")); + return; + } + + if (*eap->arg == NUL) { + // No argument: Find the other buffer in the list of diff buffers. + for (idx_other = 0; idx_other < DB_COUNT; ++idx_other) { + if ((curtab->tp_diffbuf[idx_other] != curbuf) + && (curtab->tp_diffbuf[idx_other] != NULL)) { + if ((eap->cmdidx != CMD_diffput) + || curtab->tp_diffbuf[idx_other]->b_p_ma) { + break; + } + found_not_ma = TRUE; + } + } + + if (idx_other == DB_COUNT) { + if (found_not_ma) { + EMSG(_("E793: No other buffer in diff mode is modifiable")); + } else { + EMSG(_("E100: No other buffer in diff mode")); + } + return; + } + + // Check that there isn't a third buffer in the list + for (i = idx_other + 1; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] != curbuf) + && (curtab->tp_diffbuf[i] != NULL) + && ((eap->cmdidx != CMD_diffput) || curtab->tp_diffbuf[i]->b_p_ma)) { + EMSG(_("E101: More than two buffers in diff mode, don't know " + "which one to use")); + return; + } + } + } else { + // Buffer number or pattern given. Ignore trailing white space. + p = eap->arg + STRLEN(eap->arg); + while (p > eap->arg && vim_iswhite(p[-1])) { + p--; + } + + for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i) { + } + + if (eap->arg + i == p) { + // digits only + i = atol((char *)eap->arg); + } else { + i = buflist_findpat(eap->arg, p, FALSE, TRUE, FALSE); + + if (i < 0) { + // error message already given + return; + } + } + buf = buflist_findnr(i); + + if (buf == NULL) { + EMSG2(_("E102: Can't find buffer \"%s\""), eap->arg); + return; + } + + if (buf == curbuf) { + // nothing to do + return; + } + idx_other = diff_buf_idx(buf); + + if (idx_other == DB_COUNT) { + EMSG2(_("E103: Buffer \"%s\" is not in diff mode"), eap->arg); + return; + } + } + + diff_busy = TRUE; + + // When no range given include the line above or below the cursor. + if (eap->addr_count == 0) { + // Make it possible that ":diffget" on the last line gets line below + // the cursor line when there is no difference above the cursor. + if ((eap->cmdidx == CMD_diffget) + && (eap->line1 == curbuf->b_ml.ml_line_count) + && (diff_check(curwin, eap->line1) == 0) + && ((eap->line1 == 1) || (diff_check(curwin, eap->line1 - 1) == 0))) { + ++eap->line2; + } else if (eap->line1 > 0) { + --eap->line1; + } + } + + if (eap->cmdidx == CMD_diffget) { + idx_from = idx_other; + idx_to = idx_cur; + } else { + idx_from = idx_cur; + idx_to = idx_other; + + // Need to make the other buffer the current buffer to be able to make + // changes in it. + + // set curwin/curbuf to buf and save a few things + aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]); + } + + // May give the warning for a changed buffer here, which can trigger the + // FileChangedRO autocommand, which may do nasty things and mess + // everything up. + if (!curbuf->b_changed) { + change_warning(0); + if (diff_buf_idx(curbuf) != idx_to) { + EMSG(_("E787: Buffer changed unexpectedly")); + return; + } + } + + dprev = NULL; + + for (dp = curtab->tp_first_diff; dp != NULL;) { + if (dp->df_lnum[idx_cur] > eap->line2 + off) { + // past the range that was specified + break; + } + dfree = NULL; + lnum = dp->df_lnum[idx_to]; + count = dp->df_count[idx_to]; + + if ((dp->df_lnum[idx_cur] + dp->df_count[idx_cur] > eap->line1 + off) + && (u_save(lnum - 1, lnum + count) != FAIL)) { + // Inside the specified range and saving for undo worked. + start_skip = 0; + end_skip = 0; + + if (eap->addr_count > 0) { + // A range was specified: check if lines need to be skipped. + start_skip = eap->line1 + off - dp->df_lnum[idx_cur]; + if (start_skip > 0) { + // range starts below start of current diff block + if (start_skip > count) { + lnum += count; + count = 0; + } else { + count -= start_skip; + lnum += start_skip; + } + } else { + start_skip = 0; + } + + end_skip = dp->df_lnum[idx_cur] + dp->df_count[idx_cur] - 1 + - (eap->line2 + off); + + if (end_skip > 0) { + // range ends above end of current/from diff block + if (idx_cur == idx_from) { + // :diffput + i = dp->df_count[idx_cur] - start_skip - end_skip; + + if (count > i) { + count = i; + } + } else { + // :diffget + count -= end_skip; + end_skip = dp->df_count[idx_from] - start_skip - count; + + if (end_skip < 0) { + end_skip = 0; + } + } + } else { + end_skip = 0; + } + } + + buf_empty = FALSE; + added = 0; + + for (i = 0; i < count; ++i) { + // remember deleting the last line of the buffer + buf_empty = curbuf->b_ml.ml_line_count == 1; + ml_delete(lnum, FALSE); + added--; + } + + for (i = 0; i < dp->df_count[idx_from] - start_skip - end_skip; ++i) { + linenr_T nr = dp->df_lnum[idx_from] + start_skip + i; + if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) { + break; + } + p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, FALSE)); + if (p != NULL) { + ml_append(lnum + i - 1, p, 0, FALSE); + free(p); + added++; + if (buf_empty && (curbuf->b_ml.ml_line_count == 2)) { + // Added the first line into an empty buffer, need to + // delete the dummy empty line. + buf_empty = FALSE; + ml_delete((linenr_T)2, FALSE); + } + } + } + new_count = dp->df_count[idx_to] + added; + dp->df_count[idx_to] = new_count; + + if ((start_skip == 0) && (end_skip == 0)) { + // Check if there are any other buffers and if the diff is + // equal in them. + for (i = 0; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] != NULL) + && (i != idx_from) + && (i != idx_to) + && !diff_equal_entry(dp, idx_from, i)) { + break; + } + } + + if (i == DB_COUNT) { + // delete the diff entry, the buffers are now equal here + dfree = dp; + dp = dp->df_next; + + if (dprev == NULL) { + curtab->tp_first_diff = dp; + } else { + dprev->df_next = dp; + } + } + } + + // Adjust marks. This will change the following entries! + if (added != 0) { + mark_adjust(lnum, lnum + count - 1, (long)MAXLNUM, (long)added); + if (curwin->w_cursor.lnum >= lnum) { + // Adjust the cursor position if it's in/after the changed + // lines. + if (curwin->w_cursor.lnum >= lnum + count) { + curwin->w_cursor.lnum += added; + } else if (added < 0) { + curwin->w_cursor.lnum = lnum; + } + } + } + changed_lines(lnum, 0, lnum + count, (long)added); + + if (dfree != NULL) { + // Diff is deleted, update folds in other windows. + diff_fold_update(dfree, idx_to); + free(dfree); + } else { + // mark_adjust() may have changed the count in a wrong way + dp->df_count[idx_to] = new_count; + } + + // When changing the current buffer, keep track of line numbers + if (idx_cur == idx_to) { + off += added; + } + } + + // If before the range or not deleted, go to next diff. + if (dfree == NULL) { + dprev = dp; + dp = dp->df_next; + } + } + + // restore curwin/curbuf and a few other things + if (eap->cmdidx != CMD_diffget) { + // Syncing undo only works for the current buffer, but we change + // another buffer. Sync undo if the command was typed. This isn't + // 100% right when ":diffput" is used in a function or mapping. + if (KeyTyped) { + u_sync(FALSE); + } + aucmd_restbuf(&aco); + } + + diff_busy = FALSE; + + // Check that the cursor is on a valid character and update it's position. + // When there were filler lines the topline has become invalid. + check_cursor(); + changed_line_abv_curs(); + + // Also need to redraw the other buffers. + diff_redraw(FALSE); +} + +/// Update folds for all diff buffers for entry "dp". +/// +/// Skip buffer with index "skip_idx". +/// When there are no diffs, all folds are removed. +/// +/// @param dp +/// @param skip_idx +static void diff_fold_update(diff_T *dp, int skip_idx) +{ + win_T *wp; + for (wp = firstwin; wp != NULL; wp = wp->w_next) { + int i; + for (i = 0; i < DB_COUNT; ++i) { + if ((curtab->tp_diffbuf[i] == wp->w_buffer) && (i != skip_idx)) { + foldUpdate(wp, dp->df_lnum[i], dp->df_lnum[i] + dp->df_count[i]); + } + } + } +} + +/// Checks if the buffer is in diff-mode. +/// +/// @param buf The buffer to check. +/// +/// @return TRUE if buffer "buf" is in diff-mode. +int diff_mode_buf(buf_T *buf) +{ + tabpage_T *tp; + for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) { + if (diff_buf_idx_tp(buf, tp) != DB_COUNT) { + return TRUE; + } + } + return FALSE; +} + +/// Move "count" times in direction "dir" to the next diff block. +/// +/// @param dir +/// @param count +/// +/// @return FAIL if there isn't such a diff block. +int diff_move_to(int dir, long count) +{ + linenr_T lnum = curwin->w_cursor.lnum; + int idx = diff_buf_idx(curbuf); + if ((idx == DB_COUNT) || (curtab->tp_first_diff == NULL)) { + return FAIL; + } + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + + if (curtab->tp_first_diff == NULL) { + // no diffs today + return FAIL; + } + + while (--count >= 0) { + // Check if already before first diff. + if ((dir == BACKWARD) && (lnum <= curtab->tp_first_diff->df_lnum[idx])) { + break; + } + + diff_T *dp; + for (dp = curtab->tp_first_diff;; dp = dp->df_next) { + if (dp == NULL) { + break; + } + + if (((dir == FORWARD) && (lnum < dp->df_lnum[idx])) + || ((dir == BACKWARD) + && ((dp->df_next == NULL) + || (lnum <= dp->df_next->df_lnum[idx])))) { + lnum = dp->df_lnum[idx]; + break; + } + } + } + + // don't end up past the end of the file + if (lnum > curbuf->b_ml.ml_line_count) { + lnum = curbuf->b_ml.ml_line_count; + } + + // When the cursor didn't move at all we fail. + if (lnum == curwin->w_cursor.lnum) { + return FAIL; + } + + setpcmark(); + curwin->w_cursor.lnum = lnum; + curwin->w_cursor.col = 0; + + return OK; +} + +/// Finds the corresponding line in a diff. +/// +/// @param buf1 +/// @param lnum1 +/// @param buf2 +/// @param lnum3 +/// +/// @return The corresponding line. +linenr_T diff_get_corresponding_line(buf_T *buf1, linenr_T lnum1, buf_T *buf2, + linenr_T lnum3) +{ + int idx1; + int idx2; + diff_T *dp; + int baseline = 0; + linenr_T lnum2; + + idx1 = diff_buf_idx(buf1); + idx2 = diff_buf_idx(buf2); + + if ((idx1 == DB_COUNT) + || (idx2 == DB_COUNT) + || (curtab->tp_first_diff == NULL)) { + return lnum1; + } + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + + if (curtab->tp_first_diff == NULL) { + // no diffs today + return lnum1; + } + + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + if (dp->df_lnum[idx1] > lnum1) { + lnum2 = lnum1 - baseline; + + // don't end up past the end of the file + if (lnum2 > buf2->b_ml.ml_line_count) { + lnum2 = buf2->b_ml.ml_line_count; + } + + return lnum2; + } else if ((dp->df_lnum[idx1] + dp->df_count[idx1]) > lnum1) { + // Inside the diffblock + baseline = lnum1 - dp->df_lnum[idx1]; + + if (baseline > dp->df_count[idx2]) { + baseline = dp->df_count[idx2]; + } + + return dp->df_lnum[idx2] + baseline; + } else if ((dp->df_lnum[idx1] == lnum1) + && (dp->df_count[idx1] == 0) + && (dp->df_lnum[idx2] <= lnum3) + && ((dp->df_lnum[idx2] + dp->df_count[idx2]) > lnum3)) { + // Special case: if the cursor is just after a zero-count + // block (i.e. all filler) and the target cursor is already + // inside the corresponding block, leave the target cursor + // unmoved. This makes repeated CTRL-W W operations work + // as expected. + return lnum3; + } + baseline = (dp->df_lnum[idx1] + dp->df_count[idx1]) + - (dp->df_lnum[idx2] + dp->df_count[idx2]); + } + + // If we get here then the cursor is after the last diff + lnum2 = lnum1 - baseline; + + // don't end up past the end of the file + if (lnum2 > buf2->b_ml.ml_line_count) { + lnum2 = buf2->b_ml.ml_line_count; + } + + return lnum2; +} + +/// For line "lnum" in the current window find the equivalent lnum in window +/// "wp", compensating for inserted/deleted lines. +linenr_T diff_lnum_win(linenr_T lnum, win_T *wp) +{ + diff_T *dp; + int idx; + int i; + linenr_T n; + + idx = diff_buf_idx(curbuf); + + if (idx == DB_COUNT) { + // safety check + return (linenr_T)0; + } + + if (curtab->tp_diff_invalid) { + // update after a big change + ex_diffupdate(NULL); + } + + // search for a change that includes "lnum" in the list of diffblocks. + for (dp = curtab->tp_first_diff; dp != NULL; dp = dp->df_next) { + if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) { + break; + } + } + + // When after the last change, compute relative to the last line number. + if (dp == NULL) { + return wp->w_buffer->b_ml.ml_line_count + - (curbuf->b_ml.ml_line_count - lnum); + } + + // Find index for "wp". + i = diff_buf_idx(wp->w_buffer); + + if (i == DB_COUNT) { + // safety check + return (linenr_T)0; + } + + n = lnum + (dp->df_lnum[i] - dp->df_lnum[idx]); + if (n > dp->df_lnum[i] + dp->df_count[i]) { + n = dp->df_lnum[i] + dp->df_count[i]; + } + return n; +} |