vim/src/diff.c at master · somini/vim

Repository navigation

100

101

102

103

104

/* vi:set ts=8 sts=4 sw=4 noet:

* VIM - Vi IMproved by Bram Moolenaar

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

* diff.c: code for diff'ing two, three or four buffers.

#include "vim.h"

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

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 */

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 */

#endif

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);

#ifdef FEAT_FOLDING

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

#endif

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

* Called when deleting or unloading a buffer: No longer make a diff with it.

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)

diff_redraw(TRUE);

}

* Check if the current buffer should be added to or removed from the list of

* diff buffers.

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);

}

* 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.

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;

}

EMSGN(_("E96: Cannot diff more than %ld buffers"), DB_COUNT);

}

* Remove all buffers to make diffs for.

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);

}

* Find buffer "buf" in the list of diff buffers for the current tab page.

* 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".

* 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.

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);

}

* Called by mark_adjust(): update line numbers in "curbuf".

void

diff_mark_adjust(

linenr_T line1,

linenr_T line2,

long amount,

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);

}

* 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.

static void

diff_mark_adjust_tp(

tabpage_T *tp,

int idx,

linenr_T line1,

linenr_T line2,

long amount,

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 (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)

10000

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;

* Check for these situations:

* 1 2 3

* line1 2 3 4 5

* 2 3 4 5

* line2 2 3 4 5

* 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)

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)

{

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;

}

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])

{

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;

vim_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. */

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;

vim_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".

static diff_T *

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

{

diff_T *dnew;

dnew = (diff_T *)alloc((unsigned)sizeof(diff_T));

if (dnew != NULL)

{

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.

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;

}

* Check if a diff block doesn't contain invalid line numbers.

* This can happen when the diff program returns invalid results.

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.

static void

diff_redraw(

int dofold) /* also recompute the folds */

{

win_T *wp;

int n;

FOR_ALL_WINDOWS(wp)

if (wp->w_p_diff)

{

redraw_win_later(wp, SOME_VALID);

#ifdef FEAT_FOLDING

if (dofold && foldmethodIsDiff(wp))

foldUpdateAll(wp);

#endif

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

* of that for other windows. */

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;

check_topfill(wp, FALSE);

}

* Write buffer "buf" to file "name".

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

* Return FAIL for failure

static int

diff_write(buf_T *buf, char_u *fname)

{

int r;

char_u *save_ff;

save_ff = buf->b_p_ff;

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

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).

void

ex_diffupdate(

exarg_T *eap) /* can be NULL */

{

buf_T *buf;

int idx_orig;

int idx_new;

char_u *tmp_orig;

char_u *tmp_new;

char_u *tmp_diff;

FILE *fd;

int ok;

int io_error = FALSE;

/* Delete all diffblocks. */

diff_clear(curtab);

curtab->tp_diff_invalid = FALSE;

/* Use the first buffer as the original text. */

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. */

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. */

tmp_orig = vim_tempname('o', TRUE);

tmp_new = vim_tempname('n', TRUE);

tmp_diff = vim_tempname('d', TRUE);

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.

for (;;)

{

ok = FALSE;

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);

}

mch_remove(tmp_diff);

mch_remove(tmp_new);

}

mch_remove(tmp_orig);

}

#ifdef FEAT_EVAL

/* When using 'diffexpr' break here. */

if (*p_dex != NUL)

break;

#endif

#if defined(MSWIN)

/* If the "-a" argument works, also check if "--binary" works. */

if (ok && diff_a_works == MAYBE && diff_bin_works == MAYBE)

{

diff_a_works = TRUE;

diff_bin_works = TRUE;

continue;

}

if (!ok && diff_a_works == TRUE && diff_bin_works == TRUE)

{

/* Tried --binary, but it failed. "-a" works though. */

diff_bin_works = FALSE;

ok = TRUE;

}

#endif

/* 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;

#if defined(MSWIN)

diff_bin_works = MAYBE;

#endif

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);

}

/* Write the first buffer to a tempfile. */

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 = curtab->tp_diffbuf[idx_new];

if (buf == NULL || buf->b_ml.ml_mfp == NULL)

continue; /* skip buffer that isn't loaded */

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);

mch_remove(tmp_diff);

mch_remove(tmp_new);

}

mch_remove(tmp_orig);

/* force updating cursor position on screen */

curwin->w_valid_cursor.lnum = 0;

diff_redraw(TRUE);

theend:

vim_free(tmp_orig);

vim_free(tmp_new);

vim_free(tmp_diff);

}

* Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff".

static void

diff_file(

char_u *tmp_orig,

char_u *tmp_new,

char_u *tmp_diff)

{

char_u *cmd;

size_t len;

#ifdef FEAT_EVAL

if (*p_dex != NUL)

/* Use 'diffexpr' to generate the diff file. */

eval_diff(tmp_orig, tmp_new, tmp_diff);

else

#endif

{

len = STRLEN(tmp_orig) + STRLEN(tmp_new)

+ STRLEN(tmp_diff) + STRLEN(p_srr) + 27;

cmd = alloc((unsigned)len);

if (cmd != NULL)

{

/* We don't want $DIFF_OPTIONS to get in the way. */

if (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 ",

#if defined(MSWIN)

diff_bin_works == TRUE ? "--binary " : "",

#else

"",

#endif

(diff_flags & DIFF_IWHITE) ? "-b " : "",

(diff_flags & DIFF_ICASE) ? "-i " : "",

tmp_orig, tmp_new);

append_redir(cmd, (int)len, p_srr, tmp_diff);

#ifdef FEAT_AUTOCMD

block_autocmds(); /* Avoid ShellCmdPost stuff */

#endif

(void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT);

#ifdef FEAT_AUTOCMD

unblock_autocmds();

#endif

vim_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).

void

ex_diffpatch(exarg_T *eap)

{

char_u *tmp_orig; /* name of original temp file */

char_u *tmp_new; /* name of patched temp file */

char_u *buf = NULL;

size_t buflen;

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 FEAT_BROWSE

char_u *browseFile = NULL;

int browse_flag = cmdmod.browse;

#endif

stat_T st;

char_u *esc_name = NULL;

#ifdef FEAT_BROWSE

if (cmdmod.browse)

{

browseFile = do_browse(0, (char_u *)_("Patch file"),

eap->arg, NULL, NULL, BROWSE_FILTER_ALL_FILES, NULL);

if (browseFile == NULL)

return; /* operation cancelled */

eap->arg = browseFile;

cmdmod.browse = FALSE; /* don't let do_ecmd() browse again */

}

#endif

/* We need two temp file names. */

tmp_orig = vim_tempname('o', FALSE);

tmp_new = vim_tempname('n', FALSE);

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

esc_name = vim_strsave_shellescape(

# ifdef UNIX

fullname != NULL ? fullname :

# endif

eap->arg, TRUE, TRUE);

if (esc_name == NULL)

goto theend;

buflen = STRLEN(tmp_orig) + STRLEN(esc_name) + STRLEN(tmp_new) + 16;

buf = alloc((unsigned)buflen);

if (buf == NULL)

goto theend;

#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 (mch_dirname(dirbuf, MAXPATHL) != OK || mch_chdir((char *)dirbuf) != 0)

dirbuf[0] = NUL;

else

{

# ifdef TEMPDIRNAMES

if (vim_tempdir != NULL)

ignored = mch_chdir((char *)vim_tempdir);

else

# endif

ignored = mch_chdir("/tmp");

shorten_fnames(TRUE);

}

#endif

#ifdef FEAT_EVAL

if (*p_pex != NUL)

/* Use 'patchexpr' to generate the new file. */

eval_patch(tmp_orig,

# ifdef UNIX

fullname != NULL ? fullname :

# endif

eap->arg, tmp_new);

else

#endif

{

/* Build the patch command and execute it. Ignore errors. Switch to

* cooked mode to allow the user to respond to prompts. */

vim_snprintf((char *)buf, buflen, "patch -o %s %s < %s",

tmp_new, tmp_orig, esc_name);

#ifdef FEAT_AUTOCMD

block_autocmds(); /* Avoid ShellCmdPost stuff */

#endif

(void)call_shell(buf, SHELL_FILTER | SHELL_COOKED);

#ifdef FEAT_AUTOCMD

unblock_autocmds();

#endif

}

#ifdef UNIX

if (dirbuf[0] != NUL)

{

if (mch_chdir((char *)dirbuf) != 0)

EMSG(_(e_prev_dir));

shorten_fnames(TRUE);

View remainder of file in raw view

FilesExpand file tree

diff.c

Latest commit

History

diff.c

File metadata and controls